From 1547f5b65f170561dc0443b7fbbccda44cb962d8 Mon Sep 17 00:00:00 2001
From: Marcin Jahn <10273406+marcinjahn@users.noreply.github.com>
Date: Sun, 10 Nov 2024 15:58:46 +0100
Subject: [PATCH 1/4] feat: add allocation-free overloads for Result.Map

---
 .../ResultTests/Extensions/MapTests.Base.cs   |  68 ++--
 .../Extensions/MapTests.Task.Left.cs          | 335 ++++++++++++-----
 .../Extensions/MapTests.Task.Right.cs         | 335 ++++++++++++-----
 .../ResultTests/Extensions/MapTests.Task.cs   | 335 ++++++++++++-----
 .../Extensions/MapTests.ValueTask.Left.cs     | 337 +++++++++++++-----
 .../Extensions/MapTests.ValueTask.Right.cs    | 337 +++++++++++++-----
 .../Extensions/MapTests.ValueTask.cs          | 337 +++++++++++++-----
 .../ResultTests/Extensions/MapTests.cs        | 333 ++++++++++++-----
 .../Methods/Extensions/Map.Task.Left.cs       | 149 +++++---
 .../Methods/Extensions/Map.Task.Right.cs      | 237 ++++++++----
 .../Result/Methods/Extensions/Map.Task.cs     | 221 ++++++++----
 .../Methods/Extensions/Map.ValueTask.Left.cs  | 156 +++++---
 .../Methods/Extensions/Map.ValueTask.Right.cs | 247 +++++++++----
 .../Methods/Extensions/Map.ValueTask.cs       | 228 ++++++++----
 .../Result/Methods/Extensions/Map.cs          | 162 ++++++---
 15 files changed, 2686 insertions(+), 1131 deletions(-)

diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Base.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Base.cs
index 3b58f089..325a04bc 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Base.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Base.cs
@@ -1,32 +1,36 @@
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public abstract class MapTestsBase : TestBase
-    {
-        protected bool FuncExecuted;
-
-        protected MapTestsBase()
-        {
-            FuncExecuted = false;
-        }
-
-        protected K Func_K() 
-        { 
-            FuncExecuted = true; 
-            return K.Value;
-        }
-
-        protected K Func_T_K(T value) 
-        {
-            FuncExecuted = true; 
-            return K.Value;
-        }
-
-        protected Task<K> Task_Func_K() => Func_K().AsTask();
-        protected Task<K> Task_Func_T_K(T value) => Func_T_K(value).AsTask();
-        
-        protected ValueTask<K> ValueTask_Func_K() => Func_K().AsValueTask();
-        protected ValueTask<K> ValueTask_Func_T_K(T value) => Func_T_K(value).AsValueTask();
-    }
-}
\ No newline at end of file
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public abstract class MapTestsBase : TestBase
+    {
+        protected bool FuncExecuted;
+
+        protected MapTestsBase()
+        {
+            FuncExecuted = false;
+        }
+
+        protected K Func_K()
+        {
+            FuncExecuted = true;
+            return K.Value;
+        }
+
+        protected K Func_T_K(T value)
+        {
+            FuncExecuted = true;
+            return K.Value;
+        }
+
+        protected Task<K> Task_Func_K() => Func_K().AsTask();
+
+        protected Task<K> Task_Func_T_K(T value) => Func_T_K(value).AsTask();
+
+        protected ValueTask<K> ValueTask_Func_K() => Func_K().AsValueTask();
+
+        protected ValueTask<K> ValueTask_Func_T_K(T value) => Func_T_K(value).AsValueTask();
+
+        protected readonly string ContextMessage = "Context data";
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.Left.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.Left.cs
index 4e3a47c3..893d975b 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.Left.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.Left.cs
@@ -1,96 +1,239 @@
-using FluentAssertions;
-using System.Threading.Tasks;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions 
-{
-    public class MapTests_Task_Left : MapTestsBase 
-    {
-        [Fact]
-        public async Task Map_Task_Left_executes_on_success_returns_new_success()
-        {
-            Task<Result> result = Result.Success().AsTask();
-            Result<K> actual = await result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_executes_on_failure_returns_new_failure()
-        {
-            Task<Result> result = Result.Failure(ErrorMessage).AsTask();
-            Result<K> actual = await result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_T_executes_on_success_returns_new_success()
-        {
-            Task<Result<T>> result = Result.Success(T.Value).AsTask();
-            Result<K> actual = await result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_T_executes_on_failure_returns_new_failure()
-        {
-            Task<Result<T>> result = Result.Failure<T>(ErrorMessage).AsTask();
-            Result<K> actual = await result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_T_E_executes_on_success_returns_new_success()
-        {
-            Task<Result<T, E>> result = Result.Success<T, E>(T.Value).AsTask();
-            Result<K, E> actual = await result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_T_E_executes_on_failure_returns_new_failure()
-        {
-            Task<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsTask();
-            Result<K, E> actual = await result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_UnitResult_E_executes_on_success_returns_success()
-        {
-            Task<UnitResult<E>> result = UnitResult.Success<E>().AsTask();
-            Result<K, E> actual = await result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_UnitResult_E_executes_on_failure_returns_failure()
-        {
-            Task<UnitResult<E>> result = UnitResult.Failure(E.Value).AsTask();
-            Result<K, E> actual = await result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-    }
-}
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapTests_Task_Left : MapTestsBase
+    {
+        [Fact]
+        public async Task Map_Task_Left_executes_on_success_returns_new_success()
+        {
+            Task<Result> result = Result.Success().AsTask();
+            Result<K> actual = await result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_executes_on_failure_returns_new_failure()
+        {
+            Task<Result> result = Result.Failure(ErrorMessage).AsTask();
+            Result<K> actual = await result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_T_executes_on_success_returns_new_success()
+        {
+            Task<Result<T>> result = Result.Success(T.Value).AsTask();
+            Result<K> actual = await result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_T_executes_on_failure_returns_new_failure()
+        {
+            Task<Result<T>> result = Result.Failure<T>(ErrorMessage).AsTask();
+            Result<K> actual = await result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_T_E_executes_on_success_returns_new_success()
+        {
+            Task<Result<T, E>> result = Result.Success<T, E>(T.Value).AsTask();
+            Result<K, E> actual = await result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_T_E_executes_on_failure_returns_new_failure()
+        {
+            Task<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsTask();
+            Result<K, E> actual = await result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_UnitResult_E_executes_on_success_returns_success()
+        {
+            Task<UnitResult<E>> result = UnitResult.Success<E>().AsTask();
+            Result<K, E> actual = await result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_UnitResult_E_executes_on_failure_returns_failure()
+        {
+            Task<UnitResult<E>> result = UnitResult.Failure(E.Value).AsTask();
+            Result<K, E> actual = await result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Task<Result> result = Result.Success().AsTask();
+            Result<K> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Task<Result> result = Result.Failure(ErrorMessage).AsTask();
+            Result<K> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_T_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Task<Result<T>> result = Result.Success(T.Value).AsTask();
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_T_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Task<Result<T>> result = Result.Failure<T>(ErrorMessage).AsTask();
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_T_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Task<Result<T, E>> result = Result.Success<T, E>(T.Value).AsTask();
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_T_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Task<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsTask();
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Task<UnitResult<E>> result = UnitResult.Success<E>().AsTask();
+            Result<K, E> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Task<UnitResult<E>> result = UnitResult.Failure(E.Value).AsTask();
+            Result<K, E> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.Right.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.Right.cs
index dcc59619..e767cd2a 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.Right.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.Right.cs
@@ -1,96 +1,239 @@
-using FluentAssertions;
-using System.Threading.Tasks;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions 
-{
-    public class MapTests_Task_Right : MapTestsBase 
-    {
-        [Fact]
-        public async Task Map_Task_Right_executes_on_success_returns_new_success()
-        {
-            Result result = Result.Success();
-            Result<K> actual = await result.Map(Task_Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_executes_on_failure_returns_new_failure()
-        {
-            Result result = Result.Failure(ErrorMessage);
-            Result<K> actual = await result.Map(Task_Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_T_executes_on_success_returns_new_success()
-        {
-            Result<T> result = Result.Success(T.Value);
-            Result<K> actual = await result.Map(Task_Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_T_executes_on_failure_returns_new_failure()
-        {
-            Result<T> result = Result.Failure<T>(ErrorMessage);
-            Result<K> actual = await result.Map(Task_Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_T_E_executes_on_success_returns_new_success()
-        {
-            Result<T, E> result = Result.Success<T, E>(T.Value);
-            Result<K, E> actual = await result.Map(Task_Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_T_E_executes_on_failure_returns_new_failure()
-        {
-            Result<T, E> result = Result.Failure<T, E>(E.Value);
-            Result<K, E> actual = await result.Map(Task_Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_UnitResult_E_executes_on_success_returns_success()
-        {
-            UnitResult<E> result = UnitResult.Success<E>();
-            Result<K, E> actual = await result.Map(Task_Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_UnitResult_E_executes_on_failure_returns_failure()
-        {
-            UnitResult<E> result = UnitResult.Failure(E.Value);
-            Result<K, E> actual = await result.Map(Task_Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-    }
-}
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapTests_Task_Right : MapTestsBase
+    {
+        [Fact]
+        public async Task Map_Task_Right_executes_on_success_returns_new_success()
+        {
+            Result result = Result.Success();
+            Result<K> actual = await result.Map(Task_Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_executes_on_failure_returns_new_failure()
+        {
+            Result result = Result.Failure(ErrorMessage);
+            Result<K> actual = await result.Map(Task_Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_T_executes_on_success_returns_new_success()
+        {
+            Result<T> result = Result.Success(T.Value);
+            Result<K> actual = await result.Map(Task_Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_T_executes_on_failure_returns_new_failure()
+        {
+            Result<T> result = Result.Failure<T>(ErrorMessage);
+            Result<K> actual = await result.Map(Task_Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_T_E_executes_on_success_returns_new_success()
+        {
+            Result<T, E> result = Result.Success<T, E>(T.Value);
+            Result<K, E> actual = await result.Map(Task_Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_T_E_executes_on_failure_returns_new_failure()
+        {
+            Result<T, E> result = Result.Failure<T, E>(E.Value);
+            Result<K, E> actual = await result.Map(Task_Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_UnitResult_E_executes_on_success_returns_success()
+        {
+            UnitResult<E> result = UnitResult.Success<E>();
+            Result<K, E> actual = await result.Map(Task_Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_UnitResult_E_executes_on_failure_returns_failure()
+        {
+            UnitResult<E> result = UnitResult.Failure(E.Value);
+            Result<K, E> actual = await result.Map(Task_Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Result result = Result.Success();
+            Result<K> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Result result = Result.Failure(ErrorMessage);
+            Result<K> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_T_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Result<T> result = Result.Success(T.Value);
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_T_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Result<T> result = Result.Failure<T>(ErrorMessage);
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_T_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Result<T, E> result = Result.Success<T, E>(T.Value);
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_T_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Result<T, E> result = Result.Failure<T, E>(E.Value);
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            UnitResult<E> result = UnitResult.Success<E>();
+            Result<K, E> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            UnitResult<E> result = UnitResult.Failure(E.Value);
+            Result<K, E> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.cs
index a93a5ac4..b3e5f09a 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.cs
@@ -1,96 +1,239 @@
-using FluentAssertions;
-using System.Threading.Tasks;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions 
-{
-    public class MapTests_Task : MapTestsBase 
-    {
-        [Fact]
-        public async Task Map_Task_executes_on_success_returns_new_success()
-        {
-            Task<Result> result = Result.Success().AsTask();
-            Result<K> actual = await result.Map(Task_Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_executes_on_failure_returns_new_failure()
-        {
-            Task<Result> result = Result.Failure(ErrorMessage).AsTask();
-            Result<K> actual = await result.Map(Task_Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_T_executes_on_success_returns_new_success()
-        {
-            Task<Result<T>> result = Result.Success(T.Value).AsTask();
-            Result<K> actual = await result.Map(Task_Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_T_executes_on_failure_returns_new_failure()
-        {
-            Task<Result<T>> result = Result.Failure<T>(ErrorMessage).AsTask();
-            Result<K> actual = await result.Map(Task_Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_T_E_executes_on_success_returns_new_success()
-        {
-            Task<Result<T, E>> result = Result.Success<T, E>(T.Value).AsTask();
-            Result<K, E> actual = await result.Map(Task_Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_T_E_executes_on_failure_returns_new_failure()
-        {
-            Task<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsTask();
-            Result<K, E> actual = await result.Map(Task_Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_UnitResult_E_executes_on_success_returns_success()
-        {
-            Task<UnitResult<E>> result = UnitResult.Success<E>().AsTask();
-            Result<K, E> actual = await result.Map(Task_Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_UnitResult_E_executes_on_failure_returns_failure()
-        {
-            Task<UnitResult<E>> result = UnitResult.Failure(E.Value).AsTask();
-            Result<K, E> actual = await result.Map(Task_Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-    }
-}
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapTests_Task : MapTestsBase
+    {
+        [Fact]
+        public async Task Map_Task_executes_on_success_returns_new_success()
+        {
+            Task<Result> result = Result.Success().AsTask();
+            Result<K> actual = await result.Map(Task_Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_executes_on_failure_returns_new_failure()
+        {
+            Task<Result> result = Result.Failure(ErrorMessage).AsTask();
+            Result<K> actual = await result.Map(Task_Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_T_executes_on_success_returns_new_success()
+        {
+            Task<Result<T>> result = Result.Success(T.Value).AsTask();
+            Result<K> actual = await result.Map(Task_Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_T_executes_on_failure_returns_new_failure()
+        {
+            Task<Result<T>> result = Result.Failure<T>(ErrorMessage).AsTask();
+            Result<K> actual = await result.Map(Task_Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_T_E_executes_on_success_returns_new_success()
+        {
+            Task<Result<T, E>> result = Result.Success<T, E>(T.Value).AsTask();
+            Result<K, E> actual = await result.Map(Task_Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_T_E_executes_on_failure_returns_new_failure()
+        {
+            Task<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsTask();
+            Result<K, E> actual = await result.Map(Task_Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_UnitResult_E_executes_on_success_returns_success()
+        {
+            Task<UnitResult<E>> result = UnitResult.Success<E>().AsTask();
+            Result<K, E> actual = await result.Map(Task_Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_UnitResult_E_executes_on_failure_returns_failure()
+        {
+            Task<UnitResult<E>> result = UnitResult.Failure(E.Value).AsTask();
+            Result<K, E> actual = await result.Map(Task_Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Task<Result> result = Result.Success().AsTask();
+            Result<K> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Task<Result> result = Result.Failure(ErrorMessage).AsTask();
+            Result<K> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_T_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Task<Result<T>> result = Result.Success(T.Value).AsTask();
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_T_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Task<Result<T>> result = Result.Failure<T>(ErrorMessage).AsTask();
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_T_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Task<Result<T, E>> result = Result.Success<T, E>(T.Value).AsTask();
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_T_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Task<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsTask();
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Task<UnitResult<E>> result = UnitResult.Success<E>().AsTask();
+            Result<K, E> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Task<UnitResult<E>> result = UnitResult.Failure(E.Value).AsTask();
+            Result<K, E> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.Left.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.Left.cs
index f724c6da..e35aaefd 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.Left.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.Left.cs
@@ -1,97 +1,240 @@
-using FluentAssertions;
-using System.Threading.Tasks;
-using CSharpFunctionalExtensions.ValueTasks;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions 
-{
-    public class MapTests_ValueTask_Left : MapTestsBase 
-    {
-        [Fact]
-        public async Task Map_ValueTask_Left_executes_on_success_returns_new_success()
-        {
-            ValueTask<Result> result = Result.Success().AsValueTask();
-            Result<K> actual = await result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_executes_on_failure_returns_new_failure()
-        {
-            ValueTask<Result> result = Result.Failure(ErrorMessage).AsValueTask();
-            Result<K> actual = await result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_T_executes_on_success_returns_new_success()
-        {
-            ValueTask<Result<T>> result = Result.Success(T.Value).AsValueTask();
-            Result<K> actual = await result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_T_executes_on_failure_returns_new_failure()
-        {
-            ValueTask<Result<T>> result = Result.Failure<T>(ErrorMessage).AsValueTask();
-            Result<K> actual = await result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_T_E_executes_on_success_returns_new_success()
-        {
-            ValueTask<Result<T, E>> result = Result.Success<T, E>(T.Value).AsValueTask();
-            Result<K, E> actual = await result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_T_E_executes_on_failure_returns_new_failure()
-        {
-            ValueTask<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsValueTask();
-            Result<K, E> actual = await result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_UnitResult_E_executes_on_success_returns_success()
-        {
-            ValueTask<UnitResult<E>> result = UnitResult.Success<E>().AsValueTask();
-            Result<K, E> actual = await result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_UnitResult_E_executes_on_failure_returns_failure()
-        {
-            ValueTask<UnitResult<E>> result = UnitResult.Failure(E.Value).AsValueTask();
-            Result<K, E> actual = await result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-    }
-}
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapTests_ValueTask_Left : MapTestsBase
+    {
+        [Fact]
+        public async Task Map_ValueTask_Left_executes_on_success_returns_new_success()
+        {
+            ValueTask<Result> result = Result.Success().AsValueTask();
+            Result<K> actual = await result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_executes_on_failure_returns_new_failure()
+        {
+            ValueTask<Result> result = Result.Failure(ErrorMessage).AsValueTask();
+            Result<K> actual = await result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_T_executes_on_success_returns_new_success()
+        {
+            ValueTask<Result<T>> result = Result.Success(T.Value).AsValueTask();
+            Result<K> actual = await result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_T_executes_on_failure_returns_new_failure()
+        {
+            ValueTask<Result<T>> result = Result.Failure<T>(ErrorMessage).AsValueTask();
+            Result<K> actual = await result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_T_E_executes_on_success_returns_new_success()
+        {
+            ValueTask<Result<T, E>> result = Result.Success<T, E>(T.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_T_E_executes_on_failure_returns_new_failure()
+        {
+            ValueTask<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_UnitResult_E_executes_on_success_returns_success()
+        {
+            ValueTask<UnitResult<E>> result = UnitResult.Success<E>().AsValueTask();
+            Result<K, E> actual = await result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_UnitResult_E_executes_on_failure_returns_failure()
+        {
+            ValueTask<UnitResult<E>> result = UnitResult.Failure(E.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_with_context_executes_on_success_and_passes_correct_context()
+        {
+            ValueTask<Result> result = Result.Success().AsValueTask();
+            Result<K> actual = await result.Map(
+                context =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            ValueTask<Result> result = Result.Failure(ErrorMessage).AsValueTask();
+            Result<K> actual = await result.Map(
+                context =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_T_with_context_executes_on_success_and_passes_correct_context()
+        {
+            ValueTask<Result<T>> result = Result.Success(T.Value).AsValueTask();
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_T_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            ValueTask<Result<T>> result = Result.Failure<T>(ErrorMessage).AsValueTask();
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_T_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            ValueTask<Result<T, E>> result = Result.Success<T, E>(T.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_T_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            ValueTask<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            ValueTask<UnitResult<E>> result = UnitResult.Success<E>().AsValueTask();
+            Result<K, E> actual = await result.Map(
+                context =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            ValueTask<UnitResult<E>> result = UnitResult.Failure(E.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(
+                context =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.Right.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.Right.cs
index b9248b11..0077cedf 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.Right.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.Right.cs
@@ -1,97 +1,240 @@
-using FluentAssertions;
-using System.Threading.Tasks;
-using CSharpFunctionalExtensions.ValueTasks;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions 
-{
-    public class MapTests_ValueTask_Right : MapTestsBase 
-    {
-        [Fact]
-        public async Task Map_ValueTask_Right_executes_on_success_returns_new_success()
-        {
-            Result result = Result.Success();
-            Result<K> actual = await result.Map(valueTask: ValueTask_Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_executes_on_failure_returns_new_failure()
-        {
-            Result result = Result.Failure(ErrorMessage);
-            Result<K> actual = await result.Map(valueTask: ValueTask_Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_T_executes_on_success_returns_new_success()
-        {
-            Result<T> result = Result.Success(T.Value);
-            Result<K> actual = await result.Map(valueTask: ValueTask_Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_T_executes_on_failure_returns_new_failure()
-        {
-            Result<T> result = Result.Failure<T>(ErrorMessage);
-            Result<K> actual = await result.Map(valueTask: ValueTask_Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_T_E_executes_on_success_returns_new_success()
-        {
-            Result<T, E> result = Result.Success<T, E>(T.Value);
-            Result<K, E> actual = await result.Map(valueTask: ValueTask_Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_T_E_executes_on_failure_returns_new_failure()
-        {
-            Result<T, E> result = Result.Failure<T, E>(E.Value);
-            Result<K, E> actual = await result.Map(valueTask: ValueTask_Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_UnitResult_E_executes_on_success_returns_success()
-        {
-            UnitResult<E> result = UnitResult.Success<E>();
-            Result<K, E> actual = await result.Map(valueTask: ValueTask_Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_UnitResult_E_executes_on_failure_returns_failure()
-        {
-            UnitResult<E> result = UnitResult.Failure(E.Value);
-            Result<K, E> actual = await result.Map(valueTask: ValueTask_Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-    }
-}
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapTests_ValueTask_Right : MapTestsBase
+    {
+        [Fact]
+        public async Task Map_ValueTask_Right_executes_on_success_returns_new_success()
+        {
+            Result result = Result.Success();
+            Result<K> actual = await result.Map(valueTask: ValueTask_Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_executes_on_failure_returns_new_failure()
+        {
+            Result result = Result.Failure(ErrorMessage);
+            Result<K> actual = await result.Map(valueTask: ValueTask_Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_T_executes_on_success_returns_new_success()
+        {
+            Result<T> result = Result.Success(T.Value);
+            Result<K> actual = await result.Map(valueTask: ValueTask_Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_T_executes_on_failure_returns_new_failure()
+        {
+            Result<T> result = Result.Failure<T>(ErrorMessage);
+            Result<K> actual = await result.Map(valueTask: ValueTask_Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_T_E_executes_on_success_returns_new_success()
+        {
+            Result<T, E> result = Result.Success<T, E>(T.Value);
+            Result<K, E> actual = await result.Map(valueTask: ValueTask_Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_T_E_executes_on_failure_returns_new_failure()
+        {
+            Result<T, E> result = Result.Failure<T, E>(E.Value);
+            Result<K, E> actual = await result.Map(valueTask: ValueTask_Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_UnitResult_E_executes_on_success_returns_success()
+        {
+            UnitResult<E> result = UnitResult.Success<E>();
+            Result<K, E> actual = await result.Map(valueTask: ValueTask_Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_UnitResult_E_executes_on_failure_returns_failure()
+        {
+            UnitResult<E> result = UnitResult.Failure(E.Value);
+            Result<K, E> actual = await result.Map(valueTask: ValueTask_Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Result result = Result.Success();
+            Result<K> actual = await result.Map(
+                valueTask: context =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Result result = Result.Failure(ErrorMessage);
+            Result<K> actual = await result.Map(
+                valueTask: context =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_T_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Result<T> result = Result.Success(T.Value);
+            Result<K> actual = await result.Map(
+                valueTask: (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_T_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Result<T> result = Result.Failure<T>(ErrorMessage);
+            Result<K> actual = await result.Map(
+                valueTask: (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_T_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Result<T, E> result = Result.Success<T, E>(T.Value);
+            Result<K, E> actual = await result.Map(
+                valueTask: (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_T_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Result<T, E> result = Result.Failure<T, E>(E.Value);
+            Result<K, E> actual = await result.Map(
+                valueTask: (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            UnitResult<E> result = UnitResult.Success<E>();
+            Result<K, E> actual = await result.Map(
+                valueTask: context =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            UnitResult<E> result = UnitResult.Failure(E.Value);
+            Result<K, E> actual = await result.Map(
+                valueTask: context =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.cs
index df10b54d..361309e8 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.cs
@@ -1,97 +1,240 @@
-using FluentAssertions;
-using System.Threading.Tasks;
-using CSharpFunctionalExtensions.ValueTasks;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions 
-{
-    public class MapTests_ValueTask : MapTestsBase 
-    {
-        [Fact]
-        public async Task Map_ValueTask_executes_on_success_returns_new_success()
-        {
-            ValueTask<Result> result = Result.Success().AsValueTask();
-            Result<K> actual = await result.Map(ValueTask_Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_executes_on_failure_returns_new_failure()
-        {
-            ValueTask<Result> result = Result.Failure(ErrorMessage).AsValueTask();
-            Result<K> actual = await result.Map(ValueTask_Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_T_executes_on_success_returns_new_success()
-        {
-            ValueTask<Result<T>> result = Result.Success(T.Value).AsValueTask();
-            Result<K> actual = await result.Map(ValueTask_Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_T_executes_on_failure_returns_new_failure()
-        {
-            ValueTask<Result<T>> result = Result.Failure<T>(ErrorMessage).AsValueTask();
-            Result<K> actual = await result.Map(ValueTask_Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_T_E_executes_on_success_returns_new_success()
-        {
-            ValueTask<Result<T, E>> result = Result.Success<T, E>(T.Value).AsValueTask();
-            Result<K, E> actual = await result.Map(ValueTask_Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_T_E_executes_on_failure_returns_new_failure()
-        {
-            ValueTask<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsValueTask();
-            Result<K, E> actual = await result.Map(ValueTask_Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_UnitResult_E_executes_on_success_returns_success()
-        {
-            ValueTask<UnitResult<E>> result = UnitResult.Success<E>().AsValueTask();
-            Result<K, E> actual = await result.Map(ValueTask_Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_UnitResult_E_executes_on_failure_returns_failure()
-        {
-            ValueTask<UnitResult<E>> result = UnitResult.Failure(E.Value).AsValueTask();
-            Result<K, E> actual = await result.Map(ValueTask_Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-    }
-}
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapTests_ValueTask : MapTestsBase
+    {
+        [Fact]
+        public async Task Map_ValueTask_executes_on_success_returns_new_success()
+        {
+            ValueTask<Result> result = Result.Success().AsValueTask();
+            Result<K> actual = await result.Map(ValueTask_Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_executes_on_failure_returns_new_failure()
+        {
+            ValueTask<Result> result = Result.Failure(ErrorMessage).AsValueTask();
+            Result<K> actual = await result.Map(ValueTask_Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_T_executes_on_success_returns_new_success()
+        {
+            ValueTask<Result<T>> result = Result.Success(T.Value).AsValueTask();
+            Result<K> actual = await result.Map(ValueTask_Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_T_executes_on_failure_returns_new_failure()
+        {
+            ValueTask<Result<T>> result = Result.Failure<T>(ErrorMessage).AsValueTask();
+            Result<K> actual = await result.Map(ValueTask_Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_T_E_executes_on_success_returns_new_success()
+        {
+            ValueTask<Result<T, E>> result = Result.Success<T, E>(T.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(ValueTask_Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_T_E_executes_on_failure_returns_new_failure()
+        {
+            ValueTask<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(ValueTask_Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_UnitResult_E_executes_on_success_returns_success()
+        {
+            ValueTask<UnitResult<E>> result = UnitResult.Success<E>().AsValueTask();
+            Result<K, E> actual = await result.Map(ValueTask_Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_UnitResult_E_executes_on_failure_returns_failure()
+        {
+            ValueTask<UnitResult<E>> result = UnitResult.Failure(E.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(ValueTask_Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_with_context_executes_on_success_and_passes_correct_context()
+        {
+            ValueTask<Result> result = Result.Success().AsValueTask();
+            Result<K> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            ValueTask<Result> result = Result.Failure(ErrorMessage).AsValueTask();
+            Result<K> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_T_with_context_executes_on_success_and_passes_correct_context()
+        {
+            ValueTask<Result<T>> result = Result.Success(T.Value).AsValueTask();
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_T_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            ValueTask<Result<T>> result = Result.Failure<T>(ErrorMessage).AsValueTask();
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_T_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            ValueTask<Result<T, E>> result = Result.Success<T, E>(T.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_T_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            ValueTask<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            ValueTask<UnitResult<E>> result = UnitResult.Success<E>().AsValueTask();
+            Result<K, E> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            ValueTask<UnitResult<E>> result = UnitResult.Failure(E.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.cs
index ed5f2684..c65bb66b 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.cs
@@ -1,95 +1,238 @@
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapTests : MapTestsBase
-    {
-        [Fact]
-        public void Map_executes_on_success_returns_new_success()
-        {
-            Result result = Result.Success();
-            Result<K> actual = result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public void Map_executes_on_failure_returns_new_failure()
-        {
-            Result result = Result.Failure(ErrorMessage);
-            Result<K> actual = result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public void Map_T_executes_on_success_returns_new_success()
-        {
-            Result<T> result = Result.Success(T.Value);
-            Result<K> actual = result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public void Map_T_executes_on_failure_returns_new_failure()
-        {
-            Result<T> result = Result.Failure<T>(ErrorMessage);
-            Result<K> actual = result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public void Map_T_E_executes_on_success_returns_new_success()
-        {
-            Result<T, E> result = Result.Success<T, E>(T.Value);
-            Result<K, E> actual = result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public void Map_T_E_executes_on_failure_returns_new_failure()
-        {
-            Result<T, E> result = Result.Failure<T, E>(E.Value);
-            Result<K, E> actual = result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public void Map_UnitResult_E_executes_on_success_returns_success()
-        {
-            UnitResult<E> result = UnitResult.Success<E>();
-            Result<K, E> actual = result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public void Map_UnitResult_E_executes_on_failure_returns_new_failure()
-        {
-            UnitResult<E> result = UnitResult.Failure(E.Value);
-            Result<K, E> actual = result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-    }
-}
\ No newline at end of file
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapTests : MapTestsBase
+    {
+        [Fact]
+        public void Map_executes_on_success_returns_new_success()
+        {
+            Result result = Result.Success();
+            Result<K> actual = result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public void Map_executes_on_failure_returns_new_failure()
+        {
+            Result result = Result.Failure(ErrorMessage);
+            Result<K> actual = result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Map_T_executes_on_success_returns_new_success()
+        {
+            Result<T> result = Result.Success(T.Value);
+            Result<K> actual = result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public void Map_T_executes_on_failure_returns_new_failure()
+        {
+            Result<T> result = Result.Failure<T>(ErrorMessage);
+            Result<K> actual = result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Map_T_E_executes_on_success_returns_new_success()
+        {
+            Result<T, E> result = Result.Success<T, E>(T.Value);
+            Result<K, E> actual = result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public void Map_T_E_executes_on_failure_returns_new_failure()
+        {
+            Result<T, E> result = Result.Failure<T, E>(E.Value);
+            Result<K, E> actual = result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Map_UnitResult_E_executes_on_success_returns_success()
+        {
+            UnitResult<E> result = UnitResult.Success<E>();
+            Result<K, E> actual = result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public void Map_UnitResult_E_executes_on_failure_returns_new_failure()
+        {
+            UnitResult<E> result = UnitResult.Failure(E.Value);
+            Result<K, E> actual = result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Map_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Result result = Result.Success();
+            Result<K> actual = result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public void Map_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Result result = Result.Failure(ErrorMessage);
+            Result<K> actual = result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Map_T_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Result<T> result = Result.Success(T.Value);
+            Result<K> actual = result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public void Map_T_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Result<T> result = Result.Failure<T>(ErrorMessage);
+            Result<K> actual = result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Map_T_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Result<T, E> result = Result.Success<T, E>(T.Value);
+            Result<K, E> actual = result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public void Map_T_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Result<T, E> result = Result.Failure<T, E>(E.Value);
+            Result<K, E> actual = result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Map_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            UnitResult<E> result = UnitResult.Success<E>();
+            Result<K, E> actual = result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public void Map_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            UnitResult<E> result = UnitResult.Failure(E.Value);
+            Result<K, E> actual = result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.Left.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.Left.cs
index 71728a13..2589cbef 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.Left.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.Left.cs
@@ -1,44 +1,105 @@
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions
-{
-    public static partial class AsyncResultExtensionsLeftOperand
-    {
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K, E>> Map<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, K> func)
-        {
-            Result<T, E> result = await resultTask.DefaultAwait();
-            return result.Map(func);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K, E>> Map<K, E>(this Task<UnitResult<E>> resultTask, Func<K> func) 
-        {
-            UnitResult<E> result = await resultTask.DefaultAwait();
-            return result.Map(func);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<T, K>(this Task<Result<T>> resultTask, Func<T, K> func)
-        {
-            Result<T> result = await resultTask.DefaultAwait();
-            return result.Map(func);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<K>(this Task<Result> resultTask, Func<K> func)
-        {
-            Result result = await resultTask.DefaultAwait();
-            return result.Map(func);
-        }
-    }
-}
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class AsyncResultExtensionsLeftOperand
+    {
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<T, K, E>(
+            this Task<Result<T, E>> resultTask,
+            Func<T, K> func
+        )
+        {
+            Result<T, E> result = await resultTask.DefaultAwait();
+            return result.Map(func);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<T, K, E, TContext>(
+            this Task<Result<T, E>> resultTask,
+            Func<T, TContext, K> func,
+            TContext context
+        )
+        {
+            Result<T, E> result = await resultTask.DefaultAwait();
+            return result.Map(func, context);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<K, E>(
+            this Task<UnitResult<E>> resultTask,
+            Func<K> func
+        )
+        {
+            UnitResult<E> result = await resultTask.DefaultAwait();
+            return result.Map(func);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<K, E, TContext>(
+            this Task<UnitResult<E>> resultTask,
+            Func<TContext, K> func,
+            TContext context
+        )
+        {
+            UnitResult<E> result = await resultTask.DefaultAwait();
+            return result.Map(func, context);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<T, K>(
+            this Task<Result<T>> resultTask,
+            Func<T, K> func
+        )
+        {
+            Result<T> result = await resultTask.DefaultAwait();
+            return result.Map(func);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<T, K, TContext>(
+            this Task<Result<T>> resultTask,
+            Func<T, TContext, K> func,
+            TContext context
+        )
+        {
+            Result<T> result = await resultTask.DefaultAwait();
+            return result.Map(func, context);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<K>(this Task<Result> resultTask, Func<K> func)
+        {
+            Result result = await resultTask.DefaultAwait();
+            return result.Map(func);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<K, TContext>(
+            this Task<Result> resultTask,
+            Func<TContext, K> func,
+            TContext context
+        )
+        {
+            Result result = await resultTask.DefaultAwait();
+            return result.Map(func, context);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.Right.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.Right.cs
index 514e3f59..235dd11f 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.Right.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.Right.cs
@@ -1,72 +1,165 @@
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions
-{
-    public static partial class AsyncResultExtensionsRightOperand
-    {
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K, E>> Map<T, K, E>(this Result<T, E> result, Func<T, Task<K>> func)
-        {
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await func(result.Value).DefaultAwait();
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K, E>> Map<K, E>(this UnitResult<E> result, Func<Task<K>> func) 
-        {
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await func().DefaultAwait();
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<T, K>(this Result<T> result, Func<T, Task<K>> func)
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await func(result.Value).DefaultAwait();
-
-            return Result.Success(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<T, K>(this Result<T> result, Func<T, Task<Result<K>>> func)
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            Result<K> value = await func(result.Value).DefaultAwait();
-            return value;
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<K>(this Result result, Func<Task<K>> func)
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await func().DefaultAwait();
-
-            return Result.Success(value);
-        }
-    }
-}
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class AsyncResultExtensionsRightOperand
+    {
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<T, K, E>(
+            this Result<T, E> result,
+            Func<T, Task<K>> func
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await func(result.Value).DefaultAwait();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<T, K, E, TContext>(
+            this Result<T, E> result,
+            Func<T, TContext, Task<K>> func,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await func(result.Value, context).DefaultAwait();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<K, E>(
+            this UnitResult<E> result,
+            Func<Task<K>> func
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await func().DefaultAwait();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<K, E, TContext>(
+            this UnitResult<E> result,
+            Func<TContext, Task<K>> func,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await func(context).DefaultAwait();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<T, K>(this Result<T> result, Func<T, Task<K>> func)
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await func(result.Value).DefaultAwait();
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<T, K, TContext>(
+            this Result<T> result,
+            Func<T, TContext, Task<K>> func,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await func(result.Value, context).DefaultAwait();
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<T, K>(
+            this Result<T> result,
+            Func<T, Task<Result<K>>> func
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            Result<K> value = await func(result.Value).DefaultAwait();
+            return value;
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<T, K, TContext>(
+            this Result<T> result,
+            Func<T, TContext, Task<Result<K>>> func,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            Result<K> value = await func(result.Value, context).DefaultAwait();
+            return value;
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<K>(this Result result, Func<Task<K>> func)
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await func().DefaultAwait();
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<K, TContext>(
+            this Result result,
+            Func<TContext, Task<K>> func,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await func(context).DefaultAwait();
+
+            return Result.Success(value);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.cs
index 58c9d598..7d791014 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.cs
@@ -1,68 +1,153 @@
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions
-{
-    public static partial class AsyncResultExtensionsBothOperands
-    {
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K, E>> Map<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, Task<K>> func)
-        {
-            Result<T, E> result = await resultTask.DefaultAwait();
-
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await func(result.Value).DefaultAwait();
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K, E>> Map<K, E>(this Task<UnitResult<E>> resultTask, Func<Task<K>> func) 
-        {
-            UnitResult<E> result = await resultTask.DefaultAwait();
-
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await func().DefaultAwait();
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<T, K>(this Task<Result<T>> resultTask, Func<T, Task<K>> func)
-        {
-            Result<T> result = await resultTask.DefaultAwait();
-
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await func(result.Value).DefaultAwait();
-
-            return Result.Success(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<K>(this Task<Result> resultTask, Func<Task<K>> func)
-        {
-            Result result = await resultTask.DefaultAwait();
-
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await func().DefaultAwait();
-
-            return Result.Success(value);
-        }
-    }
-}
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class AsyncResultExtensionsBothOperands
+    {
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<T, K, E>(
+            this Task<Result<T, E>> resultTask,
+            Func<T, Task<K>> func
+        )
+        {
+            Result<T, E> result = await resultTask.DefaultAwait();
+
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await func(result.Value).DefaultAwait();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<T, K, E, TContext>(
+            this Task<Result<T, E>> resultTask,
+            Func<T, TContext, Task<K>> func,
+            TContext context
+        )
+        {
+            Result<T, E> result = await resultTask.DefaultAwait();
+
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await func(result.Value, context).DefaultAwait();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<K, E>(
+            this Task<UnitResult<E>> resultTask,
+            Func<Task<K>> func
+        )
+        {
+            UnitResult<E> result = await resultTask.DefaultAwait();
+
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await func().DefaultAwait();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<K, E, TContext>(
+            this Task<UnitResult<E>> resultTask,
+            Func<TContext, Task<K>> func,
+            TContext context
+        )
+        {
+            UnitResult<E> result = await resultTask.DefaultAwait();
+
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await func(context).DefaultAwait();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<T, K>(
+            this Task<Result<T>> resultTask,
+            Func<T, Task<K>> func
+        )
+        {
+            Result<T> result = await resultTask.DefaultAwait();
+
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await func(result.Value).DefaultAwait();
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<T, K, TContext>(
+            this Task<Result<T>> resultTask,
+            Func<T, TContext, Task<K>> func,
+            TContext context
+        )
+        {
+            Result<T> result = await resultTask.DefaultAwait();
+
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await func(result.Value, context).DefaultAwait();
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<K>(this Task<Result> resultTask, Func<Task<K>> func)
+        {
+            Result result = await resultTask.DefaultAwait();
+
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await func().DefaultAwait();
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<K, TContext>(
+            this Task<Result> resultTask,
+            Func<TContext, Task<K>> func,
+            TContext context
+        )
+        {
+            Result result = await resultTask.DefaultAwait();
+
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await func(context).DefaultAwait();
+
+            return Result.Success(value);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.Left.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.Left.cs
index 2e96dd35..c1f802cb 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.Left.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.Left.cs
@@ -1,46 +1,110 @@
-#if NET5_0_OR_GREATER
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions.ValueTasks
-{
-    public static partial class AsyncResultExtensionsLeftOperand
-    {
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K, E>> Map<T, K, E>(this ValueTask<Result<T, E>> resultTask, Func<T, K> valueTask)
-        {
-            Result<T, E> result = await resultTask;
-            return result.Map(valueTask);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K, E>> Map<K, E>(this ValueTask<UnitResult<E>> resultTask, Func<K> valueTask) 
-        {
-            UnitResult<E> result = await resultTask;
-            return result.Map(valueTask);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<T, K>(this ValueTask<Result<T>> resultTask, Func<T, K> valueTask)
-        {
-            Result<T> result = await resultTask;
-            return result.Map(valueTask);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<K>(this ValueTask<Result> resultTask, Func<K> valueTask)
-        {
-            Result result = await resultTask;
-            return result.Map(valueTask);
-        }
-    }
-}
-#endif
\ No newline at end of file
+#if NET5_0_OR_GREATER
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.ValueTasks
+{
+    public static partial class AsyncResultExtensionsLeftOperand
+    {
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<T, K, E>(
+            this ValueTask<Result<T, E>> resultTask,
+            Func<T, K> valueTask
+        )
+        {
+            Result<T, E> result = await resultTask;
+            return result.Map(valueTask);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<T, K, E, TContext>(
+            this ValueTask<Result<T, E>> resultTask,
+            Func<T, TContext, K> valueTask,
+            TContext context
+        )
+        {
+            Result<T, E> result = await resultTask;
+            return result.Map(valueTask, context);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<K, E>(
+            this ValueTask<UnitResult<E>> resultTask,
+            Func<K> valueTask
+        )
+        {
+            UnitResult<E> result = await resultTask;
+            return result.Map(valueTask);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<K, E, TContext>(
+            this ValueTask<UnitResult<E>> resultTask,
+            Func<TContext, K> valueTask,
+            TContext context
+        )
+        {
+            UnitResult<E> result = await resultTask;
+            return result.Map(valueTask, context);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<T, K>(
+            this ValueTask<Result<T>> resultTask,
+            Func<T, K> valueTask
+        )
+        {
+            Result<T> result = await resultTask;
+            return result.Map(valueTask);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<T, K, TContext>(
+            this ValueTask<Result<T>> resultTask,
+            Func<T, TContext, K> valueTask,
+            TContext context
+        )
+        {
+            Result<T> result = await resultTask;
+            return result.Map(valueTask, context);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<K>(
+            this ValueTask<Result> resultTask,
+            Func<K> valueTask
+        )
+        {
+            Result result = await resultTask;
+            return result.Map(valueTask);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<K, TContext>(
+            this ValueTask<Result> resultTask,
+            Func<TContext, K> valueTask,
+            TContext context
+        )
+        {
+            Result result = await resultTask;
+            return result.Map(valueTask, context);
+        }
+    }
+}
+#endif
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.Right.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.Right.cs
index d94568d9..b300e4a5 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.Right.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.Right.cs
@@ -1,74 +1,173 @@
-#if NET5_0_OR_GREATER
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions.ValueTasks
-{
-    public static partial class AsyncResultExtensionsRightOperand
-    {
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K, E>> Map<T, K, E>(this Result<T, E> result, Func<T, ValueTask<K>> valueTask)
-        {
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await valueTask(result.Value);
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K, E>> Map<K, E>(this UnitResult<E> result, Func<ValueTask<K>> valueTask) 
-        {
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await valueTask();
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<T, K>(this Result<T> result, Func<T, ValueTask<K>> valueTask)
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await valueTask(result.Value);
-
-            return Result.Success(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<T, K>(this Result<T> result, Func<T, ValueTask<Result<K>>> valueTask)
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            Result<K> value = await valueTask(result.Value);
-            return value;
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<K>(this Result result, Func<ValueTask<K>> valueTask)
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await valueTask();
-
-            return Result.Success(value);
-        }
-    }
-}
-#endif
+#if NET5_0_OR_GREATER
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.ValueTasks
+{
+    public static partial class AsyncResultExtensionsRightOperand
+    {
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<T, K, E>(
+            this Result<T, E> result,
+            Func<T, ValueTask<K>> valueTask
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await valueTask(result.Value);
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<T, K, E, TContext>(
+            this Result<T, E> result,
+            Func<T, TContext, ValueTask<K>> valueTask,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await valueTask(result.Value, context);
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<K, E>(
+            this UnitResult<E> result,
+            Func<ValueTask<K>> valueTask
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await valueTask();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<K, E, TContext>(
+            this UnitResult<E> result,
+            Func<TContext, ValueTask<K>> valueTask,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await valueTask(context);
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<T, K>(
+            this Result<T> result,
+            Func<T, ValueTask<K>> valueTask
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await valueTask(result.Value);
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<T, K, TContext>(
+            this Result<T> result,
+            Func<T, TContext, ValueTask<K>> valueTask,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await valueTask(result.Value, context);
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<T, K>(
+            this Result<T> result,
+            Func<T, ValueTask<Result<K>>> valueTask
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            Result<K> value = await valueTask(result.Value);
+            return value;
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<T, K, TContext>(
+            this Result<T> result,
+            Func<T, TContext, ValueTask<Result<K>>> valueTask,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            Result<K> value = await valueTask(result.Value, context);
+            return value;
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<K>(
+            this Result result,
+            Func<ValueTask<K>> valueTask
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await valueTask();
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<K, TContext>(
+            this Result result,
+            Func<TContext, ValueTask<K>> valueTask,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await valueTask(context);
+
+            return Result.Success(value);
+        }
+    }
+}
+#endif
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.cs
index defe3357..cbaf6faf 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.cs
@@ -1,70 +1,158 @@
-#if NET5_0_OR_GREATER
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions.ValueTasks
-{
-    public static partial class AsyncResultExtensionsBothOperands
-    {
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K, E>> Map<T, K, E>(this ValueTask<Result<T, E>> resultTask, Func<T, ValueTask<K>> valueTask)
-        {
-            Result<T, E> result = await resultTask;
-
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await valueTask(result.Value);
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K, E>> Map<K, E>(this ValueTask<UnitResult<E>> resultTask, Func<ValueTask<K>> valueTask) 
-        {
-            UnitResult<E> result = await resultTask;
-
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await valueTask();
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<T, K>(this ValueTask<Result<T>> resultTask, Func<T, ValueTask<K>> valueTask)
-        {
-            Result<T> result = await resultTask;
-
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await valueTask(result.Value);
-
-            return Result.Success(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<K>(this ValueTask<Result> resultTask, Func<ValueTask<K>> valueTask)
-        {
-            Result result = await resultTask;
-
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await valueTask();
-
-            return Result.Success(value);
-        }
-    }
-}
-#endif
+#if NET5_0_OR_GREATER
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.ValueTasks
+{
+    public static partial class AsyncResultExtensionsBothOperands
+    {
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<T, K, E>(
+            this ValueTask<Result<T, E>> resultTask,
+            Func<T, ValueTask<K>> valueTask
+        )
+        {
+            Result<T, E> result = await resultTask;
+
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await valueTask(result.Value);
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<T, K, E, TContext>(
+            this ValueTask<Result<T, E>> resultTask,
+            Func<T, TContext, ValueTask<K>> valueTask,
+            TContext context
+        )
+        {
+            Result<T, E> result = await resultTask;
+
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await valueTask(result.Value, context);
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<K, E>(
+            this ValueTask<UnitResult<E>> resultTask,
+            Func<ValueTask<K>> valueTask
+        )
+        {
+            UnitResult<E> result = await resultTask;
+
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await valueTask();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<K, E, TContext>(
+            this ValueTask<UnitResult<E>> resultTask,
+            Func<TContext, ValueTask<K>> valueTask,
+            TContext context
+        )
+        {
+            UnitResult<E> result = await resultTask;
+
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await valueTask(context);
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<T, K>(
+            this ValueTask<Result<T>> resultTask,
+            Func<T, ValueTask<K>> valueTask
+        )
+        {
+            Result<T> result = await resultTask;
+
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await valueTask(result.Value);
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<T, K, TContext>(
+            this ValueTask<Result<T>> resultTask,
+            Func<T, TContext, ValueTask<K>> valueTask,
+            TContext context
+        )
+        {
+            Result<T> result = await resultTask;
+
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await valueTask(result.Value, context);
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<K>(
+            this ValueTask<Result> resultTask,
+            Func<ValueTask<K>> valueTask
+        )
+        {
+            Result result = await resultTask;
+
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await valueTask();
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<K, TContext>(
+            this ValueTask<Result> resultTask,
+            Func<TContext, ValueTask<K>> valueTask,
+            TContext context
+        )
+        {
+            Result result = await resultTask;
+
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await valueTask(context);
+
+            return Result.Success(value);
+        }
+    }
+}
+#endif
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.cs
index 4cdf21a2..ac35c18e 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.cs
@@ -1,51 +1,111 @@
-using System;
-
-namespace CSharpFunctionalExtensions
-{
-    public static partial class ResultExtensions
-    {
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static Result<K, E> Map<T, K, E>(this Result<T, E> result, Func<T, K> func)
-        {
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            return Result.Success<K, E>(func(result.Value));
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static Result<K, E> Map<K, E>(this UnitResult<E> result, Func<K> func) 
-        {
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            return Result.Success<K, E>(func());
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static Result<K> Map<T, K>(this Result<T> result, Func<T, K> func)
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            return Result.Success(func(result.Value));
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static Result<K> Map<K>(this Result result, Func<K> func)
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            return Result.Success(func());
-        }
-    }
-}
+using System;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class ResultExtensions
+    {
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<K, E> Map<T, K, E>(this Result<T, E> result, Func<T, K> func)
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            return Result.Success<K, E>(func(result.Value));
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<K, E> Map<T, K, E, TContext>(
+            this Result<T, E> result,
+            Func<T, TContext, K> func,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            return Result.Success<K, E>(func(result.Value, context));
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<K, E> Map<K, E>(this UnitResult<E> result, Func<K> func)
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            return Result.Success<K, E>(func());
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<K, E> Map<K, E, TContext>(
+            this UnitResult<E> result,
+            Func<TContext, K> func,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            return Result.Success<K, E>(func(context));
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<K> Map<T, K>(this Result<T> result, Func<T, K> func)
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            return Result.Success(func(result.Value));
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<K> Map<T, K, TContext>(
+            this Result<T> result,
+            Func<T, TContext, K> func,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            return Result.Success(func(result.Value, context));
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<K> Map<K>(this Result result, Func<K> func)
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            return Result.Success(func());
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<K> Map<K, TContext>(
+            this Result result,
+            Func<TContext, K> func,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            return Result.Success(func(context));
+        }
+    }
+}

From e2089b948ca940ed4a08390b5cbd01d6c17bdd30 Mon Sep 17 00:00:00 2001
From: Marcin Jahn <10273406+marcinjahn@users.noreply.github.com>
Date: Sat, 23 Nov 2024 08:47:05 +0100
Subject: [PATCH 2/4] Restore line endings

---
 .../ResultTests/Extensions/MapTests.Base.cs   |  72 +--
 .../Extensions/MapTests.Task.Left.cs          | 478 ++++++++---------
 .../Extensions/MapTests.Task.Right.cs         | 478 ++++++++---------
 .../ResultTests/Extensions/MapTests.Task.cs   | 478 ++++++++---------
 .../Extensions/MapTests.ValueTask.Left.cs     | 480 +++++++++---------
 .../Extensions/MapTests.ValueTask.Right.cs    | 480 +++++++++---------
 .../Extensions/MapTests.ValueTask.cs          | 480 +++++++++---------
 .../ResultTests/Extensions/MapTests.cs        | 476 ++++++++---------
 .../Methods/Extensions/Map.Task.Left.cs       | 210 ++++----
 .../Methods/Extensions/Map.Task.Right.cs      | 330 ++++++------
 .../Result/Methods/Extensions/Map.Task.cs     | 306 +++++------
 .../Methods/Extensions/Map.ValueTask.Left.cs  | 220 ++++----
 .../Methods/Extensions/Map.ValueTask.Right.cs | 346 ++++++-------
 .../Methods/Extensions/Map.ValueTask.cs       | 316 ++++++------
 .../Result/Methods/Extensions/Map.cs          | 222 ++++----
 15 files changed, 2686 insertions(+), 2686 deletions(-)

diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Base.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Base.cs
index 325a04bc..713f70d1 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Base.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Base.cs
@@ -1,36 +1,36 @@
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public abstract class MapTestsBase : TestBase
-    {
-        protected bool FuncExecuted;
-
-        protected MapTestsBase()
-        {
-            FuncExecuted = false;
-        }
-
-        protected K Func_K()
-        {
-            FuncExecuted = true;
-            return K.Value;
-        }
-
-        protected K Func_T_K(T value)
-        {
-            FuncExecuted = true;
-            return K.Value;
-        }
-
-        protected Task<K> Task_Func_K() => Func_K().AsTask();
-
-        protected Task<K> Task_Func_T_K(T value) => Func_T_K(value).AsTask();
-
-        protected ValueTask<K> ValueTask_Func_K() => Func_K().AsValueTask();
-
-        protected ValueTask<K> ValueTask_Func_T_K(T value) => Func_T_K(value).AsValueTask();
-
-        protected readonly string ContextMessage = "Context data";
-    }
-}
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public abstract class MapTestsBase : TestBase
+    {
+        protected bool FuncExecuted;
+
+        protected MapTestsBase()
+        {
+            FuncExecuted = false;
+        }
+
+        protected K Func_K()
+        {
+            FuncExecuted = true;
+            return K.Value;
+        }
+
+        protected K Func_T_K(T value)
+        {
+            FuncExecuted = true;
+            return K.Value;
+        }
+
+        protected Task<K> Task_Func_K() => Func_K().AsTask();
+
+        protected Task<K> Task_Func_T_K(T value) => Func_T_K(value).AsTask();
+
+        protected ValueTask<K> ValueTask_Func_K() => Func_K().AsValueTask();
+
+        protected ValueTask<K> ValueTask_Func_T_K(T value) => Func_T_K(value).AsValueTask();
+
+        protected readonly string ContextMessage = "Context data";
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.Left.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.Left.cs
index 893d975b..d2b302d7 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.Left.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.Left.cs
@@ -1,239 +1,239 @@
-using System.Threading.Tasks;
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapTests_Task_Left : MapTestsBase
-    {
-        [Fact]
-        public async Task Map_Task_Left_executes_on_success_returns_new_success()
-        {
-            Task<Result> result = Result.Success().AsTask();
-            Result<K> actual = await result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_executes_on_failure_returns_new_failure()
-        {
-            Task<Result> result = Result.Failure(ErrorMessage).AsTask();
-            Result<K> actual = await result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_T_executes_on_success_returns_new_success()
-        {
-            Task<Result<T>> result = Result.Success(T.Value).AsTask();
-            Result<K> actual = await result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_T_executes_on_failure_returns_new_failure()
-        {
-            Task<Result<T>> result = Result.Failure<T>(ErrorMessage).AsTask();
-            Result<K> actual = await result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_T_E_executes_on_success_returns_new_success()
-        {
-            Task<Result<T, E>> result = Result.Success<T, E>(T.Value).AsTask();
-            Result<K, E> actual = await result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_T_E_executes_on_failure_returns_new_failure()
-        {
-            Task<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsTask();
-            Result<K, E> actual = await result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_UnitResult_E_executes_on_success_returns_success()
-        {
-            Task<UnitResult<E>> result = UnitResult.Success<E>().AsTask();
-            Result<K, E> actual = await result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_UnitResult_E_executes_on_failure_returns_failure()
-        {
-            Task<UnitResult<E>> result = UnitResult.Failure(E.Value).AsTask();
-            Result<K, E> actual = await result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_with_context_executes_on_success_and_passes_correct_context()
-        {
-            Task<Result> result = Result.Success().AsTask();
-            Result<K> actual = await result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            Task<Result> result = Result.Failure(ErrorMessage).AsTask();
-            Result<K> actual = await result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_T_with_context_executes_on_success_and_passes_correct_context()
-        {
-            Task<Result<T>> result = Result.Success(T.Value).AsTask();
-            Result<K> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_T_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            Task<Result<T>> result = Result.Failure<T>(ErrorMessage).AsTask();
-            Result<K> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_T_E_with_context_executes_on_success_and_passes_correct_context()
-        {
-            Task<Result<T, E>> result = Result.Success<T, E>(T.Value).AsTask();
-            Result<K, E> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_T_E_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            Task<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsTask();
-            Result<K, E> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
-        {
-            Task<UnitResult<E>> result = UnitResult.Success<E>().AsTask();
-            Result<K, E> actual = await result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Left_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            Task<UnitResult<E>> result = UnitResult.Failure(E.Value).AsTask();
-            Result<K, E> actual = await result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-    }
-}
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapTests_Task_Left : MapTestsBase
+    {
+        [Fact]
+        public async Task Map_Task_Left_executes_on_success_returns_new_success()
+        {
+            Task<Result> result = Result.Success().AsTask();
+            Result<K> actual = await result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_executes_on_failure_returns_new_failure()
+        {
+            Task<Result> result = Result.Failure(ErrorMessage).AsTask();
+            Result<K> actual = await result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_T_executes_on_success_returns_new_success()
+        {
+            Task<Result<T>> result = Result.Success(T.Value).AsTask();
+            Result<K> actual = await result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_T_executes_on_failure_returns_new_failure()
+        {
+            Task<Result<T>> result = Result.Failure<T>(ErrorMessage).AsTask();
+            Result<K> actual = await result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_T_E_executes_on_success_returns_new_success()
+        {
+            Task<Result<T, E>> result = Result.Success<T, E>(T.Value).AsTask();
+            Result<K, E> actual = await result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_T_E_executes_on_failure_returns_new_failure()
+        {
+            Task<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsTask();
+            Result<K, E> actual = await result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_UnitResult_E_executes_on_success_returns_success()
+        {
+            Task<UnitResult<E>> result = UnitResult.Success<E>().AsTask();
+            Result<K, E> actual = await result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_UnitResult_E_executes_on_failure_returns_failure()
+        {
+            Task<UnitResult<E>> result = UnitResult.Failure(E.Value).AsTask();
+            Result<K, E> actual = await result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Task<Result> result = Result.Success().AsTask();
+            Result<K> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Task<Result> result = Result.Failure(ErrorMessage).AsTask();
+            Result<K> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_T_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Task<Result<T>> result = Result.Success(T.Value).AsTask();
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_T_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Task<Result<T>> result = Result.Failure<T>(ErrorMessage).AsTask();
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_T_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Task<Result<T, E>> result = Result.Success<T, E>(T.Value).AsTask();
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_T_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Task<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsTask();
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Task<UnitResult<E>> result = UnitResult.Success<E>().AsTask();
+            Result<K, E> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Left_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Task<UnitResult<E>> result = UnitResult.Failure(E.Value).AsTask();
+            Result<K, E> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.Right.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.Right.cs
index e767cd2a..4802cee9 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.Right.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.Right.cs
@@ -1,239 +1,239 @@
-using System.Threading.Tasks;
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapTests_Task_Right : MapTestsBase
-    {
-        [Fact]
-        public async Task Map_Task_Right_executes_on_success_returns_new_success()
-        {
-            Result result = Result.Success();
-            Result<K> actual = await result.Map(Task_Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_executes_on_failure_returns_new_failure()
-        {
-            Result result = Result.Failure(ErrorMessage);
-            Result<K> actual = await result.Map(Task_Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_T_executes_on_success_returns_new_success()
-        {
-            Result<T> result = Result.Success(T.Value);
-            Result<K> actual = await result.Map(Task_Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_T_executes_on_failure_returns_new_failure()
-        {
-            Result<T> result = Result.Failure<T>(ErrorMessage);
-            Result<K> actual = await result.Map(Task_Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_T_E_executes_on_success_returns_new_success()
-        {
-            Result<T, E> result = Result.Success<T, E>(T.Value);
-            Result<K, E> actual = await result.Map(Task_Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_T_E_executes_on_failure_returns_new_failure()
-        {
-            Result<T, E> result = Result.Failure<T, E>(E.Value);
-            Result<K, E> actual = await result.Map(Task_Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_UnitResult_E_executes_on_success_returns_success()
-        {
-            UnitResult<E> result = UnitResult.Success<E>();
-            Result<K, E> actual = await result.Map(Task_Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_UnitResult_E_executes_on_failure_returns_failure()
-        {
-            UnitResult<E> result = UnitResult.Failure(E.Value);
-            Result<K, E> actual = await result.Map(Task_Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_with_context_executes_on_success_and_passes_correct_context()
-        {
-            Result result = Result.Success();
-            Result<K> actual = await result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Task_Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            Result result = Result.Failure(ErrorMessage);
-            Result<K> actual = await result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Task_Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_T_with_context_executes_on_success_and_passes_correct_context()
-        {
-            Result<T> result = Result.Success(T.Value);
-            Result<K> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Task_Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_T_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            Result<T> result = Result.Failure<T>(ErrorMessage);
-            Result<K> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Task_Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_T_E_with_context_executes_on_success_and_passes_correct_context()
-        {
-            Result<T, E> result = Result.Success<T, E>(T.Value);
-            Result<K, E> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Task_Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_T_E_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            Result<T, E> result = Result.Failure<T, E>(E.Value);
-            Result<K, E> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Task_Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
-        {
-            UnitResult<E> result = UnitResult.Success<E>();
-            Result<K, E> actual = await result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Task_Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_Right_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            UnitResult<E> result = UnitResult.Failure(E.Value);
-            Result<K, E> actual = await result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Task_Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-    }
-}
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapTests_Task_Right : MapTestsBase
+    {
+        [Fact]
+        public async Task Map_Task_Right_executes_on_success_returns_new_success()
+        {
+            Result result = Result.Success();
+            Result<K> actual = await result.Map(Task_Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_executes_on_failure_returns_new_failure()
+        {
+            Result result = Result.Failure(ErrorMessage);
+            Result<K> actual = await result.Map(Task_Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_T_executes_on_success_returns_new_success()
+        {
+            Result<T> result = Result.Success(T.Value);
+            Result<K> actual = await result.Map(Task_Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_T_executes_on_failure_returns_new_failure()
+        {
+            Result<T> result = Result.Failure<T>(ErrorMessage);
+            Result<K> actual = await result.Map(Task_Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_T_E_executes_on_success_returns_new_success()
+        {
+            Result<T, E> result = Result.Success<T, E>(T.Value);
+            Result<K, E> actual = await result.Map(Task_Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_T_E_executes_on_failure_returns_new_failure()
+        {
+            Result<T, E> result = Result.Failure<T, E>(E.Value);
+            Result<K, E> actual = await result.Map(Task_Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_UnitResult_E_executes_on_success_returns_success()
+        {
+            UnitResult<E> result = UnitResult.Success<E>();
+            Result<K, E> actual = await result.Map(Task_Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_UnitResult_E_executes_on_failure_returns_failure()
+        {
+            UnitResult<E> result = UnitResult.Failure(E.Value);
+            Result<K, E> actual = await result.Map(Task_Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Result result = Result.Success();
+            Result<K> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Result result = Result.Failure(ErrorMessage);
+            Result<K> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_T_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Result<T> result = Result.Success(T.Value);
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_T_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Result<T> result = Result.Failure<T>(ErrorMessage);
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_T_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Result<T, E> result = Result.Success<T, E>(T.Value);
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_T_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Result<T, E> result = Result.Failure<T, E>(E.Value);
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            UnitResult<E> result = UnitResult.Success<E>();
+            Result<K, E> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_Right_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            UnitResult<E> result = UnitResult.Failure(E.Value);
+            Result<K, E> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.cs
index b3e5f09a..69efd4f1 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.Task.cs
@@ -1,239 +1,239 @@
-using System.Threading.Tasks;
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapTests_Task : MapTestsBase
-    {
-        [Fact]
-        public async Task Map_Task_executes_on_success_returns_new_success()
-        {
-            Task<Result> result = Result.Success().AsTask();
-            Result<K> actual = await result.Map(Task_Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_executes_on_failure_returns_new_failure()
-        {
-            Task<Result> result = Result.Failure(ErrorMessage).AsTask();
-            Result<K> actual = await result.Map(Task_Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_T_executes_on_success_returns_new_success()
-        {
-            Task<Result<T>> result = Result.Success(T.Value).AsTask();
-            Result<K> actual = await result.Map(Task_Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_T_executes_on_failure_returns_new_failure()
-        {
-            Task<Result<T>> result = Result.Failure<T>(ErrorMessage).AsTask();
-            Result<K> actual = await result.Map(Task_Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_T_E_executes_on_success_returns_new_success()
-        {
-            Task<Result<T, E>> result = Result.Success<T, E>(T.Value).AsTask();
-            Result<K, E> actual = await result.Map(Task_Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_T_E_executes_on_failure_returns_new_failure()
-        {
-            Task<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsTask();
-            Result<K, E> actual = await result.Map(Task_Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_UnitResult_E_executes_on_success_returns_success()
-        {
-            Task<UnitResult<E>> result = UnitResult.Success<E>().AsTask();
-            Result<K, E> actual = await result.Map(Task_Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_UnitResult_E_executes_on_failure_returns_failure()
-        {
-            Task<UnitResult<E>> result = UnitResult.Failure(E.Value).AsTask();
-            Result<K, E> actual = await result.Map(Task_Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_with_context_executes_on_success_and_passes_correct_context()
-        {
-            Task<Result> result = Result.Success().AsTask();
-            Result<K> actual = await result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Task_Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            Task<Result> result = Result.Failure(ErrorMessage).AsTask();
-            Result<K> actual = await result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Task_Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_T_with_context_executes_on_success_and_passes_correct_context()
-        {
-            Task<Result<T>> result = Result.Success(T.Value).AsTask();
-            Result<K> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Task_Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_T_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            Task<Result<T>> result = Result.Failure<T>(ErrorMessage).AsTask();
-            Result<K> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Task_Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_T_E_with_context_executes_on_success_and_passes_correct_context()
-        {
-            Task<Result<T, E>> result = Result.Success<T, E>(T.Value).AsTask();
-            Result<K, E> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Task_Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_T_E_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            Task<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsTask();
-            Result<K, E> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Task_Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_Task_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
-        {
-            Task<UnitResult<E>> result = UnitResult.Success<E>().AsTask();
-            Result<K, E> actual = await result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Task_Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_Task_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            Task<UnitResult<E>> result = UnitResult.Failure(E.Value).AsTask();
-            Result<K, E> actual = await result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Task_Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-    }
-}
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapTests_Task : MapTestsBase
+    {
+        [Fact]
+        public async Task Map_Task_executes_on_success_returns_new_success()
+        {
+            Task<Result> result = Result.Success().AsTask();
+            Result<K> actual = await result.Map(Task_Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_executes_on_failure_returns_new_failure()
+        {
+            Task<Result> result = Result.Failure(ErrorMessage).AsTask();
+            Result<K> actual = await result.Map(Task_Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_T_executes_on_success_returns_new_success()
+        {
+            Task<Result<T>> result = Result.Success(T.Value).AsTask();
+            Result<K> actual = await result.Map(Task_Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_T_executes_on_failure_returns_new_failure()
+        {
+            Task<Result<T>> result = Result.Failure<T>(ErrorMessage).AsTask();
+            Result<K> actual = await result.Map(Task_Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_T_E_executes_on_success_returns_new_success()
+        {
+            Task<Result<T, E>> result = Result.Success<T, E>(T.Value).AsTask();
+            Result<K, E> actual = await result.Map(Task_Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_T_E_executes_on_failure_returns_new_failure()
+        {
+            Task<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsTask();
+            Result<K, E> actual = await result.Map(Task_Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_UnitResult_E_executes_on_success_returns_success()
+        {
+            Task<UnitResult<E>> result = UnitResult.Success<E>().AsTask();
+            Result<K, E> actual = await result.Map(Task_Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_UnitResult_E_executes_on_failure_returns_failure()
+        {
+            Task<UnitResult<E>> result = UnitResult.Failure(E.Value).AsTask();
+            Result<K, E> actual = await result.Map(Task_Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Task<Result> result = Result.Success().AsTask();
+            Result<K> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Task<Result> result = Result.Failure(ErrorMessage).AsTask();
+            Result<K> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_T_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Task<Result<T>> result = Result.Success(T.Value).AsTask();
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_T_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Task<Result<T>> result = Result.Failure<T>(ErrorMessage).AsTask();
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_T_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Task<Result<T, E>> result = Result.Success<T, E>(T.Value).AsTask();
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_T_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Task<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsTask();
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_Task_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Task<UnitResult<E>> result = UnitResult.Success<E>().AsTask();
+            Result<K, E> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_Task_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Task<UnitResult<E>> result = UnitResult.Failure(E.Value).AsTask();
+            Result<K, E> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Task_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.Left.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.Left.cs
index e35aaefd..066c1f5e 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.Left.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.Left.cs
@@ -1,240 +1,240 @@
-using System.Threading.Tasks;
-using CSharpFunctionalExtensions.ValueTasks;
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapTests_ValueTask_Left : MapTestsBase
-    {
-        [Fact]
-        public async Task Map_ValueTask_Left_executes_on_success_returns_new_success()
-        {
-            ValueTask<Result> result = Result.Success().AsValueTask();
-            Result<K> actual = await result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_executes_on_failure_returns_new_failure()
-        {
-            ValueTask<Result> result = Result.Failure(ErrorMessage).AsValueTask();
-            Result<K> actual = await result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_T_executes_on_success_returns_new_success()
-        {
-            ValueTask<Result<T>> result = Result.Success(T.Value).AsValueTask();
-            Result<K> actual = await result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_T_executes_on_failure_returns_new_failure()
-        {
-            ValueTask<Result<T>> result = Result.Failure<T>(ErrorMessage).AsValueTask();
-            Result<K> actual = await result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_T_E_executes_on_success_returns_new_success()
-        {
-            ValueTask<Result<T, E>> result = Result.Success<T, E>(T.Value).AsValueTask();
-            Result<K, E> actual = await result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_T_E_executes_on_failure_returns_new_failure()
-        {
-            ValueTask<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsValueTask();
-            Result<K, E> actual = await result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_UnitResult_E_executes_on_success_returns_success()
-        {
-            ValueTask<UnitResult<E>> result = UnitResult.Success<E>().AsValueTask();
-            Result<K, E> actual = await result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_UnitResult_E_executes_on_failure_returns_failure()
-        {
-            ValueTask<UnitResult<E>> result = UnitResult.Failure(E.Value).AsValueTask();
-            Result<K, E> actual = await result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_with_context_executes_on_success_and_passes_correct_context()
-        {
-            ValueTask<Result> result = Result.Success().AsValueTask();
-            Result<K> actual = await result.Map(
-                context =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            ValueTask<Result> result = Result.Failure(ErrorMessage).AsValueTask();
-            Result<K> actual = await result.Map(
-                context =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_T_with_context_executes_on_success_and_passes_correct_context()
-        {
-            ValueTask<Result<T>> result = Result.Success(T.Value).AsValueTask();
-            Result<K> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_T_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            ValueTask<Result<T>> result = Result.Failure<T>(ErrorMessage).AsValueTask();
-            Result<K> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_T_E_with_context_executes_on_success_and_passes_correct_context()
-        {
-            ValueTask<Result<T, E>> result = Result.Success<T, E>(T.Value).AsValueTask();
-            Result<K, E> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_T_E_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            ValueTask<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsValueTask();
-            Result<K, E> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
-        {
-            ValueTask<UnitResult<E>> result = UnitResult.Success<E>().AsValueTask();
-            Result<K, E> actual = await result.Map(
-                context =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Left_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            ValueTask<UnitResult<E>> result = UnitResult.Failure(E.Value).AsValueTask();
-            Result<K, E> actual = await result.Map(
-                context =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-    }
-}
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapTests_ValueTask_Left : MapTestsBase
+    {
+        [Fact]
+        public async Task Map_ValueTask_Left_executes_on_success_returns_new_success()
+        {
+            ValueTask<Result> result = Result.Success().AsValueTask();
+            Result<K> actual = await result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_executes_on_failure_returns_new_failure()
+        {
+            ValueTask<Result> result = Result.Failure(ErrorMessage).AsValueTask();
+            Result<K> actual = await result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_T_executes_on_success_returns_new_success()
+        {
+            ValueTask<Result<T>> result = Result.Success(T.Value).AsValueTask();
+            Result<K> actual = await result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_T_executes_on_failure_returns_new_failure()
+        {
+            ValueTask<Result<T>> result = Result.Failure<T>(ErrorMessage).AsValueTask();
+            Result<K> actual = await result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_T_E_executes_on_success_returns_new_success()
+        {
+            ValueTask<Result<T, E>> result = Result.Success<T, E>(T.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_T_E_executes_on_failure_returns_new_failure()
+        {
+            ValueTask<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_UnitResult_E_executes_on_success_returns_success()
+        {
+            ValueTask<UnitResult<E>> result = UnitResult.Success<E>().AsValueTask();
+            Result<K, E> actual = await result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_UnitResult_E_executes_on_failure_returns_failure()
+        {
+            ValueTask<UnitResult<E>> result = UnitResult.Failure(E.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_with_context_executes_on_success_and_passes_correct_context()
+        {
+            ValueTask<Result> result = Result.Success().AsValueTask();
+            Result<K> actual = await result.Map(
+                context =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            ValueTask<Result> result = Result.Failure(ErrorMessage).AsValueTask();
+            Result<K> actual = await result.Map(
+                context =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_T_with_context_executes_on_success_and_passes_correct_context()
+        {
+            ValueTask<Result<T>> result = Result.Success(T.Value).AsValueTask();
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_T_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            ValueTask<Result<T>> result = Result.Failure<T>(ErrorMessage).AsValueTask();
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_T_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            ValueTask<Result<T, E>> result = Result.Success<T, E>(T.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_T_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            ValueTask<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            ValueTask<UnitResult<E>> result = UnitResult.Success<E>().AsValueTask();
+            Result<K, E> actual = await result.Map(
+                context =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Left_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            ValueTask<UnitResult<E>> result = UnitResult.Failure(E.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(
+                context =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.Right.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.Right.cs
index 0077cedf..b8877fb1 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.Right.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.Right.cs
@@ -1,240 +1,240 @@
-using System.Threading.Tasks;
-using CSharpFunctionalExtensions.ValueTasks;
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapTests_ValueTask_Right : MapTestsBase
-    {
-        [Fact]
-        public async Task Map_ValueTask_Right_executes_on_success_returns_new_success()
-        {
-            Result result = Result.Success();
-            Result<K> actual = await result.Map(valueTask: ValueTask_Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_executes_on_failure_returns_new_failure()
-        {
-            Result result = Result.Failure(ErrorMessage);
-            Result<K> actual = await result.Map(valueTask: ValueTask_Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_T_executes_on_success_returns_new_success()
-        {
-            Result<T> result = Result.Success(T.Value);
-            Result<K> actual = await result.Map(valueTask: ValueTask_Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_T_executes_on_failure_returns_new_failure()
-        {
-            Result<T> result = Result.Failure<T>(ErrorMessage);
-            Result<K> actual = await result.Map(valueTask: ValueTask_Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_T_E_executes_on_success_returns_new_success()
-        {
-            Result<T, E> result = Result.Success<T, E>(T.Value);
-            Result<K, E> actual = await result.Map(valueTask: ValueTask_Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_T_E_executes_on_failure_returns_new_failure()
-        {
-            Result<T, E> result = Result.Failure<T, E>(E.Value);
-            Result<K, E> actual = await result.Map(valueTask: ValueTask_Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_UnitResult_E_executes_on_success_returns_success()
-        {
-            UnitResult<E> result = UnitResult.Success<E>();
-            Result<K, E> actual = await result.Map(valueTask: ValueTask_Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_UnitResult_E_executes_on_failure_returns_failure()
-        {
-            UnitResult<E> result = UnitResult.Failure(E.Value);
-            Result<K, E> actual = await result.Map(valueTask: ValueTask_Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_with_context_executes_on_success_and_passes_correct_context()
-        {
-            Result result = Result.Success();
-            Result<K> actual = await result.Map(
-                valueTask: context =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return ValueTask_Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            Result result = Result.Failure(ErrorMessage);
-            Result<K> actual = await result.Map(
-                valueTask: context =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return ValueTask_Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_T_with_context_executes_on_success_and_passes_correct_context()
-        {
-            Result<T> result = Result.Success(T.Value);
-            Result<K> actual = await result.Map(
-                valueTask: (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return ValueTask_Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_T_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            Result<T> result = Result.Failure<T>(ErrorMessage);
-            Result<K> actual = await result.Map(
-                valueTask: (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return ValueTask_Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_T_E_with_context_executes_on_success_and_passes_correct_context()
-        {
-            Result<T, E> result = Result.Success<T, E>(T.Value);
-            Result<K, E> actual = await result.Map(
-                valueTask: (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return ValueTask_Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_T_E_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            Result<T, E> result = Result.Failure<T, E>(E.Value);
-            Result<K, E> actual = await result.Map(
-                valueTask: (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return ValueTask_Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
-        {
-            UnitResult<E> result = UnitResult.Success<E>();
-            Result<K, E> actual = await result.Map(
-                valueTask: context =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return ValueTask_Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_Right_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            UnitResult<E> result = UnitResult.Failure(E.Value);
-            Result<K, E> actual = await result.Map(
-                valueTask: context =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return ValueTask_Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-    }
-}
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapTests_ValueTask_Right : MapTestsBase
+    {
+        [Fact]
+        public async Task Map_ValueTask_Right_executes_on_success_returns_new_success()
+        {
+            Result result = Result.Success();
+            Result<K> actual = await result.Map(valueTask: ValueTask_Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_executes_on_failure_returns_new_failure()
+        {
+            Result result = Result.Failure(ErrorMessage);
+            Result<K> actual = await result.Map(valueTask: ValueTask_Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_T_executes_on_success_returns_new_success()
+        {
+            Result<T> result = Result.Success(T.Value);
+            Result<K> actual = await result.Map(valueTask: ValueTask_Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_T_executes_on_failure_returns_new_failure()
+        {
+            Result<T> result = Result.Failure<T>(ErrorMessage);
+            Result<K> actual = await result.Map(valueTask: ValueTask_Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_T_E_executes_on_success_returns_new_success()
+        {
+            Result<T, E> result = Result.Success<T, E>(T.Value);
+            Result<K, E> actual = await result.Map(valueTask: ValueTask_Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_T_E_executes_on_failure_returns_new_failure()
+        {
+            Result<T, E> result = Result.Failure<T, E>(E.Value);
+            Result<K, E> actual = await result.Map(valueTask: ValueTask_Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_UnitResult_E_executes_on_success_returns_success()
+        {
+            UnitResult<E> result = UnitResult.Success<E>();
+            Result<K, E> actual = await result.Map(valueTask: ValueTask_Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_UnitResult_E_executes_on_failure_returns_failure()
+        {
+            UnitResult<E> result = UnitResult.Failure(E.Value);
+            Result<K, E> actual = await result.Map(valueTask: ValueTask_Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Result result = Result.Success();
+            Result<K> actual = await result.Map(
+                valueTask: context =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Result result = Result.Failure(ErrorMessage);
+            Result<K> actual = await result.Map(
+                valueTask: context =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_T_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Result<T> result = Result.Success(T.Value);
+            Result<K> actual = await result.Map(
+                valueTask: (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_T_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Result<T> result = Result.Failure<T>(ErrorMessage);
+            Result<K> actual = await result.Map(
+                valueTask: (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_T_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Result<T, E> result = Result.Success<T, E>(T.Value);
+            Result<K, E> actual = await result.Map(
+                valueTask: (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_T_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Result<T, E> result = Result.Failure<T, E>(E.Value);
+            Result<K, E> actual = await result.Map(
+                valueTask: (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            UnitResult<E> result = UnitResult.Success<E>();
+            Result<K, E> actual = await result.Map(
+                valueTask: context =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_Right_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            UnitResult<E> result = UnitResult.Failure(E.Value);
+            Result<K, E> actual = await result.Map(
+                valueTask: context =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.cs
index 361309e8..0c8d0b14 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.ValueTask.cs
@@ -1,240 +1,240 @@
-using System.Threading.Tasks;
-using CSharpFunctionalExtensions.ValueTasks;
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapTests_ValueTask : MapTestsBase
-    {
-        [Fact]
-        public async Task Map_ValueTask_executes_on_success_returns_new_success()
-        {
-            ValueTask<Result> result = Result.Success().AsValueTask();
-            Result<K> actual = await result.Map(ValueTask_Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_executes_on_failure_returns_new_failure()
-        {
-            ValueTask<Result> result = Result.Failure(ErrorMessage).AsValueTask();
-            Result<K> actual = await result.Map(ValueTask_Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_T_executes_on_success_returns_new_success()
-        {
-            ValueTask<Result<T>> result = Result.Success(T.Value).AsValueTask();
-            Result<K> actual = await result.Map(ValueTask_Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_T_executes_on_failure_returns_new_failure()
-        {
-            ValueTask<Result<T>> result = Result.Failure<T>(ErrorMessage).AsValueTask();
-            Result<K> actual = await result.Map(ValueTask_Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_T_E_executes_on_success_returns_new_success()
-        {
-            ValueTask<Result<T, E>> result = Result.Success<T, E>(T.Value).AsValueTask();
-            Result<K, E> actual = await result.Map(ValueTask_Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_T_E_executes_on_failure_returns_new_failure()
-        {
-            ValueTask<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsValueTask();
-            Result<K, E> actual = await result.Map(ValueTask_Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_UnitResult_E_executes_on_success_returns_success()
-        {
-            ValueTask<UnitResult<E>> result = UnitResult.Success<E>().AsValueTask();
-            Result<K, E> actual = await result.Map(ValueTask_Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_UnitResult_E_executes_on_failure_returns_failure()
-        {
-            ValueTask<UnitResult<E>> result = UnitResult.Failure(E.Value).AsValueTask();
-            Result<K, E> actual = await result.Map(ValueTask_Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_with_context_executes_on_success_and_passes_correct_context()
-        {
-            ValueTask<Result> result = Result.Success().AsValueTask();
-            Result<K> actual = await result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return ValueTask_Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            ValueTask<Result> result = Result.Failure(ErrorMessage).AsValueTask();
-            Result<K> actual = await result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return ValueTask_Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_T_with_context_executes_on_success_and_passes_correct_context()
-        {
-            ValueTask<Result<T>> result = Result.Success(T.Value).AsValueTask();
-            Result<K> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return ValueTask_Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_T_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            ValueTask<Result<T>> result = Result.Failure<T>(ErrorMessage).AsValueTask();
-            Result<K> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return ValueTask_Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_T_E_with_context_executes_on_success_and_passes_correct_context()
-        {
-            ValueTask<Result<T, E>> result = Result.Success<T, E>(T.Value).AsValueTask();
-            Result<K, E> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return ValueTask_Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_T_E_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            ValueTask<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsValueTask();
-            Result<K, E> actual = await result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return ValueTask_Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
-        {
-            ValueTask<UnitResult<E>> result = UnitResult.Success<E>().AsValueTask();
-            Result<K, E> actual = await result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return ValueTask_Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Map_ValueTask_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            ValueTask<UnitResult<E>> result = UnitResult.Failure(E.Value).AsValueTask();
-            Result<K, E> actual = await result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return ValueTask_Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-    }
-}
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapTests_ValueTask : MapTestsBase
+    {
+        [Fact]
+        public async Task Map_ValueTask_executes_on_success_returns_new_success()
+        {
+            ValueTask<Result> result = Result.Success().AsValueTask();
+            Result<K> actual = await result.Map(ValueTask_Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_executes_on_failure_returns_new_failure()
+        {
+            ValueTask<Result> result = Result.Failure(ErrorMessage).AsValueTask();
+            Result<K> actual = await result.Map(ValueTask_Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_T_executes_on_success_returns_new_success()
+        {
+            ValueTask<Result<T>> result = Result.Success(T.Value).AsValueTask();
+            Result<K> actual = await result.Map(ValueTask_Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_T_executes_on_failure_returns_new_failure()
+        {
+            ValueTask<Result<T>> result = Result.Failure<T>(ErrorMessage).AsValueTask();
+            Result<K> actual = await result.Map(ValueTask_Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_T_E_executes_on_success_returns_new_success()
+        {
+            ValueTask<Result<T, E>> result = Result.Success<T, E>(T.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(ValueTask_Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_T_E_executes_on_failure_returns_new_failure()
+        {
+            ValueTask<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(ValueTask_Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_UnitResult_E_executes_on_success_returns_success()
+        {
+            ValueTask<UnitResult<E>> result = UnitResult.Success<E>().AsValueTask();
+            Result<K, E> actual = await result.Map(ValueTask_Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_UnitResult_E_executes_on_failure_returns_failure()
+        {
+            ValueTask<UnitResult<E>> result = UnitResult.Failure(E.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(ValueTask_Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_with_context_executes_on_success_and_passes_correct_context()
+        {
+            ValueTask<Result> result = Result.Success().AsValueTask();
+            Result<K> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            ValueTask<Result> result = Result.Failure(ErrorMessage).AsValueTask();
+            Result<K> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_T_with_context_executes_on_success_and_passes_correct_context()
+        {
+            ValueTask<Result<T>> result = Result.Success(T.Value).AsValueTask();
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_T_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            ValueTask<Result<T>> result = Result.Failure<T>(ErrorMessage).AsValueTask();
+            Result<K> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_T_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            ValueTask<Result<T, E>> result = Result.Success<T, E>(T.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_T_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            ValueTask<Result<T, E>> result = Result.Failure<T, E>(E.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            ValueTask<UnitResult<E>> result = UnitResult.Success<E>().AsValueTask();
+            Result<K, E> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Map_ValueTask_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            ValueTask<UnitResult<E>> result = UnitResult.Failure(E.Value).AsValueTask();
+            Result<K, E> actual = await result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return ValueTask_Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.cs
index c65bb66b..803734ed 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapTests.cs
@@ -1,238 +1,238 @@
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapTests : MapTestsBase
-    {
-        [Fact]
-        public void Map_executes_on_success_returns_new_success()
-        {
-            Result result = Result.Success();
-            Result<K> actual = result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public void Map_executes_on_failure_returns_new_failure()
-        {
-            Result result = Result.Failure(ErrorMessage);
-            Result<K> actual = result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public void Map_T_executes_on_success_returns_new_success()
-        {
-            Result<T> result = Result.Success(T.Value);
-            Result<K> actual = result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public void Map_T_executes_on_failure_returns_new_failure()
-        {
-            Result<T> result = Result.Failure<T>(ErrorMessage);
-            Result<K> actual = result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public void Map_T_E_executes_on_success_returns_new_success()
-        {
-            Result<T, E> result = Result.Success<T, E>(T.Value);
-            Result<K, E> actual = result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public void Map_T_E_executes_on_failure_returns_new_failure()
-        {
-            Result<T, E> result = Result.Failure<T, E>(E.Value);
-            Result<K, E> actual = result.Map(Func_T_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public void Map_UnitResult_E_executes_on_success_returns_success()
-        {
-            UnitResult<E> result = UnitResult.Success<E>();
-            Result<K, E> actual = result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public void Map_UnitResult_E_executes_on_failure_returns_new_failure()
-        {
-            UnitResult<E> result = UnitResult.Failure(E.Value);
-            Result<K, E> actual = result.Map(Func_K);
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public void Map_with_context_executes_on_success_and_passes_correct_context()
-        {
-            Result result = Result.Success();
-            Result<K> actual = result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public void Map_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            Result result = Result.Failure(ErrorMessage);
-            Result<K> actual = result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public void Map_T_with_context_executes_on_success_and_passes_correct_context()
-        {
-            Result<T> result = Result.Success(T.Value);
-            Result<K> actual = result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public void Map_T_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            Result<T> result = Result.Failure<T>(ErrorMessage);
-            Result<K> actual = result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(ErrorMessage);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public void Map_T_E_with_context_executes_on_success_and_passes_correct_context()
-        {
-            Result<T, E> result = Result.Success<T, E>(T.Value);
-            Result<K, E> actual = result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public void Map_T_E_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            Result<T, E> result = Result.Failure<T, E>(E.Value);
-            Result<K, E> actual = result.Map(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_T_K(value);
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-
-        [Fact]
-        public void Map_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
-        {
-            UnitResult<E> result = UnitResult.Success<E>();
-            Result<K, E> actual = result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeTrue();
-            actual.Value.Should().Be(K.Value);
-            FuncExecuted.Should().BeTrue();
-        }
-
-        [Fact]
-        public void Map_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
-        {
-            UnitResult<E> result = UnitResult.Failure(E.Value);
-            Result<K, E> actual = result.Map(
-                (context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return Func_K();
-                },
-                ContextMessage
-            );
-
-            actual.IsSuccess.Should().BeFalse();
-            actual.Error.Should().Be(E.Value);
-            FuncExecuted.Should().BeFalse();
-        }
-    }
-}
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapTests : MapTestsBase
+    {
+        [Fact]
+        public void Map_executes_on_success_returns_new_success()
+        {
+            Result result = Result.Success();
+            Result<K> actual = result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public void Map_executes_on_failure_returns_new_failure()
+        {
+            Result result = Result.Failure(ErrorMessage);
+            Result<K> actual = result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Map_T_executes_on_success_returns_new_success()
+        {
+            Result<T> result = Result.Success(T.Value);
+            Result<K> actual = result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public void Map_T_executes_on_failure_returns_new_failure()
+        {
+            Result<T> result = Result.Failure<T>(ErrorMessage);
+            Result<K> actual = result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Map_T_E_executes_on_success_returns_new_success()
+        {
+            Result<T, E> result = Result.Success<T, E>(T.Value);
+            Result<K, E> actual = result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public void Map_T_E_executes_on_failure_returns_new_failure()
+        {
+            Result<T, E> result = Result.Failure<T, E>(E.Value);
+            Result<K, E> actual = result.Map(Func_T_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Map_UnitResult_E_executes_on_success_returns_success()
+        {
+            UnitResult<E> result = UnitResult.Success<E>();
+            Result<K, E> actual = result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public void Map_UnitResult_E_executes_on_failure_returns_new_failure()
+        {
+            UnitResult<E> result = UnitResult.Failure(E.Value);
+            Result<K, E> actual = result.Map(Func_K);
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Map_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Result result = Result.Success();
+            Result<K> actual = result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public void Map_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Result result = Result.Failure(ErrorMessage);
+            Result<K> actual = result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Map_T_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Result<T> result = Result.Success(T.Value);
+            Result<K> actual = result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public void Map_T_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Result<T> result = Result.Failure<T>(ErrorMessage);
+            Result<K> actual = result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(ErrorMessage);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Map_T_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            Result<T, E> result = Result.Success<T, E>(T.Value);
+            Result<K, E> actual = result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public void Map_T_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            Result<T, E> result = Result.Failure<T, E>(E.Value);
+            Result<K, E> actual = result.Map(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_T_K(value);
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Map_UnitResult_E_with_context_executes_on_success_and_passes_correct_context()
+        {
+            UnitResult<E> result = UnitResult.Success<E>();
+            Result<K, E> actual = result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeTrue();
+            actual.Value.Should().Be(K.Value);
+            FuncExecuted.Should().BeTrue();
+        }
+
+        [Fact]
+        public void Map_UnitResult_E_with_context_executes_on_failure_and_passes_correct_context()
+        {
+            UnitResult<E> result = UnitResult.Failure(E.Value);
+            Result<K, E> actual = result.Map(
+                (context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return Func_K();
+                },
+                ContextMessage
+            );
+
+            actual.IsSuccess.Should().BeFalse();
+            actual.Error.Should().Be(E.Value);
+            FuncExecuted.Should().BeFalse();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.Left.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.Left.cs
index 2589cbef..5a90e714 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.Left.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.Left.cs
@@ -1,105 +1,105 @@
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions
-{
-    public static partial class AsyncResultExtensionsLeftOperand
-    {
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K, E>> Map<T, K, E>(
-            this Task<Result<T, E>> resultTask,
-            Func<T, K> func
-        )
-        {
-            Result<T, E> result = await resultTask.DefaultAwait();
-            return result.Map(func);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K, E>> Map<T, K, E, TContext>(
-            this Task<Result<T, E>> resultTask,
-            Func<T, TContext, K> func,
-            TContext context
-        )
-        {
-            Result<T, E> result = await resultTask.DefaultAwait();
-            return result.Map(func, context);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K, E>> Map<K, E>(
-            this Task<UnitResult<E>> resultTask,
-            Func<K> func
-        )
-        {
-            UnitResult<E> result = await resultTask.DefaultAwait();
-            return result.Map(func);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K, E>> Map<K, E, TContext>(
-            this Task<UnitResult<E>> resultTask,
-            Func<TContext, K> func,
-            TContext context
-        )
-        {
-            UnitResult<E> result = await resultTask.DefaultAwait();
-            return result.Map(func, context);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<T, K>(
-            this Task<Result<T>> resultTask,
-            Func<T, K> func
-        )
-        {
-            Result<T> result = await resultTask.DefaultAwait();
-            return result.Map(func);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<T, K, TContext>(
-            this Task<Result<T>> resultTask,
-            Func<T, TContext, K> func,
-            TContext context
-        )
-        {
-            Result<T> result = await resultTask.DefaultAwait();
-            return result.Map(func, context);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<K>(this Task<Result> resultTask, Func<K> func)
-        {
-            Result result = await resultTask.DefaultAwait();
-            return result.Map(func);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<K, TContext>(
-            this Task<Result> resultTask,
-            Func<TContext, K> func,
-            TContext context
-        )
-        {
-            Result result = await resultTask.DefaultAwait();
-            return result.Map(func, context);
-        }
-    }
-}
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class AsyncResultExtensionsLeftOperand
+    {
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<T, K, E>(
+            this Task<Result<T, E>> resultTask,
+            Func<T, K> func
+        )
+        {
+            Result<T, E> result = await resultTask.DefaultAwait();
+            return result.Map(func);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<T, K, E, TContext>(
+            this Task<Result<T, E>> resultTask,
+            Func<T, TContext, K> func,
+            TContext context
+        )
+        {
+            Result<T, E> result = await resultTask.DefaultAwait();
+            return result.Map(func, context);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<K, E>(
+            this Task<UnitResult<E>> resultTask,
+            Func<K> func
+        )
+        {
+            UnitResult<E> result = await resultTask.DefaultAwait();
+            return result.Map(func);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<K, E, TContext>(
+            this Task<UnitResult<E>> resultTask,
+            Func<TContext, K> func,
+            TContext context
+        )
+        {
+            UnitResult<E> result = await resultTask.DefaultAwait();
+            return result.Map(func, context);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<T, K>(
+            this Task<Result<T>> resultTask,
+            Func<T, K> func
+        )
+        {
+            Result<T> result = await resultTask.DefaultAwait();
+            return result.Map(func);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<T, K, TContext>(
+            this Task<Result<T>> resultTask,
+            Func<T, TContext, K> func,
+            TContext context
+        )
+        {
+            Result<T> result = await resultTask.DefaultAwait();
+            return result.Map(func, context);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<K>(this Task<Result> resultTask, Func<K> func)
+        {
+            Result result = await resultTask.DefaultAwait();
+            return result.Map(func);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<K, TContext>(
+            this Task<Result> resultTask,
+            Func<TContext, K> func,
+            TContext context
+        )
+        {
+            Result result = await resultTask.DefaultAwait();
+            return result.Map(func, context);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.Right.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.Right.cs
index 235dd11f..fd9161fc 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.Right.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.Right.cs
@@ -1,165 +1,165 @@
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions
-{
-    public static partial class AsyncResultExtensionsRightOperand
-    {
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K, E>> Map<T, K, E>(
-            this Result<T, E> result,
-            Func<T, Task<K>> func
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await func(result.Value).DefaultAwait();
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K, E>> Map<T, K, E, TContext>(
-            this Result<T, E> result,
-            Func<T, TContext, Task<K>> func,
-            TContext context
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await func(result.Value, context).DefaultAwait();
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K, E>> Map<K, E>(
-            this UnitResult<E> result,
-            Func<Task<K>> func
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await func().DefaultAwait();
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K, E>> Map<K, E, TContext>(
-            this UnitResult<E> result,
-            Func<TContext, Task<K>> func,
-            TContext context
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await func(context).DefaultAwait();
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<T, K>(this Result<T> result, Func<T, Task<K>> func)
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await func(result.Value).DefaultAwait();
-
-            return Result.Success(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<T, K, TContext>(
-            this Result<T> result,
-            Func<T, TContext, Task<K>> func,
-            TContext context
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await func(result.Value, context).DefaultAwait();
-
-            return Result.Success(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<T, K>(
-            this Result<T> result,
-            Func<T, Task<Result<K>>> func
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            Result<K> value = await func(result.Value).DefaultAwait();
-            return value;
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<T, K, TContext>(
-            this Result<T> result,
-            Func<T, TContext, Task<Result<K>>> func,
-            TContext context
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            Result<K> value = await func(result.Value, context).DefaultAwait();
-            return value;
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<K>(this Result result, Func<Task<K>> func)
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await func().DefaultAwait();
-
-            return Result.Success(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<K, TContext>(
-            this Result result,
-            Func<TContext, Task<K>> func,
-            TContext context
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await func(context).DefaultAwait();
-
-            return Result.Success(value);
-        }
-    }
-}
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class AsyncResultExtensionsRightOperand
+    {
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<T, K, E>(
+            this Result<T, E> result,
+            Func<T, Task<K>> func
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await func(result.Value).DefaultAwait();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<T, K, E, TContext>(
+            this Result<T, E> result,
+            Func<T, TContext, Task<K>> func,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await func(result.Value, context).DefaultAwait();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<K, E>(
+            this UnitResult<E> result,
+            Func<Task<K>> func
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await func().DefaultAwait();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<K, E, TContext>(
+            this UnitResult<E> result,
+            Func<TContext, Task<K>> func,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await func(context).DefaultAwait();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<T, K>(this Result<T> result, Func<T, Task<K>> func)
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await func(result.Value).DefaultAwait();
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<T, K, TContext>(
+            this Result<T> result,
+            Func<T, TContext, Task<K>> func,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await func(result.Value, context).DefaultAwait();
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<T, K>(
+            this Result<T> result,
+            Func<T, Task<Result<K>>> func
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            Result<K> value = await func(result.Value).DefaultAwait();
+            return value;
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<T, K, TContext>(
+            this Result<T> result,
+            Func<T, TContext, Task<Result<K>>> func,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            Result<K> value = await func(result.Value, context).DefaultAwait();
+            return value;
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<K>(this Result result, Func<Task<K>> func)
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await func().DefaultAwait();
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<K, TContext>(
+            this Result result,
+            Func<TContext, Task<K>> func,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await func(context).DefaultAwait();
+
+            return Result.Success(value);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.cs
index 7d791014..e46697b6 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.Task.cs
@@ -1,153 +1,153 @@
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions
-{
-    public static partial class AsyncResultExtensionsBothOperands
-    {
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K, E>> Map<T, K, E>(
-            this Task<Result<T, E>> resultTask,
-            Func<T, Task<K>> func
-        )
-        {
-            Result<T, E> result = await resultTask.DefaultAwait();
-
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await func(result.Value).DefaultAwait();
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K, E>> Map<T, K, E, TContext>(
-            this Task<Result<T, E>> resultTask,
-            Func<T, TContext, Task<K>> func,
-            TContext context
-        )
-        {
-            Result<T, E> result = await resultTask.DefaultAwait();
-
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await func(result.Value, context).DefaultAwait();
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K, E>> Map<K, E>(
-            this Task<UnitResult<E>> resultTask,
-            Func<Task<K>> func
-        )
-        {
-            UnitResult<E> result = await resultTask.DefaultAwait();
-
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await func().DefaultAwait();
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K, E>> Map<K, E, TContext>(
-            this Task<UnitResult<E>> resultTask,
-            Func<TContext, Task<K>> func,
-            TContext context
-        )
-        {
-            UnitResult<E> result = await resultTask.DefaultAwait();
-
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await func(context).DefaultAwait();
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<T, K>(
-            this Task<Result<T>> resultTask,
-            Func<T, Task<K>> func
-        )
-        {
-            Result<T> result = await resultTask.DefaultAwait();
-
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await func(result.Value).DefaultAwait();
-
-            return Result.Success(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<T, K, TContext>(
-            this Task<Result<T>> resultTask,
-            Func<T, TContext, Task<K>> func,
-            TContext context
-        )
-        {
-            Result<T> result = await resultTask.DefaultAwait();
-
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await func(result.Value, context).DefaultAwait();
-
-            return Result.Success(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<K>(this Task<Result> resultTask, Func<Task<K>> func)
-        {
-            Result result = await resultTask.DefaultAwait();
-
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await func().DefaultAwait();
-
-            return Result.Success(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async Task<Result<K>> Map<K, TContext>(
-            this Task<Result> resultTask,
-            Func<TContext, Task<K>> func,
-            TContext context
-        )
-        {
-            Result result = await resultTask.DefaultAwait();
-
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await func(context).DefaultAwait();
-
-            return Result.Success(value);
-        }
-    }
-}
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class AsyncResultExtensionsBothOperands
+    {
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<T, K, E>(
+            this Task<Result<T, E>> resultTask,
+            Func<T, Task<K>> func
+        )
+        {
+            Result<T, E> result = await resultTask.DefaultAwait();
+
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await func(result.Value).DefaultAwait();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<T, K, E, TContext>(
+            this Task<Result<T, E>> resultTask,
+            Func<T, TContext, Task<K>> func,
+            TContext context
+        )
+        {
+            Result<T, E> result = await resultTask.DefaultAwait();
+
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await func(result.Value, context).DefaultAwait();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<K, E>(
+            this Task<UnitResult<E>> resultTask,
+            Func<Task<K>> func
+        )
+        {
+            UnitResult<E> result = await resultTask.DefaultAwait();
+
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await func().DefaultAwait();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K, E>> Map<K, E, TContext>(
+            this Task<UnitResult<E>> resultTask,
+            Func<TContext, Task<K>> func,
+            TContext context
+        )
+        {
+            UnitResult<E> result = await resultTask.DefaultAwait();
+
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await func(context).DefaultAwait();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<T, K>(
+            this Task<Result<T>> resultTask,
+            Func<T, Task<K>> func
+        )
+        {
+            Result<T> result = await resultTask.DefaultAwait();
+
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await func(result.Value).DefaultAwait();
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<T, K, TContext>(
+            this Task<Result<T>> resultTask,
+            Func<T, TContext, Task<K>> func,
+            TContext context
+        )
+        {
+            Result<T> result = await resultTask.DefaultAwait();
+
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await func(result.Value, context).DefaultAwait();
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<K>(this Task<Result> resultTask, Func<Task<K>> func)
+        {
+            Result result = await resultTask.DefaultAwait();
+
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await func().DefaultAwait();
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async Task<Result<K>> Map<K, TContext>(
+            this Task<Result> resultTask,
+            Func<TContext, Task<K>> func,
+            TContext context
+        )
+        {
+            Result result = await resultTask.DefaultAwait();
+
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await func(context).DefaultAwait();
+
+            return Result.Success(value);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.Left.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.Left.cs
index c1f802cb..49f28605 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.Left.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.Left.cs
@@ -1,110 +1,110 @@
-#if NET5_0_OR_GREATER
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions.ValueTasks
-{
-    public static partial class AsyncResultExtensionsLeftOperand
-    {
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K, E>> Map<T, K, E>(
-            this ValueTask<Result<T, E>> resultTask,
-            Func<T, K> valueTask
-        )
-        {
-            Result<T, E> result = await resultTask;
-            return result.Map(valueTask);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K, E>> Map<T, K, E, TContext>(
-            this ValueTask<Result<T, E>> resultTask,
-            Func<T, TContext, K> valueTask,
-            TContext context
-        )
-        {
-            Result<T, E> result = await resultTask;
-            return result.Map(valueTask, context);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K, E>> Map<K, E>(
-            this ValueTask<UnitResult<E>> resultTask,
-            Func<K> valueTask
-        )
-        {
-            UnitResult<E> result = await resultTask;
-            return result.Map(valueTask);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K, E>> Map<K, E, TContext>(
-            this ValueTask<UnitResult<E>> resultTask,
-            Func<TContext, K> valueTask,
-            TContext context
-        )
-        {
-            UnitResult<E> result = await resultTask;
-            return result.Map(valueTask, context);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<T, K>(
-            this ValueTask<Result<T>> resultTask,
-            Func<T, K> valueTask
-        )
-        {
-            Result<T> result = await resultTask;
-            return result.Map(valueTask);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<T, K, TContext>(
-            this ValueTask<Result<T>> resultTask,
-            Func<T, TContext, K> valueTask,
-            TContext context
-        )
-        {
-            Result<T> result = await resultTask;
-            return result.Map(valueTask, context);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<K>(
-            this ValueTask<Result> resultTask,
-            Func<K> valueTask
-        )
-        {
-            Result result = await resultTask;
-            return result.Map(valueTask);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<K, TContext>(
-            this ValueTask<Result> resultTask,
-            Func<TContext, K> valueTask,
-            TContext context
-        )
-        {
-            Result result = await resultTask;
-            return result.Map(valueTask, context);
-        }
-    }
-}
-#endif
+#if NET5_0_OR_GREATER
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.ValueTasks
+{
+    public static partial class AsyncResultExtensionsLeftOperand
+    {
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<T, K, E>(
+            this ValueTask<Result<T, E>> resultTask,
+            Func<T, K> valueTask
+        )
+        {
+            Result<T, E> result = await resultTask;
+            return result.Map(valueTask);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<T, K, E, TContext>(
+            this ValueTask<Result<T, E>> resultTask,
+            Func<T, TContext, K> valueTask,
+            TContext context
+        )
+        {
+            Result<T, E> result = await resultTask;
+            return result.Map(valueTask, context);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<K, E>(
+            this ValueTask<UnitResult<E>> resultTask,
+            Func<K> valueTask
+        )
+        {
+            UnitResult<E> result = await resultTask;
+            return result.Map(valueTask);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<K, E, TContext>(
+            this ValueTask<UnitResult<E>> resultTask,
+            Func<TContext, K> valueTask,
+            TContext context
+        )
+        {
+            UnitResult<E> result = await resultTask;
+            return result.Map(valueTask, context);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<T, K>(
+            this ValueTask<Result<T>> resultTask,
+            Func<T, K> valueTask
+        )
+        {
+            Result<T> result = await resultTask;
+            return result.Map(valueTask);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<T, K, TContext>(
+            this ValueTask<Result<T>> resultTask,
+            Func<T, TContext, K> valueTask,
+            TContext context
+        )
+        {
+            Result<T> result = await resultTask;
+            return result.Map(valueTask, context);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<K>(
+            this ValueTask<Result> resultTask,
+            Func<K> valueTask
+        )
+        {
+            Result result = await resultTask;
+            return result.Map(valueTask);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<K, TContext>(
+            this ValueTask<Result> resultTask,
+            Func<TContext, K> valueTask,
+            TContext context
+        )
+        {
+            Result result = await resultTask;
+            return result.Map(valueTask, context);
+        }
+    }
+}
+#endif
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.Right.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.Right.cs
index b300e4a5..c0d98430 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.Right.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.Right.cs
@@ -1,173 +1,173 @@
-#if NET5_0_OR_GREATER
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions.ValueTasks
-{
-    public static partial class AsyncResultExtensionsRightOperand
-    {
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K, E>> Map<T, K, E>(
-            this Result<T, E> result,
-            Func<T, ValueTask<K>> valueTask
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await valueTask(result.Value);
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K, E>> Map<T, K, E, TContext>(
-            this Result<T, E> result,
-            Func<T, TContext, ValueTask<K>> valueTask,
-            TContext context
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await valueTask(result.Value, context);
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K, E>> Map<K, E>(
-            this UnitResult<E> result,
-            Func<ValueTask<K>> valueTask
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await valueTask();
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K, E>> Map<K, E, TContext>(
-            this UnitResult<E> result,
-            Func<TContext, ValueTask<K>> valueTask,
-            TContext context
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await valueTask(context);
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<T, K>(
-            this Result<T> result,
-            Func<T, ValueTask<K>> valueTask
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await valueTask(result.Value);
-
-            return Result.Success(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<T, K, TContext>(
-            this Result<T> result,
-            Func<T, TContext, ValueTask<K>> valueTask,
-            TContext context
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await valueTask(result.Value, context);
-
-            return Result.Success(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<T, K>(
-            this Result<T> result,
-            Func<T, ValueTask<Result<K>>> valueTask
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            Result<K> value = await valueTask(result.Value);
-            return value;
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<T, K, TContext>(
-            this Result<T> result,
-            Func<T, TContext, ValueTask<Result<K>>> valueTask,
-            TContext context
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            Result<K> value = await valueTask(result.Value, context);
-            return value;
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<K>(
-            this Result result,
-            Func<ValueTask<K>> valueTask
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await valueTask();
-
-            return Result.Success(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<K, TContext>(
-            this Result result,
-            Func<TContext, ValueTask<K>> valueTask,
-            TContext context
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await valueTask(context);
-
-            return Result.Success(value);
-        }
-    }
-}
-#endif
+#if NET5_0_OR_GREATER
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.ValueTasks
+{
+    public static partial class AsyncResultExtensionsRightOperand
+    {
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<T, K, E>(
+            this Result<T, E> result,
+            Func<T, ValueTask<K>> valueTask
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await valueTask(result.Value);
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<T, K, E, TContext>(
+            this Result<T, E> result,
+            Func<T, TContext, ValueTask<K>> valueTask,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await valueTask(result.Value, context);
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<K, E>(
+            this UnitResult<E> result,
+            Func<ValueTask<K>> valueTask
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await valueTask();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<K, E, TContext>(
+            this UnitResult<E> result,
+            Func<TContext, ValueTask<K>> valueTask,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await valueTask(context);
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<T, K>(
+            this Result<T> result,
+            Func<T, ValueTask<K>> valueTask
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await valueTask(result.Value);
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<T, K, TContext>(
+            this Result<T> result,
+            Func<T, TContext, ValueTask<K>> valueTask,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await valueTask(result.Value, context);
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<T, K>(
+            this Result<T> result,
+            Func<T, ValueTask<Result<K>>> valueTask
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            Result<K> value = await valueTask(result.Value);
+            return value;
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<T, K, TContext>(
+            this Result<T> result,
+            Func<T, TContext, ValueTask<Result<K>>> valueTask,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            Result<K> value = await valueTask(result.Value, context);
+            return value;
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<K>(
+            this Result result,
+            Func<ValueTask<K>> valueTask
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await valueTask();
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<K, TContext>(
+            this Result result,
+            Func<TContext, ValueTask<K>> valueTask,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await valueTask(context);
+
+            return Result.Success(value);
+        }
+    }
+}
+#endif
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.cs
index cbaf6faf..76bb63cd 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.ValueTask.cs
@@ -1,158 +1,158 @@
-#if NET5_0_OR_GREATER
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions.ValueTasks
-{
-    public static partial class AsyncResultExtensionsBothOperands
-    {
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K, E>> Map<T, K, E>(
-            this ValueTask<Result<T, E>> resultTask,
-            Func<T, ValueTask<K>> valueTask
-        )
-        {
-            Result<T, E> result = await resultTask;
-
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await valueTask(result.Value);
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K, E>> Map<T, K, E, TContext>(
-            this ValueTask<Result<T, E>> resultTask,
-            Func<T, TContext, ValueTask<K>> valueTask,
-            TContext context
-        )
-        {
-            Result<T, E> result = await resultTask;
-
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await valueTask(result.Value, context);
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K, E>> Map<K, E>(
-            this ValueTask<UnitResult<E>> resultTask,
-            Func<ValueTask<K>> valueTask
-        )
-        {
-            UnitResult<E> result = await resultTask;
-
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await valueTask();
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K, E>> Map<K, E, TContext>(
-            this ValueTask<UnitResult<E>> resultTask,
-            Func<TContext, ValueTask<K>> valueTask,
-            TContext context
-        )
-        {
-            UnitResult<E> result = await resultTask;
-
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            K value = await valueTask(context);
-
-            return Result.Success<K, E>(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<T, K>(
-            this ValueTask<Result<T>> resultTask,
-            Func<T, ValueTask<K>> valueTask
-        )
-        {
-            Result<T> result = await resultTask;
-
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await valueTask(result.Value);
-
-            return Result.Success(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<T, K, TContext>(
-            this ValueTask<Result<T>> resultTask,
-            Func<T, TContext, ValueTask<K>> valueTask,
-            TContext context
-        )
-        {
-            Result<T> result = await resultTask;
-
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await valueTask(result.Value, context);
-
-            return Result.Success(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<K>(
-            this ValueTask<Result> resultTask,
-            Func<ValueTask<K>> valueTask
-        )
-        {
-            Result result = await resultTask;
-
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await valueTask();
-
-            return Result.Success(value);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static async ValueTask<Result<K>> Map<K, TContext>(
-            this ValueTask<Result> resultTask,
-            Func<TContext, ValueTask<K>> valueTask,
-            TContext context
-        )
-        {
-            Result result = await resultTask;
-
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            K value = await valueTask(context);
-
-            return Result.Success(value);
-        }
-    }
-}
-#endif
+#if NET5_0_OR_GREATER
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.ValueTasks
+{
+    public static partial class AsyncResultExtensionsBothOperands
+    {
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<T, K, E>(
+            this ValueTask<Result<T, E>> resultTask,
+            Func<T, ValueTask<K>> valueTask
+        )
+        {
+            Result<T, E> result = await resultTask;
+
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await valueTask(result.Value);
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<T, K, E, TContext>(
+            this ValueTask<Result<T, E>> resultTask,
+            Func<T, TContext, ValueTask<K>> valueTask,
+            TContext context
+        )
+        {
+            Result<T, E> result = await resultTask;
+
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await valueTask(result.Value, context);
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<K, E>(
+            this ValueTask<UnitResult<E>> resultTask,
+            Func<ValueTask<K>> valueTask
+        )
+        {
+            UnitResult<E> result = await resultTask;
+
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await valueTask();
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K, E>> Map<K, E, TContext>(
+            this ValueTask<UnitResult<E>> resultTask,
+            Func<TContext, ValueTask<K>> valueTask,
+            TContext context
+        )
+        {
+            UnitResult<E> result = await resultTask;
+
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            K value = await valueTask(context);
+
+            return Result.Success<K, E>(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<T, K>(
+            this ValueTask<Result<T>> resultTask,
+            Func<T, ValueTask<K>> valueTask
+        )
+        {
+            Result<T> result = await resultTask;
+
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await valueTask(result.Value);
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<T, K, TContext>(
+            this ValueTask<Result<T>> resultTask,
+            Func<T, TContext, ValueTask<K>> valueTask,
+            TContext context
+        )
+        {
+            Result<T> result = await resultTask;
+
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await valueTask(result.Value, context);
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<K>(
+            this ValueTask<Result> resultTask,
+            Func<ValueTask<K>> valueTask
+        )
+        {
+            Result result = await resultTask;
+
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await valueTask();
+
+            return Result.Success(value);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given valueTask action. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static async ValueTask<Result<K>> Map<K, TContext>(
+            this ValueTask<Result> resultTask,
+            Func<TContext, ValueTask<K>> valueTask,
+            TContext context
+        )
+        {
+            Result result = await resultTask;
+
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            K value = await valueTask(context);
+
+            return Result.Success(value);
+        }
+    }
+}
+#endif
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.cs
index ac35c18e..f7e7bc1d 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/Map.cs
@@ -1,111 +1,111 @@
-using System;
-
-namespace CSharpFunctionalExtensions
-{
-    public static partial class ResultExtensions
-    {
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static Result<K, E> Map<T, K, E>(this Result<T, E> result, Func<T, K> func)
-        {
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            return Result.Success<K, E>(func(result.Value));
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static Result<K, E> Map<T, K, E, TContext>(
-            this Result<T, E> result,
-            Func<T, TContext, K> func,
-            TContext context
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            return Result.Success<K, E>(func(result.Value, context));
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static Result<K, E> Map<K, E>(this UnitResult<E> result, Func<K> func)
-        {
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            return Result.Success<K, E>(func());
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static Result<K, E> Map<K, E, TContext>(
-            this UnitResult<E> result,
-            Func<TContext, K> func,
-            TContext context
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K, E>(result.Error);
-
-            return Result.Success<K, E>(func(context));
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static Result<K> Map<T, K>(this Result<T> result, Func<T, K> func)
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            return Result.Success(func(result.Value));
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static Result<K> Map<T, K, TContext>(
-            this Result<T> result,
-            Func<T, TContext, K> func,
-            TContext context
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            return Result.Success(func(result.Value, context));
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static Result<K> Map<K>(this Result result, Func<K> func)
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            return Result.Success(func());
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static Result<K> Map<K, TContext>(
-            this Result result,
-            Func<TContext, K> func,
-            TContext context
-        )
-        {
-            if (result.IsFailure)
-                return Result.Failure<K>(result.Error);
-
-            return Result.Success(func(context));
-        }
-    }
-}
+using System;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class ResultExtensions
+    {
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<K, E> Map<T, K, E>(this Result<T, E> result, Func<T, K> func)
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            return Result.Success<K, E>(func(result.Value));
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<K, E> Map<T, K, E, TContext>(
+            this Result<T, E> result,
+            Func<T, TContext, K> func,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            return Result.Success<K, E>(func(result.Value, context));
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<K, E> Map<K, E>(this UnitResult<E> result, Func<K> func)
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            return Result.Success<K, E>(func());
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<K, E> Map<K, E, TContext>(
+            this UnitResult<E> result,
+            Func<TContext, K> func,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K, E>(result.Error);
+
+            return Result.Success<K, E>(func(context));
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<K> Map<T, K>(this Result<T> result, Func<T, K> func)
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            return Result.Success(func(result.Value));
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<K> Map<T, K, TContext>(
+            this Result<T> result,
+            Func<T, TContext, K> func,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            return Result.Success(func(result.Value, context));
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<K> Map<K>(this Result result, Func<K> func)
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            return Result.Success(func());
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<K> Map<K, TContext>(
+            this Result result,
+            Func<TContext, K> func,
+            TContext context
+        )
+        {
+            if (result.IsFailure)
+                return Result.Failure<K>(result.Error);
+
+            return Result.Success(func(context));
+        }
+    }
+}

From 7d871860fc1954de9e135549ac55fc493f9b19f8 Mon Sep 17 00:00:00 2001
From: Marcin Jahn <10273406+marcinjahn@users.noreply.github.com>
Date: Sun, 10 Nov 2024 15:58:46 +0100
Subject: [PATCH 3/4] feat: add allocation-free overloads for Result.MapIf

---
 .../ResultTests/Extensions/MapIfTests.Base.cs | 149 ++++-----
 .../Extensions/MapIfTests.Task.Left.cs        | 279 ++++++++++++-----
 .../Extensions/MapIfTests.Task.Right.cs       | 263 +++++++++++-----
 .../ResultTests/Extensions/MapIfTests.Task.cs | 266 +++++++++++-----
 .../Extensions/MapIfTests.ValueTask.Left.cs   | 281 ++++++++++++-----
 .../Extensions/MapIfTests.ValueTask.Right.cs  | 268 ++++++++++++-----
 .../Extensions/MapIfTests.ValueTask.cs        | 284 +++++++++++++-----
 .../ResultTests/Extensions/MapIfTests.cs      | 250 ++++++++++-----
 .../Methods/Extensions/MapIf.Task.Left.cs     | 124 ++++++--
 .../Methods/Extensions/MapIf.Task.Right.cs    | 172 ++++++++---
 .../Result/Methods/Extensions/MapIf.Task.cs   | 124 ++++++--
 .../Extensions/MapIf.ValueTask.Left.cs        | 128 +++++---
 .../Extensions/MapIf.ValueTask.Right.cs       | 176 ++++++++---
 .../Methods/Extensions/MapIf.ValueTask.cs     | 128 +++++---
 .../Result/Methods/Extensions/MapIf.cs        | 190 ++++++++----
 15 files changed, 2221 insertions(+), 861 deletions(-)

diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Base.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Base.cs
index 6238a701..5680eb82 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Base.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Base.cs
@@ -1,73 +1,76 @@
-using System;
-using System.Threading.Tasks;
-using FluentAssertions;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public abstract class MapIfTestsBase : TestBase
-    {
-        protected bool actionExecuted;
-        protected bool predicateExecuted;
-
-        protected MapIfTestsBase()
-        {
-            actionExecuted = false;
-            predicateExecuted = false;
-        }
-
-        protected Func<T, T> GetAction() => value =>
-        {
-            actionExecuted.Should().BeFalse();
-            value.Should().Be(T.Value);
-
-            actionExecuted = true;
-            return T.Value2;
-        };
-
-        protected Func<T, Task<T>> GetTaskAction()
-        {
-            return t => Task.FromResult(GetAction()(t));
-        }
-
-        protected Func<T, ValueTask<T>> GetValueTaskAction()
-        {
-            return t => ValueTask.FromResult(GetAction()(t));
-        }
-
-        protected Func<T, bool> GetValuePredicate(bool value)
-        {
-            return t =>
-            {
-                predicateExecuted.Should().BeFalse();
-                t.Should().Be(T.Value);
-
-                predicateExecuted = true;
-                return value;
-            };
-        }
-
-        protected static Result<T> GetExpectedValueResult(bool isSuccess, bool condition)
-        {
-            var resultChanged = isSuccess && condition;
-
-            if (!resultChanged)
-            {
-                return Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-            }
-
-            return Result.SuccessIf(isSuccess, T.Value2, ErrorMessage2);
-        }
-
-        protected static Result<T, E> GetExpectedValueErrorResult(bool isSuccess, bool condition)
-        {
-            var resultChanged = isSuccess && condition;
-
-            if (!resultChanged)
-            {
-                return Result.SuccessIf(isSuccess, T.Value, E.Value);
-            }
-
-            return Result.SuccessIf(isSuccess, T.Value2, E.Value2);
-        }
-    }
-}
+using System;
+using System.Threading.Tasks;
+using FluentAssertions;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public abstract class MapIfTestsBase : TestBase
+    {
+        protected bool actionExecuted;
+        protected bool predicateExecuted;
+
+        protected MapIfTestsBase()
+        {
+            actionExecuted = false;
+            predicateExecuted = false;
+        }
+
+        protected Func<T, T> GetAction() =>
+            value =>
+            {
+                actionExecuted.Should().BeFalse();
+                value.Should().Be(T.Value);
+
+                actionExecuted = true;
+                return T.Value2;
+            };
+
+        protected Func<T, Task<T>> GetTaskAction()
+        {
+            return t => Task.FromResult(GetAction()(t));
+        }
+
+        protected Func<T, ValueTask<T>> GetValueTaskAction()
+        {
+            return t => ValueTask.FromResult(GetAction()(t));
+        }
+
+        protected Func<T, bool> GetValuePredicate(bool value)
+        {
+            return t =>
+            {
+                predicateExecuted.Should().BeFalse();
+                t.Should().Be(T.Value);
+
+                predicateExecuted = true;
+                return value;
+            };
+        }
+
+        protected static Result<T> GetExpectedValueResult(bool isSuccess, bool condition)
+        {
+            var resultChanged = isSuccess && condition;
+
+            if (!resultChanged)
+            {
+                return Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+            }
+
+            return Result.SuccessIf(isSuccess, T.Value2, ErrorMessage2);
+        }
+
+        protected static Result<T, E> GetExpectedValueErrorResult(bool isSuccess, bool condition)
+        {
+            var resultChanged = isSuccess && condition;
+
+            if (!resultChanged)
+            {
+                return Result.SuccessIf(isSuccess, T.Value, E.Value);
+            }
+
+            return Result.SuccessIf(isSuccess, T.Value2, E.Value2);
+        }
+
+        protected readonly string ContextMessage = "Context data";
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Left.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Left.cs
index 3d3a52ca..ecc03e60 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Left.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Left.cs
@@ -1,71 +1,208 @@
-using System.Threading.Tasks;
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapIfTests_Task_Left : MapIfTestsBase
-    {
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Left_T_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-
-            Result<T> returned = await result.MapIf(condition, GetTaskAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Left_T_E_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
-
-            Result<T, E> returned = await result.MapIf(condition, GetTaskAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Left_computes_predicate_T_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-
-            Result<T> returned = await result.MapIf(GetValuePredicate(condition), GetTaskAction());
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Left_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
-
-            Result<T, E> returned = await result.MapIf(GetValuePredicate(condition), GetTaskAction());
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-    }
-}
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapIfTests_Task_Left : MapIfTestsBase
+    {
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Left_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsTask();
+
+            Result<T> returned = await resultTask.MapIf(condition, GetAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Left_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
+
+            Result<T, E> returned = await resultTask.MapIf(condition, GetAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Left_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsTask();
+
+            Result<T> returned = await resultTask.MapIf(GetValuePredicate(condition), GetAction());
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Left_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
+
+            Result<T, E> returned = await resultTask.MapIf(
+                GetValuePredicate(condition),
+                GetAction()
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Left_T_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsTask();
+
+            Result<T> returned = await resultTask.MapIf(
+                condition,
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Left_T_E_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
+
+            Result<T, E> returned = await resultTask.MapIf(
+                condition,
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Left_computes_predicate_T_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsTask();
+
+            Result<T> returned = await resultTask.MapIf(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValuePredicate(condition)(value);
+                },
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Left_computes_predicate_T_E_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
+
+            Result<T, E> returned = await resultTask.MapIf(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValuePredicate(condition)(value);
+                },
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Right.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Right.cs
index cea435bc..36f2c44c 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Right.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Right.cs
@@ -1,71 +1,192 @@
-using System.Threading.Tasks;
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapIfTests_Task_Right : MapIfTestsBase
-    {
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Right_T_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Task<Result<T>> resultTask = Result.SuccessIf(isSuccess, T.Value, ErrorMessage).AsTask();
-
-            Result<T> returned = await resultTask.MapIf(condition, GetAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Right_T_E_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
-
-            Result<T, E> returned = await resultTask.MapIf(condition, GetAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Right_computes_predicate_T_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Task<Result<T>> resultTask = Result.SuccessIf(isSuccess, T.Value, ErrorMessage).AsTask();
-
-            Result<T> returned = await resultTask.MapIf(GetValuePredicate(condition), GetAction());
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Right_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
-
-            Result<T, E> returned = await resultTask.MapIf(GetValuePredicate(condition), GetAction());
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-    }
-}
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapIfTests_Task_Right : MapIfTestsBase
+    {
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Right_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+
+            Result<T> returned = await result.MapIf(condition, GetTaskAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Right_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+
+            Result<T, E> returned = await result.MapIf(condition, GetTaskAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Right_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+
+            Result<T> returned = await result.MapIf(GetValuePredicate(condition), GetTaskAction());
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Right_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+
+            Result<T, E> returned = await result.MapIf(
+                GetValuePredicate(condition),
+                GetTaskAction()
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Right_T_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+
+            Result<T> returned = await result.MapIf(
+                condition,
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Right_T_E_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+
+            Result<T, E> returned = await result.MapIf(
+                condition,
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Right_computes_predicate_T_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+
+            Result<T> returned = await result.MapIf(
+                (value, context) => GetValuePredicate(condition)(value),
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Right_computes_predicate_T_E_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+
+            Result<T, E> returned = await result.MapIf(
+                (value, context) => GetValuePredicate(condition)(value),
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.cs
index c723527f..2c32c20f 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.cs
@@ -1,71 +1,195 @@
-using System.Threading.Tasks;
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapIfTests_Task : MapIfTestsBase
-    {
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_T_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Task<Result<T>> resultTask = Result.SuccessIf(isSuccess, T.Value, ErrorMessage).AsTask();
-
-            Result<T> returned = await resultTask.MapIf(condition, GetTaskAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_T_E_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
-
-            Result<T, E> returned = await resultTask.MapIf(condition, GetTaskAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_computes_predicate_T_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Task<Result<T>> resultTask = Result.SuccessIf(isSuccess, T.Value, ErrorMessage).AsTask();
-
-            Result<T> returned = await resultTask.MapIf(GetValuePredicate(condition), GetTaskAction());
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
-
-            Result<T, E> returned = await resultTask.MapIf(GetValuePredicate(condition), GetTaskAction());
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-    }
-}
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapIfTests_Task : MapIfTestsBase
+    {
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsTask();
+            Result<T> returned = await resultTask.MapIf(condition, GetTaskAction());
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
+            Result<T, E> returned = await resultTask.MapIf(condition, GetTaskAction());
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsTask();
+            Result<T> returned = await resultTask.MapIf(
+                GetValuePredicate(condition),
+                GetTaskAction()
+            );
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
+            Result<T, E> returned = await resultTask.MapIf(
+                GetValuePredicate(condition),
+                GetTaskAction()
+            );
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_T_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsTask();
+            Result<T> returned = await resultTask.MapIf(
+                condition,
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetTaskAction()(value);
+                },
+                ContextMessage
+            );
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_T_E_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
+            Result<T, E> returned = await resultTask.MapIf(
+                condition,
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetTaskAction()(value);
+                },
+                ContextMessage
+            );
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_computes_predicate_T_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsTask();
+            Result<T> returned = await resultTask.MapIf(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValuePredicate(condition)(value);
+                },
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetTaskAction()(value);
+                },
+                ContextMessage
+            );
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_computes_predicate_T_E_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
+            Result<T, E> returned = await resultTask.MapIf(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValuePredicate(condition)(value);
+                },
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetTaskAction()(value);
+                },
+                ContextMessage
+            );
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Left.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Left.cs
index c465a94d..fab536c8 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Left.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Left.cs
@@ -1,72 +1,209 @@
-using System.Threading.Tasks;
-using CSharpFunctionalExtensions.ValueTasks;
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapIfTests_ValueTask_Left : MapIfTestsBase
-    {
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Left_T_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-
-            Result<T> returned = await result.MapIf(condition, GetValueTaskAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Left_T_E_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
-
-            Result<T, E> returned = await result.MapIf(condition, GetValueTaskAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Left_computes_predicate_T_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-
-            Result<T> returned = await result.MapIf(GetValuePredicate(condition), GetValueTaskAction());
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Left_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
-
-            Result<T, E> returned = await result.MapIf(GetValuePredicate(condition), GetValueTaskAction());
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-    }
-}
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapIfTests_ValueTask_Left : MapIfTestsBase
+    {
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Left_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsValueTask();
+
+            Result<T> returned = await resultTask.MapIf(condition, GetAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Left_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T, E>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, E.Value)
+                .AsValueTask();
+
+            Result<T, E> returned = await resultTask.MapIf(condition, GetAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Left_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsValueTask();
+
+            Result<T> returned = await resultTask.MapIf(GetValuePredicate(condition), GetAction());
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Left_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T, E>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, E.Value)
+                .AsValueTask();
+
+            Result<T, E> returned = await resultTask.MapIf(
+                GetValuePredicate(condition),
+                GetAction()
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Left_T_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsValueTask();
+
+            Result<T> returned = await resultTask.MapIf(
+                condition,
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Left_T_E_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T, E>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, E.Value)
+                .AsValueTask();
+
+            Result<T, E> returned = await resultTask.MapIf(
+                condition,
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Left_computes_predicate_T_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsValueTask();
+
+            Result<T> returned = await resultTask.MapIf(
+                (value, context) => GetValuePredicate(condition)(value),
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Left_computes_predicate_T_E_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T, E>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, E.Value)
+                .AsValueTask();
+
+            Result<T, E> returned = await resultTask.MapIf(
+                (value, context) => GetValuePredicate(condition)(value),
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Right.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Right.cs
index d36b0e7d..6e818833 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Right.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Right.cs
@@ -1,72 +1,196 @@
-using System.Threading.Tasks;
-using CSharpFunctionalExtensions.ValueTasks;
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapIfTests_ValueTask_Right : MapIfTestsBase
-    {
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Right_T_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            ValueTask<Result<T>> resultTask = Result.SuccessIf(isSuccess, T.Value, ErrorMessage).AsValueTask();
-
-            Result<T> returned = await resultTask.MapIf(condition, GetAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Right_T_E_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            ValueTask<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsValueTask();
-
-            Result<T, E> returned = await resultTask.MapIf(condition, GetAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Right_computes_predicate_T_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            ValueTask<Result<T>> resultTask = Result.SuccessIf(isSuccess, T.Value, ErrorMessage).AsValueTask();
-
-            Result<T> returned = await resultTask.MapIf(GetValuePredicate(condition), GetAction());
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Right_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            ValueTask<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsValueTask();
-
-            Result<T, E> returned = await resultTask.MapIf(GetValuePredicate(condition), GetAction());
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-    }
-}
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapIfTests_ValueTask_Right : MapIfTestsBase
+    {
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Right_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+
+            Result<T> returned = await result.MapIf(condition, GetValueTaskAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Right_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+
+            Result<T, E> returned = await result.MapIf(condition, GetValueTaskAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Right_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+
+            Result<T> returned = await result.MapIf(
+                GetValuePredicate(condition),
+                GetValueTaskAction()
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Right_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+
+            Result<T, E> returned = await result.MapIf(
+                GetValuePredicate(condition),
+                GetValueTaskAction()
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Right_T_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+
+            Result<T> returned = await result.MapIf(
+                condition,
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValueTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Right_T_E_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+
+            Result<T, E> returned = await result.MapIf(
+                condition,
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValueTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Right_computes_predicate_T_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+
+            Result<T> returned = await result.MapIf(
+                (value, context) => GetValuePredicate(condition)(value),
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValueTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Right_computes_predicate_T_E_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+
+            Result<T, E> returned = await result.MapIf(
+                (value, context) => GetValuePredicate(condition)(value),
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValueTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.cs
index 9a33f3dd..c057efa8 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.cs
@@ -1,72 +1,212 @@
-using System.Threading.Tasks;
-using CSharpFunctionalExtensions.ValueTasks;
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapIfTests_ValueTask : MapIfTestsBase
-    {
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_T_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            ValueTask<Result<T>> resultTask = Result.SuccessIf(isSuccess, T.Value, ErrorMessage).AsValueTask();
-
-            Result<T> returned = await resultTask.MapIf(condition, GetValueTaskAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_T_E_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            ValueTask<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsValueTask();
-
-            Result<T, E> returned = await resultTask.MapIf(condition, GetValueTaskAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_computes_predicate_T_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            ValueTask<Result<T>> resultTask = Result.SuccessIf(isSuccess, T.Value, ErrorMessage).AsValueTask();
-
-            Result<T> returned = await resultTask.MapIf(GetValuePredicate(condition), GetValueTaskAction());
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            ValueTask<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsValueTask();
-
-            Result<T, E> returned = await resultTask.MapIf(GetValuePredicate(condition), GetValueTaskAction());
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-    }
-}
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapIfTests_ValueTask : MapIfTestsBase
+    {
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsValueTask();
+
+            Result<T> returned = await resultTask.MapIf(condition, GetValueTaskAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T, E>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, E.Value)
+                .AsValueTask();
+
+            Result<T, E> returned = await resultTask.MapIf(condition, GetValueTaskAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsValueTask();
+
+            Result<T> returned = await resultTask.MapIf(
+                GetValuePredicate(condition),
+                GetValueTaskAction()
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T, E>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, E.Value)
+                .AsValueTask();
+
+            Result<T, E> returned = await resultTask.MapIf(
+                GetValuePredicate(condition),
+                GetValueTaskAction()
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_T_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsValueTask();
+
+            Result<T> returned = await resultTask.MapIf(
+                condition,
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetValueTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_T_E_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T, E>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, E.Value)
+                .AsValueTask();
+
+            Result<T, E> returned = await resultTask.MapIf(
+                condition,
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetValueTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_computes_predicate_T_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsValueTask();
+
+            Result<T> returned = await resultTask.MapIf(
+                (value, context) => GetValuePredicate(condition)(value),
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetValueTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_computes_predicate_T_E_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T, E>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, E.Value)
+                .AsValueTask();
+
+            Result<T, E> returned = await resultTask.MapIf(
+                (value, context) => GetValuePredicate(condition)(value),
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetValueTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.cs
index 825654b1..784e1268 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.cs
@@ -1,70 +1,180 @@
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapIfTests : MapIfTestsBase
-    {
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public void MapIf_T_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-
-            Result<T> returned = result.MapIf(condition, GetAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public void MapIf_T_E_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
-
-            Result<T, E> returned = result.MapIf(condition, GetAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public void MapIf_computes_predicate_T_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-
-            Result<T> returned = result.MapIf(GetValuePredicate(condition), GetAction());
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public void MapIf_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(bool isSuccess, bool condition)
-        {
-            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
-
-            Result<T, E> returned = result.MapIf(GetValuePredicate(condition), GetAction());
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-    }
-}
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapIfTests : MapIfTestsBase
+    {
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void MapIf_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+            Result<T> returned = result.MapIf(condition, GetAction());
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void MapIf_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+            Result<T, E> returned = result.MapIf(condition, GetAction());
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void MapIf_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+            Result<T> returned = result.MapIf(GetValuePredicate(condition), GetAction());
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void MapIf_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+            Result<T, E> returned = result.MapIf(GetValuePredicate(condition), GetAction());
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void MapIf_T_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+            Result<T> returned = result.MapIf(
+                condition,
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void MapIf_T_E_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+            Result<T, E> returned = result.MapIf(
+                condition,
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void MapIf_computes_predicate_T_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+            Result<T> returned = result.MapIf(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValuePredicate(condition)(value);
+                },
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void MapIf_computes_predicate_T_E_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+            Result<T, E> returned = result.MapIf(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValuePredicate(condition)(value);
+                },
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Left.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Left.cs
index c702d000..578575bb 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Left.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Left.cs
@@ -1,32 +1,92 @@
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions
-{
-    public static partial class ResultExtensions
-    {
-        public static async Task<Result<T>> MapIf<T>(this Task<Result<T>> resultTask, bool condition, Func<T, T> func)
-        {
-            var result = await resultTask.DefaultAwait();
-            return result.MapIf(condition, func);
-        }
-
-        public static async Task<Result<T, E>> MapIf<T, E>(this Task<Result<T, E>> resultTask, bool condition, Func<T, T> func)
-        {
-            var result = await resultTask.DefaultAwait();
-            return result.MapIf(condition, func);
-        }
-
-        public static async Task<Result<T>> MapIf<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, T> func)
-        {
-            var result = await resultTask.DefaultAwait();
-            return result.MapIf(predicate, func);
-        }
-
-        public static async Task<Result<T, E>> MapIf<T, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Func<T, T> func)
-        {
-            var result = await resultTask.DefaultAwait();
-            return result.MapIf(predicate, func);
-        }
-    }
-}
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class ResultExtensions
+    {
+        public static async Task<Result<T>> MapIf<T>(
+            this Task<Result<T>> resultTask,
+            bool condition,
+            Func<T, T> func
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return result.MapIf(condition, func);
+        }
+
+        public static async Task<Result<T>> MapIf<T, TContext>(
+            this Task<Result<T>> resultTask,
+            bool condition,
+            Func<T, TContext, T> func,
+            TContext context
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return result.MapIf(condition, func, context);
+        }
+
+        public static async Task<Result<T, E>> MapIf<T, E>(
+            this Task<Result<T, E>> resultTask,
+            bool condition,
+            Func<T, T> func
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return result.MapIf(condition, func);
+        }
+
+        public static async Task<Result<T, E>> MapIf<T, E, TContext>(
+            this Task<Result<T, E>> resultTask,
+            bool condition,
+            Func<T, TContext, T> func,
+            TContext context
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return result.MapIf(condition, func, context);
+        }
+
+        public static async Task<Result<T>> MapIf<T>(
+            this Task<Result<T>> resultTask,
+            Func<T, bool> predicate,
+            Func<T, T> func
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return result.MapIf(predicate, func);
+        }
+
+        public static async Task<Result<T>> MapIf<T, TContext>(
+            this Task<Result<T>> resultTask,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, T> func,
+            TContext context
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return result.MapIf(predicate, func, context);
+        }
+
+        public static async Task<Result<T, E>> MapIf<T, E>(
+            this Task<Result<T, E>> resultTask,
+            Func<T, bool> predicate,
+            Func<T, T> func
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return result.MapIf(predicate, func);
+        }
+
+        public static async Task<Result<T, E>> MapIf<T, E, TContext>(
+            this Task<Result<T, E>> resultTask,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, T> func,
+            TContext context
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return result.MapIf(predicate, func, context);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Right.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Right.cs
index ec05c65c..adc7f944 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Right.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Right.cs
@@ -1,48 +1,124 @@
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions
-{
-    public static partial class ResultExtensions
-    {
-        public static Task<Result<T>> MapIf<T>(this Result<T> result, bool condition, Func<T, Task<T>> func)
-        {
-            if (!condition)
-            {
-                return result.AsCompletedTask();
-            }
-
-            return result.Map(func);
-        }
-
-        public static Task<Result<T, E>> MapIf<T, E>(this Result<T, E> result, bool condition, Func<T, Task<T>> func)
-        {
-            if (!condition)
-            {
-                return result.AsCompletedTask();
-            }
-
-            return result.Map(func);
-        }
-
-        public static Task<Result<T>> MapIf<T>(this Result<T> result, Func<T, bool> predicate, Func<T, Task<T>> func)
-        {
-            if (!result.IsSuccess || !predicate(result.Value))
-            {
-                return result.AsCompletedTask();
-            }
-
-            return result.Map(func);
-        }
-
-        public static Task<Result<T, E>> MapIf<T, E>(this Result<T, E> result, Func<T, bool> predicate, Func<T, Task<T>> func)
-        {
-            if (!result.IsSuccess || !predicate(result.Value))
-            {
-                return result.AsCompletedTask();
-            }
-
-            return result.Map(func);
-        }
-    }
-}
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class ResultExtensions
+    {
+        public static Task<Result<T>> MapIf<T>(
+            this Result<T> result,
+            bool condition,
+            Func<T, Task<T>> func
+        )
+        {
+            if (!condition)
+            {
+                return result.AsCompletedTask();
+            }
+
+            return result.Map(func);
+        }
+
+        public static Task<Result<T>> MapIf<T, TContext>(
+            this Result<T> result,
+            bool condition,
+            Func<T, TContext, Task<T>> func,
+            TContext context
+        )
+        {
+            if (!condition)
+            {
+                return result.AsCompletedTask();
+            }
+
+            return result.Map(func, context);
+        }
+
+        public static Task<Result<T, E>> MapIf<T, E>(
+            this Result<T, E> result,
+            bool condition,
+            Func<T, Task<T>> func
+        )
+        {
+            if (!condition)
+            {
+                return result.AsCompletedTask();
+            }
+
+            return result.Map(func);
+        }
+
+        public static Task<Result<T, E>> MapIf<T, E, TContext>(
+            this Result<T, E> result,
+            bool condition,
+            Func<T, TContext, Task<T>> func,
+            TContext context
+        )
+        {
+            if (!condition)
+            {
+                return result.AsCompletedTask();
+            }
+
+            return result.Map(func, context);
+        }
+
+        public static Task<Result<T>> MapIf<T>(
+            this Result<T> result,
+            Func<T, bool> predicate,
+            Func<T, Task<T>> func
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value))
+            {
+                return result.AsCompletedTask();
+            }
+
+            return result.Map(func);
+        }
+
+        public static Task<Result<T>> MapIf<T, TContext>(
+            this Result<T> result,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, Task<T>> func,
+            TContext context
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value, context))
+            {
+                return result.AsCompletedTask();
+            }
+
+            return result.Map(func, context);
+        }
+
+        public static Task<Result<T, E>> MapIf<T, E>(
+            this Result<T, E> result,
+            Func<T, bool> predicate,
+            Func<T, Task<T>> func
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value))
+            {
+                return result.AsCompletedTask();
+            }
+
+            return result.Map(func);
+        }
+
+        public static Task<Result<T, E>> MapIf<T, E, TContext>(
+            this Result<T, E> result,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, Task<T>> func,
+            TContext context
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value, context))
+            {
+                return result.AsCompletedTask();
+            }
+
+            return result.Map(func, context);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.cs
index 45eb46ac..c520ed35 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.cs
@@ -1,32 +1,92 @@
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions
-{
-    public static partial class ResultExtensions
-    {
-        public static async Task<Result<T>> MapIf<T>(this Task<Result<T>> resultTask, bool condition, Func<T, Task<T>> func)
-        {
-            var result = await resultTask.DefaultAwait();
-            return await result.MapIf(condition, func).DefaultAwait();
-        }
-
-        public static async Task<Result<T, E>> MapIf<T, E>(this Task<Result<T, E>> resultTask, bool condition, Func<T, Task<T>> func)
-        {
-            var result = await resultTask.DefaultAwait();
-            return await result.MapIf(condition, func).DefaultAwait();
-        }
-
-        public static async Task<Result<T>> MapIf<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, Task<T>> func)
-        {
-            var result = await resultTask.DefaultAwait();
-            return await result.MapIf(predicate, func).DefaultAwait();
-        }
-
-        public static async Task<Result<T, E>> MapIf<T, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Func<T, Task<T>> func)
-        {
-            var result = await resultTask.DefaultAwait();
-            return await result.MapIf(predicate, func).DefaultAwait();
-        }
-    }
-}
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class ResultExtensions
+    {
+        public static async Task<Result<T>> MapIf<T>(
+            this Task<Result<T>> resultTask,
+            bool condition,
+            Func<T, Task<T>> func
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return await result.MapIf(condition, func).DefaultAwait();
+        }
+
+        public static async Task<Result<T>> MapIf<T, TContext>(
+            this Task<Result<T>> resultTask,
+            bool condition,
+            Func<T, TContext, Task<T>> func,
+            TContext context
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return await result.MapIf(condition, func, context).DefaultAwait();
+        }
+
+        public static async Task<Result<T, E>> MapIf<T, E>(
+            this Task<Result<T, E>> resultTask,
+            bool condition,
+            Func<T, Task<T>> func
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return await result.MapIf(condition, func).DefaultAwait();
+        }
+
+        public static async Task<Result<T, E>> MapIf<T, E, TContext>(
+            this Task<Result<T, E>> resultTask,
+            bool condition,
+            Func<T, TContext, Task<T>> func,
+            TContext context
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return await result.MapIf(condition, func, context).DefaultAwait();
+        }
+
+        public static async Task<Result<T>> MapIf<T>(
+            this Task<Result<T>> resultTask,
+            Func<T, bool> predicate,
+            Func<T, Task<T>> func
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return await result.MapIf(predicate, func).DefaultAwait();
+        }
+
+        public static async Task<Result<T>> MapIf<T, TContext>(
+            this Task<Result<T>> resultTask,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, Task<T>> func,
+            TContext context
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return await result.MapIf(predicate, func, context).DefaultAwait();
+        }
+
+        public static async Task<Result<T, E>> MapIf<T, E>(
+            this Task<Result<T, E>> resultTask,
+            Func<T, bool> predicate,
+            Func<T, Task<T>> func
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return await result.MapIf(predicate, func).DefaultAwait();
+        }
+
+        public static async Task<Result<T, E>> MapIf<T, E, TContext>(
+            this Task<Result<T, E>> resultTask,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, Task<T>> func,
+            TContext context
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return await result.MapIf(predicate, func, context).DefaultAwait();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Left.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Left.cs
index e58fe375..fd7543f3 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Left.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Left.cs
@@ -1,34 +1,94 @@
-#if NET5_0_OR_GREATER
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions.ValueTasks
-{
-    public static partial class ResultExtensions
-    {
-        public static async ValueTask<Result<T>> MapIf<T>(this ValueTask<Result<T>> resultTask, bool condition, Func<T, T> valueTask)
-        {
-            var result = await resultTask;
-            return result.MapIf(condition, valueTask);
-        }
-
-        public static async ValueTask<Result<T, E>> MapIf<T, E>(this ValueTask<Result<T, E>> resultTask, bool condition, Func<T, T> valueTask)
-        {
-            var result = await resultTask;
-            return result.MapIf(condition, valueTask);
-        }
-
-        public static async ValueTask<Result<T>> MapIf<T>(this ValueTask<Result<T>> resultTask, Func<T, bool> predicate, Func<T, T> valueTask)
-        {
-            var result = await resultTask;
-            return result.MapIf(predicate, valueTask);
-        }
-
-        public static async ValueTask<Result<T, E>> MapIf<T, E>(this ValueTask<Result<T, E>> resultTask, Func<T, bool> predicate, Func<T, T> valueTask)
-        {
-            var result = await resultTask;
-            return result.MapIf(predicate, valueTask);
-        }
-    }
-}
-#endif
+#if NET5_0_OR_GREATER
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.ValueTasks
+{
+    public static partial class ResultExtensions
+    {
+        public static async ValueTask<Result<T>> MapIf<T>(
+            this ValueTask<Result<T>> resultTask,
+            bool condition,
+            Func<T, T> valueTask
+        )
+        {
+            var result = await resultTask;
+            return result.MapIf(condition, valueTask);
+        }
+
+        public static async ValueTask<Result<T>> MapIf<T, TContext>(
+            this ValueTask<Result<T>> resultTask,
+            bool condition,
+            Func<T, TContext, T> valueTask,
+            TContext context
+        )
+        {
+            var result = await resultTask;
+            return result.MapIf(condition, valueTask, context);
+        }
+
+        public static async ValueTask<Result<T, E>> MapIf<T, E>(
+            this ValueTask<Result<T, E>> resultTask,
+            bool condition,
+            Func<T, T> valueTask
+        )
+        {
+            var result = await resultTask;
+            return result.MapIf(condition, valueTask);
+        }
+
+        public static async ValueTask<Result<T, E>> MapIf<T, E, TContext>(
+            this ValueTask<Result<T, E>> resultTask,
+            bool condition,
+            Func<T, TContext, T> valueTask,
+            TContext context
+        )
+        {
+            var result = await resultTask;
+            return result.MapIf(condition, valueTask, context);
+        }
+
+        public static async ValueTask<Result<T>> MapIf<T>(
+            this ValueTask<Result<T>> resultTask,
+            Func<T, bool> predicate,
+            Func<T, T> valueTask
+        )
+        {
+            var result = await resultTask;
+            return result.MapIf(predicate, valueTask);
+        }
+
+        public static async ValueTask<Result<T>> MapIf<T, TContext>(
+            this ValueTask<Result<T>> resultTask,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, T> valueTask,
+            TContext context
+        )
+        {
+            var result = await resultTask;
+            return result.MapIf(predicate, valueTask, context);
+        }
+
+        public static async ValueTask<Result<T, E>> MapIf<T, E>(
+            this ValueTask<Result<T, E>> resultTask,
+            Func<T, bool> predicate,
+            Func<T, T> valueTask
+        )
+        {
+            var result = await resultTask;
+            return result.MapIf(predicate, valueTask);
+        }
+
+        public static async ValueTask<Result<T, E>> MapIf<T, E, TContext>(
+            this ValueTask<Result<T, E>> resultTask,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, T> valueTask,
+            TContext context
+        )
+        {
+            var result = await resultTask;
+            return result.MapIf(predicate, valueTask, context);
+        }
+    }
+}
+#endif
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Right.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Right.cs
index c8b3e30d..017ac15d 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Right.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Right.cs
@@ -1,50 +1,126 @@
-#if NET5_0_OR_GREATER
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions.ValueTasks
-{
-    public static partial class ResultExtensions
-    {
-        public static ValueTask<Result<T>> MapIf<T>(this Result<T> result, bool condition, Func<T, ValueTask<T>> valueTask)
-        {
-            if (!condition)
-            {
-                return result.AsCompletedValueTask();
-            }
-
-            return result.Map(valueTask);
-        }
-
-        public static ValueTask<Result<T, E>> MapIf<T, E>(this Result<T, E> result, bool condition, Func<T, ValueTask<T>> valueTask)
-        {
-            if (!condition)
-            {
-                return result.AsCompletedValueTask();
-            }
-
-            return result.Map(valueTask);
-        }
-
-        public static ValueTask<Result<T>> MapIf<T>(this Result<T> result, Func<T, bool> predicate, Func<T, ValueTask<T>> valueTask)
-        {
-            if (!result.IsSuccess || !predicate(result.Value))
-            {
-                return result.AsCompletedValueTask();
-            }
-
-            return result.Map(valueTask);
-        }
-
-        public static ValueTask<Result<T, E>> MapIf<T, E>(this Result<T, E> result, Func<T, bool> predicate, Func<T, ValueTask<T>> valueTask)
-        {
-            if (!result.IsSuccess || !predicate(result.Value))
-            {
-                return result.AsCompletedValueTask();
-            }
-
-            return result.Map(valueTask);
-        }
-    }
-}
-#endif
+#if NET5_0_OR_GREATER
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.ValueTasks
+{
+    public static partial class ResultExtensions
+    {
+        public static ValueTask<Result<T>> MapIf<T>(
+            this Result<T> result,
+            bool condition,
+            Func<T, ValueTask<T>> valueTask
+        )
+        {
+            if (!condition)
+            {
+                return result.AsCompletedValueTask();
+            }
+
+            return result.Map(valueTask);
+        }
+
+        public static ValueTask<Result<T>> MapIf<T, TContext>(
+            this Result<T> result,
+            bool condition,
+            Func<T, TContext, ValueTask<T>> valueTask,
+            TContext context
+        )
+        {
+            if (!condition)
+            {
+                return result.AsCompletedValueTask();
+            }
+
+            return result.Map(valueTask, context);
+        }
+
+        public static ValueTask<Result<T, E>> MapIf<T, E>(
+            this Result<T, E> result,
+            bool condition,
+            Func<T, ValueTask<T>> valueTask
+        )
+        {
+            if (!condition)
+            {
+                return result.AsCompletedValueTask();
+            }
+
+            return result.Map(valueTask);
+        }
+
+        public static ValueTask<Result<T, E>> MapIf<T, E, TContext>(
+            this Result<T, E> result,
+            bool condition,
+            Func<T, TContext, ValueTask<T>> valueTask,
+            TContext context
+        )
+        {
+            if (!condition)
+            {
+                return result.AsCompletedValueTask();
+            }
+
+            return result.Map(valueTask, context);
+        }
+
+        public static ValueTask<Result<T>> MapIf<T>(
+            this Result<T> result,
+            Func<T, bool> predicate,
+            Func<T, ValueTask<T>> valueTask
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value))
+            {
+                return result.AsCompletedValueTask();
+            }
+
+            return result.Map(valueTask);
+        }
+
+        public static ValueTask<Result<T>> MapIf<T, TContext>(
+            this Result<T> result,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, ValueTask<T>> valueTask,
+            TContext context
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value, context))
+            {
+                return result.AsCompletedValueTask();
+            }
+
+            return result.Map(valueTask, context);
+        }
+
+        public static ValueTask<Result<T, E>> MapIf<T, E>(
+            this Result<T, E> result,
+            Func<T, bool> predicate,
+            Func<T, ValueTask<T>> valueTask
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value))
+            {
+                return result.AsCompletedValueTask();
+            }
+
+            return result.Map(valueTask);
+        }
+
+        public static ValueTask<Result<T, E>> MapIf<T, E, TContext>(
+            this Result<T, E> result,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, ValueTask<T>> valueTask,
+            TContext context
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value, context))
+            {
+                return result.AsCompletedValueTask();
+            }
+
+            return result.Map(valueTask, context);
+        }
+    }
+}
+#endif
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.cs
index 758c1584..cb8395d1 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.cs
@@ -1,34 +1,94 @@
-#if NET5_0_OR_GREATER
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions.ValueTasks
-{
-    public static partial class ResultExtensions
-    {
-        public static async ValueTask<Result<T>> MapIf<T>(this ValueTask<Result<T>> resultTask, bool condition, Func<T, ValueTask<T>> valueTask)
-        {
-            var result = await resultTask;
-            return await result.MapIf(condition, valueTask);
-        }
-
-        public static async ValueTask<Result<T, E>> MapIf<T, E>(this ValueTask<Result<T, E>> resultTask, bool condition, Func<T, ValueTask<T>> valueTask)
-        {
-            var result = await resultTask;
-            return await result.MapIf(condition, valueTask);
-        }
-
-        public static async ValueTask<Result<T>> MapIf<T>(this ValueTask<Result<T>> resultTask, Func<T, bool> predicate, Func<T, ValueTask<T>> valueTask)
-        {
-            var result = await resultTask;
-            return await result.MapIf(predicate, valueTask);
-        }
-
-        public static async ValueTask<Result<T, E>> MapIf<T, E>(this ValueTask<Result<T, E>> resultTask, Func<T, bool> predicate, Func<T, ValueTask<T>> valueTask)
-        {
-            var result = await resultTask;
-            return await result.MapIf(predicate, valueTask);
-        }
-    }
-}
-#endif
+#if NET5_0_OR_GREATER
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.ValueTasks
+{
+    public static partial class ResultExtensions
+    {
+        public static async ValueTask<Result<T>> MapIf<T>(
+            this ValueTask<Result<T>> resultTask,
+            bool condition,
+            Func<T, ValueTask<T>> valueTask
+        )
+        {
+            var result = await resultTask;
+            return await result.MapIf(condition, valueTask);
+        }
+
+        public static async ValueTask<Result<T>> MapIf<T, TContext>(
+            this ValueTask<Result<T>> resultTask,
+            bool condition,
+            Func<T, TContext, ValueTask<T>> valueTask,
+            TContext context
+        )
+        {
+            var result = await resultTask;
+            return await result.MapIf(condition, valueTask, context);
+        }
+
+        public static async ValueTask<Result<T, E>> MapIf<T, E>(
+            this ValueTask<Result<T, E>> resultTask,
+            bool condition,
+            Func<T, ValueTask<T>> valueTask
+        )
+        {
+            var result = await resultTask;
+            return await result.MapIf(condition, valueTask);
+        }
+
+        public static async ValueTask<Result<T, E>> MapIf<T, E, TContext>(
+            this ValueTask<Result<T, E>> resultTask,
+            bool condition,
+            Func<T, TContext, ValueTask<T>> valueTask,
+            TContext context
+        )
+        {
+            var result = await resultTask;
+            return await result.MapIf(condition, valueTask, context);
+        }
+
+        public static async ValueTask<Result<T>> MapIf<T>(
+            this ValueTask<Result<T>> resultTask,
+            Func<T, bool> predicate,
+            Func<T, ValueTask<T>> valueTask
+        )
+        {
+            var result = await resultTask;
+            return await result.MapIf(predicate, valueTask);
+        }
+
+        public static async ValueTask<Result<T>> MapIf<T, TContext>(
+            this ValueTask<Result<T>> resultTask,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, ValueTask<T>> valueTask,
+            TContext context
+        )
+        {
+            var result = await resultTask;
+            return await result.MapIf(predicate, valueTask, context);
+        }
+
+        public static async ValueTask<Result<T, E>> MapIf<T, E>(
+            this ValueTask<Result<T, E>> resultTask,
+            Func<T, bool> predicate,
+            Func<T, ValueTask<T>> valueTask
+        )
+        {
+            var result = await resultTask;
+            return await result.MapIf(predicate, valueTask);
+        }
+
+        public static async ValueTask<Result<T, E>> MapIf<T, E, TContext>(
+            this ValueTask<Result<T, E>> resultTask,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, ValueTask<T>> valueTask,
+            TContext context
+        )
+        {
+            var result = await resultTask;
+            return await result.MapIf(predicate, valueTask, context);
+        }
+    }
+}
+#endif
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.cs
index 644861df..49e60c00 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.cs
@@ -1,59 +1,131 @@
-using System;
-
-namespace CSharpFunctionalExtensions
-{
-    /// <summary>
-    ///     Creates a new result from the return value of a given function if the condition is true. If the calling Result is a failure, a new failure result is returned instead.
-    /// </summary>
-    public static partial class ResultExtensions
-    {
-        public static Result<T> MapIf<T>(this Result<T> result, bool condition, Func<T, T> func)
-        {
-            if (!condition)
-            {
-                return result;
-            }
-
-            return result.Map(func);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function if the condition is true. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static Result<T, E> MapIf<T, E>(this Result<T, E> result, bool condition, Func<T, T> func)
-        {
-            if (!condition)
-            {
-                return result;
-            }
-
-            return result.Map(func);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function if the predicate is true. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static Result<T> MapIf<T>(this Result<T> result, Func<T, bool> predicate, Func<T, T> func)
-        {
-            if (!result.IsSuccess || !predicate(result.Value))
-            {
-                return result;
-            }
-
-            return result.Map(func);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function if the predicate is true. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static Result<T, E> MapIf<T, E>(this Result<T, E> result, Func<T, bool> predicate, Func<T, T> func)
-        {
-            if (!result.IsSuccess || !predicate(result.Value))
-            {
-                return result;
-            }
-
-            return result.Map(func);
-        }
-    }
-}
+using System;
+
+namespace CSharpFunctionalExtensions
+{
+    /// <summary>
+    ///     Creates a new result from the return value of a given function if the condition is true. If the calling Result is a failure, a new failure result is returned instead.
+    /// </summary>
+    public static partial class ResultExtensions
+    {
+        public static Result<T> MapIf<T>(this Result<T> result, bool condition, Func<T, T> func)
+        {
+            if (!condition)
+            {
+                return result;
+            }
+
+            return result.Map(func);
+        }
+
+        public static Result<T> MapIf<T, TContext>(
+            this Result<T> result,
+            bool condition,
+            Func<T, TContext, T> func,
+            TContext context
+        )
+        {
+            if (!condition)
+            {
+                return result;
+            }
+
+            return result.Map(func, context);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function if the condition is true. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<T, E> MapIf<T, E>(
+            this Result<T, E> result,
+            bool condition,
+            Func<T, T> func
+        )
+        {
+            if (!condition)
+            {
+                return result;
+            }
+
+            return result.Map(func);
+        }
+
+        public static Result<T, E> MapIf<T, E, TContext>(
+            this Result<T, E> result,
+            bool condition,
+            Func<T, TContext, T> func,
+            TContext context
+        )
+        {
+            if (!condition)
+            {
+                return result;
+            }
+
+            return result.Map(func, context);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function if the predicate is true. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<T> MapIf<T>(
+            this Result<T> result,
+            Func<T, bool> predicate,
+            Func<T, T> func
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value))
+            {
+                return result;
+            }
+
+            return result.Map(func);
+        }
+
+        public static Result<T> MapIf<T, TContext>(
+            this Result<T> result,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, T> func,
+            TContext context
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value, context))
+            {
+                return result;
+            }
+
+            return result.Map(func, context);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function if the predicate is true. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<T, E> MapIf<T, E>(
+            this Result<T, E> result,
+            Func<T, bool> predicate,
+            Func<T, T> func
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value))
+            {
+                return result;
+            }
+
+            return result.Map(func);
+        }
+
+        public static Result<T, E> MapIf<T, E, TContext>(
+            this Result<T, E> result,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, T> func,
+            TContext context
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value, context))
+            {
+                return result;
+            }
+
+            return result.Map(func, context);
+        }
+    }
+}

From b4b398c46dac6d88e31c643142ac8eac16db674d Mon Sep 17 00:00:00 2001
From: Marcin Jahn <10273406+marcinjahn@users.noreply.github.com>
Date: Sat, 23 Nov 2024 08:49:00 +0100
Subject: [PATCH 4/4] Restore line endings

---
 .../ResultTests/Extensions/MapIfTests.Base.cs | 152 +++----
 .../Extensions/MapIfTests.Task.Left.cs        | 416 ++++++++---------
 .../Extensions/MapIfTests.Task.Right.cs       | 384 ++++++++--------
 .../ResultTests/Extensions/MapIfTests.Task.cs | 390 ++++++++--------
 .../Extensions/MapIfTests.ValueTask.Left.cs   | 418 ++++++++---------
 .../Extensions/MapIfTests.ValueTask.Right.cs  | 392 ++++++++--------
 .../Extensions/MapIfTests.ValueTask.cs        | 424 +++++++++---------
 .../ResultTests/Extensions/MapIfTests.cs      | 360 +++++++--------
 .../Methods/Extensions/MapIf.Task.Left.cs     | 184 ++++----
 .../Methods/Extensions/MapIf.Task.Right.cs    | 248 +++++-----
 .../Result/Methods/Extensions/MapIf.Task.cs   | 184 ++++----
 .../Extensions/MapIf.ValueTask.Left.cs        | 188 ++++----
 .../Extensions/MapIf.ValueTask.Right.cs       | 252 +++++------
 .../Methods/Extensions/MapIf.ValueTask.cs     | 188 ++++----
 .../Result/Methods/Extensions/MapIf.cs        | 262 +++++------
 15 files changed, 2221 insertions(+), 2221 deletions(-)

diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Base.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Base.cs
index 5680eb82..f9f11f89 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Base.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Base.cs
@@ -1,76 +1,76 @@
-using System;
-using System.Threading.Tasks;
-using FluentAssertions;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public abstract class MapIfTestsBase : TestBase
-    {
-        protected bool actionExecuted;
-        protected bool predicateExecuted;
-
-        protected MapIfTestsBase()
-        {
-            actionExecuted = false;
-            predicateExecuted = false;
-        }
-
-        protected Func<T, T> GetAction() =>
-            value =>
-            {
-                actionExecuted.Should().BeFalse();
-                value.Should().Be(T.Value);
-
-                actionExecuted = true;
-                return T.Value2;
-            };
-
-        protected Func<T, Task<T>> GetTaskAction()
-        {
-            return t => Task.FromResult(GetAction()(t));
-        }
-
-        protected Func<T, ValueTask<T>> GetValueTaskAction()
-        {
-            return t => ValueTask.FromResult(GetAction()(t));
-        }
-
-        protected Func<T, bool> GetValuePredicate(bool value)
-        {
-            return t =>
-            {
-                predicateExecuted.Should().BeFalse();
-                t.Should().Be(T.Value);
-
-                predicateExecuted = true;
-                return value;
-            };
-        }
-
-        protected static Result<T> GetExpectedValueResult(bool isSuccess, bool condition)
-        {
-            var resultChanged = isSuccess && condition;
-
-            if (!resultChanged)
-            {
-                return Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-            }
-
-            return Result.SuccessIf(isSuccess, T.Value2, ErrorMessage2);
-        }
-
-        protected static Result<T, E> GetExpectedValueErrorResult(bool isSuccess, bool condition)
-        {
-            var resultChanged = isSuccess && condition;
-
-            if (!resultChanged)
-            {
-                return Result.SuccessIf(isSuccess, T.Value, E.Value);
-            }
-
-            return Result.SuccessIf(isSuccess, T.Value2, E.Value2);
-        }
-
-        protected readonly string ContextMessage = "Context data";
-    }
-}
+using System;
+using System.Threading.Tasks;
+using FluentAssertions;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public abstract class MapIfTestsBase : TestBase
+    {
+        protected bool actionExecuted;
+        protected bool predicateExecuted;
+
+        protected MapIfTestsBase()
+        {
+            actionExecuted = false;
+            predicateExecuted = false;
+        }
+
+        protected Func<T, T> GetAction() =>
+            value =>
+            {
+                actionExecuted.Should().BeFalse();
+                value.Should().Be(T.Value);
+
+                actionExecuted = true;
+                return T.Value2;
+            };
+
+        protected Func<T, Task<T>> GetTaskAction()
+        {
+            return t => Task.FromResult(GetAction()(t));
+        }
+
+        protected Func<T, ValueTask<T>> GetValueTaskAction()
+        {
+            return t => ValueTask.FromResult(GetAction()(t));
+        }
+
+        protected Func<T, bool> GetValuePredicate(bool value)
+        {
+            return t =>
+            {
+                predicateExecuted.Should().BeFalse();
+                t.Should().Be(T.Value);
+
+                predicateExecuted = true;
+                return value;
+            };
+        }
+
+        protected static Result<T> GetExpectedValueResult(bool isSuccess, bool condition)
+        {
+            var resultChanged = isSuccess && condition;
+
+            if (!resultChanged)
+            {
+                return Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+            }
+
+            return Result.SuccessIf(isSuccess, T.Value2, ErrorMessage2);
+        }
+
+        protected static Result<T, E> GetExpectedValueErrorResult(bool isSuccess, bool condition)
+        {
+            var resultChanged = isSuccess && condition;
+
+            if (!resultChanged)
+            {
+                return Result.SuccessIf(isSuccess, T.Value, E.Value);
+            }
+
+            return Result.SuccessIf(isSuccess, T.Value2, E.Value2);
+        }
+
+        protected readonly string ContextMessage = "Context data";
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Left.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Left.cs
index ecc03e60..dbf10fa0 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Left.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Left.cs
@@ -1,208 +1,208 @@
-using System.Threading.Tasks;
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapIfTests_Task_Left : MapIfTestsBase
-    {
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Left_T_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Task<Result<T>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, ErrorMessage)
-                .AsTask();
-
-            Result<T> returned = await resultTask.MapIf(condition, GetAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Left_T_E_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
-
-            Result<T, E> returned = await resultTask.MapIf(condition, GetAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Left_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Task<Result<T>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, ErrorMessage)
-                .AsTask();
-
-            Result<T> returned = await resultTask.MapIf(GetValuePredicate(condition), GetAction());
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Left_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
-
-            Result<T, E> returned = await resultTask.MapIf(
-                GetValuePredicate(condition),
-                GetAction()
-            );
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Left_T_with_context_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Task<Result<T>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, ErrorMessage)
-                .AsTask();
-
-            Result<T> returned = await resultTask.MapIf(
-                condition,
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetAction()(value);
-                },
-                ContextMessage
-            );
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Left_T_E_with_context_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
-
-            Result<T, E> returned = await resultTask.MapIf(
-                condition,
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetAction()(value);
-                },
-                ContextMessage
-            );
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Left_computes_predicate_T_with_context_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Task<Result<T>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, ErrorMessage)
-                .AsTask();
-
-            Result<T> returned = await resultTask.MapIf(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetValuePredicate(condition)(value);
-                },
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetAction()(value);
-                },
-                ContextMessage
-            );
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Left_computes_predicate_T_E_with_context_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
-
-            Result<T, E> returned = await resultTask.MapIf(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetValuePredicate(condition)(value);
-                },
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetAction()(value);
-                },
-                ContextMessage
-            );
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-    }
-}
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapIfTests_Task_Left : MapIfTestsBase
+    {
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Left_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsTask();
+
+            Result<T> returned = await resultTask.MapIf(condition, GetAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Left_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
+
+            Result<T, E> returned = await resultTask.MapIf(condition, GetAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Left_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsTask();
+
+            Result<T> returned = await resultTask.MapIf(GetValuePredicate(condition), GetAction());
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Left_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
+
+            Result<T, E> returned = await resultTask.MapIf(
+                GetValuePredicate(condition),
+                GetAction()
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Left_T_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsTask();
+
+            Result<T> returned = await resultTask.MapIf(
+                condition,
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Left_T_E_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
+
+            Result<T, E> returned = await resultTask.MapIf(
+                condition,
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Left_computes_predicate_T_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsTask();
+
+            Result<T> returned = await resultTask.MapIf(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValuePredicate(condition)(value);
+                },
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Left_computes_predicate_T_E_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
+
+            Result<T, E> returned = await resultTask.MapIf(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValuePredicate(condition)(value);
+                },
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Right.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Right.cs
index 36f2c44c..cbf41843 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Right.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Right.cs
@@ -1,192 +1,192 @@
-using System.Threading.Tasks;
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapIfTests_Task_Right : MapIfTestsBase
-    {
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Right_T_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-
-            Result<T> returned = await result.MapIf(condition, GetTaskAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Right_T_E_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
-
-            Result<T, E> returned = await result.MapIf(condition, GetTaskAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Right_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-
-            Result<T> returned = await result.MapIf(GetValuePredicate(condition), GetTaskAction());
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Right_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
-
-            Result<T, E> returned = await result.MapIf(
-                GetValuePredicate(condition),
-                GetTaskAction()
-            );
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Right_T_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-
-            Result<T> returned = await result.MapIf(
-                condition,
-                async (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return await GetTaskAction()(value);
-                },
-                ContextMessage
-            );
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Right_T_E_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
-
-            Result<T, E> returned = await result.MapIf(
-                condition,
-                async (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return await GetTaskAction()(value);
-                },
-                ContextMessage
-            );
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Right_computes_predicate_T_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-
-            Result<T> returned = await result.MapIf(
-                (value, context) => GetValuePredicate(condition)(value),
-                async (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return await GetTaskAction()(value);
-                },
-                ContextMessage
-            );
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_Right_computes_predicate_T_E_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
-
-            Result<T, E> returned = await result.MapIf(
-                (value, context) => GetValuePredicate(condition)(value),
-                async (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return await GetTaskAction()(value);
-                },
-                ContextMessage
-            );
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-    }
-}
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapIfTests_Task_Right : MapIfTestsBase
+    {
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Right_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+
+            Result<T> returned = await result.MapIf(condition, GetTaskAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Right_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+
+            Result<T, E> returned = await result.MapIf(condition, GetTaskAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Right_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+
+            Result<T> returned = await result.MapIf(GetValuePredicate(condition), GetTaskAction());
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Right_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+
+            Result<T, E> returned = await result.MapIf(
+                GetValuePredicate(condition),
+                GetTaskAction()
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Right_T_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+
+            Result<T> returned = await result.MapIf(
+                condition,
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Right_T_E_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+
+            Result<T, E> returned = await result.MapIf(
+                condition,
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Right_computes_predicate_T_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+
+            Result<T> returned = await result.MapIf(
+                (value, context) => GetValuePredicate(condition)(value),
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_Right_computes_predicate_T_E_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+
+            Result<T, E> returned = await result.MapIf(
+                (value, context) => GetValuePredicate(condition)(value),
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.cs
index 2c32c20f..c770a74e 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.cs
@@ -1,195 +1,195 @@
-using System.Threading.Tasks;
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapIfTests_Task : MapIfTestsBase
-    {
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_T_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Task<Result<T>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, ErrorMessage)
-                .AsTask();
-            Result<T> returned = await resultTask.MapIf(condition, GetTaskAction());
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_T_E_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
-            Result<T, E> returned = await resultTask.MapIf(condition, GetTaskAction());
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Task<Result<T>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, ErrorMessage)
-                .AsTask();
-            Result<T> returned = await resultTask.MapIf(
-                GetValuePredicate(condition),
-                GetTaskAction()
-            );
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
-            Result<T, E> returned = await resultTask.MapIf(
-                GetValuePredicate(condition),
-                GetTaskAction()
-            );
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_T_with_context_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Task<Result<T>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, ErrorMessage)
-                .AsTask();
-            Result<T> returned = await resultTask.MapIf(
-                condition,
-                async (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return await GetTaskAction()(value);
-                },
-                ContextMessage
-            );
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_T_E_with_context_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
-            Result<T, E> returned = await resultTask.MapIf(
-                condition,
-                async (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return await GetTaskAction()(value);
-                },
-                ContextMessage
-            );
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_computes_predicate_T_with_context_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Task<Result<T>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, ErrorMessage)
-                .AsTask();
-            Result<T> returned = await resultTask.MapIf(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetValuePredicate(condition)(value);
-                },
-                async (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return await GetTaskAction()(value);
-                },
-                ContextMessage
-            );
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_Task_computes_predicate_T_E_with_context_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
-            Result<T, E> returned = await resultTask.MapIf(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetValuePredicate(condition)(value);
-                },
-                async (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return await GetTaskAction()(value);
-                },
-                ContextMessage
-            );
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-    }
-}
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapIfTests_Task : MapIfTestsBase
+    {
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsTask();
+            Result<T> returned = await resultTask.MapIf(condition, GetTaskAction());
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
+            Result<T, E> returned = await resultTask.MapIf(condition, GetTaskAction());
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsTask();
+            Result<T> returned = await resultTask.MapIf(
+                GetValuePredicate(condition),
+                GetTaskAction()
+            );
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
+            Result<T, E> returned = await resultTask.MapIf(
+                GetValuePredicate(condition),
+                GetTaskAction()
+            );
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_T_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsTask();
+            Result<T> returned = await resultTask.MapIf(
+                condition,
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetTaskAction()(value);
+                },
+                ContextMessage
+            );
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_T_E_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
+            Result<T, E> returned = await resultTask.MapIf(
+                condition,
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetTaskAction()(value);
+                },
+                ContextMessage
+            );
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_computes_predicate_T_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsTask();
+            Result<T> returned = await resultTask.MapIf(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValuePredicate(condition)(value);
+                },
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetTaskAction()(value);
+                },
+                ContextMessage
+            );
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_Task_computes_predicate_T_E_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Task<Result<T, E>> resultTask = Result.SuccessIf(isSuccess, T.Value, E.Value).AsTask();
+            Result<T, E> returned = await resultTask.MapIf(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValuePredicate(condition)(value);
+                },
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetTaskAction()(value);
+                },
+                ContextMessage
+            );
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Left.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Left.cs
index fab536c8..a812977e 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Left.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Left.cs
@@ -1,209 +1,209 @@
-using System.Threading.Tasks;
-using CSharpFunctionalExtensions.ValueTasks;
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapIfTests_ValueTask_Left : MapIfTestsBase
-    {
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Left_T_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            ValueTask<Result<T>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, ErrorMessage)
-                .AsValueTask();
-
-            Result<T> returned = await resultTask.MapIf(condition, GetAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Left_T_E_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            ValueTask<Result<T, E>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, E.Value)
-                .AsValueTask();
-
-            Result<T, E> returned = await resultTask.MapIf(condition, GetAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Left_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            ValueTask<Result<T>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, ErrorMessage)
-                .AsValueTask();
-
-            Result<T> returned = await resultTask.MapIf(GetValuePredicate(condition), GetAction());
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Left_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            ValueTask<Result<T, E>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, E.Value)
-                .AsValueTask();
-
-            Result<T, E> returned = await resultTask.MapIf(
-                GetValuePredicate(condition),
-                GetAction()
-            );
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Left_T_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            ValueTask<Result<T>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, ErrorMessage)
-                .AsValueTask();
-
-            Result<T> returned = await resultTask.MapIf(
-                condition,
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetAction()(value);
-                },
-                ContextMessage
-            );
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Left_T_E_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            ValueTask<Result<T, E>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, E.Value)
-                .AsValueTask();
-
-            Result<T, E> returned = await resultTask.MapIf(
-                condition,
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetAction()(value);
-                },
-                ContextMessage
-            );
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Left_computes_predicate_T_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            ValueTask<Result<T>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, ErrorMessage)
-                .AsValueTask();
-
-            Result<T> returned = await resultTask.MapIf(
-                (value, context) => GetValuePredicate(condition)(value),
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetAction()(value);
-                },
-                ContextMessage
-            );
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Left_computes_predicate_T_E_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            ValueTask<Result<T, E>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, E.Value)
-                .AsValueTask();
-
-            Result<T, E> returned = await resultTask.MapIf(
-                (value, context) => GetValuePredicate(condition)(value),
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetAction()(value);
-                },
-                ContextMessage
-            );
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-    }
-}
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapIfTests_ValueTask_Left : MapIfTestsBase
+    {
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Left_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsValueTask();
+
+            Result<T> returned = await resultTask.MapIf(condition, GetAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Left_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T, E>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, E.Value)
+                .AsValueTask();
+
+            Result<T, E> returned = await resultTask.MapIf(condition, GetAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Left_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsValueTask();
+
+            Result<T> returned = await resultTask.MapIf(GetValuePredicate(condition), GetAction());
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Left_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T, E>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, E.Value)
+                .AsValueTask();
+
+            Result<T, E> returned = await resultTask.MapIf(
+                GetValuePredicate(condition),
+                GetAction()
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Left_T_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsValueTask();
+
+            Result<T> returned = await resultTask.MapIf(
+                condition,
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Left_T_E_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T, E>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, E.Value)
+                .AsValueTask();
+
+            Result<T, E> returned = await resultTask.MapIf(
+                condition,
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Left_computes_predicate_T_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsValueTask();
+
+            Result<T> returned = await resultTask.MapIf(
+                (value, context) => GetValuePredicate(condition)(value),
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Left_computes_predicate_T_E_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T, E>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, E.Value)
+                .AsValueTask();
+
+            Result<T, E> returned = await resultTask.MapIf(
+                (value, context) => GetValuePredicate(condition)(value),
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Right.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Right.cs
index 6e818833..757e5f4b 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Right.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Right.cs
@@ -1,196 +1,196 @@
-using System.Threading.Tasks;
-using CSharpFunctionalExtensions.ValueTasks;
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapIfTests_ValueTask_Right : MapIfTestsBase
-    {
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Right_T_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-
-            Result<T> returned = await result.MapIf(condition, GetValueTaskAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Right_T_E_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
-
-            Result<T, E> returned = await result.MapIf(condition, GetValueTaskAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Right_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-
-            Result<T> returned = await result.MapIf(
-                GetValuePredicate(condition),
-                GetValueTaskAction()
-            );
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Right_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
-
-            Result<T, E> returned = await result.MapIf(
-                GetValuePredicate(condition),
-                GetValueTaskAction()
-            );
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Right_T_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-
-            Result<T> returned = await result.MapIf(
-                condition,
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetValueTaskAction()(value);
-                },
-                ContextMessage
-            );
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Right_T_E_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
-
-            Result<T, E> returned = await result.MapIf(
-                condition,
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetValueTaskAction()(value);
-                },
-                ContextMessage
-            );
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Right_computes_predicate_T_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-
-            Result<T> returned = await result.MapIf(
-                (value, context) => GetValuePredicate(condition)(value),
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetValueTaskAction()(value);
-                },
-                ContextMessage
-            );
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_Right_computes_predicate_T_E_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
-
-            Result<T, E> returned = await result.MapIf(
-                (value, context) => GetValuePredicate(condition)(value),
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetValueTaskAction()(value);
-                },
-                ContextMessage
-            );
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-    }
-}
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapIfTests_ValueTask_Right : MapIfTestsBase
+    {
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Right_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+
+            Result<T> returned = await result.MapIf(condition, GetValueTaskAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Right_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+
+            Result<T, E> returned = await result.MapIf(condition, GetValueTaskAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Right_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+
+            Result<T> returned = await result.MapIf(
+                GetValuePredicate(condition),
+                GetValueTaskAction()
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Right_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+
+            Result<T, E> returned = await result.MapIf(
+                GetValuePredicate(condition),
+                GetValueTaskAction()
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Right_T_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+
+            Result<T> returned = await result.MapIf(
+                condition,
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValueTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Right_T_E_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+
+            Result<T, E> returned = await result.MapIf(
+                condition,
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValueTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Right_computes_predicate_T_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+
+            Result<T> returned = await result.MapIf(
+                (value, context) => GetValuePredicate(condition)(value),
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValueTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_Right_computes_predicate_T_E_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+
+            Result<T, E> returned = await result.MapIf(
+                (value, context) => GetValuePredicate(condition)(value),
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValueTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.cs
index c057efa8..f8ff8992 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.cs
@@ -1,212 +1,212 @@
-using System.Threading.Tasks;
-using CSharpFunctionalExtensions.ValueTasks;
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapIfTests_ValueTask : MapIfTestsBase
-    {
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_T_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            ValueTask<Result<T>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, ErrorMessage)
-                .AsValueTask();
-
-            Result<T> returned = await resultTask.MapIf(condition, GetValueTaskAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_T_E_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            ValueTask<Result<T, E>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, E.Value)
-                .AsValueTask();
-
-            Result<T, E> returned = await resultTask.MapIf(condition, GetValueTaskAction());
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            ValueTask<Result<T>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, ErrorMessage)
-                .AsValueTask();
-
-            Result<T> returned = await resultTask.MapIf(
-                GetValuePredicate(condition),
-                GetValueTaskAction()
-            );
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            ValueTask<Result<T, E>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, E.Value)
-                .AsValueTask();
-
-            Result<T, E> returned = await resultTask.MapIf(
-                GetValuePredicate(condition),
-                GetValueTaskAction()
-            );
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_T_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            ValueTask<Result<T>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, ErrorMessage)
-                .AsValueTask();
-
-            Result<T> returned = await resultTask.MapIf(
-                condition,
-                async (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return await GetValueTaskAction()(value);
-                },
-                ContextMessage
-            );
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_T_E_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            ValueTask<Result<T, E>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, E.Value)
-                .AsValueTask();
-
-            Result<T, E> returned = await resultTask.MapIf(
-                condition,
-                async (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return await GetValueTaskAction()(value);
-                },
-                ContextMessage
-            );
-
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_computes_predicate_T_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            ValueTask<Result<T>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, ErrorMessage)
-                .AsValueTask();
-
-            Result<T> returned = await resultTask.MapIf(
-                (value, context) => GetValuePredicate(condition)(value),
-                async (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return await GetValueTaskAction()(value);
-                },
-                ContextMessage
-            );
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public async Task MapIf_ValueTask_computes_predicate_T_E_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            ValueTask<Result<T, E>> resultTask = Result
-                .SuccessIf(isSuccess, T.Value, E.Value)
-                .AsValueTask();
-
-            Result<T, E> returned = await resultTask.MapIf(
-                (value, context) => GetValuePredicate(condition)(value),
-                async (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return await GetValueTaskAction()(value);
-                },
-                ContextMessage
-            );
-
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-    }
-}
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapIfTests_ValueTask : MapIfTestsBase
+    {
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsValueTask();
+
+            Result<T> returned = await resultTask.MapIf(condition, GetValueTaskAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T, E>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, E.Value)
+                .AsValueTask();
+
+            Result<T, E> returned = await resultTask.MapIf(condition, GetValueTaskAction());
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsValueTask();
+
+            Result<T> returned = await resultTask.MapIf(
+                GetValuePredicate(condition),
+                GetValueTaskAction()
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T, E>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, E.Value)
+                .AsValueTask();
+
+            Result<T, E> returned = await resultTask.MapIf(
+                GetValuePredicate(condition),
+                GetValueTaskAction()
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_T_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsValueTask();
+
+            Result<T> returned = await resultTask.MapIf(
+                condition,
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetValueTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_T_E_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T, E>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, E.Value)
+                .AsValueTask();
+
+            Result<T, E> returned = await resultTask.MapIf(
+                condition,
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetValueTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_computes_predicate_T_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, ErrorMessage)
+                .AsValueTask();
+
+            Result<T> returned = await resultTask.MapIf(
+                (value, context) => GetValuePredicate(condition)(value),
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetValueTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public async Task MapIf_ValueTask_computes_predicate_T_E_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            ValueTask<Result<T, E>> resultTask = Result
+                .SuccessIf(isSuccess, T.Value, E.Value)
+                .AsValueTask();
+
+            Result<T, E> returned = await resultTask.MapIf(
+                (value, context) => GetValuePredicate(condition)(value),
+                async (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return await GetValueTaskAction()(value);
+                },
+                ContextMessage
+            );
+
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.cs
index 784e1268..abc47e9e 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.cs
@@ -1,180 +1,180 @@
-using FluentAssertions;
-using Xunit;
-
-namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
-{
-    public class MapIfTests : MapIfTestsBase
-    {
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public void MapIf_T_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-            Result<T> returned = result.MapIf(condition, GetAction());
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public void MapIf_T_E_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
-            Result<T, E> returned = result.MapIf(condition, GetAction());
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public void MapIf_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-            Result<T> returned = result.MapIf(GetValuePredicate(condition), GetAction());
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public void MapIf_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
-            Result<T, E> returned = result.MapIf(GetValuePredicate(condition), GetAction());
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public void MapIf_T_with_context_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-            Result<T> returned = result.MapIf(
-                condition,
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetAction()(value);
-                },
-                ContextMessage
-            );
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public void MapIf_T_E_with_context_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
-            Result<T, E> returned = result.MapIf(
-                condition,
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetAction()(value);
-                },
-                ContextMessage
-            );
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public void MapIf_computes_predicate_T_with_context_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
-            Result<T> returned = result.MapIf(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetValuePredicate(condition)(value);
-                },
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetAction()(value);
-                },
-                ContextMessage
-            );
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
-        }
-
-        [Theory]
-        [InlineData(true, true)]
-        [InlineData(true, false)]
-        [InlineData(false, true)]
-        [InlineData(false, false)]
-        public void MapIf_computes_predicate_T_E_with_context_executes_func_conditionally_and_passes_context(
-            bool isSuccess,
-            bool condition
-        )
-        {
-            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
-            Result<T, E> returned = result.MapIf(
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetValuePredicate(condition)(value);
-                },
-                (value, context) =>
-                {
-                    context.Should().Be(ContextMessage);
-                    return GetAction()(value);
-                },
-                ContextMessage
-            );
-            predicateExecuted.Should().Be(isSuccess);
-            actionExecuted.Should().Be(isSuccess && condition);
-            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
-        }
-    }
-}
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class MapIfTests : MapIfTestsBase
+    {
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void MapIf_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+            Result<T> returned = result.MapIf(condition, GetAction());
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void MapIf_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+            Result<T, E> returned = result.MapIf(condition, GetAction());
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void MapIf_computes_predicate_T_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+            Result<T> returned = result.MapIf(GetValuePredicate(condition), GetAction());
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void MapIf_computes_predicate_T_E_executes_func_conditionally_and_returns_new_result(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+            Result<T, E> returned = result.MapIf(GetValuePredicate(condition), GetAction());
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void MapIf_T_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+            Result<T> returned = result.MapIf(
+                condition,
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void MapIf_T_E_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+            Result<T, E> returned = result.MapIf(
+                condition,
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void MapIf_computes_predicate_T_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T> result = Result.SuccessIf(isSuccess, T.Value, ErrorMessage);
+            Result<T> returned = result.MapIf(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValuePredicate(condition)(value);
+                },
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueResult(isSuccess, condition));
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void MapIf_computes_predicate_T_E_with_context_executes_func_conditionally_and_passes_context(
+            bool isSuccess,
+            bool condition
+        )
+        {
+            Result<T, E> result = Result.SuccessIf(isSuccess, T.Value, E.Value);
+            Result<T, E> returned = result.MapIf(
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetValuePredicate(condition)(value);
+                },
+                (value, context) =>
+                {
+                    context.Should().Be(ContextMessage);
+                    return GetAction()(value);
+                },
+                ContextMessage
+            );
+            predicateExecuted.Should().Be(isSuccess);
+            actionExecuted.Should().Be(isSuccess && condition);
+            returned.Should().Be(GetExpectedValueErrorResult(isSuccess, condition));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Left.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Left.cs
index 578575bb..dad3f3e0 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Left.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Left.cs
@@ -1,92 +1,92 @@
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions
-{
-    public static partial class ResultExtensions
-    {
-        public static async Task<Result<T>> MapIf<T>(
-            this Task<Result<T>> resultTask,
-            bool condition,
-            Func<T, T> func
-        )
-        {
-            var result = await resultTask.DefaultAwait();
-            return result.MapIf(condition, func);
-        }
-
-        public static async Task<Result<T>> MapIf<T, TContext>(
-            this Task<Result<T>> resultTask,
-            bool condition,
-            Func<T, TContext, T> func,
-            TContext context
-        )
-        {
-            var result = await resultTask.DefaultAwait();
-            return result.MapIf(condition, func, context);
-        }
-
-        public static async Task<Result<T, E>> MapIf<T, E>(
-            this Task<Result<T, E>> resultTask,
-            bool condition,
-            Func<T, T> func
-        )
-        {
-            var result = await resultTask.DefaultAwait();
-            return result.MapIf(condition, func);
-        }
-
-        public static async Task<Result<T, E>> MapIf<T, E, TContext>(
-            this Task<Result<T, E>> resultTask,
-            bool condition,
-            Func<T, TContext, T> func,
-            TContext context
-        )
-        {
-            var result = await resultTask.DefaultAwait();
-            return result.MapIf(condition, func, context);
-        }
-
-        public static async Task<Result<T>> MapIf<T>(
-            this Task<Result<T>> resultTask,
-            Func<T, bool> predicate,
-            Func<T, T> func
-        )
-        {
-            var result = await resultTask.DefaultAwait();
-            return result.MapIf(predicate, func);
-        }
-
-        public static async Task<Result<T>> MapIf<T, TContext>(
-            this Task<Result<T>> resultTask,
-            Func<T, TContext, bool> predicate,
-            Func<T, TContext, T> func,
-            TContext context
-        )
-        {
-            var result = await resultTask.DefaultAwait();
-            return result.MapIf(predicate, func, context);
-        }
-
-        public static async Task<Result<T, E>> MapIf<T, E>(
-            this Task<Result<T, E>> resultTask,
-            Func<T, bool> predicate,
-            Func<T, T> func
-        )
-        {
-            var result = await resultTask.DefaultAwait();
-            return result.MapIf(predicate, func);
-        }
-
-        public static async Task<Result<T, E>> MapIf<T, E, TContext>(
-            this Task<Result<T, E>> resultTask,
-            Func<T, TContext, bool> predicate,
-            Func<T, TContext, T> func,
-            TContext context
-        )
-        {
-            var result = await resultTask.DefaultAwait();
-            return result.MapIf(predicate, func, context);
-        }
-    }
-}
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class ResultExtensions
+    {
+        public static async Task<Result<T>> MapIf<T>(
+            this Task<Result<T>> resultTask,
+            bool condition,
+            Func<T, T> func
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return result.MapIf(condition, func);
+        }
+
+        public static async Task<Result<T>> MapIf<T, TContext>(
+            this Task<Result<T>> resultTask,
+            bool condition,
+            Func<T, TContext, T> func,
+            TContext context
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return result.MapIf(condition, func, context);
+        }
+
+        public static async Task<Result<T, E>> MapIf<T, E>(
+            this Task<Result<T, E>> resultTask,
+            bool condition,
+            Func<T, T> func
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return result.MapIf(condition, func);
+        }
+
+        public static async Task<Result<T, E>> MapIf<T, E, TContext>(
+            this Task<Result<T, E>> resultTask,
+            bool condition,
+            Func<T, TContext, T> func,
+            TContext context
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return result.MapIf(condition, func, context);
+        }
+
+        public static async Task<Result<T>> MapIf<T>(
+            this Task<Result<T>> resultTask,
+            Func<T, bool> predicate,
+            Func<T, T> func
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return result.MapIf(predicate, func);
+        }
+
+        public static async Task<Result<T>> MapIf<T, TContext>(
+            this Task<Result<T>> resultTask,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, T> func,
+            TContext context
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return result.MapIf(predicate, func, context);
+        }
+
+        public static async Task<Result<T, E>> MapIf<T, E>(
+            this Task<Result<T, E>> resultTask,
+            Func<T, bool> predicate,
+            Func<T, T> func
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return result.MapIf(predicate, func);
+        }
+
+        public static async Task<Result<T, E>> MapIf<T, E, TContext>(
+            this Task<Result<T, E>> resultTask,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, T> func,
+            TContext context
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return result.MapIf(predicate, func, context);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Right.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Right.cs
index adc7f944..6639328f 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Right.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Right.cs
@@ -1,124 +1,124 @@
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions
-{
-    public static partial class ResultExtensions
-    {
-        public static Task<Result<T>> MapIf<T>(
-            this Result<T> result,
-            bool condition,
-            Func<T, Task<T>> func
-        )
-        {
-            if (!condition)
-            {
-                return result.AsCompletedTask();
-            }
-
-            return result.Map(func);
-        }
-
-        public static Task<Result<T>> MapIf<T, TContext>(
-            this Result<T> result,
-            bool condition,
-            Func<T, TContext, Task<T>> func,
-            TContext context
-        )
-        {
-            if (!condition)
-            {
-                return result.AsCompletedTask();
-            }
-
-            return result.Map(func, context);
-        }
-
-        public static Task<Result<T, E>> MapIf<T, E>(
-            this Result<T, E> result,
-            bool condition,
-            Func<T, Task<T>> func
-        )
-        {
-            if (!condition)
-            {
-                return result.AsCompletedTask();
-            }
-
-            return result.Map(func);
-        }
-
-        public static Task<Result<T, E>> MapIf<T, E, TContext>(
-            this Result<T, E> result,
-            bool condition,
-            Func<T, TContext, Task<T>> func,
-            TContext context
-        )
-        {
-            if (!condition)
-            {
-                return result.AsCompletedTask();
-            }
-
-            return result.Map(func, context);
-        }
-
-        public static Task<Result<T>> MapIf<T>(
-            this Result<T> result,
-            Func<T, bool> predicate,
-            Func<T, Task<T>> func
-        )
-        {
-            if (!result.IsSuccess || !predicate(result.Value))
-            {
-                return result.AsCompletedTask();
-            }
-
-            return result.Map(func);
-        }
-
-        public static Task<Result<T>> MapIf<T, TContext>(
-            this Result<T> result,
-            Func<T, TContext, bool> predicate,
-            Func<T, TContext, Task<T>> func,
-            TContext context
-        )
-        {
-            if (!result.IsSuccess || !predicate(result.Value, context))
-            {
-                return result.AsCompletedTask();
-            }
-
-            return result.Map(func, context);
-        }
-
-        public static Task<Result<T, E>> MapIf<T, E>(
-            this Result<T, E> result,
-            Func<T, bool> predicate,
-            Func<T, Task<T>> func
-        )
-        {
-            if (!result.IsSuccess || !predicate(result.Value))
-            {
-                return result.AsCompletedTask();
-            }
-
-            return result.Map(func);
-        }
-
-        public static Task<Result<T, E>> MapIf<T, E, TContext>(
-            this Result<T, E> result,
-            Func<T, TContext, bool> predicate,
-            Func<T, TContext, Task<T>> func,
-            TContext context
-        )
-        {
-            if (!result.IsSuccess || !predicate(result.Value, context))
-            {
-                return result.AsCompletedTask();
-            }
-
-            return result.Map(func, context);
-        }
-    }
-}
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class ResultExtensions
+    {
+        public static Task<Result<T>> MapIf<T>(
+            this Result<T> result,
+            bool condition,
+            Func<T, Task<T>> func
+        )
+        {
+            if (!condition)
+            {
+                return result.AsCompletedTask();
+            }
+
+            return result.Map(func);
+        }
+
+        public static Task<Result<T>> MapIf<T, TContext>(
+            this Result<T> result,
+            bool condition,
+            Func<T, TContext, Task<T>> func,
+            TContext context
+        )
+        {
+            if (!condition)
+            {
+                return result.AsCompletedTask();
+            }
+
+            return result.Map(func, context);
+        }
+
+        public static Task<Result<T, E>> MapIf<T, E>(
+            this Result<T, E> result,
+            bool condition,
+            Func<T, Task<T>> func
+        )
+        {
+            if (!condition)
+            {
+                return result.AsCompletedTask();
+            }
+
+            return result.Map(func);
+        }
+
+        public static Task<Result<T, E>> MapIf<T, E, TContext>(
+            this Result<T, E> result,
+            bool condition,
+            Func<T, TContext, Task<T>> func,
+            TContext context
+        )
+        {
+            if (!condition)
+            {
+                return result.AsCompletedTask();
+            }
+
+            return result.Map(func, context);
+        }
+
+        public static Task<Result<T>> MapIf<T>(
+            this Result<T> result,
+            Func<T, bool> predicate,
+            Func<T, Task<T>> func
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value))
+            {
+                return result.AsCompletedTask();
+            }
+
+            return result.Map(func);
+        }
+
+        public static Task<Result<T>> MapIf<T, TContext>(
+            this Result<T> result,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, Task<T>> func,
+            TContext context
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value, context))
+            {
+                return result.AsCompletedTask();
+            }
+
+            return result.Map(func, context);
+        }
+
+        public static Task<Result<T, E>> MapIf<T, E>(
+            this Result<T, E> result,
+            Func<T, bool> predicate,
+            Func<T, Task<T>> func
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value))
+            {
+                return result.AsCompletedTask();
+            }
+
+            return result.Map(func);
+        }
+
+        public static Task<Result<T, E>> MapIf<T, E, TContext>(
+            this Result<T, E> result,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, Task<T>> func,
+            TContext context
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value, context))
+            {
+                return result.AsCompletedTask();
+            }
+
+            return result.Map(func, context);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.cs
index c520ed35..dc3f4a22 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.cs
@@ -1,92 +1,92 @@
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions
-{
-    public static partial class ResultExtensions
-    {
-        public static async Task<Result<T>> MapIf<T>(
-            this Task<Result<T>> resultTask,
-            bool condition,
-            Func<T, Task<T>> func
-        )
-        {
-            var result = await resultTask.DefaultAwait();
-            return await result.MapIf(condition, func).DefaultAwait();
-        }
-
-        public static async Task<Result<T>> MapIf<T, TContext>(
-            this Task<Result<T>> resultTask,
-            bool condition,
-            Func<T, TContext, Task<T>> func,
-            TContext context
-        )
-        {
-            var result = await resultTask.DefaultAwait();
-            return await result.MapIf(condition, func, context).DefaultAwait();
-        }
-
-        public static async Task<Result<T, E>> MapIf<T, E>(
-            this Task<Result<T, E>> resultTask,
-            bool condition,
-            Func<T, Task<T>> func
-        )
-        {
-            var result = await resultTask.DefaultAwait();
-            return await result.MapIf(condition, func).DefaultAwait();
-        }
-
-        public static async Task<Result<T, E>> MapIf<T, E, TContext>(
-            this Task<Result<T, E>> resultTask,
-            bool condition,
-            Func<T, TContext, Task<T>> func,
-            TContext context
-        )
-        {
-            var result = await resultTask.DefaultAwait();
-            return await result.MapIf(condition, func, context).DefaultAwait();
-        }
-
-        public static async Task<Result<T>> MapIf<T>(
-            this Task<Result<T>> resultTask,
-            Func<T, bool> predicate,
-            Func<T, Task<T>> func
-        )
-        {
-            var result = await resultTask.DefaultAwait();
-            return await result.MapIf(predicate, func).DefaultAwait();
-        }
-
-        public static async Task<Result<T>> MapIf<T, TContext>(
-            this Task<Result<T>> resultTask,
-            Func<T, TContext, bool> predicate,
-            Func<T, TContext, Task<T>> func,
-            TContext context
-        )
-        {
-            var result = await resultTask.DefaultAwait();
-            return await result.MapIf(predicate, func, context).DefaultAwait();
-        }
-
-        public static async Task<Result<T, E>> MapIf<T, E>(
-            this Task<Result<T, E>> resultTask,
-            Func<T, bool> predicate,
-            Func<T, Task<T>> func
-        )
-        {
-            var result = await resultTask.DefaultAwait();
-            return await result.MapIf(predicate, func).DefaultAwait();
-        }
-
-        public static async Task<Result<T, E>> MapIf<T, E, TContext>(
-            this Task<Result<T, E>> resultTask,
-            Func<T, TContext, bool> predicate,
-            Func<T, TContext, Task<T>> func,
-            TContext context
-        )
-        {
-            var result = await resultTask.DefaultAwait();
-            return await result.MapIf(predicate, func, context).DefaultAwait();
-        }
-    }
-}
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class ResultExtensions
+    {
+        public static async Task<Result<T>> MapIf<T>(
+            this Task<Result<T>> resultTask,
+            bool condition,
+            Func<T, Task<T>> func
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return await result.MapIf(condition, func).DefaultAwait();
+        }
+
+        public static async Task<Result<T>> MapIf<T, TContext>(
+            this Task<Result<T>> resultTask,
+            bool condition,
+            Func<T, TContext, Task<T>> func,
+            TContext context
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return await result.MapIf(condition, func, context).DefaultAwait();
+        }
+
+        public static async Task<Result<T, E>> MapIf<T, E>(
+            this Task<Result<T, E>> resultTask,
+            bool condition,
+            Func<T, Task<T>> func
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return await result.MapIf(condition, func).DefaultAwait();
+        }
+
+        public static async Task<Result<T, E>> MapIf<T, E, TContext>(
+            this Task<Result<T, E>> resultTask,
+            bool condition,
+            Func<T, TContext, Task<T>> func,
+            TContext context
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return await result.MapIf(condition, func, context).DefaultAwait();
+        }
+
+        public static async Task<Result<T>> MapIf<T>(
+            this Task<Result<T>> resultTask,
+            Func<T, bool> predicate,
+            Func<T, Task<T>> func
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return await result.MapIf(predicate, func).DefaultAwait();
+        }
+
+        public static async Task<Result<T>> MapIf<T, TContext>(
+            this Task<Result<T>> resultTask,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, Task<T>> func,
+            TContext context
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return await result.MapIf(predicate, func, context).DefaultAwait();
+        }
+
+        public static async Task<Result<T, E>> MapIf<T, E>(
+            this Task<Result<T, E>> resultTask,
+            Func<T, bool> predicate,
+            Func<T, Task<T>> func
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return await result.MapIf(predicate, func).DefaultAwait();
+        }
+
+        public static async Task<Result<T, E>> MapIf<T, E, TContext>(
+            this Task<Result<T, E>> resultTask,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, Task<T>> func,
+            TContext context
+        )
+        {
+            var result = await resultTask.DefaultAwait();
+            return await result.MapIf(predicate, func, context).DefaultAwait();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Left.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Left.cs
index fd7543f3..b6dce54e 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Left.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Left.cs
@@ -1,94 +1,94 @@
-#if NET5_0_OR_GREATER
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions.ValueTasks
-{
-    public static partial class ResultExtensions
-    {
-        public static async ValueTask<Result<T>> MapIf<T>(
-            this ValueTask<Result<T>> resultTask,
-            bool condition,
-            Func<T, T> valueTask
-        )
-        {
-            var result = await resultTask;
-            return result.MapIf(condition, valueTask);
-        }
-
-        public static async ValueTask<Result<T>> MapIf<T, TContext>(
-            this ValueTask<Result<T>> resultTask,
-            bool condition,
-            Func<T, TContext, T> valueTask,
-            TContext context
-        )
-        {
-            var result = await resultTask;
-            return result.MapIf(condition, valueTask, context);
-        }
-
-        public static async ValueTask<Result<T, E>> MapIf<T, E>(
-            this ValueTask<Result<T, E>> resultTask,
-            bool condition,
-            Func<T, T> valueTask
-        )
-        {
-            var result = await resultTask;
-            return result.MapIf(condition, valueTask);
-        }
-
-        public static async ValueTask<Result<T, E>> MapIf<T, E, TContext>(
-            this ValueTask<Result<T, E>> resultTask,
-            bool condition,
-            Func<T, TContext, T> valueTask,
-            TContext context
-        )
-        {
-            var result = await resultTask;
-            return result.MapIf(condition, valueTask, context);
-        }
-
-        public static async ValueTask<Result<T>> MapIf<T>(
-            this ValueTask<Result<T>> resultTask,
-            Func<T, bool> predicate,
-            Func<T, T> valueTask
-        )
-        {
-            var result = await resultTask;
-            return result.MapIf(predicate, valueTask);
-        }
-
-        public static async ValueTask<Result<T>> MapIf<T, TContext>(
-            this ValueTask<Result<T>> resultTask,
-            Func<T, TContext, bool> predicate,
-            Func<T, TContext, T> valueTask,
-            TContext context
-        )
-        {
-            var result = await resultTask;
-            return result.MapIf(predicate, valueTask, context);
-        }
-
-        public static async ValueTask<Result<T, E>> MapIf<T, E>(
-            this ValueTask<Result<T, E>> resultTask,
-            Func<T, bool> predicate,
-            Func<T, T> valueTask
-        )
-        {
-            var result = await resultTask;
-            return result.MapIf(predicate, valueTask);
-        }
-
-        public static async ValueTask<Result<T, E>> MapIf<T, E, TContext>(
-            this ValueTask<Result<T, E>> resultTask,
-            Func<T, TContext, bool> predicate,
-            Func<T, TContext, T> valueTask,
-            TContext context
-        )
-        {
-            var result = await resultTask;
-            return result.MapIf(predicate, valueTask, context);
-        }
-    }
-}
-#endif
+#if NET5_0_OR_GREATER
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.ValueTasks
+{
+    public static partial class ResultExtensions
+    {
+        public static async ValueTask<Result<T>> MapIf<T>(
+            this ValueTask<Result<T>> resultTask,
+            bool condition,
+            Func<T, T> valueTask
+        )
+        {
+            var result = await resultTask;
+            return result.MapIf(condition, valueTask);
+        }
+
+        public static async ValueTask<Result<T>> MapIf<T, TContext>(
+            this ValueTask<Result<T>> resultTask,
+            bool condition,
+            Func<T, TContext, T> valueTask,
+            TContext context
+        )
+        {
+            var result = await resultTask;
+            return result.MapIf(condition, valueTask, context);
+        }
+
+        public static async ValueTask<Result<T, E>> MapIf<T, E>(
+            this ValueTask<Result<T, E>> resultTask,
+            bool condition,
+            Func<T, T> valueTask
+        )
+        {
+            var result = await resultTask;
+            return result.MapIf(condition, valueTask);
+        }
+
+        public static async ValueTask<Result<T, E>> MapIf<T, E, TContext>(
+            this ValueTask<Result<T, E>> resultTask,
+            bool condition,
+            Func<T, TContext, T> valueTask,
+            TContext context
+        )
+        {
+            var result = await resultTask;
+            return result.MapIf(condition, valueTask, context);
+        }
+
+        public static async ValueTask<Result<T>> MapIf<T>(
+            this ValueTask<Result<T>> resultTask,
+            Func<T, bool> predicate,
+            Func<T, T> valueTask
+        )
+        {
+            var result = await resultTask;
+            return result.MapIf(predicate, valueTask);
+        }
+
+        public static async ValueTask<Result<T>> MapIf<T, TContext>(
+            this ValueTask<Result<T>> resultTask,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, T> valueTask,
+            TContext context
+        )
+        {
+            var result = await resultTask;
+            return result.MapIf(predicate, valueTask, context);
+        }
+
+        public static async ValueTask<Result<T, E>> MapIf<T, E>(
+            this ValueTask<Result<T, E>> resultTask,
+            Func<T, bool> predicate,
+            Func<T, T> valueTask
+        )
+        {
+            var result = await resultTask;
+            return result.MapIf(predicate, valueTask);
+        }
+
+        public static async ValueTask<Result<T, E>> MapIf<T, E, TContext>(
+            this ValueTask<Result<T, E>> resultTask,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, T> valueTask,
+            TContext context
+        )
+        {
+            var result = await resultTask;
+            return result.MapIf(predicate, valueTask, context);
+        }
+    }
+}
+#endif
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Right.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Right.cs
index 017ac15d..9ac754bd 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Right.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Right.cs
@@ -1,126 +1,126 @@
-#if NET5_0_OR_GREATER
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions.ValueTasks
-{
-    public static partial class ResultExtensions
-    {
-        public static ValueTask<Result<T>> MapIf<T>(
-            this Result<T> result,
-            bool condition,
-            Func<T, ValueTask<T>> valueTask
-        )
-        {
-            if (!condition)
-            {
-                return result.AsCompletedValueTask();
-            }
-
-            return result.Map(valueTask);
-        }
-
-        public static ValueTask<Result<T>> MapIf<T, TContext>(
-            this Result<T> result,
-            bool condition,
-            Func<T, TContext, ValueTask<T>> valueTask,
-            TContext context
-        )
-        {
-            if (!condition)
-            {
-                return result.AsCompletedValueTask();
-            }
-
-            return result.Map(valueTask, context);
-        }
-
-        public static ValueTask<Result<T, E>> MapIf<T, E>(
-            this Result<T, E> result,
-            bool condition,
-            Func<T, ValueTask<T>> valueTask
-        )
-        {
-            if (!condition)
-            {
-                return result.AsCompletedValueTask();
-            }
-
-            return result.Map(valueTask);
-        }
-
-        public static ValueTask<Result<T, E>> MapIf<T, E, TContext>(
-            this Result<T, E> result,
-            bool condition,
-            Func<T, TContext, ValueTask<T>> valueTask,
-            TContext context
-        )
-        {
-            if (!condition)
-            {
-                return result.AsCompletedValueTask();
-            }
-
-            return result.Map(valueTask, context);
-        }
-
-        public static ValueTask<Result<T>> MapIf<T>(
-            this Result<T> result,
-            Func<T, bool> predicate,
-            Func<T, ValueTask<T>> valueTask
-        )
-        {
-            if (!result.IsSuccess || !predicate(result.Value))
-            {
-                return result.AsCompletedValueTask();
-            }
-
-            return result.Map(valueTask);
-        }
-
-        public static ValueTask<Result<T>> MapIf<T, TContext>(
-            this Result<T> result,
-            Func<T, TContext, bool> predicate,
-            Func<T, TContext, ValueTask<T>> valueTask,
-            TContext context
-        )
-        {
-            if (!result.IsSuccess || !predicate(result.Value, context))
-            {
-                return result.AsCompletedValueTask();
-            }
-
-            return result.Map(valueTask, context);
-        }
-
-        public static ValueTask<Result<T, E>> MapIf<T, E>(
-            this Result<T, E> result,
-            Func<T, bool> predicate,
-            Func<T, ValueTask<T>> valueTask
-        )
-        {
-            if (!result.IsSuccess || !predicate(result.Value))
-            {
-                return result.AsCompletedValueTask();
-            }
-
-            return result.Map(valueTask);
-        }
-
-        public static ValueTask<Result<T, E>> MapIf<T, E, TContext>(
-            this Result<T, E> result,
-            Func<T, TContext, bool> predicate,
-            Func<T, TContext, ValueTask<T>> valueTask,
-            TContext context
-        )
-        {
-            if (!result.IsSuccess || !predicate(result.Value, context))
-            {
-                return result.AsCompletedValueTask();
-            }
-
-            return result.Map(valueTask, context);
-        }
-    }
-}
-#endif
+#if NET5_0_OR_GREATER
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.ValueTasks
+{
+    public static partial class ResultExtensions
+    {
+        public static ValueTask<Result<T>> MapIf<T>(
+            this Result<T> result,
+            bool condition,
+            Func<T, ValueTask<T>> valueTask
+        )
+        {
+            if (!condition)
+            {
+                return result.AsCompletedValueTask();
+            }
+
+            return result.Map(valueTask);
+        }
+
+        public static ValueTask<Result<T>> MapIf<T, TContext>(
+            this Result<T> result,
+            bool condition,
+            Func<T, TContext, ValueTask<T>> valueTask,
+            TContext context
+        )
+        {
+            if (!condition)
+            {
+                return result.AsCompletedValueTask();
+            }
+
+            return result.Map(valueTask, context);
+        }
+
+        public static ValueTask<Result<T, E>> MapIf<T, E>(
+            this Result<T, E> result,
+            bool condition,
+            Func<T, ValueTask<T>> valueTask
+        )
+        {
+            if (!condition)
+            {
+                return result.AsCompletedValueTask();
+            }
+
+            return result.Map(valueTask);
+        }
+
+        public static ValueTask<Result<T, E>> MapIf<T, E, TContext>(
+            this Result<T, E> result,
+            bool condition,
+            Func<T, TContext, ValueTask<T>> valueTask,
+            TContext context
+        )
+        {
+            if (!condition)
+            {
+                return result.AsCompletedValueTask();
+            }
+
+            return result.Map(valueTask, context);
+        }
+
+        public static ValueTask<Result<T>> MapIf<T>(
+            this Result<T> result,
+            Func<T, bool> predicate,
+            Func<T, ValueTask<T>> valueTask
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value))
+            {
+                return result.AsCompletedValueTask();
+            }
+
+            return result.Map(valueTask);
+        }
+
+        public static ValueTask<Result<T>> MapIf<T, TContext>(
+            this Result<T> result,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, ValueTask<T>> valueTask,
+            TContext context
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value, context))
+            {
+                return result.AsCompletedValueTask();
+            }
+
+            return result.Map(valueTask, context);
+        }
+
+        public static ValueTask<Result<T, E>> MapIf<T, E>(
+            this Result<T, E> result,
+            Func<T, bool> predicate,
+            Func<T, ValueTask<T>> valueTask
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value))
+            {
+                return result.AsCompletedValueTask();
+            }
+
+            return result.Map(valueTask);
+        }
+
+        public static ValueTask<Result<T, E>> MapIf<T, E, TContext>(
+            this Result<T, E> result,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, ValueTask<T>> valueTask,
+            TContext context
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value, context))
+            {
+                return result.AsCompletedValueTask();
+            }
+
+            return result.Map(valueTask, context);
+        }
+    }
+}
+#endif
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.cs
index cb8395d1..ec233242 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.cs
@@ -1,94 +1,94 @@
-#if NET5_0_OR_GREATER
-using System;
-using System.Threading.Tasks;
-
-namespace CSharpFunctionalExtensions.ValueTasks
-{
-    public static partial class ResultExtensions
-    {
-        public static async ValueTask<Result<T>> MapIf<T>(
-            this ValueTask<Result<T>> resultTask,
-            bool condition,
-            Func<T, ValueTask<T>> valueTask
-        )
-        {
-            var result = await resultTask;
-            return await result.MapIf(condition, valueTask);
-        }
-
-        public static async ValueTask<Result<T>> MapIf<T, TContext>(
-            this ValueTask<Result<T>> resultTask,
-            bool condition,
-            Func<T, TContext, ValueTask<T>> valueTask,
-            TContext context
-        )
-        {
-            var result = await resultTask;
-            return await result.MapIf(condition, valueTask, context);
-        }
-
-        public static async ValueTask<Result<T, E>> MapIf<T, E>(
-            this ValueTask<Result<T, E>> resultTask,
-            bool condition,
-            Func<T, ValueTask<T>> valueTask
-        )
-        {
-            var result = await resultTask;
-            return await result.MapIf(condition, valueTask);
-        }
-
-        public static async ValueTask<Result<T, E>> MapIf<T, E, TContext>(
-            this ValueTask<Result<T, E>> resultTask,
-            bool condition,
-            Func<T, TContext, ValueTask<T>> valueTask,
-            TContext context
-        )
-        {
-            var result = await resultTask;
-            return await result.MapIf(condition, valueTask, context);
-        }
-
-        public static async ValueTask<Result<T>> MapIf<T>(
-            this ValueTask<Result<T>> resultTask,
-            Func<T, bool> predicate,
-            Func<T, ValueTask<T>> valueTask
-        )
-        {
-            var result = await resultTask;
-            return await result.MapIf(predicate, valueTask);
-        }
-
-        public static async ValueTask<Result<T>> MapIf<T, TContext>(
-            this ValueTask<Result<T>> resultTask,
-            Func<T, TContext, bool> predicate,
-            Func<T, TContext, ValueTask<T>> valueTask,
-            TContext context
-        )
-        {
-            var result = await resultTask;
-            return await result.MapIf(predicate, valueTask, context);
-        }
-
-        public static async ValueTask<Result<T, E>> MapIf<T, E>(
-            this ValueTask<Result<T, E>> resultTask,
-            Func<T, bool> predicate,
-            Func<T, ValueTask<T>> valueTask
-        )
-        {
-            var result = await resultTask;
-            return await result.MapIf(predicate, valueTask);
-        }
-
-        public static async ValueTask<Result<T, E>> MapIf<T, E, TContext>(
-            this ValueTask<Result<T, E>> resultTask,
-            Func<T, TContext, bool> predicate,
-            Func<T, TContext, ValueTask<T>> valueTask,
-            TContext context
-        )
-        {
-            var result = await resultTask;
-            return await result.MapIf(predicate, valueTask, context);
-        }
-    }
-}
-#endif
+#if NET5_0_OR_GREATER
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.ValueTasks
+{
+    public static partial class ResultExtensions
+    {
+        public static async ValueTask<Result<T>> MapIf<T>(
+            this ValueTask<Result<T>> resultTask,
+            bool condition,
+            Func<T, ValueTask<T>> valueTask
+        )
+        {
+            var result = await resultTask;
+            return await result.MapIf(condition, valueTask);
+        }
+
+        public static async ValueTask<Result<T>> MapIf<T, TContext>(
+            this ValueTask<Result<T>> resultTask,
+            bool condition,
+            Func<T, TContext, ValueTask<T>> valueTask,
+            TContext context
+        )
+        {
+            var result = await resultTask;
+            return await result.MapIf(condition, valueTask, context);
+        }
+
+        public static async ValueTask<Result<T, E>> MapIf<T, E>(
+            this ValueTask<Result<T, E>> resultTask,
+            bool condition,
+            Func<T, ValueTask<T>> valueTask
+        )
+        {
+            var result = await resultTask;
+            return await result.MapIf(condition, valueTask);
+        }
+
+        public static async ValueTask<Result<T, E>> MapIf<T, E, TContext>(
+            this ValueTask<Result<T, E>> resultTask,
+            bool condition,
+            Func<T, TContext, ValueTask<T>> valueTask,
+            TContext context
+        )
+        {
+            var result = await resultTask;
+            return await result.MapIf(condition, valueTask, context);
+        }
+
+        public static async ValueTask<Result<T>> MapIf<T>(
+            this ValueTask<Result<T>> resultTask,
+            Func<T, bool> predicate,
+            Func<T, ValueTask<T>> valueTask
+        )
+        {
+            var result = await resultTask;
+            return await result.MapIf(predicate, valueTask);
+        }
+
+        public static async ValueTask<Result<T>> MapIf<T, TContext>(
+            this ValueTask<Result<T>> resultTask,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, ValueTask<T>> valueTask,
+            TContext context
+        )
+        {
+            var result = await resultTask;
+            return await result.MapIf(predicate, valueTask, context);
+        }
+
+        public static async ValueTask<Result<T, E>> MapIf<T, E>(
+            this ValueTask<Result<T, E>> resultTask,
+            Func<T, bool> predicate,
+            Func<T, ValueTask<T>> valueTask
+        )
+        {
+            var result = await resultTask;
+            return await result.MapIf(predicate, valueTask);
+        }
+
+        public static async ValueTask<Result<T, E>> MapIf<T, E, TContext>(
+            this ValueTask<Result<T, E>> resultTask,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, ValueTask<T>> valueTask,
+            TContext context
+        )
+        {
+            var result = await resultTask;
+            return await result.MapIf(predicate, valueTask, context);
+        }
+    }
+}
+#endif
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.cs
index 49e60c00..391ae1e7 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.cs
@@ -1,131 +1,131 @@
-using System;
-
-namespace CSharpFunctionalExtensions
-{
-    /// <summary>
-    ///     Creates a new result from the return value of a given function if the condition is true. If the calling Result is a failure, a new failure result is returned instead.
-    /// </summary>
-    public static partial class ResultExtensions
-    {
-        public static Result<T> MapIf<T>(this Result<T> result, bool condition, Func<T, T> func)
-        {
-            if (!condition)
-            {
-                return result;
-            }
-
-            return result.Map(func);
-        }
-
-        public static Result<T> MapIf<T, TContext>(
-            this Result<T> result,
-            bool condition,
-            Func<T, TContext, T> func,
-            TContext context
-        )
-        {
-            if (!condition)
-            {
-                return result;
-            }
-
-            return result.Map(func, context);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function if the condition is true. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static Result<T, E> MapIf<T, E>(
-            this Result<T, E> result,
-            bool condition,
-            Func<T, T> func
-        )
-        {
-            if (!condition)
-            {
-                return result;
-            }
-
-            return result.Map(func);
-        }
-
-        public static Result<T, E> MapIf<T, E, TContext>(
-            this Result<T, E> result,
-            bool condition,
-            Func<T, TContext, T> func,
-            TContext context
-        )
-        {
-            if (!condition)
-            {
-                return result;
-            }
-
-            return result.Map(func, context);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function if the predicate is true. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static Result<T> MapIf<T>(
-            this Result<T> result,
-            Func<T, bool> predicate,
-            Func<T, T> func
-        )
-        {
-            if (!result.IsSuccess || !predicate(result.Value))
-            {
-                return result;
-            }
-
-            return result.Map(func);
-        }
-
-        public static Result<T> MapIf<T, TContext>(
-            this Result<T> result,
-            Func<T, TContext, bool> predicate,
-            Func<T, TContext, T> func,
-            TContext context
-        )
-        {
-            if (!result.IsSuccess || !predicate(result.Value, context))
-            {
-                return result;
-            }
-
-            return result.Map(func, context);
-        }
-
-        /// <summary>
-        ///     Creates a new result from the return value of a given function if the predicate is true. If the calling Result is a failure, a new failure result is returned instead.
-        /// </summary>
-        public static Result<T, E> MapIf<T, E>(
-            this Result<T, E> result,
-            Func<T, bool> predicate,
-            Func<T, T> func
-        )
-        {
-            if (!result.IsSuccess || !predicate(result.Value))
-            {
-                return result;
-            }
-
-            return result.Map(func);
-        }
-
-        public static Result<T, E> MapIf<T, E, TContext>(
-            this Result<T, E> result,
-            Func<T, TContext, bool> predicate,
-            Func<T, TContext, T> func,
-            TContext context
-        )
-        {
-            if (!result.IsSuccess || !predicate(result.Value, context))
-            {
-                return result;
-            }
-
-            return result.Map(func, context);
-        }
-    }
-}
+using System;
+
+namespace CSharpFunctionalExtensions
+{
+    /// <summary>
+    ///     Creates a new result from the return value of a given function if the condition is true. If the calling Result is a failure, a new failure result is returned instead.
+    /// </summary>
+    public static partial class ResultExtensions
+    {
+        public static Result<T> MapIf<T>(this Result<T> result, bool condition, Func<T, T> func)
+        {
+            if (!condition)
+            {
+                return result;
+            }
+
+            return result.Map(func);
+        }
+
+        public static Result<T> MapIf<T, TContext>(
+            this Result<T> result,
+            bool condition,
+            Func<T, TContext, T> func,
+            TContext context
+        )
+        {
+            if (!condition)
+            {
+                return result;
+            }
+
+            return result.Map(func, context);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function if the condition is true. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<T, E> MapIf<T, E>(
+            this Result<T, E> result,
+            bool condition,
+            Func<T, T> func
+        )
+        {
+            if (!condition)
+            {
+                return result;
+            }
+
+            return result.Map(func);
+        }
+
+        public static Result<T, E> MapIf<T, E, TContext>(
+            this Result<T, E> result,
+            bool condition,
+            Func<T, TContext, T> func,
+            TContext context
+        )
+        {
+            if (!condition)
+            {
+                return result;
+            }
+
+            return result.Map(func, context);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function if the predicate is true. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<T> MapIf<T>(
+            this Result<T> result,
+            Func<T, bool> predicate,
+            Func<T, T> func
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value))
+            {
+                return result;
+            }
+
+            return result.Map(func);
+        }
+
+        public static Result<T> MapIf<T, TContext>(
+            this Result<T> result,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, T> func,
+            TContext context
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value, context))
+            {
+                return result;
+            }
+
+            return result.Map(func, context);
+        }
+
+        /// <summary>
+        ///     Creates a new result from the return value of a given function if the predicate is true. If the calling Result is a failure, a new failure result is returned instead.
+        /// </summary>
+        public static Result<T, E> MapIf<T, E>(
+            this Result<T, E> result,
+            Func<T, bool> predicate,
+            Func<T, T> func
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value))
+            {
+                return result;
+            }
+
+            return result.Map(func);
+        }
+
+        public static Result<T, E> MapIf<T, E, TContext>(
+            this Result<T, E> result,
+            Func<T, TContext, bool> predicate,
+            Func<T, TContext, T> func,
+            TContext context
+        )
+        {
+            if (!result.IsSuccess || !predicate(result.Value, context))
+            {
+                return result;
+            }
+
+            return result.Map(func, context);
+        }
+    }
+}