Added additional delegate helpers

Author: sakno

src/DotNext.Tests/DelegateHelpersTests.cs

@@ -1,6 +1,7 @@
 using System.Globalization;
 using System.Linq.Expressions;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 
 namespace DotNext;
 
@@ -498,4 +499,48 @@ public static void Identity()
     {
         Equal(42, Func.Identity<int>().Invoke(42));
     }
+
+    [Fact]
+    public static void ToAsync1()
+    {
+        var func = new Action(static () => { }).ToAsync();
+        True(func.Invoke(new(canceled: false)).IsCompletedSuccessfully);
+        True(func.Invoke(new(canceled: true)).IsCanceled);
+
+        func = new Action(static () => throw new Exception()).ToAsync();
+        True(func.Invoke(new(canceled: false)).IsFaulted);
+    }
+
+    [Fact]
+    public static void ToAsync2()
+    {
+        var func = new Action<int>(static _ => { }).ToAsync();
+        True(func.Invoke(42, new(canceled: false)).IsCompletedSuccessfully);
+        True(func.Invoke(42, new(canceled: true)).IsCanceled);
+
+        func = new Action<int>(static _ => throw new Exception()).ToAsync();
+        True(func.Invoke(42, new(canceled: false)).IsFaulted);
+    }
+
+    [Fact]
+    public static void HideReturnValue1()
+    {
+        var box = new StrongBox<int>();
+        var action = new Func<int>(ChangeValue).HideReturnValue();
+        action.Invoke();
+        Equal(42, box.Value);
+        
+        int ChangeValue() => box.Value = 42;
+    }
+    
+    [Fact]
+    public static void HideReturnValue2()
+    {
+        var box = new StrongBox<int>();
+        var action = new Func<int, int>(ChangeValue).HideReturnValue();
+        action.Invoke(42);
+        Equal(42, box.Value);
+        
+        int ChangeValue(int value) => box.Value = value;
+    }
 }

src/DotNext/DelegateHelpers.cs

@@ -88,4 +88,112 @@ public static EventHandler<T> Contravariant<TBase, T>(this EventHandler<TBase> h
     public static TDelegate ChangeType<TDelegate>(this Delegate d)
         where TDelegate : Delegate
         => d is TDelegate ? Unsafe.As<TDelegate>(d) : ChangeType<TDelegate, EmptyTargetRewriter>(d, new EmptyTargetRewriter());
+
+    /// <summary>
+    /// Converts action to async delegate.
+    /// </summary>
+    /// <param name="action">Synchronous action.</param>
+    /// <typeparam name="T">The type of the argument to be passed to the action.</typeparam>
+    /// <returns>The asynchronous function that wraps <paramref name="action"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="action"/> is <see langword="null"/>.</exception>
+    public static Func<T, CancellationToken, ValueTask> ToAsync<T>(this Action<T> action)
+    {
+        ArgumentNullException.ThrowIfNull(action);
+
+        return action.Invoke;
+    }
+
+    private static ValueTask Invoke<T>(this Action<T> action, T arg, CancellationToken token)
+    {
+        ValueTask task;
+        if (token.IsCancellationRequested)
+        {
+            task = ValueTask.FromCanceled(token);
+        }
+        else
+        {
+            task = ValueTask.CompletedTask;
+            try
+            {
+                action.Invoke(arg);
+            }
+            catch (Exception e)
+            {
+                task = ValueTask.FromException(e);
+            }
+        }
+
+        return task;
+    }
+    
+    /// <summary>
+    /// Converts action to async delegate.
+    /// </summary>
+    /// <param name="action">Synchronous action.</param>
+    /// <returns>The asynchronous function that wraps <paramref name="action"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="action"/> is <see langword="null"/>.</exception>
+    public static Func<CancellationToken, ValueTask> ToAsync(this Action action)
+    {
+        ArgumentNullException.ThrowIfNull(action);
+
+        return action.Invoke;
+    }
+
+    private static ValueTask Invoke(this Action action, CancellationToken token)
+    {
+        ValueTask task;
+        if (token.IsCancellationRequested)
+        {
+            task = ValueTask.FromCanceled(token);
+        }
+        else
+        {
+            task = ValueTask.CompletedTask;
+            try
+            {
+                action.Invoke();
+            }
+            catch (Exception e)
+            {
+                task = ValueTask.FromException(e);
+            }
+        }
+
+        return task;
+    }
+
+    /// <summary>
+    /// Creates a delegate that hides the return value.
+    /// </summary>
+    /// <param name="func">The function.</param>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <returns>The action that invokes the same method as <paramref name="func"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="func"/> is <see langword="null"/>.</exception>
+    public static Action HideReturnValue<TResult>(this Func<TResult> func)
+    {
+        ArgumentNullException.ThrowIfNull(func);
+
+        return func.InvokeNoReturn;
+    }
+
+    private static void InvokeNoReturn<TResult>(this Func<TResult> func)
+        => func.Invoke();
+    
+    /// <summary>
+    /// Creates a delegate that hides the return value.
+    /// </summary>
+    /// <param name="func">The function.</param>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <typeparam name="T">The type of the argument to be passed to the action.</typeparam>
+    /// <returns>The action that invokes the same method as <paramref name="func"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="func"/> is <see langword="null"/>.</exception>
+    public static Action<T> HideReturnValue<T, TResult>(this Func<T, TResult> func)
+    {
+        ArgumentNullException.ThrowIfNull(func);
+
+        return func.InvokeNoReturn;
+    }
+
+    private static void InvokeNoReturn<T, TResult>(this Func<T, TResult> func, T arg)
+        => func.Invoke(arg);
 }