Added conversion to Task<T>

Author: sakno

src/DotNext.Metaprogramming/Threading/Tasks/CompletedTask.cs

@@ -1,6 +1,4 @@
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
+using System.Runtime.InteropServices;
 
 namespace DotNext.Threading.Tasks;
 
@@ -37,41 +35,31 @@ public static implicit operator ValueTask(CompletedTask task)
 [StructLayout(LayoutKind.Auto)]
 internal readonly struct CompletedTask<T>
 {
-    private readonly Exception? failure;
-
-    [AllowNull]
-    private readonly T result;
+    private readonly Result<T> result;
 
     /// <summary>
     /// Creates task that has completed with a specified exception.
     /// </summary>
     /// <param name="failure">The exception with which to complete the task.</param>
-    public CompletedTask(Exception failure) => this.failure = failure;
+    public CompletedTask(Exception failure) => result = new(failure);
 
     /// <summary>
     /// Creates task that has completed successfully with a specified result.
     /// </summary>
     /// <param name="result">The task result.</param>
-    public CompletedTask(T result) => this.result = result;
+    public CompletedTask(T result) => this.result = new(result);
 
     /// <summary>
     /// Obtains <see cref="Task{TResult}"/> completed synchronously.
     /// </summary>
     /// <param name="task">Completed task.</param>
     public static implicit operator Task<T>(CompletedTask<T> task)
-        => task.failure is null ? Task.FromResult(task.result) : Task.FromException<T>(task.failure);
+        => task.result.AsTask();
 
     /// <summary>
     /// Obtains <see cref="ValueTask{TResult}"/> completed synchronously.
     /// </summary>
     /// <param name="task">Completed task.</param>
     public static implicit operator ValueTask<T>(CompletedTask<T> task)
-    {
-        var builder = AsyncValueTaskMethodBuilder<T>.Create();
-        if (task.failure is null)
-            builder.SetResult(task.result);
-        else
-            builder.SetException(task.failure);
-        return builder.Task;
-    }
+        => new(task.result.AsTask());
 }

src/DotNext/Result.cs

@@ -315,6 +315,25 @@ public unsafe T OrInvoke(delegate*<Exception, T> defaultFunc)
     public static Result<T> operator |(in Result<T> x, in Result<T> y)
         => x.IsSuccessful ? x : y;
 
+    /// <summary>
+    /// Converts this result to <see cref="Task{TResult}"/>.
+    /// </summary>
+    /// <returns>The completed task representing the result.</returns>
+    public Task<T> AsTask()
+        => exception?.SourceException switch
+        {
+            null => Task.FromResult(value),
+            OperationCanceledException canceledEx => Task.FromCanceled<T>(canceledEx.CancellationToken),
+            { } error => Task.FromException<T>(error),
+        };
+
+    /// <summary>
+    /// Converts the result to <see cref="Task{TResult}"/>.
+    /// </summary>
+    /// <param name="result">The result to be converted.</param>
+    /// <returns>The completed task representing the result.</returns>
+    public static explicit operator Task<T>(in Result<T> result) => result.AsTask();
+
     /// <summary>
     /// Gets boxed representation of the result.
     /// </summary>