From b6419f39ad389caa6e1b8645b065fdbbde51a033 Mon Sep 17 00:00:00 2001
From: Ben Smith <bsmithpct@gmail.com>
Date: Mon, 23 Mar 2020 19:24:15 -0700
Subject: [PATCH] TapIf overloads for handling result-returning funcs

---
 .../Extensions/TapIfAsyncBothTests.cs         | 90 +++++++++++++++++++
 .../Extensions/TapIfAsyncLeftTests.cs         | 90 +++++++++++++++++++
 .../Extensions/TapIfAsyncRightTests.cs        | 90 +++++++++++++++++++
 .../ResultTests/Extensions/TapIfTests.cs      | 90 +++++++++++++++++++
 .../ResultTests/Extensions/TapIfTestsBase.cs  |  8 ++
 .../Result/Extensions/TapIf.cs                | 48 ++++++++++
 .../Result/Extensions/TapIfAsyncBoth.cs       | 54 +++++++++++
 .../Result/Extensions/TapIfAsyncLeft.cs       | 54 +++++++++++
 .../Result/Extensions/TapIfAsyncRight.cs      | 48 ++++++++++
 9 files changed, 572 insertions(+)

diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfAsyncBothTests.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfAsyncBothTests.cs
index 9f3619b2..71219829 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfAsyncBothTests.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfAsyncBothTests.cs
@@ -80,6 +80,51 @@ public void TapIf_T_E_AsyncBoth_executes_action_T_conditionally_and_returns_self
             result.Should().Be(returned);
         }
 
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_AsyncBoth_executes_func_result_T_conditionally_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool> result = Result.SuccessIf(isSuccess, condition, ErrorMessage);
+
+            var returned = result.AsTask().TapIf(condition, Task_Func_Result).Result;
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_AsyncBoth_executes_func_result_K_conditionally_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool> result = Result.SuccessIf(isSuccess, condition, ErrorMessage);
+
+            var returned = result.AsTask().TapIf(condition, Task_Func_Result_K).Result;
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_AsyncBoth_executes_func_result_K_E_conditionally_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool, E> result = Result.SuccessIf(isSuccess, condition, E.Value);
+
+            var returned = result.AsTask().TapIf(condition, Task_Func_Result_K_E).Result;
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
         [Theory]
         [InlineData(true, true)]
         [InlineData(true, false)]
@@ -143,5 +188,50 @@ public void TapIf_T_E_AsyncBoth_executes_action_T_per_predicate_and_returns_self
             actionExecuted.Should().Be(isSuccess && condition);
             result.Should().Be(returned);
         }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_AsyncBoth_executes_func_result_T_per_predicate_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool> result = Result.SuccessIf(isSuccess, condition, ErrorMessage);
+
+            var returned = result.AsTask().TapIf(Predicate, Task_Func_Result).Result;
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_AsyncBoth_executes_func_result_K_per_predicate_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool> result = Result.SuccessIf(isSuccess, condition, ErrorMessage);
+
+            var returned = result.AsTask().TapIf(Predicate, Task_Func_Result_K).Result;
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_AsyncBoth_executes_func_result_K_E_per_predicate_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool, E> result = Result.SuccessIf(isSuccess, condition, E.Value);
+
+            var returned = result.AsTask().TapIf(Predicate, Task_Func_Result_K_E).Result;
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
     }
 }
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfAsyncLeftTests.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfAsyncLeftTests.cs
index 476f6d1b..e0523620 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfAsyncLeftTests.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfAsyncLeftTests.cs
@@ -80,6 +80,51 @@ public void TapIf_T_E_AsyncLeft_executes_action_T_conditionally_and_returns_self
             result.Should().Be(returned);
         }
 
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_AsyncLeft_executes_func_result_T_conditionally_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool> result = Result.SuccessIf(isSuccess, condition, ErrorMessage);
+
+            var returned = result.AsTask().TapIf(condition, Func_Result).Result;
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_AsyncLeft_executes_func_result_K_conditionally_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool> result = Result.SuccessIf(isSuccess, condition, ErrorMessage);
+
+            var returned = result.AsTask().TapIf(condition, Func_Result_K).Result;
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_AsyncLeft_executes_func_result_K_E_conditionally_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool, E> result = Result.SuccessIf(isSuccess, condition, E.Value);
+
+            var returned = result.AsTask().TapIf(condition, Func_Result_K_E).Result;
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
         [Theory]
         [InlineData(true, true)]
         [InlineData(true, false)]
