feature/result-select (#63)

Added `Select` and `SelectMany` functions to allow interchangeable `Result` to `Result<T>` transformations.

Author: MrMatthewLayton

OnixLabs.Core.UnitTests/ResultNonGenericTests.cs

@@ -236,6 +236,32 @@ public void ResultFailureMatchShouldProduceExpectedResult()
 
     [Fact(DisplayName = "Result Success.Select should produce the expected result")]
     public void ResultSuccessSelectShouldProduceExpectedResult()
+    {
+        // Given
+        Result expected = Result.Success();
+
+        // When
+        Result actual = expected.Select(() => { });
+
+        // Then
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact(DisplayName = "Result Failure.Select should produce the expected result")]
+    public void ResultFailureSelectShouldProduceExpectedResult()
+    {
+        // Given
+        Result expected = Result.Failure(new Exception("Failure"));
+
+        // When
+        Result actual = expected.Select(() => { });
+
+        // Then
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact(DisplayName = "Result Success.Select<TResult> should produce the expected result")]
+    public void ResultSuccessSelectTResultShouldProduceExpectedResult()
     {
         // Given
         const int expected = 9;
@@ -248,8 +274,8 @@ public void ResultSuccessSelectShouldProduceExpectedResult()
         Assert.Equal(expected, actual);
     }
 
-    [Fact(DisplayName = "Result Failure.Select should produce the expected result")]
-    public void ResultFailureSelectShouldProduceExpectedResult()
+    [Fact(DisplayName = "Result Failure.Select<TResult> should produce the expected result")]
+    public void ResultFailureSelectTResultShouldProduceExpectedResult()
     {
         // Given
         Exception exception = new("failure");
@@ -264,6 +290,32 @@ public void ResultFailureSelectShouldProduceExpectedResult()
 
     [Fact(DisplayName = "Result Success.SelectMany should produce the expected result")]
     public void ResultSuccessSelectManyShouldProduceExpectedResult()
+    {
+        // Given
+        Result expected = Result.Success();
+
+        // When
+        Result actual = expected.SelectMany(Result.Success);
+
+        // Then
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact(DisplayName = "Result Failure.SelectMany should produce the expected result")]
+    public void ResultFailureSelectManyShouldProduceExpectedResult()
+    {
+        // Given
+        Result expected = Result.Failure(new Exception("Failure"));
+
+        // When
+        Result actual = expected.SelectMany(Result.Success);
+
+        // Then
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact(DisplayName = "Result Success.SelectMany<TResult> should produce the expected result")]
+    public void ResultSuccessSelectTResultManyShouldProduceExpectedResult()
     {
         // Given
         const int expected = 9;
@@ -276,8 +328,8 @@ public void ResultSuccessSelectManyShouldProduceExpectedResult()
         Assert.Equal(expected, actual);
     }
 
-    [Fact(DisplayName = "Result Failure.SelectMany should produce the expected result")]
-    public void ResultFailureSelectManyShouldProduceExpectedResult()
+    [Fact(DisplayName = "Result Failure.SelectMany<TResult> should produce the expected result")]
+    public void ResultFailureSelectTResultManyShouldProduceExpectedResult()
     {
         // Given
         Exception exception = new("failure");

OnixLabs.Core.UnitTests/ResultTests.cs

@@ -430,25 +430,54 @@ public void ResultFailureMatchShouldProduceExpectedResult()
     public void ResultSuccessSelectShouldProduceExpectedResult()
     {
         // Given
-        const int expected = 9;
-        Result<int> result = 3;
+        Result expected = Result.Success();
+        Result<int> result = 123;
 
         // When
-        Result<int> actual = result.Select(value => value * value);
+        Result actual = result.Select(_ => { });
 
         // Then
         Assert.Equal(expected, actual);
     }
 
     [Fact(DisplayName = "Result Failure.Select should produce the expected result")]
     public void ResultFailureSelectShouldProduceExpectedResult()
+    {
+        // Given
+        Exception exception = new("Failure");
+        Result expected = Result.Failure(exception);
+        Result<int> result = Result<int>.Failure(exception);
+
+        // When
+        Result actual = result.Select(_ => { });
+
+        // Then
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact(DisplayName = "Result Success.Select<TResult> should produce the expected result")]
+    public void ResultSuccessSelectTResultShouldProduceExpectedResult()
+    {
+        // Given
+        Result<int> expected = 9;
+        Result<int> result = 3;
+
+        // When
+        Result<int> actual = result.Select(x => x * x);
+
+        // Then
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact(DisplayName = "Result Failure.Select<TResult> should produce the expected result")]
+    public void ResultFailureSelectTResultShouldProduceExpectedResult()
     {
         // Given
         Exception exception = new("failure");
         Result<int> result = Result<int>.Failure(exception);
 
         // When
-        Result<int> actual = result.Select(value => value * value);
+        Result<int> actual = result.Select(x => x * x);
 
         // Then
         Assert.Equal(Result<int>.Failure(exception), actual);
@@ -458,25 +487,54 @@ public void ResultFailureSelectShouldProduceExpectedResult()
     public void ResultSuccessSelectManyShouldProduceExpectedResult()
     {
         // Given
-        const int expected = 9;
+        Result expected = Result.Success();
         Result<int> result = 3;
 
         // When
-        Result<int> actual = result.SelectMany<int>(value => value * value);
+        Result actual = result.SelectMany(_ => Result.Success());
 
         // Then
         Assert.Equal(expected, actual);
     }
 
     [Fact(DisplayName = "Result Failure.SelectMany should produce the expected result")]
     public void ResultFailureSelectManyShouldProduceExpectedResult()
+    {
+        // Given
+        Exception exception = new("Failure");
+        Result expected = Result.Failure(exception);
+        Result<int> result = Result<int>.Failure(exception);
+
+        // When
+        Result actual = result.SelectMany(_ => Result.Success());
+
+        // Then
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact(DisplayName = "Result Success.SelectMany<TResult> should produce the expected result")]
+    public void ResultSuccessSelectTResultManyShouldProduceExpectedResult()
+    {
+        // Given
+        Result<int> expected = 9;
+        Result<int> result = 3;
+
+        // When
+        Result<int> actual = result.SelectMany(x => Result<int>.Success(x * x));
+
+        // Then
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact(DisplayName = "Result Failure.SelectMany<TResult> should produce the expected result")]
+    public void ResultFailureSelectTResultManyShouldProduceExpectedResult()
     {
         // Given
         Exception exception = new("failure");
         Result<int> result = Result<int>.Failure(exception);
 
         // When
-        Result<int> actual = result.SelectMany<int>(value => value * value);
+        Result<int> actual = result.SelectMany(x => Result<int>.Success(x * x));
 
         // Then
         Assert.Equal(Result<int>.Failure(exception), actual);

OnixLabs.Core/OnixLabs.Core.csproj

@@ -11,7 +11,7 @@
         <NeutralLanguage>en</NeutralLanguage>
         <Copyright>Copyright © ONIXLabs 2020</Copyright>
         <RepositoryUrl>https://github.com/onix-labs/onixlabs-dotnet</RepositoryUrl>
-        <PackageVersion>8.7.0</PackageVersion>
+        <PackageVersion>8.8.0</PackageVersion>
         <PackageLicenseUrl></PackageLicenseUrl>
     </PropertyGroup>
     <PropertyGroup>

OnixLabs.Core/Result.Failure.cs

@@ -87,25 +87,41 @@ public sealed class Failure : Result, IValueEquatable<Failure>
     /// </returns>
     public override TResult Match<TResult>(Func<TResult> success, Func<Exception, TResult> failure) => failure(Exception);
 
+    /// <summary>
+    /// Applies the provided selector action to the value of the current <see cref="Result"/> instance.
+    /// </summary>
+    /// <param name="selector">The action to apply to current <see cref="Result"/> instance.</param>
+    /// <returns>
+    /// Returns <see cref="Success"/> if the current <see cref="Result"/> is in a successful state, and the action invocation is also successful; otherwise; <see cref="Failure"/>.
+    /// </returns>
+    public override Result Select(Action selector) => this;
+
     /// <summary>
     /// Applies the provided selector function to the value of the current <see cref="Result"/> instance.
     /// </summary>
-    /// <param name="selector">The function to apply to the value of the current <see cref="Result"/> instance.</param>
+    /// <param name="selector">The function to apply to the current <see cref="Result"/> instance.</param>
     /// <typeparam name="TResult">The underlying type of the result produced by the selector function.</typeparam>
     /// <returns>
-    /// Returns a new <see cref="Result{TResult}"/> instance containing the result of the function if the current
-    /// <see cref="Result"/> instance is in a successful state; otherwise, returns the current failed <see cref="Result"/> instance.
+    /// Returns <see cref="Success{T}"/> if the current <see cref="Result"/> is in a successful state, and the action invocation is also successful; otherwise; <see cref="Failure{T}"/>.
     /// </returns>
     public override Result<TResult> Select<TResult>(Func<TResult> selector) => Result<TResult>.Failure(Exception);
 
     /// <summary>
     /// Applies the provided selector function to the value of the current <see cref="Result"/> instance.
     /// </summary>
-    /// <param name="selector">The function to apply to the value of the current <see cref="Result"/> instance.</param>
+    /// <param name="selector">The action to function to the current <see cref="Result"/> instance.</param>
+    /// <returns>
+    /// Returns <see cref="Success"/> if the current <see cref="Result"/> is in a successful state, and the action invocation is also successful; otherwise; <see cref="Failure"/>.
+    /// </returns>
+    public override Result SelectMany(Func<Result> selector) => this;
+
+    /// <summary>
+    /// Applies the provided selector function to the value of the current <see cref="Result"/> instance.
+    /// </summary>
+    /// <param name="selector">The function to apply to the current <see cref="Result"/> instance.</param>
     /// <typeparam name="TResult">The underlying type of the result produced by the selector function.</typeparam>
     /// <returns>
-    /// Returns a new <see cref="Result{TResult}"/> instance containing the result of the function if the current
-    /// <see cref="Result"/> instance is in a successful state; otherwise, returns the current failed <see cref="Result"/> instance.
+    /// Returns <see cref="Success{T}"/> if the current <see cref="Result"/> is in a successful state, and the action invocation is also successful; otherwise; <see cref="Failure{T}"/>.
     /// </returns>
     public override Result<TResult> SelectMany<TResult>(Func<Result<TResult>> selector) => Result<TResult>.Failure(Exception);
 
@@ -224,25 +240,41 @@ public sealed class Failure<T> : Result<T>, IValueEquatable<Failure<T>>
     /// </returns>
     public override TResult Match<TResult>(Func<T, TResult> success, Func<Exception, TResult> failure) => failure(Exception);
 
+    /// <summary>
+    /// Applies the provided selector action to the value of the current <see cref="Result{T}"/> instance.
+    /// </summary>
+    /// <param name="selector">The action to apply to the value of the current <see cref="Result{T}"/> instance.</param>
+    /// <returns>
+    /// Returns <see cref="Success"/> if the current <see cref="Result{T}"/> is in a successful state, and the action invocation is also successful; otherwise; <see cref="Failure"/>.
+    /// </returns>
+    public override Result Select(Action<T> selector) => Result.Failure(Exception);
+
     /// <summary>
     /// Applies the provided selector function to the value of the current <see cref="Result{T}"/> instance.
     /// </summary>
     /// <param name="selector">The function to apply to the value of the current <see cref="Result{T}"/> instance.</param>
     /// <typeparam name="TResult">The underlying type of the result produced by the selector function.</typeparam>
     /// <returns>
-    /// Returns a new <see cref="Result{TResult}"/> instance containing the result of the function if the current
-    /// <see cref="Result{T}"/> instance is in a successful state; otherwise, returns the current failed <see cref="Result{T}"/> instance.
+    /// Returns <see cref="Success{T}"/> if the current <see cref="Result{T}"/> is in a successful state, and the action invocation is also successful; otherwise; <see cref="Failure{T}"/>.
     /// </returns>
     public override Result<TResult> Select<TResult>(Func<T, TResult> selector) => Result<TResult>.Failure(Exception);
 
+    /// <summary>
+    /// Applies the provided selector function to the value of the current <see cref="Result{T}"/> instance.
+    /// </summary>
+    /// <param name="selector">The function to apply to the value of the current <see cref="Result{T}"/> instance.</param>
+    /// <returns>
+    /// Returns <see cref="Success"/> if the current <see cref="Result{T}"/> is in a successful state, and the action invocation is also successful; otherwise; <see cref="Failure"/>.
+    /// </returns>
+    public override Result SelectMany(Func<T, Result> selector) => Result.Failure(Exception);
+
     /// <summary>
     /// Applies the provided selector function to the value of the current <see cref="Result{T}"/> instance.
     /// </summary>
     /// <param name="selector">The function to apply to the value of the current <see cref="Result{T}"/> instance.</param>
     /// <typeparam name="TResult">The underlying type of the result produced by the selector function.</typeparam>
     /// <returns>
-    /// Returns a new <see cref="Result{TResult}"/> instance containing the result of the function if the current
-    /// <see cref="Result{T}"/> instance is in a successful state; otherwise, returns the current failed <see cref="Result{T}"/> instance.
+    /// Returns <see cref="Success{T}"/> if the current <see cref="Result{T}"/> is in a successful state, and the action invocation is also successful; otherwise; <see cref="Failure{T}"/>.
     /// </returns>
     public override Result<TResult> SelectMany<TResult>(Func<T, Result<TResult>> selector) => Result<TResult>.Failure(Exception);