Implement void Match; closes #23

true-myth · Jan 9, 2019 · 0ace247 · 0ace247
1 parent 5f71bff
commit 0ace247
Show file tree

Hide file tree

Showing 5 changed files with 60 additions and 0 deletions.
diff --git a/src/TrueMyth/Maybe.cs b/src/TrueMyth/Maybe.cs
@@ -302,6 +302,21 @@ private Maybe(TValue value)
         /// </example>
         public UValue Match<UValue>(Func<TValue,UValue> just, Func<UValue> nothing) => this._isJust ? just(this._value) : nothing();
 
+        /// <summary>
+        /// Provides a similar functionality as <see cref="Match{UValue}(Func{TValue,UValue}, Func{UValue})"/>, but without return types.
+        /// </summary>
+        public void Match(Action<TValue> just, Action nothing) 
+        {
+            if (this._isJust)
+            {
+                just(this._value);
+            }
+            else
+            {
+                nothing();
+            }
+        }
+
         /// <summary>
         /// Static factory method for creation of new <b>Just</b> <c>Maybe&lt;TValue&gt;</c>s.  If <c>value</c> is a 
         /// reference type and is <c>null</c>, this returns a <b>Nothing</b>.

diff --git a/src/TrueMyth/Result.cs b/src/TrueMyth/Result.cs
@@ -392,6 +392,21 @@ public Result<TValue, UError> MapErr<UError>(Func<TError,UError> mapFn) => !this
         /// </example>
         public T Match<T>(Func<TValue,T> ok, Func<TError,T> err) => this._isOk ? ok(this._value) : err(this._error);
 
+        /// <summary>
+        /// Provides similar functionality as <see cref="Match{T}(Func{TValue,T}, Func{TError,T})"/>, but with no return type.
+        /// </summary>
+        public void Match(Action<TValue> ok, Action<TError> err) 
+        {
+            if (this.IsOk)
+            {
+                ok(this._value);
+            }
+            else
+            {
+                err(this._error);
+            }
+        }
+
         /// <summary>
         /// Provide a fallback for a given <c>Result</c>. Behaves like a logical or: if the result value is an Ok, returns that result; otherwise, 
         /// returns the <c>defaultResult</c> value.

diff --git a/test/TrueMyth.Test/MaybeTests.cs b/test/TrueMyth.Test/MaybeTests.cs
@@ -184,6 +184,20 @@ public void Match_Theory(Maybe<int> m1)
             if (m1.IsNothing) Assert.Equal(2, result);
         }
 
+        [Theory]
+        [MemberData(nameof(GetEqualityTheoryData1Param))]
+        public void Match_Void_Theory(Maybe<int> m1)
+        {
+            m1.Match(
+                just: _ => {
+                    Assert.True(m1.IsJust);
+                },
+                nothing: () => {
+                    Assert.True(m1.IsNothing);
+                }
+            );
+        }
+
         [Theory]
         [MemberData(nameof(GetOrTheoryData))]
         public void Or_Theory(Maybe<int> m1, Maybe<int> m2, Maybe<int> expectation)

diff --git a/test/TrueMyth.Test/ResultTests.MemberData.cs b/test/TrueMyth.Test/ResultTests.MemberData.cs
@@ -28,5 +28,11 @@ public static IEnumerable<object[]> GetToStringTests()
             yield return new object[] { SimpleResult.Ok(7), $"Ok<{7.GetType().Name}>[7]"};
             yield return new object[] { SimpleResult.Err("error"), $"Err<{"error".GetType().Name}>[error]"};
         }
+
+        public static IEnumerable<object[]> GetResultTheoryData1()
+        {
+            yield return new object[] { SimpleResult.Ok(7) };
+            yield return new object[] { SimpleResult.Err("test") };
+        }
     }
 }
diff --git a/test/TrueMyth.Test/ResultTests.cs b/test/TrueMyth.Test/ResultTests.cs
@@ -164,6 +164,16 @@ public void Match_OkCallsOk_Ok()
             Assert.Equal("ok", functionCalled);
         }
 
+        [Theory]
+        [MemberData(nameof(GetResultTheoryData1))]
+        public void Match_Void_Theory(SimpleResult r)
+        {
+            r.Match(
+                ok: _ => Assert.True(r.IsOk),
+                err: _ => Assert.True(r.IsErr)
+            );
+        }
+
         // Or
         [Fact]
         public void Or_OkReturnsThis_Ok()