@@ -143,5 +188,50 @@ public void TapIf_T_E_AsyncLeft_executes_action_T_per_predicate_and_returns_self
             actionExecuted.Should().Be(isSuccess && condition);
             result.Should().Be(returned);
         }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_AsyncLeft_executes_func_result_T_per_predicate_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool> result = Result.SuccessIf(isSuccess, condition, ErrorMessage);
+
+            var returned = result.AsTask().TapIf(Predicate, Func_Result).Result;
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_AsyncLeft_executes_func_result_K_per_predicate_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool> result = Result.SuccessIf(isSuccess, condition, ErrorMessage);
+
+            var returned = result.AsTask().TapIf(Predicate, Func_Result_K).Result;
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_AsyncLeft_executes_func_result_K_E_per_predicate_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool, E> result = Result.SuccessIf(isSuccess, condition, E.Value);
+
+            var returned = result.AsTask().TapIf(Predicate, Func_Result_K_E).Result;
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
     }
 }
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfAsyncRightTests.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfAsyncRightTests.cs
index 2636b572..ea05f4da 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfAsyncRightTests.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfAsyncRightTests.cs
@@ -80,6 +80,51 @@ public void Tap_T_E_AsyncRight_executes_action_T_conditionally_and_returns_self(
             result.Should().Be(returned);
         }
 
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_AsyncRight_executes_func_result_T_conditionally_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool> result = Result.SuccessIf(isSuccess, condition, ErrorMessage);
+
+            var returned = result.TapIf(condition, Task_Func_Result).Result;
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_AsyncRight_executes_func_result_K_conditionally_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool> result = Result.SuccessIf(isSuccess, condition, ErrorMessage);
+
+            var returned = result.TapIf(condition, Task_Func_Result_K).Result;
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_AsyncRight_executes_func_result_K_E_conditionally_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool, E> result = Result.SuccessIf(isSuccess, condition, E.Value);
+
+            var returned = result.TapIf(condition, Task_Func_Result_K_E).Result;
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
         [Theory]
         [InlineData(true, true)]
         [InlineData(true, false)]
@@ -143,5 +188,50 @@ public void Tap_T_E_AsyncRight_executes_action_T_per_func_condition_and_returns_
             actionExecuted.Should().Be(isSuccess && condition);
             result.Should().Be(returned);
         }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_AsyncRight_executes_func_result_T_per_func_condition_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool> result = Result.SuccessIf(isSuccess, condition, ErrorMessage);
+
+            var returned = result.TapIf(Predicate, Task_Func_Result).Result;
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_AsyncRight_executes_func_result_K_per_func_condition_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool> result = Result.SuccessIf(isSuccess, condition, ErrorMessage);
+
+            var returned = result.TapIf(Predicate, Task_Func_Result_K).Result;
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_AsyncRight_executes_func_result_K_E_per_func_condition_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool, E> result = Result.SuccessIf(isSuccess, condition, E.Value);
+
+            var returned = result.TapIf(Predicate, Task_Func_Result_K_E).Result;
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
     }
 }
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfTests.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfTests.cs
index 5aaf25c4..0f24e803 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfTests.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfTests.cs
@@ -80,6 +80,51 @@ public void TapIf_T_E_executes_action_T_conditionally_and_returns_self(bool isSu
             result.Should().Be(returned);
         }
 
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_executes_func_result_T_conditionally_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool> result = Result.SuccessIf(isSuccess, condition, ErrorMessage);
+
+            var returned = result.TapIf(condition, Func_Result);
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_executes_func_result_K_conditionally_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool> result = Result.SuccessIf(isSuccess, condition, ErrorMessage);
+
+            var returned = result.TapIf(condition, Func_Result_K);
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_executes_func_result_K_E_conditionally_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool, E> result = Result.SuccessIf(isSuccess, condition, E.Value);
+
+            var returned = result.TapIf(condition, Func_Result_K_E);
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
         [Theory]
         [InlineData(true, true)]
         [InlineData(true, false)]
