Add Maybe.or(Supplier<Maybe>)

Like a flatMap for the negative case.

CHANGELOG

@@ -4,6 +4,7 @@ CHANGELOG
 0.12.0
 ------
 
+* Add Maybe.or(Supplier<Maybe>)
 * Add Result.reduce(Result,BinaryOperator)
 * Rename Result.invert() as Result.swap()
 * [admin] pom: update urls to github

README.org

@@ -444,6 +444,16 @@
      #+END_SRC
 
 
+**** =T or(Supplier<Maybe<T> alternative)=
+
+     Provide an alternative Maybe to use when Maybe is Nothing.
+
+     #+BEGIN_SRC java
+     final Maybe<Integer> value = Maybe.maybe(getValue())
+                                       .or(() -> Maybe.just(defaultValue));
+     #+END_SRC
+
+
 **** =void orElseThrow(Supplier<Exception> error)=
 
      Throw the exception if the Maybe is a Nothing.

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

@@ -118,6 +118,11 @@ final class Just<T> implements Maybe<T> {
         justMatcher.accept(value);
     }
 
+    @Override
+    public Maybe<T> or(final Supplier<Maybe<T>> alternative) {
+        return this;
+    }
+
     @Override
     public Stream<T> stream() {
         return Stream.of(value);

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

@@ -177,4 +177,13 @@ public interface Maybe<T> extends Functor<T, Maybe<?>> {
      * @param nothingMatcher the Runnable to call if the Maybe is a Nothing
      */
     void match(Consumer<T> justMatcher, Runnable nothingMatcher);
+
+    /**
+     * Maps the Maybe into another Maybe only when it is nothing.
+     *
+     * @param alternative the maybe to map the nothing into
+     *
+     * @return the original Maybe if not nothing, or the alternative
+     */
+    Maybe<T> or(Supplier<Maybe<T>> alternative);
 }

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

@@ -100,6 +100,11 @@ final class Nothing<T> implements Maybe<T> {
         nothingMatcher.run();
     }
 
+    @Override
+    public Maybe<T> or(final Supplier<Maybe<T>> alternative) {
+        return alternative.get();
+    }
+
     @Override
     public Stream<T> stream() {
         return Stream.empty();

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

@@ -292,4 +292,23 @@ public class MaybeTest implements WithAssertions {
         assertThat(isNothing).isTrue();
     }
 
+    @Test
+    public void just_or_ignoreTheAlternative() {
+        //given
+        final Maybe<String> one = Maybe.just("one");
+        //when
+        final Maybe<String> result = one.or(() -> Maybe.just("two"));
+        //then
+        assertThat(result.toOptional()).contains("one");
+    }
+
+    @Test
+    public void nothing_or_isTheAlternative() {
+        //given
+        final Maybe<String> one = Maybe.nothing();
+        //when
+        final Maybe<String> result = one.or(() -> Maybe.just("two"));
+        //then
+        assertThat(result.toOptional()).contains("two");
+    }
 }