From b17b2177e6c0fe4afa18e0ada5771d706fe0bb9d Mon Sep 17 00:00:00 2001
From: Gregory Dunn <44067421+beyondunn@users.noreply.github.com>
Date: Sat, 1 May 2021 21:21:35 -0300
Subject: [PATCH] Add Result.MapOr extension and unit tests for it. (#44)

* Add Result.MapOr extension and unit tests for it.

* Remove extra newline

* Adjust method comment
---
 .../Extensions/ResultMapping_Test.cs          | 19 ++++++++++++++-
 .../Extensions/ResultMappingExtensions.cs     | 24 +++++++++++++++----
 2 files changed, 38 insertions(+), 5 deletions(-)

diff --git a/wimm.Secundatives.UnitTests/Extensions/ResultMapping_Test.cs b/wimm.Secundatives.UnitTests/Extensions/ResultMapping_Test.cs
index f42db91..3911ade 100644
--- a/wimm.Secundatives.UnitTests/Extensions/ResultMapping_Test.cs
+++ b/wimm.Secundatives.UnitTests/Extensions/ResultMapping_Test.cs
@@ -153,7 +153,6 @@ public async Task MapErrorTask_IsErrorAndFuncReturnsValue_ReturnsResultOfFunc()
             Assert.Equal(OtherError.OtherSadness, res.Error);
         }
 
-
         [Fact]
         public async Task MapErrorTask_IsSuccessAndFuncReturnsValue_ReturnsValue()
         {
@@ -163,6 +162,24 @@ public async Task MapErrorTask_IsSuccessAndFuncReturnsValue_ReturnsValue()
             Assert.Equal("doot", res.Value);
         }
 
+        [Fact]
+        public void MapOr_IsSuccess_ReturnsResultOfFunc()
+        {
+            var underTest = ConstructWith(1);
+            var res = underTest.MapOr(_ => "deet", _ => OtherError.OtherSadness.ToString());
+
+            Assert.Equal("deet", res);
+        }
+
+
+        [Fact]
+        public void MapOr_IsError_ReturnsResultOfErrorFunc()
+        {
+            var underTest = new Result<string, TestError>(TestError.Sadness);
+            var res = underTest.MapOr(_ => "deet", _ => OtherError.OtherSadness.ToString());
+
+            Assert.Equal(OtherError.OtherSadness.ToString(), res);
+        }
 
         private Result<T, TestError> ConstructWith<T>(T value)
         {
diff --git a/wimm.Secundatives/Extensions/ResultMappingExtensions.cs b/wimm.Secundatives/Extensions/ResultMappingExtensions.cs
index 7f2958c..dced3c5 100644
--- a/wimm.Secundatives/Extensions/ResultMappingExtensions.cs
+++ b/wimm.Secundatives/Extensions/ResultMappingExtensions.cs
@@ -1,7 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Threading.Tasks;
 
 namespace wimm.Secundatives
@@ -125,7 +122,7 @@ public static async Task<Result<U, TError>> Map<T, U, TError>(this Result<T, TEr
             return result.Error;
         }
 
-        
+
         /// <summary>
         /// Asynchronously transforms a <see cref="Result{T, TError}"/> into a <see cref="Result{U, TError}"/> by applying an async function and collapsing
         /// the result if the mapped  <see cref="Result{T, TError}"/> containts a value otherwise by constructing a new 
@@ -197,5 +194,24 @@ public static async Task<Result<T, UError>> MapError<T, TError, UError>(this Tas
             return val.MapError(func);
         }
 
+        /// <summary>
+        /// Transforms a <see cref="Result{T, TError}"/> into a <typeparamref name="U"/> by applying a function if the mapped
+        /// <see cref="Result{T, TError}"/> containts a value, otherwise by applying a function to the 
+        /// <typeparamref name="TError"/> contained within <paramref name="result"/>
+        /// </summary>
+        /// <typeparam name="T"> The success type of the initial result </typeparam>
+        /// <typeparam name="U"> The type that <paramref name="result"/>'s value and error are transformed to by
+        /// <paramref name="valueFunc"/> and <paramref name="errorFunc"/> </typeparam>
+        /// <typeparam name="TError"> The error type of the result </typeparam>
+        /// <param name="result"> A <see cref="Result{T, TError}"/> whose state determines which function is applied </param>
+        /// <param name="valueFunc"> The function that will transform <paramref name="result"/>'s <typeparamref name="T"/> if it exists</param>
+        /// <param name="errorFunc"> The function that will transform <paramref name="result"/>'s <typeparamref name="TError"/> if it exists</param>
+        /// <returns> A <typeparamref name="U"/> that is returned by calling <paramref name="valueFunc"/> on the value of <paramref
+        /// name="result"/> or by calling <paramref name="errorFunc"/> on the error from <paramref name="result"/>
+        /// </returns>
+        public static U MapOr<T, U, TError>(this Result<T, TError> result, Func<T, U> valueFunc, Func<TError, U> errorFunc)
+        {
+            return result.IsValue ? valueFunc(result.Value) : errorFunc(result.Error);
+        }
     }
 }