@@ -143,5 +188,50 @@ public void TapIf_T_E_executes_action_T_per_predicate_and_returns_self(bool isSu
             actionExecuted.Should().Be(isSuccess && condition);
             result.Should().Be(returned);
         }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_executes_func_result_T_per_predicate_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool> result = Result.SuccessIf(isSuccess, condition, ErrorMessage);
+
+            var returned = result.TapIf(Predicate, Func_Result);
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_executes_func_result_K_per_predicate_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool> result = Result.SuccessIf(isSuccess, condition, ErrorMessage);
+
+            var returned = result.TapIf(Predicate, Func_Result_K);
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
+
+        [Theory]
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        public void TapIf_T_executes_func_result_K_E_per_predicate_and_returns_self(bool isSuccess, bool condition)
+        {
+            Result<bool, E> result = Result.SuccessIf(isSuccess, condition, E.Value);
+
+            var returned = result.TapIf(Predicate, Func_Result_K_E);
+
+            actionExecuted.Should().Be(isSuccess && condition);
+            result.Should().Be(returned);
+        }
     }
 }
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfTestsBase.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfTestsBase.cs
index 574f6188..b601d947 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfTestsBase.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/TapIfTestsBase.cs
@@ -21,6 +21,14 @@ protected TapIfTestsBase()
         protected async Task Task_Action_T(T _) { actionExecuted = true; }
         protected async Task Task_Action_T(bool _) { actionExecuted = true; }
 
+        protected Result Func_Result(bool _) { actionExecuted = true; return Result.Success(); } 
+        protected Result<K> Func_Result_K(bool _) { actionExecuted = true; return Result.Success<K>(K.Value); }
+        protected Result<K,E> Func_Result_K_E(bool _) { actionExecuted = true; return Result.Success<K, E>(K.Value); }
+
+        protected Task<Result> Task_Func_Result(bool _) { actionExecuted = true; return Result.Success().AsTask(); }
+        protected Task<Result<K>> Task_Func_Result_K(bool _) { actionExecuted = true; return Result.Success<K>(K.Value).AsTask(); }
+        protected Task<Result<K, E>> Task_Func_Result_K_E(bool _) { actionExecuted = true; return Result.Success<K, E>(K.Value).AsTask(); }
+
         protected bool Predicate(bool b) { predicateExecuted = true; return b; }
     }
 }
diff --git a/CSharpFunctionalExtensions/Result/Extensions/TapIf.cs b/CSharpFunctionalExtensions/Result/Extensions/TapIf.cs
index 22e47338..51575a39 100644
--- a/CSharpFunctionalExtensions/Result/Extensions/TapIf.cs
+++ b/CSharpFunctionalExtensions/Result/Extensions/TapIf.cs
@@ -59,6 +59,30 @@ public static Result<T, E> TapIf<T, E>(this Result<T, E> result, bool condition,
                 return result;
         }
 
+        public static Result<T> TapIf<T>(this Result<T> result, bool condition, Func<T, Result> func)
+        {
+            if (condition)
+                return result.Tap(func);
+            else
+                return result;
+        }
+
+        public static Result<T> TapIf<T, K>(this Result<T> result, bool condition, Func<T, Result<K>> func)
+        {
+            if (condition)
+                return result.Tap(func);
+            else
+                return result;
+        }
+
+        public static Result<T, E> TapIf<T, K, E>(this Result<T, E> result, bool condition, Func<T, Result<K, E>> func)
+        {
+            if (condition)
+                return result.Tap(func);
+            else
+                return result;
+        }
+
         /// <summary>
         ///     Executes the given action if the calling result is a success and condition is true. Returns the calling result.
         /// </summary>
@@ -102,5 +126,29 @@ public static Result<T, E> TapIf<T, E>(this Result<T, E> result, Func<T, bool> p
             else
                 return result;
         }
+
+        public static Result<T> TapIf<T>(this Result<T> result, Func<T, bool> predicate, Func<T, Result> func)
+        {
+            if (result.IsSuccess && predicate(result.Value))
+                return result.Tap(func);
+            else
+                return result;
+        }
+
+        public static Result<T> TapIf<T, K>(this Result<T> result, Func<T, bool> predicate, Func<T, Result<K>> func)
+        {
+            if (result.IsSuccess && predicate(result.Value))
+                return result.Tap(func);
+            else
+                return result;
+        }
+
+        public static Result<T, E> TapIf<T, K, E>(this Result<T, E> result, Func<T, bool> predicate, Func<T, Result<K, E>> func)
+        {
+            if (result.IsSuccess && predicate(result.Value))
+                return result.Tap(func);
+            else
+                return result;
+        }
     }
 }
