From 7d3b2ae34d620c1523a5326d2613753bcce74316 Mon Sep 17 00:00:00 2001
From: Julian Thurner <julianthurner@web.de>
Date: Tue, 4 Feb 2025 12:52:44 +0100
Subject: [PATCH 1/4] Extensions for monad chaining

---
 src/DotNext/Optional.cs |  89 +++++++++++++++
 src/DotNext/Result.cs   | 235 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 324 insertions(+)

diff --git a/src/DotNext/Optional.cs b/src/DotNext/Optional.cs
index c6dc79320..35d4b731b 100644
--- a/src/DotNext/Optional.cs
+++ b/src/DotNext/Optional.cs
@@ -48,6 +48,69 @@ public static class Optional
     public static async Task<Optional<TOutput>> Convert<TInput, TOutput>(this Task<Optional<TInput>> task, Converter<TInput, TOutput> converter)
         => (await task.ConfigureAwait(false)).Convert(converter);
 
+    /// <summary>
+    /// If a value is present, apply the provided mapping function to it, and if the result is
+    /// non-null, return an Optional describing the result. Otherwise returns <see cref="Optional{T}.None"/>.
+    /// </summary>
+    /// <typeparam name="TInput">The type of stored in the Optional container.</typeparam>
+    /// <typeparam name="TOutput">The type of the result of the mapping function.</typeparam>
+    /// <param name="task">The task containing Optional value.</param>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <returns>An Optional describing the result of applying a mapping function to the value of this Optional, if a value is present, otherwise <see cref="Optional{T}.None"/>.</returns>
+    public static async Task<Optional<TOutput>> Convert<TInput, TOutput>(this Task<Optional<TInput>> task, Converter<TInput, Optional<TOutput>> converter)
+        => (await task.ConfigureAwait(false)).Convert(converter);
+
+    /// <summary>
+    /// If a value is present, apply the provided mapping function to it, and if the result is
+    /// non-null, return an Optional describing the result. Otherwise returns <see cref="Optional{T}.None"/>.
+    /// </summary>
+    /// <typeparam name="TInput">The type of stored in the Optional container.</typeparam>
+    /// <typeparam name="TOutput">The type of the result of the mapping function.</typeparam>
+    /// <param name="task">The task containing Optional value.</param>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <returns>An Optional describing the result of applying a mapping function to the value of this Optional, if a value is present, otherwise <see cref="Optional{T}.None"/>.</returns>
+    public static async Task<Optional<TOutput>> Convert<TInput, TOutput>(this Task<Optional<TInput>> task, Converter<TInput, Task<Optional<TOutput>>> converter)
+        => await (await task.ConfigureAwait(false)).Convert(converter).ConfigureAwait(false);
+
+    /// <summary>
+    /// Creates <see cref="Result{T}"/> from <see cref="Optional{T}"/> instance.
+    /// </summary>
+    /// <param name="optional">The optional value.</param>
+    /// <returns>The converted optional value.</returns>
+    public static Result<T> ToResult<T>(this in Optional<T> optional)
+        => Result<T>.FromOptional(optional);
+
+    /// <summary>
+    /// Creates <see cref="Result{T}"/> from <see cref="Optional{T}"/> instance.
+    /// </summary>
+    /// <param name="task">The task containing Optional value.</param>
+    /// <returns>The converted optional value.</returns>
+    public static async Task<Result<T>> ToResult<T>(this Task<Optional<T>> task)
+        => Result<T>.FromOptional(await task.ConfigureAwait(false));
+
+    /// <summary>
+    /// Creates <see cref="Result{T, TError}"/> from <see cref="Optional{T}"/> instance.
+    /// </summary>
+    /// <param name="optional">The optional value.</param>
+    /// <param name="error">The error code to apply if the value is not present.</param>
+    /// <returns>The converted optional value.</returns>
+    public static Result<T, TError> ToResult<T, TError>(this in Optional<T> optional, TError error)
+        where TError : struct, Enum
+        => optional.HasValue ? new(optional.Value) : new(error);
+
+    /// <summary>
+    /// Creates <see cref="Result{T, TError}"/> from <see cref="Optional{T}"/> instance.
+    /// </summary>
+    /// <param name="task">The task containing Optional value.</param>
+    /// <param name="error">The error code to apply if the value is not present.</param>
+    /// <returns>The converted optional value.</returns>
+    public static async Task<Result<T, TError>> ToResult<T, TError>(this Task<Optional<T>> task, TError error)
+        where TError : struct, Enum
+    {
+        var optional = await task.ConfigureAwait(false);
+        return optional.HasValue ? new(optional.Value) : new(error);
+    }
+
     /// <summary>
     /// If a value is present, returns the value, otherwise throw exception.
     /// </summary>
