Adjustments for AwaitableResult

Author: julianthurner

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.

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,32 @@ 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.
+    /// 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, Result<TResult, TError>> 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<Result<TResult>>> converter)
+        => task.TransformAwaitableResult((result) => result.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, AwaitableResult<TResult>> converter)
+        => task.TransformAwaitableResult((result) => result.Convert(converter));
 
     /// <summary>
     /// Converts the result into <see cref="Optional{T}"/>.
@@ -183,6 +180,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>
@@ -341,24 +345,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 +443,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 +496,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 +621,13 @@ public ValueTask<T> AsTask()
             { } error => ValueTask.FromException<T>(error),
         };
 
+    /// <summary>
+    /// Converts this result to <see cref="AwaitableResult{TResult}"/>.
+    /// </summary>
+    /// <returns>The completed task 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 +848,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 +868,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 +890,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>