From 5d39be36ff72bc8efd013acea06eacbe61a7ea99 Mon Sep 17 00:00:00 2001
From: Paul Campbell <pcampbell@kemitix.net>
Date: Mon, 25 Jun 2018 22:35:31 +0100
Subject: [PATCH] Maybe satisfies the three Monad Laws

---
 README.md                                     |  2 +
 src/main/java/net/kemitix/mon/maybe/Just.java |  5 +++
 .../java/net/kemitix/mon/maybe/Maybe.java     |  9 ++++
 .../java/net/kemitix/mon/maybe/Nothing.java   |  5 +++
 .../java/net/kemitix/mon/MaybeMonadTest.java  | 39 +++++++++++++++++
 src/test/java/net/kemitix/mon/MaybeTest.java  | 43 +++++++++++++++++++
 6 files changed, 103 insertions(+)
 create mode 100644 src/test/java/net/kemitix/mon/MaybeMonadTest.java

diff --git a/README.md b/README.md
index 5036111..337b0b2 100644
--- a/README.md
+++ b/README.md
@@ -55,6 +55,8 @@ class Example {
 
 ### Maybe
 
+A Monad.
+
 A non-final substitute for Optional with `peek()` and `stream()` methods.
 
 ```java
diff --git a/src/main/java/net/kemitix/mon/maybe/Just.java b/src/main/java/net/kemitix/mon/maybe/Just.java
index 449e523..f801bde 100644
--- a/src/main/java/net/kemitix/mon/maybe/Just.java
+++ b/src/main/java/net/kemitix/mon/maybe/Just.java
@@ -43,6 +43,11 @@ final class Just<T> implements Maybe<T> {
 
     private final T value;
 
+    @Override
+    public <R> Maybe<R> flatMap(Function<T, Maybe<R>> f) {
+        return f.apply(value);
+    }
+
     @Override
     public <R> Maybe<R> map(final Function<T, R> f) {
         return new Just<>(f.apply(value));
diff --git a/src/main/java/net/kemitix/mon/maybe/Maybe.java b/src/main/java/net/kemitix/mon/maybe/Maybe.java
index bcbf64a..0f87840 100644
--- a/src/main/java/net/kemitix/mon/maybe/Maybe.java
+++ b/src/main/java/net/kemitix/mon/maybe/Maybe.java
@@ -76,6 +76,15 @@ public interface Maybe<T> extends Functor<T, Maybe<?>> {
         return new Just<>(value);
     }
 
+    /**
+     * Monad binder maps the Maybe into another Maybe using the binder method f.
+     *
+     * @param f   the mapper function
+     * @param <R> the type of the value in the final maybe
+     * @return a Maybe with the mapped value
+     */
+    <R> Maybe<R> flatMap(Function<T, Maybe<R>> f);
+
     @Override
     <R> Maybe<R> map(Function<T, R> f);
 
diff --git a/src/main/java/net/kemitix/mon/maybe/Nothing.java b/src/main/java/net/kemitix/mon/maybe/Nothing.java
index c90beb5..7a72d46 100644
--- a/src/main/java/net/kemitix/mon/maybe/Nothing.java
+++ b/src/main/java/net/kemitix/mon/maybe/Nothing.java
@@ -38,6 +38,11 @@ final class Nothing<T> implements Maybe<T> {
 
     static final Maybe<?> INSTANCE = new Nothing<>();
 
+    @Override
+    public <R> Maybe<R> flatMap(Function<T, Maybe<R>> f) {
+        return Maybe.nothing();
+    }
+
     @Override
     @SuppressWarnings("unchecked")
     public <R> Maybe<R> map(final Function<T, R> f) {
diff --git a/src/test/java/net/kemitix/mon/MaybeMonadTest.java b/src/test/java/net/kemitix/mon/MaybeMonadTest.java
new file mode 100644
index 0000000..28e9e8b
--- /dev/null
+++ b/src/test/java/net/kemitix/mon/MaybeMonadTest.java
@@ -0,0 +1,39 @@
+package net.kemitix.mon;
+
+import net.kemitix.mon.maybe.Maybe;
+import org.assertj.core.api.WithAssertions;
+import org.junit.Test;
+
+import java.util.function.Function;
+
+public class MaybeMonadTest implements WithAssertions {
+
+    @Test
+    public void leftIdentity() {
+        //given
+        final int value = 1;
+        final Maybe<Integer> maybe = Maybe.maybe(value);
+        final Function<Integer, Maybe<Integer>> f = i -> Maybe.maybe(i * 2);
+        //then
+        assertThat(maybe.flatMap(f)).isEqualTo(f.apply(value));
+    }
+
+    @Test
+    public void rightIdentity() {
+        //given
+        final Maybe<Integer> maybe = Maybe.maybe(1);
+        //then
+        assertThat(maybe.flatMap(Maybe::maybe)).isEqualTo(maybe);
+    }
+
+    @Test
+    public void associativity() {
+        //given
+        final Maybe<Integer> maybe = Maybe.maybe(1);
+        final Function<Integer, Maybe<Integer>> f = i -> Maybe.maybe(i * 2);
+        final Function<Integer, Maybe<Integer>> g = i -> Maybe.maybe(i + 6);
+        //then
+        assertThat(maybe.flatMap(f).flatMap(g)).isEqualTo(maybe.flatMap(x -> f.apply(x).flatMap(g)));
+    }
+
+}
diff --git a/src/test/java/net/kemitix/mon/MaybeTest.java b/src/test/java/net/kemitix/mon/MaybeTest.java
index 12ec238..61941ee 100644
--- a/src/test/java/net/kemitix/mon/MaybeTest.java
+++ b/src/test/java/net/kemitix/mon/MaybeTest.java
@@ -123,4 +123,47 @@ public class MaybeTest implements WithAssertions {
         //then
         assertThat(stream).isEmpty();
     }
+
+    @Test
+    public void justFlatMap() {
+        //given
+        final Maybe<Integer> just1 = Maybe.just(1);
+        final Maybe<Integer> just2 = Maybe.just(2);
+        //when
+        final Maybe<Integer> result = just1.flatMap(v1 ->
+                just2.flatMap(v2 ->
+                        Maybe.maybe(v1 + v2)
+                ));
+        //then
+        assertThat(result.toOptional()).contains(3);
+    }
+
+    @Test
+    public void nothingFlatMap() {
+        //given
+        final Maybe<Integer> nothing1 = Maybe.nothing();
+        final Maybe<Integer> nothing2 = Maybe.nothing();
+        //when
+        final Maybe<Integer> result = nothing1.flatMap(v1 ->
+                nothing2.flatMap(v2 ->
+                        Maybe.maybe(v1 + v2)
+                ));
+        //then
+        assertThat(result.toOptional()).isEmpty();
+    }
+
+    @Test
+    public void justNothingFlatMap() {
+        //given
+        final Maybe<Integer> just1 = Maybe.just(1);
+        final Maybe<Integer> nothing2 = Maybe.nothing();
+        //when
+        final Maybe<Integer> result = just1.flatMap(v1 ->
+                nothing2.flatMap(v2 ->
+                        Maybe.maybe(v1 + v2)
+                ));
+        //then
+        assertThat(result.toOptional()).isEmpty();
+    }
+
 }