diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Left.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Left.cs
new file mode 100644
index 00000000..ad2ba1de
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Left.cs
@@ -0,0 +1,22 @@
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapNoValueTests_Task_Left : MaybeTestBase
+    {
+        [Fact]
+        public async Task TapNoValue_Task_Left_executes_action_when_no_value()
+        {
+            string property = null;
+
+            Maybe<T> maybe = null;
+
+            var returnedMaybe = await maybe.AsTask().TapNoValue(() => property = "Some value");
+
+            property.Should().Be("Some value");
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Right.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Right.cs
new file mode 100644
index 00000000..d1dd8cde
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Right.cs
@@ -0,0 +1,26 @@
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapNoValueTests_Task_Right : MaybeTestBase
+    {
+        [Fact]
+        public async Task TapNoValue_Task_Right_executes_action_when_no_value()
+        {
+            string property = null;
+
+            Maybe<T> maybe = null;
+
+            var returnedMaybe = await maybe.TapNoValue(() =>
+            {
+                property = "Some value";
+                return Task.CompletedTask;
+            });
+
+            property.Should().Be("Some value");
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.cs
new file mode 100644
index 00000000..73faa1be
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.cs
@@ -0,0 +1,24 @@
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapNoValueTests_Task : MaybeTestBase
+    {
+        [Fact]
+        public async Task TapNoValue_Task_executes_action_when_no_value()
+        {
+            string property = null;
+
+            Maybe<T> maybe = null;
+
+            var returnedMaybe = await maybe
+                .AsTask()
+                .TapNoValue(() => property = "Some value");
+
+            property.Should().Be("Some value");
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Left.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Left.cs
new file mode 100644
index 00000000..57ffc63a
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Left.cs
@@ -0,0 +1,23 @@
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapNoValueTests_ValueTask_Left : MaybeTestBase
+    {
+        [Fact]
+        public async Task TapNoValue_ValueTask_Left_executes_action_when_no_value()
+        {
+            string property = null;
+
+            Maybe<T> maybe = null;
+
+            var returnedMaybe = await maybe.AsValueTask().TapNoValue(() => property = "Some value");
+
+            property.Should().Be("Some value");
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Right.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Right.cs
new file mode 100644
index 00000000..2a37de55
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Right.cs
@@ -0,0 +1,27 @@
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapNoValueTests_ValueTask_Right : MaybeTestBase
+    {
+        [Fact]
+        public async Task TapNoValue_ValueTask_Right_executes_action_when_no_value()
+        {
+            string property = null;
+
+            Maybe<T> maybe = null;
+
+            var returnedMaybe = await maybe.TapNoValue(() =>
+            {
+                property = "Some value";
+                return ValueTask.CompletedTask;
+            });
+
+            property.Should().Be("Some value");
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.cs
new file mode 100644
index 00000000..beb35952
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.cs
@@ -0,0 +1,25 @@
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapNoValueTests_ValueTask : MaybeTestBase
+    {
+        [Fact]
+        public async Task TapNoValue_ValueTask_executes_action_when_no_value()
+        {
+            string property = null;
+
+            Maybe<T> maybe = null;
+
+            var returnedMaybe = await maybe
+                .AsValueTask()
+                .TapNoValue(() => property = "Some value");
+
+            property.Should().Be("Some value");
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.cs
new file mode 100644
index 00000000..5c503430
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.cs
@@ -0,0 +1,21 @@
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapNoValueTests : MaybeTestBase
+    {
+        [Fact]
+        public void TapNoValue_executes_action_when_no_value()
+        {
+            string property = null;
+
+            Maybe<T> maybe = null;
+
+            var returnedMaybe = maybe.TapNoValue(() => property = "Some value");
+
+            property.Should().Be("Some value");
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Left.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Left.cs
new file mode 100644
index 00000000..0e6bffc1
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Left.cs
@@ -0,0 +1,32 @@
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapTests_Task_Left : MaybeTestBase
+    {
+        [Fact]
+        public async Task Tap_Task_Lef_does_not_execute_action_if_no_value()
+        {
+            Maybe<T> maybe = null;
+            var executed = false;
+
+            var returnedMaybe = await maybe.AsTask().Tap(value => executed = true);
+
+            executed.Should().BeFalse();
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Tap_Task_Lef_executes_action_if_value()
+        {
+            Maybe<T> maybe = T.Value;
+
+            var returnedMaybe = await maybe.AsTask().Tap(value => value.Should().Be(T.Value));
+
+            maybe.Value.Should().Be(T.Value);
+            returnedMaybe.Value.Should().BeSameAs(maybe.Value);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Right.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Right.cs
new file mode 100644
index 00000000..6632eb3e
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Right.cs
@@ -0,0 +1,40 @@
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapTests_Task_Right : MaybeTestBase
+    {
+        [Fact]
+        public async Task Tap_Task_Right_does_not_execute_action_if_no_value()
+        {
+            Maybe<T> maybe = null;
+
+            var returnedMaybe = await maybe.Tap(value =>
+            {
+                maybe = T.Value;
+                return Task.CompletedTask;
+            });
+
+            maybe.HasNoValue.Should().BeTrue();
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Tap_Task_Right_executes_action_if_value()
+        {
+            Maybe<T> maybe = T.Value;
+
+
+            var returnedMaybe = await maybe.Tap(value =>
+            {
+                value.Should().Be(T.Value);
+                return Task.CompletedTask;
+            });
+
+            maybe.Value.Should().Be(T.Value);
+            returnedMaybe.Value.Should().BeSameAs(maybe.Value);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.cs
new file mode 100644
index 00000000..2272b217
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.cs
@@ -0,0 +1,44 @@
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapTests_Task : MaybeTestBase
+    {
+        [Fact]
+        public async Task Tap_Task_does_not_execute_action_if_no_value()
+        {
+            Maybe<T> maybe = null;
+            var executed = false;
+
+            var returnedMaybe = await maybe
+                .AsTask()
+                .Tap(value =>
+                {
+                    executed = true;
+                    return Task.CompletedTask;
+                });
+
+            executed.Should().BeFalse();
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Tap_Task_executes_action_if_value()
+        {
+            Maybe<T> maybe = T.Value;
+
+            var returnedMaybe = await maybe
+                .AsTask()
+                .Tap(value =>
+                {
+                    value.Should().Be(T.Value);
+                    return Task.CompletedTask;
+                });
+
+            maybe.Value.Should().Be(T.Value);
+            returnedMaybe.Value.Should().BeSameAs(maybe.Value);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Left.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Left.cs
new file mode 100644
index 00000000..7b9c7e0f
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Left.cs
@@ -0,0 +1,33 @@
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapTests_ValueTask_Left : MaybeTestBase
+    {
+        [Fact]
+        public async Task Tap_ValueTask_Lef_does_not_execute_action_if_no_value()
+        {
+            Maybe<T> maybe = null;
+            var executed = false;
+
+            var returnedMaybe = await maybe.AsValueTask().Tap(value => executed = true);
+
+            executed.Should().BeFalse();
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Tap_ValueTask_Lef_executes_action_if_value()
+        {
+            Maybe<T> maybe = T.Value;
+
+            var returnedMaybe = await maybe.AsValueTask().Tap(value => value.Should().Be(T.Value));
+
+            maybe.Value.Should().Be(T.Value);
+            returnedMaybe.Value.Should().BeSameAs(maybe.Value);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Right.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Right.cs
new file mode 100644
index 00000000..a42b77f8
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Right.cs
@@ -0,0 +1,41 @@
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapTests_ValueTask_Right : MaybeTestBase
+    {
+        [Fact]
+        public async Task Tap_ValueTask_Right_does_not_execute_action_if_no_value()
+        {
+            Maybe<T> maybe = null;
+            var executed = false;
+
+            var returnedMaybe = await maybe.Tap(value =>
+            {
+                executed = true;
+                return ValueTask.CompletedTask;
+            });
+
+            executed.Should().BeFalse();
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Tap_ValueTask_Right_executes_action_if_value()
+        {
+            Maybe<T> maybe = T.Value;
+
+            var returnedMaybe = await maybe.Tap(value =>
+            {
+                value.Should().Be(T.Value);
+                return ValueTask.CompletedTask;
+            });
+
+            maybe.Value.Should().Be(T.Value);
+            returnedMaybe.Value.Should().BeSameAs(maybe.Value);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.cs
new file mode 100644
index 00000000..05df5979
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.cs
@@ -0,0 +1,45 @@
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapTests_ValueTask : MaybeTestBase
+    {
+        [Fact]
+        public async Task Tap_ValueTask_does_not_execute_action_if_no_value()
+        {
+            Maybe<T> maybe = null;
+            var executed = false;
+
+            var returnedMaybe = await maybe
+                .AsValueTask()
+                .Tap(value =>
+                {
+                    executed = true;
+                    return ValueTask.CompletedTask;
+                });
+
+            executed.Should().BeFalse();
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Tap_ValueTask_executes_action_if_value()
+        {
+            Maybe<T> maybe = T.Value;
+
+            var returnedMaybe = await maybe
+                .AsValueTask()
+                .Tap(value =>
+                {
+                    value.Should().Be(T.Value);
+                    return ValueTask.CompletedTask;
+                });
+
+            maybe.Value.Should().Be(T.Value);
+            returnedMaybe.Value.Should().BeSameAs(maybe.Value);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.cs b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.cs
new file mode 100644
index 00000000..9e707189
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.cs
@@ -0,0 +1,31 @@
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapTests : MaybeTestBase
+    {
+        [Fact]
+        public void Tap_does_not_execute_action_if_no_value()
+        {
+            Maybe<T> maybe = null;
+            var executed = false;
+
+            var returnedMaybe = maybe.Tap(value => executed = true);
+
+            executed.Should().BeFalse();
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+
+        [Fact]
+        public void Tap_executes_action_if_value()
+        {
+            Maybe<T> maybe = T.Value;
+
+            var returnedMaybe = maybe.Tap(value => value.Should().Be(T.Value));
+
+            maybe.Value.Should().Be(T.Value);
+            returnedMaybe.Value.Should().BeSameAs(maybe.Value);
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.Left.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.Left.cs
index b359cd52..3e6a72a2 100644
--- a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.Left.cs
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.Left.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading.Tasks;
 
 namespace CSharpFunctionalExtensions
@@ -12,6 +12,7 @@ public static partial class MaybeExtensions
         /// <param name="action"></param>
         /// <typeparam name="T"></typeparam>
         /// <returns></returns>
+        [Obsolete("Use TapValue instead")]
         public static async Task Execute<T>(this Task<Maybe<T>> maybeTask, Action<T> action)
         {
             var maybe = await maybeTask.DefaultAwait();
@@ -22,4 +23,4 @@ public static async Task Execute<T>(this Task<Maybe<T>> maybeTask, Action<T> act
             action(maybe.GetValueOrThrow());
         }
     }
-}
\ No newline at end of file
+}
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.Right.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.Right.cs
index 5b303c0f..afbf3d75 100644
--- a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.Right.cs
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.Right.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading.Tasks;
 
 namespace CSharpFunctionalExtensions
@@ -11,6 +11,7 @@ public static partial class MaybeExtensions
         /// <param name="maybe"></param>
         /// <param name="action"></param>
         /// <typeparam name="T"></typeparam>
+        [Obsolete("Use TapValue instead")]
         public static async Task Execute<T>(this Maybe<T> maybe, Func<T, Task> action)
         {
             if (maybe.HasNoValue)
@@ -19,4 +20,4 @@ public static async Task Execute<T>(this Maybe<T> maybe, Func<T, Task> action)
             await action(maybe.GetValueOrThrow()).DefaultAwait();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.cs
index 7129bde4..809aeabf 100644
--- a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.cs
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.Task.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading.Tasks;
 
 namespace CSharpFunctionalExtensions
@@ -12,6 +12,7 @@ public static partial class MaybeExtensions
         /// <param name="asyncAction"></param>
         /// <typeparam name="T"></typeparam>
         /// <returns></returns>
+        [Obsolete("Use TapValue instead")]
         public static async Task Execute<T>(this Task<Maybe<T>> maybeTask, Func<T, Task> asyncAction)
         {
             var maybe = await maybeTask.DefaultAwait();
@@ -22,4 +23,4 @@ public static async Task Execute<T>(this Task<Maybe<T>> maybeTask, Func<T, Task>
             await asyncAction(maybe.GetValueOrThrow()).DefaultAwait();
         } 
     }
-}
\ No newline at end of file
+}
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.Left.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.Left.cs
index 9a572430..193735e2 100644
--- a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.Left.cs
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.Left.cs
@@ -1,4 +1,4 @@
-#if NET5_0_OR_GREATER
+#if NET5_0_OR_GREATER
 using System;
 using System.Threading.Tasks;
 
@@ -13,6 +13,7 @@ public static partial class MaybeExtensions
         /// <param name="action"></param>
         /// <typeparam name="T"></typeparam>
         /// <returns></returns>
+        [Obsolete("Use TapValue instead")]
         public static async Task Execute<T>(this ValueTask<Maybe<T>> maybeTask, Action<T> action)
         {
             var maybe = await maybeTask;
@@ -24,4 +25,4 @@ public static async Task Execute<T>(this ValueTask<Maybe<T>> maybeTask, Action<T
         }
     }
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.Right.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.Right.cs
index f0af1baa..97ec5a1d 100644
--- a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.Right.cs
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.Right.cs
@@ -1,4 +1,4 @@
-#if NET5_0_OR_GREATER
+#if NET5_0_OR_GREATER
 using System;
 using System.Threading.Tasks;
 
@@ -12,6 +12,7 @@ public static partial class MaybeExtensions
         /// <param name="maybe"></param>
         /// <param name="valueTask"></param>
         /// <typeparam name="T"></typeparam>
+        [Obsolete("Use TapValue instead")]
         public static async Task Execute<T>(this Maybe<T> maybe, Func<T, ValueTask> valueTask)
         {
             if (maybe.HasNoValue)
@@ -21,4 +22,4 @@ public static async Task Execute<T>(this Maybe<T> maybe, Func<T, ValueTask> valu
         }
     }
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.cs
index 9dc615c6..6ed7c1b8 100644
--- a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.cs
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.ValueTask.cs
@@ -1,4 +1,4 @@
-#if NET5_0_OR_GREATER
+#if NET5_0_OR_GREATER
 using System;
 using System.Threading.Tasks;
 
@@ -13,6 +13,7 @@ public static partial class MaybeExtensions
         /// <param name="valueTask"></param>
         /// <typeparam name="T"></typeparam>
         /// <returns></returns>
+        [Obsolete("Use TapValue instead")]
         public static async Task Execute<T>(this ValueTask<Maybe<T>> maybeTask, Func<T, ValueTask> valueTask)
         {
             var maybe = await maybeTask;
@@ -24,4 +25,4 @@ public static async Task Execute<T>(this ValueTask<Maybe<T>> maybeTask, Func<T,
         }
     }
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.cs
index 96433f3a..b9bd1fde 100644
--- a/CSharpFunctionalExtensions/Maybe/Extensions/Execute.cs
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/Execute.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace CSharpFunctionalExtensions
 {
@@ -10,6 +10,7 @@ public static partial class MaybeExtensions
         /// <param name="maybe"></param>
         /// <param name="action"></param>
         /// <typeparam name="T"></typeparam>
+        [Obsolete("Use TapValue instead")]
         public static void Execute<T>(in this Maybe<T> maybe, Action<T> action)
         {
             if (maybe.HasNoValue)
@@ -18,4 +19,4 @@ public static void Execute<T>(in this Maybe<T> maybe, Action<T> action)
             action(maybe.GetValueOrThrow());
         }
     }
-}
\ No newline at end of file
+}
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.Left.cs b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.Left.cs
index f1090a8a..68b353df 100644
--- a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.Left.cs
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.Left.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading.Tasks;
 
 namespace CSharpFunctionalExtensions
@@ -11,6 +11,7 @@ public static partial class MaybeExtensions
         /// <param name="maybeTask"></param>
         /// <param name="action"></param>
         /// <typeparam name="T"></typeparam>
+        [Obsolete("Use TapNoValue instead")]
         public static async Task ExecuteNoValue<T>(this Task<Maybe<T>> maybeTask, Action action)
         {
             var maybe = await maybeTask.DefaultAwait();
@@ -21,4 +22,4 @@ public static async Task ExecuteNoValue<T>(this Task<Maybe<T>> maybeTask, Action
             action();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.Right.cs b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.Right.cs
index 90e53a66..a6e7781a 100644
--- a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.Right.cs
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.Right.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading.Tasks;
 
 namespace CSharpFunctionalExtensions
@@ -11,6 +11,7 @@ public static partial class MaybeExtensions
         /// <param name="maybe"></param>
         /// <param name="action"></param>
         /// <typeparam name="T"></typeparam>
+        [Obsolete("Use TapNoValue instead")]
         public static async Task ExecuteNoValue<T>(this Maybe<T> maybe, Func<Task> action)
         {
             if (maybe.HasValue)
@@ -19,4 +20,4 @@ public static async Task ExecuteNoValue<T>(this Maybe<T> maybe, Func<Task> actio
             await action().DefaultAwait();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.cs b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.cs
index 32658d25..b7b851c9 100644
--- a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.cs
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.Task.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading.Tasks;
 
 namespace CSharpFunctionalExtensions
@@ -11,6 +11,7 @@ public static partial class MaybeExtensions
         /// <param name="maybeTask"></param>
         /// <param name="asyncAction"></param>
         /// <typeparam name="T"></typeparam>
+        [Obsolete("Use TapNoValue instead")]
         public static async Task ExecuteNoValue<T>(this Task<Maybe<T>> maybeTask, Func<Task> asyncAction)
         {
             var maybe = await maybeTask.DefaultAwait();
@@ -21,4 +22,4 @@ public static async Task ExecuteNoValue<T>(this Task<Maybe<T>> maybeTask, Func<T
             await asyncAction().DefaultAwait();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.Left.cs b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.Left.cs
index 5b50df72..2058369e 100644
--- a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.Left.cs
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.Left.cs
@@ -1,4 +1,4 @@
-#if NET5_0_OR_GREATER
+#if NET5_0_OR_GREATER
 using System;
 using System.Threading.Tasks;
 
@@ -12,6 +12,7 @@ public static partial class MaybeExtensions
         /// <param name="maybeTask"></param>
         /// <param name="action"></param>
         /// <typeparam name="T"></typeparam>
+        [Obsolete("Use TapNoValue instead")]
         public static async Task ExecuteNoValue<T>(this ValueTask<Maybe<T>> maybeTask, Action action)
         {
             var maybe = await maybeTask;
@@ -23,4 +24,4 @@ public static async Task ExecuteNoValue<T>(this ValueTask<Maybe<T>> maybeTask, A
         }
     }
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.Right.cs b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.Right.cs
index e1303380..082514df 100644
--- a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.Right.cs
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.Right.cs
@@ -1,4 +1,4 @@
-#if NET5_0_OR_GREATER
+#if NET5_0_OR_GREATER
 using System;
 using System.Threading.Tasks;
 
@@ -12,6 +12,7 @@ public static partial class MaybeExtensions
         /// <param name="maybe"></param>
         /// <param name="valueTask"></param>
         /// <typeparam name="T"></typeparam>
+        [Obsolete("Use TapNoValue instead")]
         public static async Task ExecuteNoValue<T>(this Maybe<T> maybe, Func<ValueTask> valueTask)
         {
             if (maybe.HasValue)
@@ -21,4 +22,4 @@ public static async Task ExecuteNoValue<T>(this Maybe<T> maybe, Func<ValueTask>
         }
     }
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.cs b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.cs
index eb8ad8da..53242f9a 100644
--- a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.cs
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.ValueTask.cs
@@ -1,4 +1,4 @@
-#if NET5_0_OR_GREATER
+#if NET5_0_OR_GREATER
 using System;
 using System.Threading.Tasks;
 
@@ -12,6 +12,7 @@ public static partial class MaybeExtensions
         /// <param name="maybeTask"></param>
         /// <param name="valueTask"></param>
         /// <typeparam name="T"></typeparam>
+        [Obsolete("Use TapNoValue instead")]
         public static async Task ExecuteNoValue<T>(this ValueTask<Maybe<T>> maybeTask, Func<ValueTask> valueTask)
         {
             var maybe = await maybeTask;
@@ -24,4 +25,4 @@ public static async Task ExecuteNoValue<T>(this ValueTask<Maybe<T>> maybeTask, F
 
     }
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.cs b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.cs
index 0749cee3..a92ec865 100644
--- a/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.cs
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/ExecuteNoValue.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace CSharpFunctionalExtensions
 {
@@ -10,6 +10,7 @@ public static partial class MaybeExtensions
         /// <param name="maybe"></param>
         /// <param name="action"></param>
         /// <typeparam name="T"></typeparam>
+        [Obsolete("Use TapNoValue instead")]
         public static void ExecuteNoValue<T>(in this Maybe<T> maybe, Action action)
         {
             if (maybe.HasValue)
@@ -18,4 +19,4 @@ public static void ExecuteNoValue<T>(in this Maybe<T> maybe, Action action)
             action();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.Left.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.Left.cs
new file mode 100644
index 00000000..9fcdce87
--- /dev/null
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.Left.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class MaybeExtensions
+    {
+        /// <summary>
+        ///     Executes the given <paramref name="action" /> if the <paramref name="maybeTask" /> produces a value
+        /// Returns the calling maybe.
+        /// </summary>
+        /// <param name="maybeTask"></param>
+        /// <param name="action"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns>The calling maybe</returns>
+        public static async Task<Maybe<T>> Tap<T>(this Task<Maybe<T>> maybeTask, Action<T> action)
+        {
+            var maybe = await maybeTask.DefaultAwait();
+
+            if (maybe.HasValue)
+            {
+                action(maybe.GetValueOrThrow());
+            }
+
+            return maybe;
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.Right.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.Right.cs
new file mode 100644
index 00000000..f7710b96
--- /dev/null
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.Right.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class MaybeExtensions
+    {
+        /// <summary>
+        ///     Executes the given async <paramref name="action" /> if the <paramref name="maybe" /> has a value
+        /// Returns the calling maybe.
+        /// </summary>
+        /// <param name="maybe"></param>
+        /// <param name="action"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns>The calling maybe</returns>
+        public static async Task<Maybe<T>> Tap<T>(this Maybe<T> maybe, Func<T, Task> action)
+        {
+            if (maybe.HasValue)
+            {
+                await action(maybe.GetValueOrThrow()).DefaultAwait();
+            }
+
+            return maybe;
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.cs
new file mode 100644
index 00000000..33db528e
--- /dev/null
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.Task.cs
@@ -0,0 +1,31 @@
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class MaybeExtensions
+    {
+        /// <summary>
+        ///     Executes the given <paramref name="asyncAction" /> if the <paramref name="maybeTask" /> produces a value
+        /// Returns the calling maybe.
+        /// </summary>
+        /// <param name="maybeTask"></param>
+        /// <param name="asyncAction"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns>The calling maybe</returns>
+        public static async Task<Maybe<T>> Tap<T>(
+            this Task<Maybe<T>> maybeTask,
+            Func<T, Task> asyncAction
+        )
+        {
+            var maybe = await maybeTask.DefaultAwait();
+
+            if (maybe.HasValue)
+            {
+                await asyncAction(maybe.GetValueOrThrow()).DefaultAwait();
+            }
+
+            return maybe;
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.Left.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.Left.cs
new file mode 100644
index 00000000..a9eafdf0
--- /dev/null
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.Left.cs
@@ -0,0 +1,33 @@
+#if NET5_0_OR_GREATER
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.ValueTasks
+{
+    public static partial class MaybeExtensions
+    {
+        /// <summary>
+        /// Executes the given <paramref name="action" /> if the <paramref name="maybeTask" /> produces a value
+        /// Returns the calling maybe.
+        /// </summary>
+        /// <param name="maybeTask"></param>
+        /// <param name="action"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns>The calling maybe</returns>
+        public static async ValueTask<Maybe<T>> Tap<T>(
+            this ValueTask<Maybe<T>> maybeTask,
+            Action<T> action
+        )
+        {
+            var maybe = await maybeTask;
+
+            if (maybe.HasValue)
+            {
+                action(maybe.GetValueOrThrow());
+            }
+
+            return maybe;
+        }
+    }
+}
+#endif
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.Right.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.Right.cs
new file mode 100644
index 00000000..874336a8
--- /dev/null
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.Right.cs
@@ -0,0 +1,30 @@
+#if NET5_0_OR_GREATER
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.ValueTasks
+{
+    public static partial class MaybeExtensions
+    {
+        /// <summary>
+        ///     Executes the given async <paramref name="valueTask" /> if the <paramref name="maybe" /> has a value
+        /// Returns the calling maybe.
+        /// </summary>
+        /// <param name="maybe"></param>
+        /// <param name="valueTask"></param>
+        /// <typeparam name="T"></typeparam>
+        public static async ValueTask<Maybe<T>> Tap<T>(
+            this Maybe<T> maybe,
+            Func<T, ValueTask> valueTask
+        )
+        {
+            if (maybe.HasValue)
+            {
+                await valueTask(maybe.GetValueOrThrow());
+            }
+
+            return maybe;
+        }
+    }
+}
+#endif
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.cs
new file mode 100644
index 00000000..874d44d7
--- /dev/null
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.ValueTask.cs
@@ -0,0 +1,31 @@
+#if NET5_0_OR_GREATER
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.ValueTasks
+{
+    public static partial class MaybeExtensions
+    {
+        /// <summary>
+        /// Executes the given <paramref name="valueTask" /> if the <paramref name="maybeTask" /> produces a value
+        /// Returns the calling maybe.
+        /// </summary>
+        /// <param name="maybeTask"></param>
+        /// <param name="valueTask"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns>The calling maybe</returns>
+        public static async ValueTask<Maybe<T>> Tap<T>(
+            this ValueTask<Maybe<T>> maybeTask,
+            Func<T, ValueTask> valueTask
+        )
+        {
+            var maybe = await maybeTask;
+
+            if (maybe.HasValue)
+                await valueTask(maybe.GetValueOrThrow());
+
+            return maybe;
+        }
+    }
+}
+#endif
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/Tap.cs b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.cs
new file mode 100644
index 00000000..c8e2b4b7
--- /dev/null
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/Tap.cs
@@ -0,0 +1,25 @@
+using System;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class MaybeExtensions
+    {
+        /// <summary>
+        ///     Executes the given <paramref name="action" /> if the <paramref name="maybe" /> has a value
+        /// Returns the calling maybe.
+        /// </summary>
+        /// <param name="maybe"></param>
+        /// <param name="action"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns>The calling maybe</returns>
+        public static Maybe<T> Tap<T>(in this Maybe<T> maybe, Action<T> action)
+        {
+            if (maybe.HasValue)
+            {
+                action(maybe.GetValueOrThrow());
+            }
+
+            return maybe;
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.Left.cs b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.Left.cs
new file mode 100644
index 00000000..fa3084cf
--- /dev/null
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.Left.cs
@@ -0,0 +1,30 @@
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class MaybeExtensions
+    {
+        /// <summary>
+        ///     Executes the given <paramref name="action" /> if the <paramref name="maybeTask" /> produces no value
+        /// Returns the calling maybe.
+        /// </summary>
+        /// <param name="maybeTask"></param>
+        /// <param name="action"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns>The calling maybe</returns>
+        public static async Task<Maybe<T>> TapNoValue<T>(
+            this Task<Maybe<T>> maybeTask,
+            Action action
+        )
+        {
+            var maybe = await maybeTask.DefaultAwait();
+
+            if (maybe.HasNoValue)
+            {
+                action();
+            }
+            return maybe;
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.Right.cs b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.Right.cs
new file mode 100644
index 00000000..b6b82df7
--- /dev/null
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.Right.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class MaybeExtensions
+    {
+        /// <summary>
+        ///     Executes the given async <paramref name="action" /> if the <paramref name="maybe" /> has no value
+        /// Returns the calling maybe.
+        /// </summary>
+        /// <param name="maybe"></param>
+        /// <param name="action"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns>The calling maybe</returns>
+        public static async Task<Maybe<T>> TapNoValue<T>(this Maybe<T> maybe, Func<Task> action)
+        {
+            if (maybe.HasNoValue)
+            {
+                await action().DefaultAwait();
+            }
+
+            return maybe;
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.cs b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.cs
new file mode 100644
index 00000000..beecdd00
--- /dev/null
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.Task.cs
@@ -0,0 +1,30 @@
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class MaybeExtensions
+    {
+        /// <summary>
+        ///     Executes the given <paramref name="asyncAction" /> if the <paramref name="maybeTask" /> produces no value
+        /// Returns the calling maybe.
+        /// </summary>
+        /// <param name="maybeTask"></param>
+        /// <param name="asyncAction"></param>
+        /// <typeparam name="T"></typeparam>
+        public static async Task<Maybe<T>> TapNoValue<T>(
+            this Task<Maybe<T>> maybeTask,
+            Func<Task> asyncAction
+        )
+        {
+            var maybe = await maybeTask.DefaultAwait();
+
+            if (maybe.HasNoValue)
+            {
+                await asyncAction().DefaultAwait();
+            }
+
+            return maybe;
+        }
+    }
+}
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.Left.cs b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.Left.cs
new file mode 100644
index 00000000..bc741fbe
--- /dev/null
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.Left.cs
@@ -0,0 +1,33 @@
+#if NET5_0_OR_GREATER
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.ValueTasks
+{
+    public static partial class MaybeExtensions
+    {
+        /// <summary>
+        /// Executes the given <paramref name="action" /> if the <paramref name="maybeTask" /> produces no value
+        /// Returns the calling maybe.
+        /// </summary>
+        /// <param name="maybeTask"></param>
+        /// <param name="action"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns>The calling maybe</returns>
+        public static async ValueTask<Maybe<T>> TapNoValue<T>(
+            this ValueTask<Maybe<T>> maybeTask,
+            Action action
+        )
+        {
+            var maybe = await maybeTask;
+
+            if (maybe.HasNoValue)
+            {
+                action();
+            }
+
+            return maybe;
+        }
+    }
+}
+#endif
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.Right.cs b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.Right.cs
new file mode 100644
index 00000000..7d52a475
--- /dev/null
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.Right.cs
@@ -0,0 +1,31 @@
+#if NET5_0_OR_GREATER
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.ValueTasks
+{
+    public static partial class MaybeExtensions
+    {
+        /// <summary>
+        ///     Executes the given async <paramref name="valueTask" /> if the <paramref name="maybe" /> has no value
+        /// Returns the calling maybe.
+        /// </summary>
+        /// <param name="maybe"></param>
+        /// <param name="valueTask"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns>The calling maybe</returns>
+        public static async ValueTask<Maybe<T>> TapNoValue<T>(
+            this Maybe<T> maybe,
+            Func<ValueTask> valueTask
+        )
+        {
+            if (maybe.HasNoValue)
+            {
+                await valueTask();
+            }
+
+            return maybe;
+        }
+    }
+}
+#endif
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.cs b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.cs
new file mode 100644
index 00000000..06ea5b49
--- /dev/null
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.ValueTask.cs
@@ -0,0 +1,33 @@
+#if NET5_0_OR_GREATER
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.ValueTasks
+{
+    public static partial class MaybeExtensions
+    {
+        /// <summary>
+        /// Executes the given <paramref name="valueTask" /> if the <paramref name="maybeTask" /> produces no value
+        /// Returns the calling maybe.
+        /// </summary>
+        /// <param name="maybeTask"></param>
+        /// <param name="valueTask"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns>The calling maybe</returns>
+        public static async Task<Maybe<T>> TapNoValue<T>(
+            this ValueTask<Maybe<T>> maybeTask,
+            Func<ValueTask> valueTask
+        )
+        {
+            var maybe = await maybeTask;
+
+            if (maybe.HasNoValue)
+            {
+                await valueTask();
+            }
+
+            return maybe;
+        }
+    }
+}
+#endif
diff --git a/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.cs b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.cs
new file mode 100644
index 00000000..4e6518bb
--- /dev/null
+++ b/CSharpFunctionalExtensions/Maybe/Extensions/TapNoValue.cs
@@ -0,0 +1,25 @@
+using System;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class MaybeExtensions
+    {
+        /// <summary>
+        ///     Executes the given <paramref name="action" /> if the <paramref name="maybe" /> has no value
+        /// Returns the calling maybe.
+        /// </summary>
+        /// <param name="maybe"></param>
+        /// <param name="action"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns>The calling maybe</returns>
+        public static Maybe<T> TapNoValue<T>(in this Maybe<T> maybe, Action action)
+        {
+            if (maybe.HasNoValue)
+            {
+                action();
+            }
+
+            return maybe;
+        }
+    }
+}