diff --git a/CSharpFunctionalExtensions/Result/Extensions/TapIfAsyncBoth.cs b/CSharpFunctionalExtensions/Result/Extensions/TapIfAsyncBoth.cs
index bc8ba912..ec0f55f8 100644
--- a/CSharpFunctionalExtensions/Result/Extensions/TapIfAsyncBoth.cs
+++ b/CSharpFunctionalExtensions/Result/Extensions/TapIfAsyncBoth.cs
@@ -60,6 +60,30 @@ public static Task<Result<T, E>> TapIf<T, E>(this Task<Result<T, E>> resultTask,
                 return resultTask;
         }
 
+        public static Task<Result<T>> TapIf<T>(this Task<Result<T>> resultTask, bool condition, Func<T, Task<Result>> func)
+        {
+            if (condition)
+                return resultTask.Tap(func);
+            else
+                return resultTask;
+        }
+
+        public static Task<Result<T>> TapIf<T, K>(this Task<Result<T>> resultTask, bool condition, Func<T, Task<Result<K>>> func)
+        {
+            if (condition)
+                return resultTask.Tap(func);
+            else
+                return resultTask;
+        }
+
+        public static Task<Result<T, E>> TapIf<T, K, E>(this Task<Result<T, E>> resultTask, bool condition, Func<T, Task<Result<K, E>>> func)
+        {
+            if (condition)
+                return resultTask.Tap(func);
+            else
+                return resultTask;
+        }
+
         /// <summary>
         ///     Executes the given action if the calling result is a success and condition is true. Returns the calling result.
         /// </summary>
@@ -111,5 +135,35 @@ public static async Task<Result<T, E>> TapIf<T, E>(this Task<Result<T, E>> resul
             else
                 return result;
         }
+
+        public static async Task<Result<T>> TapIf<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, Task<Result>> func)
+        {
+            Result<T> result = await resultTask.DefaultAwait();
+
+            if (result.IsSuccess && predicate(result.Value))
+                return await result.Tap(func).DefaultAwait();
+            else
+                return result;
+        }
+
+        public static async Task<Result<T>> TapIf<T, K>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, Task<Result<K>>> func)
+        {
+            Result<T> result = await resultTask.DefaultAwait();
+
+            if (result.IsSuccess && predicate(result.Value))
+                return await result.Tap(func).DefaultAwait();
+            else
+                return result;
+        }
+
+        public static async Task<Result<T, E>> TapIf<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Func<T, Task<Result<K, E>>> func)
+        {
+            Result<T, E> result = await resultTask.DefaultAwait();
+
+            if (result.IsSuccess && predicate(result.Value))
+                return await result.Tap(func).DefaultAwait();
+            else
+                return result;
+        }
     }
 }
diff --git a/CSharpFunctionalExtensions/Result/Extensions/TapIfAsyncLeft.cs b/CSharpFunctionalExtensions/Result/Extensions/TapIfAsyncLeft.cs
index 50affdd1..154d6c27 100644
--- a/CSharpFunctionalExtensions/Result/Extensions/TapIfAsyncLeft.cs
+++ b/CSharpFunctionalExtensions/Result/Extensions/TapIfAsyncLeft.cs
@@ -60,6 +60,30 @@ public static Task<Result<T, E>> TapIf<T, E>(this Task<Result<T, E>> resultTask,
                 return resultTask;
         }
 
+        public static Task<Result<T>> TapIf<T>(this Task<Result<T>> resultTask, bool condition, Func<T, Result> func)
+        {
+            if (condition)
+                return resultTask.Tap(func);
+            else
+                return resultTask;
+        }
+
+        public static Task<Result<T>> TapIf<T, K>(this Task<Result<T>> resultTask, bool condition, Func<T, Result<K>> func)
+        {
+            if (condition)
+                return resultTask.Tap(func);
+            else
+                return resultTask;
+        }
+
+        public static Task<Result<T, E>> TapIf<T, K, E>(this Task<Result<T, E>> resultTask, bool condition, Func<T, Result<K, E>> func)
+        {
+            if (condition)
+                return resultTask.Tap(func);
+            else
+                return resultTask;
+        }
+
         /// <summary>
         ///     Executes the given action if the calling result is a success and condition is true. Returns the calling result.
         /// </summary>
