Add Maybe.match(Consumer,Runnable)

src/main/java/net/kemitix/mon/maybe/Just.java

@@ -98,6 +98,11 @@ final class Just<T> implements Maybe<T> {
         // ignore - not nothing
     }
 
+    @Override
+    public void match(final Consumer<T> justMatcher, final Runnable nothingMatcher) {
+        justMatcher.accept(value);
+    }
+
     @Override
     public void orElseThrow(final Supplier<Exception> e) {
         // do not throw

src/main/java/net/kemitix/mon/maybe/Maybe.java

@@ -149,4 +149,12 @@ public interface Maybe<T> extends Functor<T, Maybe<?>> {
      * @param runnable the runnable to call if this is a Nothing
      */
     void ifNothing(Runnable runnable);
+
+    /**
+     * Matches the Maybe, either just or nothing, and performs either the Consumer, for Just, or Runnable for nothing.
+     *
+     * @param justMatcher    the Consumer to pass the value of a Just to
+     * @param nothingMatcher the Runnable to call if the Maybe is a Nothing
+     */
+    void match(Consumer<T> justMatcher, Runnable nothingMatcher);
 }

src/main/java/net/kemitix/mon/maybe/Nothing.java

@@ -34,6 +34,7 @@ import java.util.stream.Stream;
  * @param <T> the type of the missing content
  * @author Paul Campbell (pcampbell@kemitix.net)
  */
+@SuppressWarnings("methodcount")
 final class Nothing<T> implements Maybe<T> {
 
     static final Maybe<?> INSTANCE = new Nothing<>();
@@ -79,6 +80,11 @@ final class Nothing<T> implements Maybe<T> {
         runnable.run();
     }
 
+    @Override
+    public void match(final Consumer<T> justMatcher, final Runnable nothingMatcher) {
+        nothingMatcher.run();
+    }
+
     @Override
     public void orElseThrow(final Supplier<Exception> e) throws Exception {
         throw e.get();

src/test/java/net/kemitix/mon/MaybeTest.java

@@ -22,7 +22,7 @@ public class MaybeTest implements WithAssertions {
     @Test
     public void justMustBeNonNull() {
         assertThatNullPointerException().isThrownBy(() -> just(null))
-                                        .withMessageContaining("value");
+                .withMessageContaining("value");
     }
 
     @Test
@@ -84,7 +84,7 @@ public class MaybeTest implements WithAssertions {
     public void toOptional() {
         assertThat(just(1).toOptional()).isEqualTo(Optional.of(1));
         assertThat(nothing()
-                        .toOptional()).isEqualTo(Optional.empty());
+                .toOptional()).isEqualTo(Optional.empty());
     }
 
     @Test
@@ -194,4 +194,29 @@ public class MaybeTest implements WithAssertions {
         assertThat(capture).isTrue();
     }
 
+    @Test
+    public void just_whenMatch_thenJustTriggers() {
+        //given
+        final Maybe<Integer> maybe = Maybe.just(1);
+        //then
+        maybe.match(
+                just -> assertThat(just).isEqualTo(1),
+                () -> fail("Not nothing")
+        );
+    }
+
+    @Test
+    public void nothing_whenMatch_thenNothingTriggers() {
+        //given
+        final Maybe<Integer> maybe = Maybe.nothing();
+        final AtomicBoolean flag = new AtomicBoolean(false);
+        //when
+        maybe.match(
+                just -> fail("Not a just"),
+                () -> flag.set(true)
+        );
+        //then
+        assertThat(flag).isTrue();
+    }
+
 }