Unified naming for methods with similar semantics

Author: sakno

src/DotNext.Tests/Threading/Tasks/ConversionTests.cs

@@ -50,11 +50,11 @@ public static async Task SuspendException()
         await Task.FromException(new Exception()).SuspendException(Predicate.Constant<Exception>(true)).ConfigureAwait(true);
         await ValueTask.FromException(new Exception()).SuspendException(Predicate.Constant<Exception>(true)).ConfigureAwait(true);
 
-        var result = await Task.FromException<int>(new ArithmeticException()).SuspendException().ConfigureAwait(true);
+        var result = await Task.FromException<int>(new ArithmeticException()).CatchException().ConfigureAwait(true);
         False(result.IsSuccessful);
         IsType<ArithmeticException>(result.Error);
 
-        result = await ValueTask.FromException<int>(new ArithmeticException()).SuspendException().ConfigureAwait(true);
+        result = await ValueTask.FromException<int>(new ArithmeticException()).CatchException().ConfigureAwait(true);
         False(result.IsSuccessful);
         IsType<ArithmeticException>(result.Error);
     }
@@ -80,11 +80,11 @@ public static async Task SuspendException2()
     [Fact]
     public static async Task ConvertExceptionToError()
     {
-        var result = await Task.FromException<int>(new Exception()).SuspendException(ToError).ConfigureAwait(true);
+        var result = await Task.FromException<int>(new Exception()).CatchException(ToError).ConfigureAwait(true);
         False(result.IsSuccessful);
         Equal(EnvironmentVariableTarget.Machine, result.Error);
 
-        result = await ValueTask.FromException<int>(new Exception()).SuspendException(ToError).ConfigureAwait(true);
+        result = await ValueTask.FromException<int>(new Exception()).CatchException(ToError).ConfigureAwait(true);
         False(result.IsSuccessful);
         Equal(EnvironmentVariableTarget.Machine, result.Error);
 

src/DotNext/Threading/Tasks/Conversion.cs

@@ -73,7 +73,17 @@ public static async Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> tas
     /// <param name="task">The task to convert.</param>
     /// <typeparam name="T">The type of the task.</typeparam>
     /// <returns>The task that never throws an exception. Instead, the <see cref="Result{T}"/> contains an exception.</returns>
+    [Obsolete("Use CatchException() instead.")]
     public static AwaitableResult<T> SuspendException<T>(this Task<T> task)
+        => CatchException(task);
+
+    /// <summary>
+    /// Returns a task that never throws an exception.
+    /// </summary>
+    /// <param name="task">The task to convert.</param>
+    /// <typeparam name="T">The type of the task.</typeparam>
+    /// <returns>The task that never throws an exception. Instead, the <see cref="Result{T}"/> contains an exception.</returns>
+    public static AwaitableResult<T> CatchException<T>(this Task<T> task)
     {
         ArgumentNullException.ThrowIfNull(task);
 
@@ -86,7 +96,16 @@ public static AwaitableResult<T> SuspendException<T>(this Task<T> task)
     /// <param name="task">The task to convert.</param>
     /// <typeparam name="T">The type of the task.</typeparam>
     /// <returns>The task that never throws an exception. Instead, the <see cref="Result{T}"/> contains an exception.</returns>
-    public static AwaitableResult<T> SuspendException<T>(this ValueTask<T> task) => new(task);
+    [Obsolete("Use CatchException() instead.")]
+    public static AwaitableResult<T> SuspendException<T>(this ValueTask<T> task) => CatchException(task);
+
+    /// <summary>
+    /// Returns a task that never throws an exception.
+    /// </summary>
+    /// <param name="task">The task to convert.</param>
+    /// <typeparam name="T">The type of the task.</typeparam>
+    /// <returns>The task that never throws an exception. Instead, the <see cref="Result{T}"/> contains an exception.</returns>
+    public static AwaitableResult<T> CatchException<T>(this ValueTask<T> task) => new(task);
 
     /// <summary>
     /// Returns a task that never throws an exception.
@@ -96,7 +115,21 @@ public static AwaitableResult<T> SuspendException<T>(this Task<T> task)
     /// <typeparam name="T">The type of the task.</typeparam>
     /// <typeparam name="TError">The type of the error.</typeparam>
     /// <returns>The task that never throws an exception. Instead, the <see cref="Result{T}"/> contains an exception.</returns>
+    [Obsolete("Use CatchException() instead.")]
     public static AwaitableResult<T, TError> SuspendException<T, TError>(this ValueTask<T> task,
+        Converter<Exception, TError> converter)
+        where TError : struct, Enum
+        => CatchException(task, converter);
+    
+    /// <summary>
+    /// Returns a task that never throws an exception.
+    /// </summary>
+    /// <param name="task">The task to convert.</param>
+    /// <param name="converter">The exception converter.</param>
+    /// <typeparam name="T">The type of the task.</typeparam>
+    /// <typeparam name="TError">The type of the error.</typeparam>
+    /// <returns>The task that never throws an exception. Instead, the <see cref="Result{T}"/> contains an exception.</returns>
+    public static AwaitableResult<T, TError> CatchException<T, TError>(this ValueTask<T> task,
         Converter<Exception, TError> converter)
         where TError : struct, Enum
         => new(task, converter);
@@ -109,10 +142,28 @@ public static AwaitableResult<T, TError> SuspendException<T, TError>(this ValueT
     /// <typeparam name="T">The type of the task.</typeparam>
     /// <typeparam name="TError">The type of the error.</typeparam>
     /// <returns>The task that never throws an exception. Instead, the <see cref="Result{T}"/> contains an exception.</returns>
+    [Obsolete("Use CatchException() instead.")]
     public static AwaitableResult<T, TError> SuspendException<T, TError>(this Task<T> task,
         Converter<Exception, TError> converter)
         where TError : struct, Enum
-        => new(task, converter);
+        => CatchException(task, converter);
+
+    /// <summary>
+    /// Returns a task that never throws an exception.
+    /// </summary>
+    /// <param name="task">The task to convert.</param>
+    /// <param name="converter">The exception converter.</param>
+    /// <typeparam name="T">The type of the task.</typeparam>
+    /// <typeparam name="TError">The type of the error.</typeparam>
+    /// <returns>The task that never throws an exception. Instead, the <see cref="Result{T}"/> contains an exception.</returns>
+    public static AwaitableResult<T, TError> CatchException<T, TError>(this Task<T> task,
+        Converter<Exception, TError> converter)
+        where TError : struct, Enum
+    {
+        ArgumentNullException.ThrowIfNull(task);
+        
+        return new(task, converter);
+    }
 
     /// <summary>
     /// Suspends the exception that can be raised by the task.