@@ -111,5 +135,35 @@ public static async Task<Result<T, E>> TapIf<T, E>(this Task<Result<T, E>> resul
             else
                 return result;
         }
+
+        public static async Task<Result<T>> TapIf<T>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, Result> func)
+        {
+            Result<T> result = await resultTask.DefaultAwait();
+
+            if (result.IsSuccess && predicate(result.Value))
+                return result.Tap(func);
+            else
+                return result;
+        }
+
+        public static async Task<Result<T>> TapIf<T, K>(this Task<Result<T>> resultTask, Func<T, bool> predicate, Func<T, Result<K>> func)
+        {
+            Result<T> result = await resultTask.DefaultAwait();
+
+            if (result.IsSuccess && predicate(result.Value))
+                return result.Tap(func);
+            else
+                return result;
+        }
+
+        public static async Task<Result<T, E>> TapIf<T, K, E>(this Task<Result<T, E>> resultTask, Func<T, bool> predicate, Func<T, Result<K, E>> func)
+        {
+            Result<T, E> result = await resultTask.DefaultAwait();
+
+            if (result.IsSuccess && predicate(result.Value))
+                return result.Tap(func);
+            else
+                return result;
+        }
     }
 }
diff --git a/CSharpFunctionalExtensions/Result/Extensions/TapIfAsyncRight.cs b/CSharpFunctionalExtensions/Result/Extensions/TapIfAsyncRight.cs
index c982122e..0ef72261 100644
--- a/CSharpFunctionalExtensions/Result/Extensions/TapIfAsyncRight.cs
+++ b/CSharpFunctionalExtensions/Result/Extensions/TapIfAsyncRight.cs
@@ -60,6 +60,30 @@ public static Task<Result<T, E>> TapIf<T, E>(this Result<T, E> result, bool cond
                 return Task.FromResult(result);
         }
 
+        public static Task<Result<T>> TapIf<T>(this Result<T> result, bool condition, Func<T, Task<Result>> func)
+        {
+            if (condition)
+                return result.Tap(func);
+            else
+                return Task.FromResult(result);
+        }
+
+        public static Task<Result<T>> TapIf<T, K>(this Result<T> result, bool condition, Func<T, Task<Result<K>>> func)
+        {
+            if (condition)
+                return result.Tap(func);
+            else
+                return Task.FromResult(result);
+        }
+
+        public static Task<Result<T, E>> TapIf<T, K, E>(this Result<T, E> result, bool condition, Func<T, Task<Result<K, E>>> func)
+        {
+            if (condition)
+                return result.Tap(func);
+            else
+                return Task.FromResult(result);
+        }
+
         /// <summary>
         ///     Executes the given action if the calling result is a success and condition is true. Returns the calling result.
         /// </summary>
@@ -103,5 +127,29 @@ public static Task<Result<T, E>> TapIf<T, E>(this Result<T, E> result, Func<T, b
             else
                 return Task.FromResult(result);
         }
+
+        public static Task<Result<T>> TapIf<T>(this Result<T> result, Func<T, bool> predicate, Func<T, Task<Result>> func)
+        {
+            if (result.IsSuccess && predicate(result.Value))
+                return result.Tap(func);
+            else
+                return Task.FromResult(result);
+        }
+
+        public static Task<Result<T>> TapIf<T, K>(this Result<T> result, Func<T, bool> predicate, Func<T, Task<Result<K>>> func)
+        {
+            if (result.IsSuccess && predicate(result.Value))
+                return result.Tap(func);
+            else
+                return Task.FromResult(result);
+        }
+
+        public static Task<Result<T, E>> TapIf<T, K, E>(this Result<T, E> result, Func<T, bool> predicate, Func<T, Task<Result<K, E>>> func)
+        {
+            if (result.IsSuccess && predicate(result.Value))
+                return result.Tap(func);
+            else
+                return Task.FromResult(result);
+        }
     }
 }