diff --git a/CSharpFunctionalExtensions.Tests/CSharpFunctionalExtensions.Tests.csproj b/CSharpFunctionalExtensions.Tests/CSharpFunctionalExtensions.Tests.csproj
index 8fd462a7..2728130d 100644
--- a/CSharpFunctionalExtensions.Tests/CSharpFunctionalExtensions.Tests.csproj
+++ b/CSharpFunctionalExtensions.Tests/CSharpFunctionalExtensions.Tests.csproj
@@ -34,6 +34,27 @@
     <Compile Update="ResultTests\Extensions\MapTests.Task.Right.cs">
       <DependentUpon>MapTests.Task.cs</DependentUpon>
     </Compile>
+    <Compile Update="ResultTests\Extensions\MapIfTests.Base.cs">
+      <DependentUpon>MapIfTests.cs</DependentUpon>
+    </Compile>
+    <Compile Update="ResultTests\Extensions\MapIfTests.Task.cs">
+      <DependentUpon>MapIfTests.cs</DependentUpon>
+    </Compile>
+    <Compile Update="ResultTests\Extensions\MapIfTests.Task.Left.cs">
+      <DependentUpon>MapIfTests.Task.cs</DependentUpon>
+    </Compile>
+    <Compile Update="ResultTests\Extensions\MapIfTests.Task.Right.cs">
+      <DependentUpon>MapIfTests.Task.cs</DependentUpon>
+    </Compile>
+    <Compile Update="ResultTests\Extensions\MapIfTests.ValueTask.cs">
+      <DependentUpon>MapIfTests.cs</DependentUpon>
+    </Compile>
+    <Compile Update="ResultTests\Extensions\MapIfTests.ValueTask.Left.cs">
+      <DependentUpon>MapIfTests.ValueTask.cs</DependentUpon>
+    </Compile>
+    <Compile Update="ResultTests\Extensions\MapIfTests.ValueTask.Right.cs">
+      <DependentUpon>MapIfTests.ValueTask.cs</DependentUpon>
+    </Compile>
     <Compile Update="ResultTests\Extensions\MapErrorTests.Task.Left.cs">
       <DependentUpon>MapErrorTests.Task.cs</DependentUpon>
     </Compile>
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Base.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Base.cs
new file mode 100644
index 00000000..6238a701
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Base.cs
@@ -0,0 +1,73 @@
+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);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Left.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Left.cs
new file mode 100644
index 00000000..3d3a52ca
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Left.cs
@@ -0,0 +1,71 @@
+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));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Right.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Right.cs
new file mode 100644
index 00000000..cea435bc
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.Right.cs
@@ -0,0 +1,71 @@
+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));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.cs
new file mode 100644
index 00000000..c723527f
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.Task.cs
@@ -0,0 +1,71 @@
+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));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Left.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Left.cs
new file mode 100644
index 00000000..c465a94d
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Left.cs
@@ -0,0 +1,72 @@
+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));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Right.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Right.cs
new file mode 100644
index 00000000..d36b0e7d
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.Right.cs
@@ -0,0 +1,72 @@
+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));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.cs
new file mode 100644
index 00000000..9a33f3dd
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.ValueTask.cs
@@ -0,0 +1,72 @@
+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));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.cs
new file mode 100644
index 00000000..825654b1
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/MapIfTests.cs
@@ -0,0 +1,70 @@
+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));
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/CSharpFunctionalExtensions.csproj b/CSharpFunctionalExtensions/CSharpFunctionalExtensions.csproj
index 31b6bfea..f125cfcf 100644
--- a/CSharpFunctionalExtensions/CSharpFunctionalExtensions.csproj
+++ b/CSharpFunctionalExtensions/CSharpFunctionalExtensions.csproj
@@ -120,6 +120,24 @@
     <Compile Update="Maybe\Extensions\Map.Task.cs">
       <DependentUpon>Map.cs</DependentUpon>
     </Compile>
+    <Compile Update="Result\Methods\Extensions\MapIf.Task.cs">
+      <DependentUpon>MapIf.cs</DependentUpon>
+    </Compile>
+    <Compile Update="Result\Methods\Extensions\MapIf.Task.Right.cs">
+      <DependentUpon>MapIf.Task.cs</DependentUpon>
+    </Compile>
+    <Compile Update="Result\Methods\Extensions\MapIf.Task.Left.cs">
+      <DependentUpon>MapIf.Task.cs</DependentUpon>
+    </Compile>
+    <Compile Update="Result\Methods\Extensions\MapIf.ValueTask.Right.cs">
+      <DependentUpon>MapIf.ValueTask.cs</DependentUpon>
+    </Compile>
+    <Compile Update="Result\Methods\Extensions\MapIf.ValueTask.Left.cs">
+      <DependentUpon>MapIf.ValueTask.cs</DependentUpon>
+    </Compile>
+    <Compile Update="Result\Methods\Extensions\MapIf.ValueTask.cs">
+      <DependentUpon>MapIf.cs</DependentUpon>
+    </Compile>
     <Compile Update="Maybe\Extensions\Or.Task.cs">
       <DependentUpon>Or.cs</DependentUpon>
     </Compile>
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Left.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Left.cs
new file mode 100644
index 00000000..c702d000
--- /dev/null
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Left.cs
@@ -0,0 +1,32 @@
+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);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Right.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Right.cs
new file mode 100644
index 00000000..ec05c65c
--- /dev/null
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.Right.cs
@@ -0,0 +1,48 @@
+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);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.cs
new file mode 100644
index 00000000..45eb46ac
--- /dev/null
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.Task.cs
@@ -0,0 +1,32 @@
+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();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Left.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Left.cs
new file mode 100644
index 00000000..e58fe375
--- /dev/null
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Left.cs
@@ -0,0 +1,34 @@
+#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
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Right.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Right.cs
new file mode 100644
index 00000000..c8b3e30d
--- /dev/null
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.Right.cs
@@ -0,0 +1,50 @@
+#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
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.cs
new file mode 100644
index 00000000..758c1584
--- /dev/null
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.ValueTask.cs
@@ -0,0 +1,34 @@
+#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
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.cs
new file mode 100644
index 00000000..b5b64312
--- /dev/null
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/MapIf.cs
@@ -0,0 +1,47 @@
+using System;
+
+namespace CSharpFunctionalExtensions
+{
+    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, 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> 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, 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);
+        }
+    }
+}