@@ -553,6 +616,11 @@ private Optional<TResult> ConvertOptional<TResult, TConverter>(TConverter conver
         where TConverter : struct, ISupplier<T, Optional<TResult>>
         => HasValue ? converter.Invoke(value) : Optional<TResult>.None;
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private Task<Optional<TResult>> ConvertOptionalTask<TResult, TConverter>(TConverter converter)
+        where TConverter : struct, ISupplier<T, Task<Optional<TResult>>>
+        => HasValue ? converter.Invoke(value) : Task.FromResult(Optional<TResult>.None);
+
     /// <summary>
     /// If a value is present, apply the provided mapping function to it, and if the result is
     /// non-null, return an Optional describing the result. Otherwise, returns <see cref="None"/>.
@@ -570,10 +638,31 @@ public Optional<TResult> Convert<TResult>(Converter<T, Optional<TResult>> mapper
     /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
     /// <param name="mapper">A mapping function to be applied to the value, if present.</param>
     /// <returns>An Optional describing the result of applying a mapping function to the value of this Optional, if a value is present, otherwise <see cref="None"/>.</returns>
+    public Task<Optional<TResult>> Convert<TResult>(Converter<T, Task<Optional<TResult>>> mapper)
+        => ConvertOptionalTask<TResult, DelegatingConverter<T, Task<Optional<TResult>>>>(mapper);
+
+    /// <summary>
+    /// If a value is present, apply the provided mapping function to it, and if the result is
+    /// non-null, return an Optional describing the result. Otherwise returns <see cref="None"/>.
+    /// </summary>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <param name="mapper">A mapping function to be applied to the value, if present.</param>
+    /// <returns>An Optional describing the result of applying a mapping function to the value of this Optional, if a value is present, otherwise <see cref="None"/>.</returns>
     [CLSCompliant(false)]
     public unsafe Optional<TResult> Convert<TResult>(delegate*<T, Optional<TResult>> mapper)
         => ConvertOptional<TResult, Supplier<T, Optional<TResult>>>(mapper);
 
+    /// <summary>
+    /// If a value is present, apply the provided mapping function to it, and if the result is
+    /// non-null, return an Optional describing the result. Otherwise returns <see cref="None"/>.
+    /// </summary>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <param name="mapper">A mapping function to be applied to the value, if present.</param>
+    /// <returns>An Optional describing the result of applying a mapping function to the value of this Optional, if a value is present, otherwise <see cref="None"/>.</returns>
+    [CLSCompliant(false)]
+    public unsafe Task<Optional<TResult>> Convert<TResult>(delegate*<T, Task<Optional<TResult>>> mapper)
+        => ConvertOptionalTask<TResult, Supplier<T, Task<Optional<TResult>>>>(mapper);
+
     /// <inheritdoc cref="IFunctional{TDelegate}.ToDelegate()"/>
     Func<object?> IFunctional<Func<object?>>.ToDelegate() => Func.Constant<object?>(kind is NotEmptyValue ? value : null);
 
diff --git a/src/DotNext/Result.cs b/src/DotNext/Result.cs
index c9b2839eb..19b9fb7be 100644
--- a/src/DotNext/Result.cs
+++ b/src/DotNext/Result.cs
@@ -75,6 +75,99 @@ public static class Result
     /// <param name="e">The exception to be placed to the container.</param>
     /// <returns>The exception encapsulated by <see cref="Result{T}"/>.</returns>
     public static Result<T> FromException<T>(Exception e) => new(e);
+
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function hiding any exception
+    /// caused by the converter.
+    /// </summary>
+    /// <param name="task">The task containing Result value.</param>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    public static async Task<Result<TResult>> Convert<T, TResult>(this Task<Result<T>> task, Converter<T, TResult> converter)
+        => (await task.ConfigureAwait(false)).Convert(converter);
+
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the exception.
+    /// </summary>
+    /// <param name="task">The task containing Result value.</param>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    public static async Task<Result<TResult>> Convert<T, TResult>(this Task<Result<T>> task, Converter<T, Result<TResult>> converter)
+        => (await task.ConfigureAwait(false)).Convert(converter);
+
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the exception.
+    /// </summary>
+    /// <param name="task">The task containing Result value.</param>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    public static async Task<Result<TResult>> Convert<T, TResult>(this Task<Result<T>> task, Converter<T, Task<Result<TResult>>> converter)
+        => await (await task.ConfigureAwait(false)).Convert(converter).ConfigureAwait(false);
+
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function hiding any exception
+    /// caused by the converter.
+    /// </summary>
+    /// <param name="task">The task containing Result value.</param>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <typeparam name="TError">The type of the error code. Default value must represent the successful result.</typeparam>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    public static async Task<Result<TResult, TError>> Convert<T, TError, TResult>(this Task<Result<T, TError>> task, Converter<T, TResult> converter)
+        where TError: struct, Enum
+        => (await task.ConfigureAwait(false)).Convert(converter);
+
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the error.
+    /// </summary>
+    /// <param name="task">The task containing Result value.</param>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <typeparam name="TError">The type of the error code. Default value must represent the successful result.</typeparam>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    public static async Task<Result<TResult, TError>> Convert<T, TError, TResult>(this Task<Result<T, TError>> task, Converter<T, Result<TResult, TError>> converter)
+        where TError : struct, Enum
+        => (await task.ConfigureAwait(false)).Convert(converter);
+
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the error.
+    /// </summary>
+    /// <param name="task">The task containing Result value.</param>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <typeparam name="TError">The type of the error code. Default value must represent the successful result.</typeparam>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    public static async Task<Result<TResult, TError>> Convert<T, TError, TResult>(this Task<Result<T, TError>> task, Converter<T, Task<Result<TResult, TError>>> converter)
+        where TError : struct, Enum
+        => await (await task.ConfigureAwait(false)).Convert(converter).ConfigureAwait(false);
+
+    /// <summary>
+    /// Converts the result into <see cref="Optional{T}"/>.
+    /// </summary>
+    /// <returns>Option monad representing value in this monad.</returns>
+    public static async Task<Optional<T>> TryGet<T>(this Task<Result<T>> task)
+        => (await task.ConfigureAwait(false)).TryGet();
+
+    /// <summary>
+    /// Converts the result into <see cref="Optional{T}"/>.
+    /// </summary>
+    /// <returns>Option monad representing value in this monad.</returns>
+    public static async Task<Optional<T>> TryGet<T, TError>(this Task<Result<T, TError>> task)
+        where TError : struct, Enum
+        => (await task.ConfigureAwait(false)).TryGet();
 }
 
 /// <summary>
@@ -201,6 +294,54 @@ private Result<TResult> Convert<TResult, TConverter>(TConverter converter)
         return result;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private Result<TResult> ConvertResult<TResult, TConverter>(TConverter converter)
+        where TConverter : struct, ISupplier<T, Result<TResult>>
+    {
+        Result<TResult> result;
+        if (exception is null)
+        {
+            try
+            {
+                result = converter.Invoke(value);
+            }
+            catch (Exception e)
+            {
+                result = new(e);
+            }
+        }
+        else
+        {
+            result = new(exception);
+        }
+
+        return result;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private Task<Result<TResult>> ConvertResultTask<TResult, TConverter>(TConverter converter)
+        where TConverter : struct, ISupplier<T, Task<Result<TResult>>>
+    {
+        Task<Result<TResult>> result;
+        if (exception is null)
+        {
+            try
+            {
+                result = converter.Invoke(value);
+            }
+            catch (Exception e)
+            {
+                result = Task.FromResult(new Result<TResult>(e));
+            }
+        }
+        else
+        {
+            result = Task.FromResult(new Result<TResult>(exception));
+        }
+
+        return result;
+    }
+
     /// <summary>
     /// If successful result is present, apply the provided mapping function hiding any exception
     /// caused by the converter.
@@ -211,6 +352,26 @@ private Result<TResult> Convert<TResult, TConverter>(TConverter converter)
     public Result<TResult> Convert<TResult>(Converter<T, TResult> converter)
         => Convert<TResult, DelegatingConverter<T, TResult>>(converter);
 
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the exception.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    public Result<TResult> Convert<TResult>(Converter<T, Result<TResult>> converter)
+        => ConvertResult<TResult, DelegatingConverter<T, Result<TResult>>>(converter);
+
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the exception.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    public Task<Result<TResult>> Convert<TResult>(Converter<T, Task<Result<TResult>>> converter)
+        => ConvertResultTask<TResult, DelegatingConverter<T, Task<Result<TResult>>>>(converter);
+
     /// <summary>
     /// If successful result is present, apply the provided mapping function hiding any exception
     /// caused by the converter.
@@ -222,6 +383,28 @@ public Result<TResult> Convert<TResult>(Converter<T, TResult> converter)
     public unsafe Result<TResult> Convert<TResult>(delegate*<T, TResult> converter)
         => Convert<TResult, Supplier<T, TResult>>(converter);
 
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the exception.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    [CLSCompliant(false)]
+    public unsafe Result<TResult> Convert<TResult>(delegate*<T, Result<TResult>> converter)
+        => ConvertResult<TResult, Supplier<T, Result<TResult>>>(converter);
+
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the exception.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    [CLSCompliant(false)]
+    public unsafe Task<Result<TResult>> Convert<TResult>(delegate*<T, Task<Result<TResult>>> converter)
+        => ConvertResultTask<TResult, Supplier<T, Task<Result<TResult>>>>(converter);
+
     /// <summary>
     /// Attempts to extract value from container if it is present.
     /// </summary>
@@ -537,6 +720,16 @@ private Result<TResult, TError> Convert<TResult, TConverter>(TConverter converte
         where TConverter : struct, ISupplier<T, TResult>
         => IsSuccessful ? new(converter.Invoke(value)) : new(Error);
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private Result<TResult, TError> ConvertResult<TResult, TConverter>(TConverter converter)
+        where TConverter : struct, ISupplier<T, Result<TResult, TError>>
+        => IsSuccessful ? converter.Invoke(value) : new(Error);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private Task<Result<TResult, TError>> ConvertResultTask<TResult, TConverter>(TConverter converter)
+        where TConverter : struct, ISupplier<T, Task<Result<TResult, TError>>>
+        => IsSuccessful ? converter.Invoke(value) : Task.FromResult(new Result<TResult, TError>(Error));
+
     /// <summary>
     /// If successful result is present, apply the provided mapping function hiding any exception
     /// caused by the converter.
@@ -547,6 +740,26 @@ private Result<TResult, TError> Convert<TResult, TConverter>(TConverter converte
     public Result<TResult, TError> Convert<TResult>(Converter<T, TResult> converter)
         => Convert<TResult, DelegatingConverter<T, TResult>>(converter);
 
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the error.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    public Result<TResult, TError> Convert<TResult>(Converter<T, Result<TResult, TError>> converter)
+        => ConvertResult<TResult, DelegatingConverter<T, Result<TResult,TError>>>(converter);
+
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the error.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    public Task<Result<TResult, TError>> Convert<TResult>(Converter<T, Task<Result<TResult, TError>>> converter)
+        => ConvertResultTask<TResult, DelegatingConverter<T, Task<Result<TResult, TError>>>>(converter);
+
     /// <summary>
     /// If successful result is present, apply the provided mapping function hiding any exception
     /// caused by the converter.
@@ -558,6 +771,28 @@ public Result<TResult, TError> Convert<TResult>(Converter<T, TResult> converter)
     public unsafe Result<TResult, TError> Convert<TResult>(delegate*<T, TResult> converter)
         => Convert<TResult, Supplier<T, TResult>>(converter);
 
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the error.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    [CLSCompliant(false)]
+    public unsafe Result<TResult, TError> Convert<TResult>(delegate*<T, Result<TResult, TError>> converter)
+        => ConvertResult<TResult, Supplier<T, Result<TResult, TError>>>(converter);
+
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the error.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    [CLSCompliant(false)]
+    public unsafe Task<Result<TResult, TError>> Convert<TResult>(delegate*<T, Task<Result<TResult, TError>>> converter)
+        => ConvertResultTask<TResult, Supplier<T, Task<Result<TResult, TError>>>>(converter);
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private T OrInvoke<TSupplier>(TSupplier defaultFunc)
         where TSupplier : struct, ISupplier<T>

From d0011cdc823983e67247cf859afbf59ee3f43bdf Mon Sep 17 00:00:00 2001
From: Julian Thurner <julianthurner@web.de>
Date: Tue, 4 Feb 2025 15:25:36 +0100
Subject: [PATCH 2/4] Optional and Result Extensions for quick creation

---
 src/DotNext/Optional.cs |  8 ++++++++
 src/DotNext/Result.cs   | 22 ++++++++++++++++++++++
 2 files changed, 30 insertions(+)

diff --git a/src/DotNext/Optional.cs b/src/DotNext/Optional.cs
index 35d4b731b..c0518e4a9 100644
--- a/src/DotNext/Optional.cs
+++ b/src/DotNext/Optional.cs
@@ -72,6 +72,14 @@ public static async Task<Optional<TOutput>> Convert<TInput, TOutput>(this Task<O
     public static async Task<Optional<TOutput>> Convert<TInput, TOutput>(this Task<Optional<TInput>> task, Converter<TInput, Task<Optional<TOutput>>> converter)
         => await (await task.ConfigureAwait(false)).Convert(converter).ConfigureAwait(false);
 
+    /// <summary>
+    /// Creates a new instance of <see cref="Optional{T}"/> from the specified value.
+    /// </summary>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <param name="value">The value to be placed to the container.</param>
+    /// <returns>The value encapsulated by <see cref="Result{T}"/>.</returns>
+    public static Optional<T> FromValue<T>(T value) => new(value);
+
     /// <summary>
     /// Creates <see cref="Result{T}"/> from <see cref="Optional{T}"/> instance.
     /// </summary>
diff --git a/src/DotNext/Result.cs b/src/DotNext/Result.cs
index 19b9fb7be..e6526a6a2 100644
--- a/src/DotNext/Result.cs
+++ b/src/DotNext/Result.cs
@@ -68,6 +68,17 @@ public static class Result
     /// <returns>The value encapsulated by <see cref="Result{T}"/>.</returns>
     public static Result<T> FromValue<T>(T value) => new(value);
 
+    /// <summary>
+    /// Creates a new instance of <see cref="Result{T}"/> from the specified value.
+    /// </summary>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <typeparam name="TError">The type of the error code. Default value must represent the successful result.</typeparam>
+    /// <param name="value">The value to be placed to the container.</param>
+    /// <returns>The value encapsulated by <see cref="Result{T, TError}"/>.</returns>
+    public static Result<T, TError> FromValue<T, TError>(T value)
+        where TError: struct, Enum
+        => new(value);
+
     /// <summary>
     /// Creates a new instance of <see cref="Result{T}"/> from the specified exception.
     /// </summary>
@@ -76,6 +87,17 @@ public static class Result
     /// <returns>The exception encapsulated by <see cref="Result{T}"/>.</returns>
     public static Result<T> FromException<T>(Exception e) => new(e);
 
+    /// <summary>
+    /// Creates a new instance of <see cref="Result{T, TError}"/> from the specified exception.
+    /// </summary>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <typeparam name="TError">The type of the error code. Default value must represent the successful result.</typeparam>
+    /// <param name="e">The error to be placed to the container.</param>
+    /// <returns>The exception encapsulated by <see cref="Result{T}"/>.</returns>
+    public static Result<T, TError> FromError<T, TError>(TError e)
+        where TError: struct, Enum
+        => new(e);
+
     /// <summary>
     /// If successful result is present, apply the provided mapping function hiding any exception
     /// caused by the converter.

From f58043fbc47f47855ab772acd3157565a32eac1e Mon Sep 17 00:00:00 2001
From: Julian Thurner <julianthurner@web.de>
Date: Wed, 26 Feb 2025 12:01:05 +0100
Subject: [PATCH 3/4] Adjustments for AwaitableResult

---
 src/DotNext/Optional.cs                   |   2 +-
 src/DotNext/Result.cs                     | 246 ++++++++++++++--------
 src/DotNext/Threading/Tasks/Conversion.cs |  50 +++++
 3 files changed, 213 insertions(+), 85 deletions(-)

diff --git a/src/DotNext/Optional.cs b/src/DotNext/Optional.cs
index c0518e4a9..98fb8b414 100644
--- a/src/DotNext/Optional.cs
+++ b/src/DotNext/Optional.cs
@@ -78,7 +78,7 @@ public static async Task<Optional<TOutput>> Convert<TInput, TOutput>(this Task<O
     /// <typeparam name="T">The type of the value.</typeparam>
     /// <param name="value">The value to be placed to the container.</param>
     /// <returns>The value encapsulated by <see cref="Result{T}"/>.</returns>
-    public static Optional<T> FromValue<T>(T value) => new(value);
+    public static Optional<T> From<T>(T value) => new(value);
 
     /// <summary>
     /// Creates <see cref="Result{T}"/> from <see cref="Optional{T}"/> instance.
diff --git a/src/DotNext/Result.cs b/src/DotNext/Result.cs
index e6526a6a2..ae5238826 100644
--- a/src/DotNext/Result.cs
+++ b/src/DotNext/Result.cs
@@ -7,6 +7,8 @@
 
 namespace DotNext;
 
+using System;
+using DotNext.Threading.Tasks;
 using Runtime.CompilerServices;
 using Intrinsics = Runtime.Intrinsics;
 
@@ -68,17 +70,6 @@ public static class Result
     /// <returns>The value encapsulated by <see cref="Result{T}"/>.</returns>
     public static Result<T> FromValue<T>(T value) => new(value);
 
-    /// <summary>
-    /// Creates a new instance of <see cref="Result{T}"/> from the specified value.
-    /// </summary>
-    /// <typeparam name="T">The type of the value.</typeparam>
-    /// <typeparam name="TError">The type of the error code. Default value must represent the successful result.</typeparam>
-    /// <param name="value">The value to be placed to the container.</param>
-    /// <returns>The value encapsulated by <see cref="Result{T, TError}"/>.</returns>
-    public static Result<T, TError> FromValue<T, TError>(T value)
-        where TError: struct, Enum
-        => new(value);
-
     /// <summary>
     /// Creates a new instance of <see cref="Result{T}"/> from the specified exception.
     /// </summary>
@@ -98,6 +89,30 @@ public static Result<T, TError> FromError<T, TError>(TError e)
         where TError: struct, Enum
         => new(e);
 
+    private static AwaitableResult<TResult> TransformAwaitableResult<T, TResult>(this AwaitableResult<T> task, Converter<Result<T>, Result<TResult>> converter)
+    {
+        async Task<TResult> ConvertInternal()
+        {
+            var result = await task.ConfigureAwait(false);
+            var conversionResult = converter(result);
+            return conversionResult.IsSuccessful ? conversionResult.Value : throw conversionResult.Error;
+        }
+
+        return ConvertInternal().SuspendException();
+    }
+
+    private static AwaitableResult<TResult> TransformAwaitableResult<T, TResult>(this AwaitableResult<T> task, Converter<Result<T>, AwaitableResult<TResult>> converter)
+    {
+        async Task<TResult> ConvertInternal()
+        {
+            var result = await task.ConfigureAwait(false);
+            var conversionResult = await converter(result);
+            return conversionResult.IsSuccessful ? conversionResult.Value : throw conversionResult.Error;
+        }
+
+        return ConvertInternal().SuspendException();
+    }
+
     /// <summary>
     /// If successful result is present, apply the provided mapping function hiding any exception
     /// caused by the converter.
@@ -107,8 +122,8 @@ public static Result<T, TError> FromError<T, TError>(TError e)
     /// <typeparam name="T">The type of the value.</typeparam>
     /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
     /// <returns>The conversion result.</returns>
-    public static async Task<Result<TResult>> Convert<T, TResult>(this Task<Result<T>> task, Converter<T, TResult> converter)
-        => (await task.ConfigureAwait(false)).Convert(converter);
+    public static AwaitableResult<TResult> Convert<T, TResult>(this AwaitableResult<T> task, Converter<T, TResult> converter)
+        => task.TransformAwaitableResult((result) => result.Convert(converter));
 
     /// <summary>
     /// If successful result is present, apply the provided mapping function. If not,
@@ -119,8 +134,8 @@ public static async Task<Result<TResult>> Convert<T, TResult>(this Task<Result<T
     /// <typeparam name="T">The type of the value.</typeparam>
     /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
     /// <returns>The conversion result.</returns>
-    public static async Task<Result<TResult>> Convert<T, TResult>(this Task<Result<T>> task, Converter<T, Result<TResult>> converter)
-        => (await task.ConfigureAwait(false)).Convert(converter);
+    public static AwaitableResult<TResult> Convert<T, TResult>(this AwaitableResult<T> task, Converter<T, Result<TResult>> converter)
+        => task.TransformAwaitableResult((result) => result.Convert(converter));
 
     /// <summary>
     /// If successful result is present, apply the provided mapping function. If not,
@@ -131,50 +146,20 @@ public static async Task<Result<TResult>> Convert<T, TResult>(this Task<Result<T
     /// <typeparam name="T">The type of the value.</typeparam>
     /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
     /// <returns>The conversion result.</returns>
-    public static async Task<Result<TResult>> Convert<T, TResult>(this Task<Result<T>> task, Converter<T, Task<Result<TResult>>> converter)
-        => await (await task.ConfigureAwait(false)).Convert(converter).ConfigureAwait(false);
-
-    /// <summary>
-    /// If successful result is present, apply the provided mapping function hiding any exception
-    /// caused by the converter.
-    /// </summary>
-    /// <param name="task">The task containing Result value.</param>
-    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
-    /// <typeparam name="T">The type of the value.</typeparam>
-    /// <typeparam name="TError">The type of the error code. Default value must represent the successful result.</typeparam>
-    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
-    /// <returns>The conversion result.</returns>
-    public static async Task<Result<TResult, TError>> Convert<T, TError, TResult>(this Task<Result<T, TError>> task, Converter<T, TResult> converter)
-        where TError: struct, Enum
-        => (await task.ConfigureAwait(false)).Convert(converter);
+    public static AwaitableResult<TResult> Convert<T, TResult>(this AwaitableResult<T> task, Converter<T, Task<TResult>> converter)
+        => task.TransformAwaitableResult((result) => result.Convert(converter));
 
     /// <summary>
     /// If successful result is present, apply the provided mapping function. If not,
-    /// forward the error.
-    /// </summary>
-    /// <param name="task">The task containing Result value.</param>
-    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
-    /// <typeparam name="T">The type of the value.</typeparam>
-    /// <typeparam name="TError">The type of the error code. Default value must represent the successful result.</typeparam>
-    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
-    /// <returns>The conversion result.</returns>
-    public static async Task<Result<TResult, TError>> Convert<T, TError, TResult>(this Task<Result<T, TError>> task, Converter<T, Result<TResult, TError>> converter)
-        where TError : struct, Enum
-        => (await task.ConfigureAwait(false)).Convert(converter);
-
-    /// <summary>
-    /// If successful result is present, apply the provided mapping function. If not,
-    /// forward the error.
+    /// forward the exception.
     /// </summary>
     /// <param name="task">The task containing Result value.</param>
     /// <param name="converter">A mapping function to be applied to the value, if present.</param>
     /// <typeparam name="T">The type of the value.</typeparam>
-    /// <typeparam name="TError">The type of the error code. Default value must represent the successful result.</typeparam>
     /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
     /// <returns>The conversion result.</returns>
-    public static async Task<Result<TResult, TError>> Convert<T, TError, TResult>(this Task<Result<T, TError>> task, Converter<T, Task<Result<TResult, TError>>> converter)
-        where TError : struct, Enum
-        => await (await task.ConfigureAwait(false)).Convert(converter).ConfigureAwait(false);
+    public static AwaitableResult<TResult> Convert<T, TResult>(this AwaitableResult<T> task, Converter<T, Task<Result<TResult>>> converter)
+        => task.TransformAwaitableResult((result) => result.Convert(converter));
 
     /// <summary>
     /// Converts the result into <see cref="Optional{T}"/>.
@@ -183,6 +168,13 @@ public static async Task<Result<TResult, TError>> Convert<T, TError, TResult>(th
     public static async Task<Optional<T>> TryGet<T>(this Task<Result<T>> task)
         => (await task.ConfigureAwait(false)).TryGet();
 
+    /// <summary>
+    /// Converts the awaitable Result into a task holding <see cref="Optional{T}"/>.
+    /// </summary>
+    /// <returns>A task holding an Option monad representing value in this monad.</returns>
+    public static async Task<Optional<T>> TryGet<T>(this AwaitableResult<T> awaitableResult)
+        => (await awaitableResult.ConfigureAwait(false)).TryGet();
+
     /// <summary>
     /// Converts the result into <see cref="Optional{T}"/>.
     /// </summary>
@@ -190,6 +182,21 @@ public static async Task<Optional<T>> TryGet<T>(this Task<Result<T>> task)
     public static async Task<Optional<T>> TryGet<T, TError>(this Task<Result<T, TError>> task)
         where TError : struct, Enum
         => (await task.ConfigureAwait(false)).TryGet();
+
+    /// <summary>
+    /// Converts this task containing a Result to <see cref="AwaitableResult{TResult}"/>.
+    /// </summary>
+    /// <returns>The completed task representing the result.</returns>
+    public static AwaitableResult<T> ToAwaitable<T>(this Task<Result<T>> task)
+    {
+        async Task<T> ConvertInternal()
+        {
+            var result = await task.ConfigureAwait(false);
+            return result.IsSuccessful ? result.Value : throw result.Error;
+        }
+
+        return ConvertInternal().SuspendException();
+    }
 }
 
 /// <summary>
@@ -341,24 +348,72 @@ private Result<TResult> ConvertResult<TResult, TConverter>(TConverter converter)
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private Task<Result<TResult>> ConvertResultTask<TResult, TConverter>(TConverter converter)
-        where TConverter : struct, ISupplier<T, Task<Result<TResult>>>
+    private AwaitableResult<TResult> ConvertTask<TResult, TConverter>(TConverter converter)
+        where TConverter : struct, ISupplier<T, Task<TResult>>
     {
-        Task<Result<TResult>> result;
+        AwaitableResult<TResult> result;
         if (exception is null)
         {
             try
             {
-                result = converter.Invoke(value);
+                result = converter.Invoke(value).SuspendException();
             }
             catch (Exception e)
             {
-                result = Task.FromResult(new Result<TResult>(e));
+                result = new(Task.FromException<TResult>(e));
             }
         }
         else
         {
-            result = Task.FromResult(new Result<TResult>(exception));
+            result = new(Task.FromException<TResult>(exception.SourceException));
+        }
+
+        return result;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private AwaitableResult<TResult> ConvertResultTask<TResult, TConverter>(TConverter converter)
+        where TConverter : struct, ISupplier<T, Task<Result<TResult>>>
+    {
+        AwaitableResult<TResult> result;
+        if (exception is null)
+        {
+            var valueCopy = value;
+            async Task<TResult> GetConversionResult()
+            {
+                var conversionResult = await converter.Invoke(valueCopy).ConfigureAwait(false);
+                return conversionResult.IsSuccessful ? conversionResult.Value : throw conversionResult.Error;
+            }
+
+            result = new(GetConversionResult());
+        }
+        else
+        {
+            result = new(Task.FromException<TResult>(exception.SourceException));
+        }
+
+        return result;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private AwaitableResult<TResult> ConvertAwaitableResult<TResult, TConverter>(TConverter converter)
+        where TConverter : struct, ISupplier<T, AwaitableResult<TResult>>
+    {
+        AwaitableResult<TResult> result;
+        if (exception is null)
+        {
+            var valueCopy = value;
+            async Task<TResult> GetConversionResult()
+            {
+                var conversionResult = await converter.Invoke(valueCopy).ConfigureAwait(false);
+                return conversionResult.IsSuccessful ? conversionResult.Value : throw conversionResult.Error;
+            }
+
+            result = new(GetConversionResult());
+        }
+        else
+        {
+            result = new(Task.FromException<TResult>(exception.SourceException));
         }
 
         return result;
@@ -391,9 +446,29 @@ public Result<TResult> Convert<TResult>(Converter<T, Result<TResult>> converter)
     /// <param name="converter">A mapping function to be applied to the value, if present.</param>
     /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
     /// <returns>The conversion result.</returns>
-    public Task<Result<TResult>> Convert<TResult>(Converter<T, Task<Result<TResult>>> converter)
+    public AwaitableResult<TResult> Convert<TResult>(Converter<T, Task<TResult>> converter)
+        => ConvertTask<TResult, DelegatingConverter<T, Task<TResult>>>(converter);
+
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the exception.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    public AwaitableResult<TResult> Convert<TResult>(Converter<T, Task<Result<TResult>>> converter)
         => ConvertResultTask<TResult, DelegatingConverter<T, Task<Result<TResult>>>>(converter);
 
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the exception.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    public AwaitableResult<TResult> Convert<TResult>(Converter<T, AwaitableResult<TResult>> converter)
+        => ConvertAwaitableResult<TResult, DelegatingConverter<T, AwaitableResult<TResult>>>(converter);
+
     /// <summary>
     /// If successful result is present, apply the provided mapping function hiding any exception
     /// caused by the converter.
@@ -424,9 +499,31 @@ public unsafe Result<TResult> Convert<TResult>(delegate*<T, Result<TResult>> con
     /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
     /// <returns>The conversion result.</returns>
     [CLSCompliant(false)]
-    public unsafe Task<Result<TResult>> Convert<TResult>(delegate*<T, Task<Result<TResult>>> converter)
+    public unsafe AwaitableResult<TResult> Convert<TResult>(delegate*<T, Task<TResult>> converter)
+        => ConvertTask<TResult, Supplier<T, Task<TResult>>>(converter);
+
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the exception.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    [CLSCompliant(false)]
+    public unsafe AwaitableResult<TResult> Convert<TResult>(delegate*<T, Task<Result<TResult>>> converter)
         => ConvertResultTask<TResult, Supplier<T, Task<Result<TResult>>>>(converter);
 
+    /// <summary>
+    /// If successful result is present, apply the provided mapping function. If not,
+    /// forward the exception.
+    /// </summary>
+    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
+    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
+    /// <returns>The conversion result.</returns>
+    [CLSCompliant(false)]
+    public unsafe AwaitableResult<TResult> Convert<TResult>(delegate*<T, AwaitableResult<TResult>> converter)
+        => ConvertAwaitableResult<TResult, Supplier<T, AwaitableResult<TResult>>>(converter);
+
     /// <summary>
     /// Attempts to extract value from container if it is present.
     /// </summary>
@@ -527,6 +624,13 @@ public ValueTask<T> AsTask()
             { } error => ValueTask.FromException<T>(error),
         };
 
+    /// <summary>
+    /// Converts this result to <see cref="AwaitableResult{TResult}"/>.
+    /// </summary>
+    /// <returns>The awaitable Result representing the result.</returns>
+    public AwaitableResult<T> ToAwaitable()
+        => IsSuccessful ? new(Task.FromResult(value)) : new(Task.FromException<T>(Error));
+
     /// <summary>
     /// Converts the result to <see cref="Task{TResult}"/>.
     /// </summary>
@@ -747,11 +851,6 @@ private Result<TResult, TError> ConvertResult<TResult, TConverter>(TConverter co
         where TConverter : struct, ISupplier<T, Result<TResult, TError>>
         => IsSuccessful ? converter.Invoke(value) : new(Error);
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private Task<Result<TResult, TError>> ConvertResultTask<TResult, TConverter>(TConverter converter)
-        where TConverter : struct, ISupplier<T, Task<Result<TResult, TError>>>
-        => IsSuccessful ? converter.Invoke(value) : Task.FromResult(new Result<TResult, TError>(Error));
-
     /// <summary>
     /// If successful result is present, apply the provided mapping function hiding any exception
     /// caused by the converter.
@@ -772,16 +871,6 @@ public Result<TResult, TError> Convert<TResult>(Converter<T, TResult> converter)
     public Result<TResult, TError> Convert<TResult>(Converter<T, Result<TResult, TError>> converter)
         => ConvertResult<TResult, DelegatingConverter<T, Result<TResult,TError>>>(converter);
 
-    /// <summary>
-    /// If successful result is present, apply the provided mapping function. If not,
-    /// forward the error.
-    /// </summary>
-    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
-    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
-    /// <returns>The conversion result.</returns>
-    public Task<Result<TResult, TError>> Convert<TResult>(Converter<T, Task<Result<TResult, TError>>> converter)
-        => ConvertResultTask<TResult, DelegatingConverter<T, Task<Result<TResult, TError>>>>(converter);
-
     /// <summary>
     /// If successful result is present, apply the provided mapping function hiding any exception
     /// caused by the converter.
@@ -804,17 +893,6 @@ public unsafe Result<TResult, TError> Convert<TResult>(delegate*<T, TResult> con
     public unsafe Result<TResult, TError> Convert<TResult>(delegate*<T, Result<TResult, TError>> converter)
         => ConvertResult<TResult, Supplier<T, Result<TResult, TError>>>(converter);
 
-    /// <summary>
-    /// If successful result is present, apply the provided mapping function. If not,
-    /// forward the error.
-    /// </summary>
-    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
-    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
-    /// <returns>The conversion result.</returns>
-    [CLSCompliant(false)]
-    public unsafe Task<Result<TResult, TError>> Convert<TResult>(delegate*<T, Task<Result<TResult, TError>>> converter)
-        => ConvertResultTask<TResult, Supplier<T, Task<Result<TResult, TError>>>>(converter);
-
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private T OrInvoke<TSupplier>(TSupplier defaultFunc)
         where TSupplier : struct, ISupplier<T>
diff --git a/src/DotNext/Threading/Tasks/Conversion.cs b/src/DotNext/Threading/Tasks/Conversion.cs
index ac0535739..9624a3f25 100644
--- a/src/DotNext/Threading/Tasks/Conversion.cs
+++ b/src/DotNext/Threading/Tasks/Conversion.cs
@@ -3,6 +3,7 @@
 
 namespace DotNext.Threading.Tasks;
 
+using System.Threading.Tasks;
 using Runtime.CompilerServices;
 
 /// <summary>
@@ -20,6 +21,16 @@ public static class Conversion
     public static Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> task)
         where TInput : TOutput => task.Convert(Converter.Identity<TInput, TOutput>());
 
+    /// <summary>
+    /// Converts one type of task into another.
+    /// </summary>
+    /// <typeparam name="TInput">The source Result type.</typeparam>
+    /// <typeparam name="TOutput">The target Result type.</typeparam>
+    /// <param name="awaitableResult">The awaitable Result to convert.</param>
+    /// <returns>The converted task.</returns>
+    public static AwaitableResult<TOutput> Convert<TInput, TOutput>(this AwaitableResult<TInput> awaitableResult)
+        where TInput : TOutput => awaitableResult.Convert(Converter.Identity<TInput, TOutput>());
+
     /// <summary>
     /// Converts one type of task into another.
     /// </summary>
@@ -31,6 +42,25 @@ public static Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> task)
     public static async Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> task, Converter<TInput, TOutput> converter)
         => converter(await task.ConfigureAwait(false));
 
+    /// <summary>
+    /// Converts one type of task into another.
+    /// </summary>
+    /// <typeparam name="TInput">The source Result type.</typeparam>
+    /// <typeparam name="TOutput">The target Result type.</typeparam>
+    /// <param name="awaitableResult">The awaitable Result to convert.</param>
+    /// <param name="converter">Non-blocking conversion function.</param>
+    /// <returns>The converted task.</returns>
+    public static AwaitableResult<TOutput> Convert<TInput, TOutput>(this AwaitableResult<TInput> awaitableResult, Converter<TInput, TOutput> converter)
+    {
+        async Task<TOutput> ConvertInternal()
+        {
+            var result = await awaitableResult.ConfigureAwait(false);
+            return result.IsSuccessful ? converter(result.Value) : throw result.Error;
+        }
+
+        return ConvertInternal().SuspendException();
+    }
+
     /// <summary>
     /// Converts value type into nullable value type.
     /// </summary>
@@ -53,6 +83,26 @@ public static async Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> tas
     public static async Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> task, Converter<TInput, Task<TOutput>> converter)
         => await converter(await task.ConfigureAwait(false)).ConfigureAwait(false);
 
+    /// <summary>
+    /// Converts one type of awaitable Result into another.
+    /// </summary>
+    /// <typeparam name="TInput">The source Result type.</typeparam>
+    /// <typeparam name="TOutput">The target Result type.</typeparam>
+    /// <param name="awaitableResult">The awaitable Result to convert.</param>
+    /// <param name="converter">Asynchronous conversion function.</param>
+    /// <returns>The converted task.</returns>
+    public static AwaitableResult<TOutput> Convert<TInput, TOutput>(this AwaitableResult<TInput> awaitableResult, Converter<TInput, AwaitableResult<TOutput>> converter)
+    {
+        async Task<TOutput> ConvertInternal()
+        {
+            var result = await awaitableResult.ConfigureAwait(false);
+            var conversionResult = result.IsSuccessful ? await converter(result.Value).ConfigureAwait(false) : throw result.Error;
+            return conversionResult.IsSuccessful ? conversionResult.Value : throw conversionResult.Error;
+        }
+
+        return ConvertInternal().SuspendException();
+    }
+
     /// <summary>
     /// Allows to convert <see cref="Task{TResult}"/> of unknown result type into dynamically
     /// typed task which result can be obtained as <see cref="object"/>

From fab91690633201034619d2f3714478fe3ab7a71b Mon Sep 17 00:00:00 2001
From: Julian Thurner <julianthurner@web.de>
Date: Tue, 4 Mar 2025 10:44:12 +0100
Subject: [PATCH 4/4] Review adjustments

---
 src/DotNext/Optional.cs                   |   8 --
 src/DotNext/Result.cs                     | 142 +++++-----------------
 src/DotNext/Threading/Tasks/Conversion.cs |   6 +-
 3 files changed, 32 insertions(+), 124 deletions(-)

diff --git a/src/DotNext/Optional.cs b/src/DotNext/Optional.cs
index 98fb8b414..35d4b731b 100644
--- a/src/DotNext/Optional.cs
+++ b/src/DotNext/Optional.cs
@@ -72,14 +72,6 @@ public static async Task<Optional<TOutput>> Convert<TInput, TOutput>(this Task<O
     public static async Task<Optional<TOutput>> Convert<TInput, TOutput>(this Task<Optional<TInput>> task, Converter<TInput, Task<Optional<TOutput>>> converter)
         => await (await task.ConfigureAwait(false)).Convert(converter).ConfigureAwait(false);
 
-    /// <summary>
-    /// Creates a new instance of <see cref="Optional{T}"/> from the specified value.
-    /// </summary>
-    /// <typeparam name="T">The type of the value.</typeparam>
-    /// <param name="value">The value to be placed to the container.</param>
-    /// <returns>The value encapsulated by <see cref="Result{T}"/>.</returns>
-    public static Optional<T> From<T>(T value) => new(value);
-
     /// <summary>
     /// Creates <see cref="Result{T}"/> from <see cref="Optional{T}"/> instance.
     /// </summary>
diff --git a/src/DotNext/Result.cs b/src/DotNext/Result.cs
index ae5238826..345d91284 100644
--- a/src/DotNext/Result.cs
+++ b/src/DotNext/Result.cs
@@ -89,30 +89,6 @@ public static Result<T, TError> FromError<T, TError>(TError e)
         where TError: struct, Enum
         => new(e);
 
-    private static AwaitableResult<TResult> TransformAwaitableResult<T, TResult>(this AwaitableResult<T> task, Converter<Result<T>, Result<TResult>> converter)
-    {
-        async Task<TResult> ConvertInternal()
-        {
-            var result = await task.ConfigureAwait(false);
-            var conversionResult = converter(result);
-            return conversionResult.IsSuccessful ? conversionResult.Value : throw conversionResult.Error;
-        }
-
-        return ConvertInternal().SuspendException();
-    }
-
-    private static AwaitableResult<TResult> TransformAwaitableResult<T, TResult>(this AwaitableResult<T> task, Converter<Result<T>, AwaitableResult<TResult>> converter)
-    {
-        async Task<TResult> ConvertInternal()
-        {
-            var result = await task.ConfigureAwait(false);
-            var conversionResult = await converter(result);
-            return conversionResult.IsSuccessful ? conversionResult.Value : throw conversionResult.Error;
-        }
-
-        return ConvertInternal().SuspendException();
-    }
-
     /// <summary>
     /// If successful result is present, apply the provided mapping function hiding any exception
     /// caused by the converter.
@@ -123,7 +99,16 @@ async Task<TResult> ConvertInternal()
     /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
     /// <returns>The conversion result.</returns>
     public static AwaitableResult<TResult> Convert<T, TResult>(this AwaitableResult<T> task, Converter<T, TResult> converter)
-        => task.TransformAwaitableResult((result) => result.Convert(converter));
+    {
+        async Task<TResult> ConvertInternal()
+        {
+            var result = await task.ConfigureAwait(false);
+            var conversionResult = result.Convert(converter);
+            return conversionResult.IsSuccessful ? conversionResult.Value : throw conversionResult.Error;
+        }
+
+        return ConvertInternal().SuspendException();
+    }
 
     /// <summary>
     /// If successful result is present, apply the provided mapping function. If not,
@@ -135,19 +120,16 @@ public static AwaitableResult<TResult> Convert<T, TResult>(this AwaitableResult<
     /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
     /// <returns>The conversion result.</returns>
     public static AwaitableResult<TResult> Convert<T, TResult>(this AwaitableResult<T> task, Converter<T, Result<TResult>> converter)
-        => task.TransformAwaitableResult((result) => result.Convert(converter));
+    {
+        async Task<TResult> ConvertInternal()
+        {
+            var result = await task.ConfigureAwait(false);
+            var conversionResult = result.Convert(converter);
+            return conversionResult.IsSuccessful ? conversionResult.Value : throw conversionResult.Error;
+        }
 
-    /// <summary>
-    /// If successful result is present, apply the provided mapping function. If not,
-    /// forward the exception.
-    /// </summary>
-    /// <param name="task">The task containing Result value.</param>
-    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
-    /// <typeparam name="T">The type of the value.</typeparam>
-    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
-    /// <returns>The conversion result.</returns>
-    public static AwaitableResult<TResult> Convert<T, TResult>(this AwaitableResult<T> task, Converter<T, Task<TResult>> converter)
-        => task.TransformAwaitableResult((result) => result.Convert(converter));
+        return ConvertInternal().SuspendException();
+    }
 
     /// <summary>
     /// If successful result is present, apply the provided mapping function. If not,
@@ -158,15 +140,17 @@ public static AwaitableResult<TResult> Convert<T, TResult>(this AwaitableResult<
     /// <typeparam name="T">The type of the value.</typeparam>
     /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
     /// <returns>The conversion result.</returns>
-    public static AwaitableResult<TResult> Convert<T, TResult>(this AwaitableResult<T> task, Converter<T, Task<Result<TResult>>> converter)
-        => task.TransformAwaitableResult((result) => result.Convert(converter));
+    public static AwaitableResult<TResult> Convert<T, TResult>(this AwaitableResult<T> task, Converter<T, Task<TResult>> converter)
+    {
+        async Task<TResult> ConvertInternal()
+        {
+            var result = await task.ConfigureAwait(false);
+            var conversionResult = await result.Convert(converter);
+            return conversionResult.IsSuccessful ? conversionResult.Value : throw conversionResult.Error;
+        }
 
-    /// <summary>
-    /// Converts the result into <see cref="Optional{T}"/>.
-    /// </summary>
-    /// <returns>Option monad representing value in this monad.</returns>
-    public static async Task<Optional<T>> TryGet<T>(this Task<Result<T>> task)
-        => (await task.ConfigureAwait(false)).TryGet();
+        return ConvertInternal().SuspendException();
+    }
 
     /// <summary>
     /// Converts the awaitable Result into a task holding <see cref="Optional{T}"/>.
@@ -174,29 +158,6 @@ public static async Task<Optional<T>> TryGet<T>(this Task<Result<T>> task)
     /// <returns>A task holding an Option monad representing value in this monad.</returns>
     public static async Task<Optional<T>> TryGet<T>(this AwaitableResult<T> awaitableResult)
         => (await awaitableResult.ConfigureAwait(false)).TryGet();
-
-    /// <summary>
-    /// Converts the result into <see cref="Optional{T}"/>.
-    /// </summary>
-    /// <returns>Option monad representing value in this monad.</returns>
-    public static async Task<Optional<T>> TryGet<T, TError>(this Task<Result<T, TError>> task)
-        where TError : struct, Enum
-        => (await task.ConfigureAwait(false)).TryGet();
-
-    /// <summary>
-    /// Converts this task containing a Result to <see cref="AwaitableResult{TResult}"/>.
-    /// </summary>
-    /// <returns>The completed task representing the result.</returns>
-    public static AwaitableResult<T> ToAwaitable<T>(this Task<Result<T>> task)
-    {
-        async Task<T> ConvertInternal()
-        {
-            var result = await task.ConfigureAwait(false);
-            return result.IsSuccessful ? result.Value : throw result.Error;
-        }
-
-        return ConvertInternal().SuspendException();
-    }
 }
 
 /// <summary>
@@ -371,30 +332,6 @@ private AwaitableResult<TResult> ConvertTask<TResult, TConverter>(TConverter con
         return result;
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private AwaitableResult<TResult> ConvertResultTask<TResult, TConverter>(TConverter converter)
-        where TConverter : struct, ISupplier<T, Task<Result<TResult>>>
-    {
-        AwaitableResult<TResult> result;
-        if (exception is null)
-        {
-            var valueCopy = value;
-            async Task<TResult> GetConversionResult()
-            {
-                var conversionResult = await converter.Invoke(valueCopy).ConfigureAwait(false);
-                return conversionResult.IsSuccessful ? conversionResult.Value : throw conversionResult.Error;
-            }
-
-            result = new(GetConversionResult());
-        }
-        else
-        {
-            result = new(Task.FromException<TResult>(exception.SourceException));
-        }
-
-        return result;
-    }
-
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private AwaitableResult<TResult> ConvertAwaitableResult<TResult, TConverter>(TConverter converter)
         where TConverter : struct, ISupplier<T, AwaitableResult<TResult>>
@@ -449,16 +386,6 @@ public Result<TResult> Convert<TResult>(Converter<T, Result<TResult>> converter)
     public AwaitableResult<TResult> Convert<TResult>(Converter<T, Task<TResult>> converter)
         => ConvertTask<TResult, DelegatingConverter<T, Task<TResult>>>(converter);
 
-    /// <summary>
-    /// If successful result is present, apply the provided mapping function. If not,
-    /// forward the exception.
-    /// </summary>
-    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
-    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
-    /// <returns>The conversion result.</returns>
-    public AwaitableResult<TResult> Convert<TResult>(Converter<T, Task<Result<TResult>>> converter)
-        => ConvertResultTask<TResult, DelegatingConverter<T, Task<Result<TResult>>>>(converter);
-
     /// <summary>
     /// If successful result is present, apply the provided mapping function. If not,
     /// forward the exception.
@@ -502,17 +429,6 @@ public unsafe Result<TResult> Convert<TResult>(delegate*<T, Result<TResult>> con
     public unsafe AwaitableResult<TResult> Convert<TResult>(delegate*<T, Task<TResult>> converter)
         => ConvertTask<TResult, Supplier<T, Task<TResult>>>(converter);
 
-    /// <summary>
-    /// If successful result is present, apply the provided mapping function. If not,
-    /// forward the exception.
-    /// </summary>
-    /// <param name="converter">A mapping function to be applied to the value, if present.</param>
-    /// <typeparam name="TResult">The type of the result of the mapping function.</typeparam>
-    /// <returns>The conversion result.</returns>
-    [CLSCompliant(false)]
-    public unsafe AwaitableResult<TResult> Convert<TResult>(delegate*<T, Task<Result<TResult>>> converter)
-        => ConvertResultTask<TResult, Supplier<T, Task<Result<TResult>>>>(converter);
-
     /// <summary>
     /// If successful result is present, apply the provided mapping function. If not,
     /// forward the exception.
diff --git a/src/DotNext/Threading/Tasks/Conversion.cs b/src/DotNext/Threading/Tasks/Conversion.cs
index 9624a3f25..5d235be85 100644
--- a/src/DotNext/Threading/Tasks/Conversion.cs
+++ b/src/DotNext/Threading/Tasks/Conversion.cs
@@ -22,7 +22,7 @@ public static Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> task)
         where TInput : TOutput => task.Convert(Converter.Identity<TInput, TOutput>());
 
     /// <summary>
-    /// Converts one type of task into another.
+    /// Converts one type of <see cref="AwaitableResult{T}"/> into another.
     /// </summary>
     /// <typeparam name="TInput">The source Result type.</typeparam>
     /// <typeparam name="TOutput">The target Result type.</typeparam>
@@ -43,7 +43,7 @@ public static async Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> tas
         => converter(await task.ConfigureAwait(false));
 
     /// <summary>
-    /// Converts one type of task into another.
+    /// Converts one type of <see cref="AwaitableResult{T}"/> into another.
     /// </summary>
     /// <typeparam name="TInput">The source Result type.</typeparam>
     /// <typeparam name="TOutput">The target Result type.</typeparam>
@@ -84,7 +84,7 @@ public static async Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> tas
         => await converter(await task.ConfigureAwait(false)).ConfigureAwait(false);
 
     /// <summary>
-    /// Converts one type of awaitable Result into another.
+    /// Converts one type of <see cref="AwaitableResult{T}"/> into another.
     /// </summary>
     /// <typeparam name="TInput">The source Result type.</typeparam>
     /// <typeparam name="TOutput">The target Result type.</typeparam>