diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/AmbiguityTests.cs b/CSharpFunctionalExtensions.Tests/ResultTests/AmbiguityTests.cs
index 7330b65d..8fc5697b 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/AmbiguityTests.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/AmbiguityTests.cs
@@ -23,16 +23,16 @@ await result
             .Bind(async _ => await GetTask());
     }
 
-    private Task<Result<Profile>> GetProfileAsync() =>
-        Result.Try(async () =>
+    private ValueTask<Result<Profile>> GetProfileAsync() =>
+        Result.Try(valueTask: async () =>
         {
             await Task.Yield();
 
             return new Profile();
         });
 
-    private Task<Result<Profile, Error>> GetProfileWithErrorAsync() =>
-        Result.Try(async () =>
+    private ValueTask<Result<Profile, Error>> GetProfileWithErrorAsync() =>
+        Result.Try(valueTask: async () =>
         {
             await Task.Yield();
 
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/OnSuccessTryTests.Task.Left.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/OnSuccessTryTests.Task.Left.cs
index 5f8d98f2..814c1b7f 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/OnSuccessTryTests.Task.Left.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/OnSuccessTryTests.Task.Left.cs
@@ -1,5 +1,6 @@
 using System.Threading.Tasks;
 using CSharpFunctionalExtensions.Tests.ResultTests.Methods.Try;
+using CSharpFunctionalExtensions.ValueTasks;
 using FluentAssertions;
 using Xunit;
 
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/OnSuccessTryTests.Task.Right.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/OnSuccessTryTests.Task.Right.cs
index edfc3ce8..533842ce 100644
--- a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/OnSuccessTryTests.Task.Right.cs
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/OnSuccessTryTests.Task.Right.cs
@@ -1,188 +1,129 @@
 using System.Threading.Tasks;
 using CSharpFunctionalExtensions.Tests.ResultTests.Methods.Try;
+using CSharpFunctionalExtensions.ValueTasks;
 using FluentAssertions;
-using FluentAssertions.CSharpFunctionalExtensions;
 using Xunit;
 
 namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
 {
-    public class OnSuccessTryTestBaseTests_Task_Right : TryTestBaseTask
+    public class OnSuccessTryTests_ValueTask_Right : TryTestBaseTask
     {
-       [Fact]
-        public async Task OnSuccess_Task_Right_execute_action_success_without_error_handler_function_result_expected()
-        {
-            var success = Result.Success();
-            var result = await success.OnSuccessTry(Func_Task);
-
-            result.IsSuccess.Should().BeTrue();        
-        }
-
-        [Fact]
-        public async Task OnSuccess_Task_Right_execute_action_failed_without_error_handler_failed_result_expected()
-        {
-            var success = Result.Success();
-            var result = await success.OnSuccessTry(Throwing_Func_Task);
-
-            result.Should()
-                .BeFailure()
-                .And.Subject.Error.Should()
-                .Be(ErrorMessage);
-        }
-
-        [Fact]
-        public async Task OnSuccess_Task_Right_execute_action_failed_with_error_handler_failed_result_expected()
-        {
-            var success = Result.Success();
-            var result = await success.OnSuccessTry(Throwing_Func_Task, ErrorHandler);
-
-            result.IsFailure.Should().BeTrue();
-            result.Error.Should().Be(ErrorHandlerMessage);
-        }
 
         [Fact] 
-        public async Task OnSuccess_Task_Right_T_execute_function_success_without_error_handler_function_result_expected()
+        public async Task OnSuccess_ValueTask_Right_T_execute_function_success_without_error_handler_function_result_expected()
         {
             var success = Result.Success();
-            var result = await success.OnSuccessTry(Func_Task_T);
+            var result = await success.OnSuccessTry(valueTask: Func_ValueTask_T);
 
             result.IsSuccess.Should().BeTrue();
             result.Value.Should().Be(T.Value);
         }
 
         [Fact] 
-        public async Task OnSuccess_Task_Right_T_execute_function_failed_without_error_handler_failed_result_expected()
+        public async Task OnSuccess_ValueTask_Right_T_execute_function_failed_without_error_handler_failed_result_expected()
         {
             var success = Result.Success();
-            var result = await success.OnSuccessTry(Throwing_Func_Task_T);
+            var result = await success.OnSuccessTry(valueTask: Throwing_Func_ValueTask_T);
 
             result.IsFailure.Should().BeTrue();
             result.Error.Should().Be(ErrorMessage);
         }
 
         [Fact] 
-        public async Task OnSuccess_Task_Right_T_execute_function_failed_with_error_handler_failed_result_expected()
+        public async Task OnSuccess_ValueTask_Right_T_execute_function_failed_with_error_handler_failed_result_expected()
         {
             var success = Result.Success();
-            var result = await success.OnSuccessTry(Throwing_Func_Task_T, ErrorHandler);
-
-            result.IsFailure.Should().BeTrue();
-            result.Error.Should().Be(ErrorHandlerMessage);
-        }
-
-        [Fact]
-        public async Task OnSuccess_Task_Right_T_execute_action_success_without_error_handler_function_result_expected()
-        {
-            var success = Result.Success(T.Value);
-            var result = await success.OnSuccessTry(Func_T_Task);
-
-            result.IsSuccess.Should().BeTrue();
-        }
-        
-        [Fact]
-        public async Task OnSuccess_Task_Right_T_execute_action_failed_without_error_handler_failed_result_expected()
-        {
-            var success = Result.Success(T.Value);
-            var result = await success.OnSuccessTry(Throwing_Func_T_Task);
-
-            result.IsFailure.Should().BeTrue();
-            result.Error.Should().Be(ErrorMessage);
-        }
-        
-        [Fact]
-        public async Task OnSuccess_Task_Right_T_execute_action_failed_with_error_handler_failed_result_expected()
-        {
-            var success = Result.Success(T.Value);
-            var result = await success.OnSuccessTry(Throwing_Func_T_Task, ErrorHandler);
+            var result = await success.OnSuccessTry(valueTask: Throwing_Func_ValueTask_T, ErrorHandler);
 
             result.IsFailure.Should().BeTrue();
             result.Error.Should().Be(ErrorHandlerMessage);
         }
         
         [Fact]
-        public async Task OnSuccess_Task_Right_T_K_execute_function_success_without_error_handler_function_result_expected()
+        public async Task OnSuccess_ValueTask_Right_T_K_execute_function_success_without_error_handler_function_result_expected()
         {
             var success = Result.Success(T.Value);
-            var result = await success.OnSuccessTry(Func_T_Task_K);
+            var result = await success.OnSuccessTry(valueTask: Func_T_ValueTask_K);
 
             result.IsSuccess.Should().BeTrue();
             result.Value.Should().Be(K.Value);
         }
 
         [Fact] 
-        public async Task OnSuccess_Task_Right_T_K_execute_function_failed_without_error_handler_failed_result_expected()
+        public async Task OnSuccess_ValueTask_Right_T_K_execute_function_failed_without_error_handler_failed_result_expected()
         {
             var success = Result.Success(T.Value);
-            var result = await success.OnSuccessTry(Throwing_Func_T_Task_K);
+            var result = await success.OnSuccessTry(valueTask: Throwing_Func_T_ValueTask_K);
 
             result.IsFailure.Should().BeTrue();
             result.Error.Should().Be(ErrorMessage);
         }
 
         [Fact] 
-        public async Task OnSuccess_Task_Right_T_K_execute_function_failed_with_error_handler_failed_result_expected()
+        public async Task OnSuccess_ValueTask_Right_T_K_execute_function_failed_with_error_handler_failed_result_expected()
         {
             var success = Result.Success(T.Value);
-            var result = await success.OnSuccessTry(Throwing_Func_T_Task_K, ErrorHandler);
+            var result = await success.OnSuccessTry(valueTask: Throwing_Func_T_ValueTask_K, ErrorHandler);
 
             result.IsFailure.Should().BeTrue();
             result.Error.Should().Be(ErrorHandlerMessage);
         }
         
         [Fact]
-        public async Task OnSuccess_Task_Right_T_E_execute_function_success_without_error_handler_function_result_expected()
+        public async Task OnSuccess_ValueTask_Right_T_E_execute_function_success_without_error_handler_function_result_expected()
         {
             var success = Result.Success<T, E>(T.Value);
-            var result = await success.OnSuccessTry(Func_Task_T, ErrorHandler_E);
+            var result = await success.OnSuccessTry(Func_ValueTask_T, ErrorHandler_E);
 
             result.IsSuccess.Should().BeTrue();
             result.Value.Should().Be(T.Value);
         }
 
         [Fact] 
-        public async Task OnSuccess_Task_Right_T_E_execute_function_failed_without_error_handler_failed_result_expected()
+        public async Task OnSuccess_ValueTask_Right_T_E_execute_function_failed_without_error_handler_failed_result_expected()
         {
             var success =  Result.Success<T, E>(T.Value);
-            var result = await success.OnSuccessTry(Throwing_Func_Task_T, ErrorHandler_E);
+            var result = await success.OnSuccessTry(Throwing_Func_ValueTask_T, ErrorHandler_E);
 
             result.IsFailure.Should().BeTrue();
             result.Error.Should().Be(E.Value);
         }
 
         [Fact] 
-        public async Task OnSuccess_Task_Right_T_E_execute_function_failed_with_error_handler_failed_result_expected()
+        public async Task OnSuccess_ValueTask_Right_T_E_execute_function_failed_with_error_handler_failed_result_expected()
         {
             var success =  Result.Success<T, E>(T.Value);
-            var result = await success.OnSuccessTry(Throwing_Func_Task_T, ErrorHandler_E);
+            var result = await success.OnSuccessTry(Throwing_Func_ValueTask_T, ErrorHandler_E);
 
             result.IsFailure.Should().BeTrue();
             result.Error.Should().Be(E.Value);
         }
         
         [Fact]
-        public async Task OnSuccess_Task_Right_T_K_E_execute_function_success_without_error_handler_function_result_expected()
+        public async Task OnSuccess_ValueTask_Right_T_K_E_execute_function_success_without_error_handler_function_result_expected()
         {
             var success = Result.Success<T, E>(T.Value);
-            var result = await success.OnSuccessTry(Func_T_Task_K, ErrorHandler_E);
+            var result = await success.OnSuccessTry(valueTask: Func_T_ValueTask_K, ErrorHandler_E);
 
             result.IsSuccess.Should().BeTrue();
             result.Value.Should().Be(K.Value);
         }
 
         [Fact] 
-        public async Task OnSuccess_Task_Right_T_K_E_execute_function_failed_without_error_handler_failed_result_expected()
+        public async Task OnSuccess_ValueTask_Right_T_K_E_execute_function_failed_without_error_handler_failed_result_expected()
         {
             var success = Result.Success<T, E>(T.Value);
-            var result = await success.OnSuccessTry(Throwing_Func_T_Task_K, ErrorHandler_E);
+            var result = await success.OnSuccessTry(valueTask: Throwing_Func_T_ValueTask_K, ErrorHandler_E);
 
             result.IsFailure.Should().BeTrue();
             result.Error.Should().Be(E.Value);
         }
 
         [Fact] 
-        public async Task OnSuccess_Task_Right_T_K_E_execute_function_failed_with_error_handler_failed_result_expected()
+        public async Task OnSuccess_ValueTask_Right_T_K_E_execute_function_failed_with_error_handler_failed_result_expected()
         {
             var success = Result.Success<T, E>(T.Value);
-            var result = await success.OnSuccessTry(Throwing_Func_T_Task_K, ErrorHandler_E);
+            var result = await success.OnSuccessTry(valueTask: Throwing_Func_T_ValueTask_K, ErrorHandler_E);
 
             result.IsFailure.Should().BeTrue();
             result.Error.Should().Be(E.Value);
diff --git a/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/OnSuccessTryTests.ValueTask.cs b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/OnSuccessTryTests.ValueTask.cs
new file mode 100644
index 00000000..f8f244f4
--- /dev/null
+++ b/CSharpFunctionalExtensions.Tests/ResultTests/Extensions/OnSuccessTryTests.ValueTask.cs
@@ -0,0 +1,202 @@
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.Tests.ResultTests.Methods.Try;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.ResultTests.Extensions
+{
+    public class OnSuccessTryTests_ValueTask_Tests : TryTestBaseTask
+    {
+        [Fact]
+        public async Task OnSuccessTry_ValueTask_execute_action_success_without_error_handler_function_result_expected()
+        {
+            var success = Result.Success().AsValueTask();
+            var result = await success.OnSuccessTry(Func_ValueTask);
+
+            result.IsSuccess.Should().BeTrue();        
+        }
+        
+        [Fact]
+        public async Task OnSuccessTry_ValueTask_execute_action_failed_without_error_handler_failed_result_expected()
+        {
+            var success = Result.Success().AsValueTask();
+            var result = await success.OnSuccessTry(Throwing_Func_ValueTask);
+
+            result.IsFailure.Should().BeTrue();
+            result.Error.Should().Be(ErrorMessage);
+        }
+
+        [Fact]
+        public async Task OnSuccessTry_ValueTask_execute_action_failed_with_configured_default_error_handler_failed_result_expected()
+        {
+            var defaultTryErrorHandler = Result.Configuration.DefaultTryErrorHandler;
+            Result.Configuration.DefaultTryErrorHandler = ErrorHandler;
+            var success = Result.Success().AsValueTask();
+            var result = await success.OnSuccessTry(Throwing_Func_ValueTask);
+            Result.Configuration.DefaultTryErrorHandler = defaultTryErrorHandler;
+
+            result.IsFailure.Should().BeTrue();
+            result.Error.Should().Be(ErrorHandlerMessage);
+        }
+
+        [Fact]
+        public async Task OnSuccessTry_ValueTask_execute_action_failed_with_error_handler_failed_result_expected()
+        {
+            var success = Result.Success().AsValueTask();
+            var result = await success.OnSuccessTry(Throwing_Func_ValueTask, ErrorHandler);
+
+            result.IsFailure.Should().BeTrue();
+            result.Error.Should().Be(ErrorHandlerMessage);
+        }
+
+        [Fact] 
+        public async Task OnSuccessTry_ValueTask_T_execute_function_success_without_error_handler_function_result_expected()
+        {
+            var success = Result.Success().AsValueTask();
+            var result = await success.OnSuccessTry(Func_ValueTask_T);
+
+            result.IsSuccess.Should().BeTrue();
+            result.Value.Should().Be(T.Value);
+        }
+
+        [Fact] 
+        public async Task OnSuccessTry_ValueTask_T_execute_function_failed_without_error_handler_failed_result_expected()
+        {
+            var success = Result.Success().AsValueTask();
+            var result = await success.OnSuccessTry(Throwing_Func_ValueTask_T);
+
+            result.IsFailure.Should().BeTrue();
+            result.Error.Should().Be(ErrorMessage);
+        }
+
+        [Fact] 
+        public async Task OnSuccessTry_ValueTask_T_execute_function_failed_with_error_handler_failed_result_expected()
+        {
+            var success = Result.Success().AsValueTask();
+            var result = await success.OnSuccessTry(Throwing_Func_ValueTask_T, ErrorHandler);
+
+            result.IsFailure.Should().BeTrue();
+            result.Error.Should().Be(ErrorHandlerMessage);
+        }
+
+        [Fact]
+        public async Task OnSuccessTry_ValueTask_T_execute_action_success_without_error_handler_function_result_expected()
+        {
+            var success = Result.Success(T.Value).AsValueTask();
+            var result = await success.OnSuccessTry(Func_T_ValueTask);
+
+            result.IsSuccess.Should().BeTrue();
+        }
+        
+        [Fact]
+        public async Task OnSuccessTry_ValueTask_T_execute_action_failed_without_error_handler_failed_result_expected()
+        {
+            var success = Result.Success(T.Value).AsValueTask();
+            var result = await success.OnSuccessTry(Throwing_Func_T_ValueTask);
+
+            result.IsFailure.Should().BeTrue();
+            result.Error.Should().Be(ErrorMessage);
+        }
+        
+        [Fact]
+        public async Task OnSuccessTry_ValueTask_T_execute_action_failed_with_error_handler_failed_result_expected()
+        {
+            var success = Result.Success(T.Value).AsValueTask();
+            var result = await success.OnSuccessTry(Throwing_Func_T_ValueTask, ErrorHandler);
+
+            result.IsFailure.Should().BeTrue();
+            result.Error.Should().Be(ErrorHandlerMessage);
+        }
+        
+        [Fact]
+        public async Task OnSuccessTry_ValueTask_T_K_execute_function_success_without_error_handler_function_result_expected()
+        {
+            var success = Result.Success(T.Value).AsValueTask();
+            var result = await success.OnSuccessTry(Func_T_ValueTask_K);
+
+            result.IsSuccess.Should().BeTrue();
+            result.Value.Should().Be(K.Value);
+        }
+
+        [Fact] 
+        public async Task OnSuccessTry_ValueTask_T_K_execute_function_failed_without_error_handler_failed_result_expected()
+        {
+            var success = Result.Success(T.Value).AsValueTask();
+            var result = await success.OnSuccessTry(Throwing_Func_T_ValueTask_K);
+
+            result.IsFailure.Should().BeTrue();
+            result.Error.Should().Be(ErrorMessage);
+        }
+
+        [Fact] 
+        public async Task OnSuccessTry_ValueTask_T_K_execute_function_failed_with_error_handler_failed_result_expected()
+        {
+            var success = Result.Success(T.Value).AsValueTask();
+            var result = await success.OnSuccessTry(Throwing_Func_T_ValueTask_K, ErrorHandler);
+
+            result.IsFailure.Should().BeTrue();
+            result.Error.Should().Be(ErrorHandlerMessage);
+        }
+        
+        [Fact]
+        public async Task OnSuccessTry_ValueTask_T_E_execute_function_success_without_error_handler_function_result_expected()
+        {
+            var success = Result.Success<T, E>(T.Value).AsValueTask();
+            var result = await success.OnSuccessTry(Func_ValueTask_T, ErrorHandler_E);
+
+            result.IsSuccess.Should().BeTrue();
+            result.Value.Should().Be(T.Value);
+        }
+
+        [Fact] 
+        public async Task OnSuccessTry_ValueTask_T_E_execute_function_failed_without_error_handler_failed_result_expected()
+        {
+            var success =  Result.Success<T, E>(T.Value).AsValueTask();
+            var result = await success.OnSuccessTry(Throwing_Func_ValueTask_T, ErrorHandler_E);
+
+            result.IsFailure.Should().BeTrue();
+            result.Error.Should().Be(E.Value);
+        }
+
+        [Fact] 
+        public async Task OnSuccessTry_ValueTask_T_E_execute_function_failed_with_error_handler_failed_result_expected()
+        {
+            var success =  Result.Success<T, E>(T.Value).AsValueTask();
+            var result = await success.OnSuccessTry(Throwing_Func_ValueTask_T, ErrorHandler_E);
+
+            result.IsFailure.Should().BeTrue();
+            result.Error.Should().Be(E.Value);
+        }
+        
+        [Fact]
+        public async Task OnSuccessTry_ValueTask_T_K_E_execute_function_success_without_error_handler_function_result_expected()
+        {
+            var success = Result.Success<T, E>(T.Value).AsValueTask();
+            var result = await success.OnSuccessTry(Func_T_ValueTask_K, ErrorHandler_E);
+
+            result.IsSuccess.Should().BeTrue();
+            result.Value.Should().Be(K.Value);
+        }
+
+        [Fact] 
+        public async Task OnSuccessTry_ValueTask_T_K_E_execute_function_failed_without_error_handler_failed_result_expected()
+        {
+            var success = Result.Success<T, E>(T.Value).AsValueTask();
+            var result = await success.OnSuccessTry(Throwing_Func_T_ValueTask_K, ErrorHandler_E);
+
+            result.IsFailure.Should().BeTrue();
+            result.Error.Should().Be(E.Value);
+        }
+
+        [Fact] 
+        public async Task OnSuccessTry_ValueTask_T_K_E_execute_function_failed_with_error_handler_failed_result_expected()
+        {
+            var success = Result.Success<T, E>(T.Value).AsValueTask();
+            var result = await success.OnSuccessTry(Throwing_Func_T_ValueTask_K, ErrorHandler_E);
+
+            result.IsFailure.Should().BeTrue();
+            result.Error.Should().Be(E.Value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/CSharpFunctionalExtensions/CSharpFunctionalExtensions.csproj b/CSharpFunctionalExtensions/CSharpFunctionalExtensions.csproj
index 9586c8b0..8e1fc9b6 100644
--- a/CSharpFunctionalExtensions/CSharpFunctionalExtensions.csproj
+++ b/CSharpFunctionalExtensions/CSharpFunctionalExtensions.csproj
@@ -474,9 +474,18 @@
     <Compile Update="Result\Methods\Extensions\OnSuccessTry.Task.Left.cs">
       <DependentUpon>OnSuccessTry.Task.cs</DependentUpon>
     </Compile>
+    <Compile Update="Result\Methods\Extensions\OnSuccessTry.ValueTask.Right.cs">
+      <DependentUpon>OnSuccessTry.ValueTask.cs</DependentUpon>
+    </Compile>
+    <Compile Update="Result\Methods\Extensions\OnSuccessTry.ValueTask.Left.cs">
+      <DependentUpon>OnSuccessTry.ValueTask.cs</DependentUpon>
+    </Compile>
     <Compile Update="Result\Methods\Extensions\OnSuccessTry.Task.cs">
       <DependentUpon>OnSuccessTry.cs</DependentUpon>
     </Compile>
+    <Compile Update="Result\Methods\Extensions\OnSuccessTry.ValueTask.cs">
+      <DependentUpon>OnSuccessTry.cs</DependentUpon>
+    </Compile>
     <Compile Update="Result\Methods\Extensions\SelectMany.Task.Left.cs">
       <DependentUpon>SelectMany.Task.cs</DependentUpon>
     </Compile>
@@ -519,6 +528,14 @@
     <Compile Update="Result\Methods\FailureIf.Task.cs">
       <DependentUpon>FailureIf.cs</DependentUpon>
     </Compile>
+    <Compile Update="Result\Methods\Try.ValueTask.cs">
+      <DependentUpon>Try.cs</DependentUpon>
+    </Compile>
+    <Compile Update="Result\Methods\Try.Task.cs">
+      <DependentUpon>Try.cs</DependentUpon>
+    </Compile>
+  </ItemGroup>
+  
     <Compile Update="Result\Methods\Try.Task.cs">
       <DependentUpon>Try.cs</DependentUpon>
     </Compile>
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/OnSuccessTry.Task.Left.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/OnSuccessTry.Task.Left.cs
index 3a59efb2..cd9c0c85 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/OnSuccessTry.Task.Left.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/OnSuccessTry.Task.Left.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Threading.Tasks;
 
-namespace CSharpFunctionalExtensions
+namespace CSharpFunctionalExtensions.ValueTasks
 {
     public static partial class ResultExtensions
     {
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/OnSuccessTry.Task.Right.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/OnSuccessTry.Task.Right.cs
index a38ea14c..5c6f92d3 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Extensions/OnSuccessTry.Task.Right.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/OnSuccessTry.Task.Right.cs
@@ -1,56 +1,59 @@
+#if NET5_0_OR_GREATER
 using System;
 using System.Threading.Tasks;
 
-namespace CSharpFunctionalExtensions
+namespace CSharpFunctionalExtensions.ValueTasks
 {
     public static partial class ResultExtensions
     {
-        public static async Task<Result> OnSuccessTry(this Result result, Func<Task> func,
+        public static async ValueTask<Result> OnSuccessTry(this Result result, Func<ValueTask> valueTask,
             Func<Exception, string> errorHandler = null)
         {
             return result.IsFailure
                 ? result
-                : await Result.Try(func, errorHandler).DefaultAwait();
+                : await Result.Try(valueTask, errorHandler);
         }
 
-        public static async Task<Result<T>> OnSuccessTry<T>(this Result result, Func<Task<T>> func,
+        public static async ValueTask<Result<T>> OnSuccessTry<T>(this Result result, Func<ValueTask<T>> valueTask,
             Func<Exception, string> errorHandler = null)
         {
             return result.IsFailure
                 ? Result.Failure<T>(result.Error)
-                : await Result.Try(func, errorHandler).DefaultAwait();
+                : await Result.Try(valueTask, errorHandler);
         }
 
-        public static async Task<Result<T, E>> OnSuccessTry<T, E>(this Result<T, E> result, Func<Task<T>> func,
+        public static async ValueTask<Result<T, E>> OnSuccessTry<T, E>(this Result<T, E> result, Func<ValueTask<T>> valueTask,
             Func<Exception, E> errorHandler = null)
         {
             return result.IsFailure
                 ? Result.Failure<T, E>(result.Error)
-                : await Result.Try(func, errorHandler).DefaultAwait();
+                : await Result.Try(valueTask, errorHandler);
         }
 
-        public static async Task<Result> OnSuccessTry<T>(this Result<T> result, Func<T, Task> func,
+        public static async ValueTask<Result> OnSuccessTry<T>(this Result<T> result, Func<T, ValueTask> valueTask,
             Func<Exception, string> errorHandler = null)
         {
             return result.IsFailure
                 ? Result.Failure(result.Error)
-                : await Result.Try(() => func.Invoke(result.Value), errorHandler).DefaultAwait();
+                : await Result.Try(() => valueTask.Invoke(result.Value), errorHandler);
         }
 
-        public static async Task<Result<K>> OnSuccessTry<T, K>(this Result<T> result, Func<T, Task<K>> func,
+        public static async ValueTask<Result<K>> OnSuccessTry<T, K>(this Result<T> result, Func<T, ValueTask<K>> valueTask,
             Func<Exception, string> errorHandler = null)
         {
             return result.IsFailure
                 ? Result.Failure<K>(result.Error)
-                : await Result.Try(() => func.Invoke(result.Value), errorHandler).DefaultAwait();
+                : await Result.Try(() => valueTask.Invoke(result.Value), errorHandler);
         }
 
-        public static async Task<Result<K, E>> OnSuccessTry<T, K, E>(this Result<T, E> result, Func<T, Task<K>> func,
+        public static async ValueTask<Result<K, E>> OnSuccessTry<T, K, E>(this Result<T, E> result, Func<T, ValueTask<K>> valueTask,
             Func<Exception, E> errorHandler = null)
         {
             return result.IsFailure
                 ? Result.Failure<K, E>(result.Error)
-                : await Result.Try(() => func.Invoke(result.Value), errorHandler).DefaultAwait();
+                : await Result.Try(() => valueTask.Invoke(result.Value), errorHandler);
         }
     }
 }
+
+#endif
diff --git a/CSharpFunctionalExtensions/Result/Methods/Extensions/OnSuccessTry.ValueTask.cs b/CSharpFunctionalExtensions/Result/Methods/Extensions/OnSuccessTry.ValueTask.cs
new file mode 100644
index 00000000..ccf5fcce
--- /dev/null
+++ b/CSharpFunctionalExtensions/Result/Methods/Extensions/OnSuccessTry.ValueTask.cs
@@ -0,0 +1,52 @@
+#if NET5_0_OR_GREATER
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions.ValueTasks
+{
+    public static partial class ResultExtensions
+    {
+        public static async ValueTask<Result> OnSuccessTry(this ValueTask<Result> task, Func<ValueTask> valueTask,
+            Func<Exception, string> errorHandler = null)
+        {
+            var result = await task;
+            return await result.OnSuccessTry(valueTask, errorHandler);
+        }
+
+        public static async ValueTask<Result<T>> OnSuccessTry<T>(this ValueTask<Result> task, Func<ValueTask<T>> valueTask,
+            Func<Exception, string> errorHandler = null)
+        {
+            var result = await task;
+            return await result.OnSuccessTry(valueTask, errorHandler);
+        }
+
+        public static async ValueTask<Result<T, E>> OnSuccessTry<T, E>(this ValueTask<Result<T, E>> task, Func<ValueTask<T>> valueTask,
+            Func<Exception, E> errorHandler = null)
+        {
+            var result = await task;
+            return await result.OnSuccessTry(valueTask, errorHandler);
+        }
+
+        public static async ValueTask<Result> OnSuccessTry<T>(this ValueTask<Result<T>> task, Func<T, ValueTask> valueTask,
+            Func<Exception, string> errorHandler = null)
+        {
+            var result = await task;
+            return await result.OnSuccessTry(valueTask, errorHandler);
+        }
+
+        public static async ValueTask<Result<K>> OnSuccessTry<T, K>(this ValueTask<Result<T>> task, Func<T, ValueTask<K>> valueTask,
+            Func<Exception, string> errorHandler = null)
+        {
+            var result = await task;
+            return await result.OnSuccessTry(valueTask, errorHandler);
+        }
+        
+        public static async ValueTask<Result<K, E>> OnSuccessTry<T, K, E>(this ValueTask<Result<T, E>> task, Func<T, ValueTask<K>> valueTask,
+            Func<Exception, E> errorHandler = null)
+        {
+            var result = await task;
+            return await result.OnSuccessTry(valueTask, errorHandler);
+        }
+    }
+}
+#endif
diff --git a/CSharpFunctionalExtensions/Result/Methods/Try.Task.cs b/CSharpFunctionalExtensions/Result/Methods/Try.Task.cs
index df2df261..6d176468 100644
--- a/CSharpFunctionalExtensions/Result/Methods/Try.Task.cs
+++ b/CSharpFunctionalExtensions/Result/Methods/Try.Task.cs
@@ -1,4 +1,5 @@
-using System;
+#if NET5_0_OR_GREATER
+using System;
 using System.Threading.Tasks;
 
 namespace CSharpFunctionalExtensions
@@ -8,13 +9,13 @@ public partial struct Result
         /// <summary>
         ///     Attempts to execute the supplied action. Returns a Result indicating whether the action executed successfully.
         /// </summary>
-        public static async Task<Result> Try(Func<Task> action, Func<Exception, string> errorHandler = null)
+        public static async ValueTask<Result> Try(Func<ValueTask> valueTask, Func<Exception, string> errorHandler = null)
         {
             errorHandler ??= Configuration.DefaultTryErrorHandler;
 
             try
             {
-                await action().DefaultAwait();
+                await valueTask();
                 return Success();
             }
             catch (Exception exc)
@@ -25,16 +26,16 @@ public static async Task<Result> Try(Func<Task> action, Func<Exception, string>
         }
         
         /// <summary>
-        ///     Attempts to execute the supplied function. Returns a Result indicating whether the function executed successfully.
-        ///     If the function executed successfully, the result contains its return value.
+        ///     Attempts to execute the supplied valueTask action. Returns a Result indicating whether the valueTask action executed successfully.
+        ///     If the valueTask action executed successfully, the result contains its return value.
         /// </summary>
-        public static async Task<Result<T>> Try<T>(Func<Task<T>> func, Func<Exception, string> errorHandler = null)
+        public static async ValueTask<Result<T>> Try<T>(Func<ValueTask<T>> valueTask, Func<Exception, string> errorHandler = null)
         {
             errorHandler ??= Configuration.DefaultTryErrorHandler;
 
             try
             {
-                var result = await func().DefaultAwait();
+                var result = await valueTask();
                 return Success(result);
             }
             catch (Exception exc)
@@ -45,14 +46,14 @@ public static async Task<Result<T>> Try<T>(Func<Task<T>> func, Func<Exception, s
         }
         
         /// <summary>
-        ///     Attempts to execute the supplied function. Returns a Result indicating whether the function executed successfully.
-        ///     If the function executed successfully, the result contains its return value.
+        ///     Attempts to execute the supplied valueTask action. Returns a Result indicating whether the valueTask action executed successfully.
+        ///     If the valueTask action executed successfully, the result contains its return value.
         /// </summary>
-        public static async Task<Result<T, E>> Try<T, E>(Func<Task<T>> func, Func<Exception, E> errorHandler)
+        public static async ValueTask<Result<T, E>> Try<T, E>(Func<ValueTask<T>> valueTask, Func<Exception, E> errorHandler)
         {
             try
             {
-                var result = await func().DefaultAwait();
+                var result = await valueTask();
                 return Success<T, E>(result);
             }
             catch (Exception exc)
@@ -62,4 +63,5 @@ public static async Task<Result<T, E>> Try<T, E>(Func<Task<T>> func, Func<Except
             }
         }
     }
-}
\ No newline at end of file
+}
+#endif
\ No newline at end of file