Maybe is now a coproduct of Unit and A

jnape · jnape · commit d6ac5bb7c706 · 2018-10-21T17:16:30.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -15,7 +15,8 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - monoid folding now implicitly starts with the identity, regardless of iterable population
 - `Concat` monoid can now fold infinite iterables
 - all `Function<? super XXX, Boolean>` are now `Function<? super XXX, ? extends Boolean>` for better compatibility  
-- `Either#diverge` returns a `Choice3`  
+- `Either#diverge` returns a `Choice3`
+- `Maybe` is now a `CoProduct2` of `Unit` and `A`  
 
 ### Added
 - `Predicate#predicate` static factory method
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/Maybe.java b/src/main/java/com/jnape/palatable/lambda/adt/Maybe.java
@@ -1,5 +1,10 @@
 package com.jnape.palatable.lambda.adt;
 
+import com.jnape.palatable.lambda.adt.choice.Choice2;
+import com.jnape.palatable.lambda.adt.choice.Choice3;
+import com.jnape.palatable.lambda.adt.coproduct.CoProduct2;
+import com.jnape.palatable.lambda.adt.hlist.HList;
+import com.jnape.palatable.lambda.adt.hlist.Tuple2;
 import com.jnape.palatable.lambda.functions.builtin.fn2.Peek;
 import com.jnape.palatable.lambda.functions.specialized.checked.CheckedSupplier;
 import com.jnape.palatable.lambda.functor.Applicative;
@@ -14,6 +19,9 @@
 import java.util.function.Supplier;
 
 import static com.jnape.palatable.lambda.adt.Either.left;
+import static com.jnape.palatable.lambda.adt.Unit.UNIT;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
 
 /**
  * The optional type, representing a potentially absent value. This is lambda's analog of {@link Optional}, supporting
@@ -22,7 +30,8 @@
  * @param <A> the optional parameter type
  * @see Optional
  */
-public abstract class Maybe<A> implements Monad<A, Maybe>, Traversable<A, Maybe> {
+public abstract class Maybe<A> implements CoProduct2<Unit, A, Maybe<A>>, Monad<A, Maybe>, Traversable<A, Maybe> {
+
     private Maybe() {
     }
 
@@ -32,7 +41,9 @@ private Maybe() {
      * @param otherSupplier the supplier for the other value
      * @return this value, or the supplied other value
      */
-    public abstract A orElseGet(Supplier<A> otherSupplier);
+    public final A orElseGet(Supplier<A> otherSupplier) {
+        return match(__ -> otherSupplier.get(), id());
+    }
 
     /**
      * If the value is present, return it; otherwise, return <code>other</code>.
@@ -130,7 +141,24 @@ public final <B> Maybe<A> discardR(Applicative<B, Maybe> appB) {
     }
 
     @Override
-    public abstract <B> Maybe<B> flatMap(Function<? super A, ? extends Monad<B, Maybe>> f);
+    public final <B> Maybe<B> flatMap(Function<? super A, ? extends Monad<B, Maybe>> f) {
+        return match(constantly(nothing()), f.andThen(Applicative::coerce));
+    }
+
+    @Override
+    public <B> Choice3<Unit, A, B> diverge() {
+        return match(Choice3::a, Choice3::b);
+    }
+
+    @Override
+    public Tuple2<Maybe<Unit>, Maybe<A>> project() {
+        return CoProduct2.super.project().into(HList::tuple);
+    }
+
+    @Override
+    public Choice2<A, Unit> invert() {
+        return match(Choice2::b, Choice2::a);
+    }
 
     /**
      * If this value is present, accept it by <code>consumer</code>; otherwise, do nothing.
@@ -142,6 +170,14 @@ public final Maybe<A> peek(Consumer<A> consumer) {
         return Peek.peek(consumer, this);
     }
 
+    @Override
+    @SuppressWarnings("unchecked")
+    public final <B, App extends Applicative, TravB extends Traversable<B, Maybe>, AppB extends Applicative<B, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
+            Function<? super A, ? extends AppB> fn,
+            Function<? super TravB, ? extends AppTrav> pure) {
+        return match(__ -> pure.apply((TravB) Maybe.<B>nothing()), a -> (AppTrav) fn.apply(a).fmap(Maybe::just));
+    }
+
     /**
      * Convenience static factory method for creating a {@link Maybe} from an {@link Either}. If <code>either</code> is
      * a right value, wrap the value in a <code>just</code> and return it; otherwise, return {@link #nothing()}.
@@ -192,80 +228,60 @@ public static <A> Maybe<A> just(A a) {
         return new Just<>(a);
     }
 
+    /**
+     * Return nothing.
+     *
+     * @param <A> the type of the value, if there was one
+     * @return nothing
+     */
     @SuppressWarnings("unchecked")
     public static <A> Maybe<A> nothing() {
         return Nothing.INSTANCE;
     }
 
-    private static final class Just<A> extends Maybe<A> {
-
-        private final A a;
-
-        private Just(A a) {
-            this.a = a;
-        }
-
-        @Override
-        public A orElseGet(Supplier<A> otherSupplier) {
-            return a;
-        }
-
-        @Override
-        public <B> Maybe<B> flatMap(Function<? super A, ? extends Monad<B, Maybe>> f) {
-            return f.apply(a).coerce();
-        }
-
-        @Override
-        @SuppressWarnings("unchecked")
-        public <B, App extends Applicative, TravB extends Traversable<B, Maybe>,
-                AppB extends Applicative<B, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
-                Function<? super A, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
-            return fn.apply(a).fmap(Just::new).<TravB>fmap(Applicative::coerce).coerce();
-        }
+    private static final class Nothing<A> extends Maybe<A> {
+        private static final Nothing INSTANCE = new Nothing();
 
-        @Override
-        public boolean equals(Object other) {
-            return other instanceof Just && Objects.equals(this.a, ((Just) other).a);
+        private Nothing() {
         }
 
         @Override
-        public int hashCode() {
-            return Objects.hash(a);
+        public <R> R match(Function<? super Unit, ? extends R> aFn, Function<? super A, ? extends R> bFn) {
+            return aFn.apply(UNIT);
         }
 
         @Override
         public String toString() {
-            return "Just " + a;
+            return "Nothing";
         }
     }
 
-    private static final class Nothing<A> extends Maybe<A> {
-        private static final Nothing INSTANCE = new Nothing();
+    private static final class Just<A> extends Maybe<A> {
 
-        private Nothing() {
+        private final A a;
+
+        private Just(A a) {
+            this.a = a;
         }
 
         @Override
-        @SuppressWarnings("unchecked")
-        public <B> Maybe<B> flatMap(Function<? super A, ? extends Monad<B, Maybe>> f) {
-            return nothing();
+        public <R> R match(Function<? super Unit, ? extends R> aFn, Function<? super A, ? extends R> bFn) {
+            return bFn.apply(a);
         }
 
         @Override
-        @SuppressWarnings("unchecked")
-        public <B, App extends Applicative, TravB extends Traversable<B, Maybe>, AppB extends Applicative<B, App>, AppTrav extends Applicative<TravB, App>> AppTrav traverse(
-                Function<? super A, ? extends AppB> fn, Function<? super TravB, ? extends AppTrav> pure) {
-            return pure.apply((TravB) nothing());
+        public boolean equals(Object other) {
+            return other instanceof Just && Objects.equals(this.a, ((Just) other).a);
         }
 
         @Override
-        public A orElseGet(Supplier<A> otherSupplier) {
-            return otherSupplier.get();
+        public int hashCode() {
+            return Objects.hash(a);
         }
 
         @Override
         public String toString() {
-            return "Nothing";
+            return "Just " + a;
         }
     }
 }
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/MaybeTest.java b/src/test/java/com/jnape/palatable/lambda/adt/MaybeTest.java
@@ -1,5 +1,7 @@
 package com.jnape.palatable.lambda.adt;
 
+import com.jnape.palatable.lambda.adt.choice.Choice2;
+import com.jnape.palatable.lambda.adt.choice.Choice3;
 import com.jnape.palatable.traitor.annotations.TestTraits;
 import com.jnape.palatable.traitor.framework.Subjects;
 import com.jnape.palatable.traitor.runners.Traits;
@@ -17,6 +19,8 @@
 import static com.jnape.palatable.lambda.adt.Either.right;
 import static com.jnape.palatable.lambda.adt.Maybe.just;
 import static com.jnape.palatable.lambda.adt.Maybe.nothing;
+import static com.jnape.palatable.lambda.adt.Unit.UNIT;
+import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
 import static com.jnape.palatable.lambda.functions.builtin.fn2.Eq.eq;
 import static com.jnape.palatable.traitor.framework.Subjects.subjects;
 import static org.junit.Assert.assertEquals;
@@ -108,4 +112,22 @@ public void justOrThrow() {
     public void nothingOrThrow() {
         nothing().orElseThrow(IllegalStateException::new);
     }
+
+    @Test
+    public void divergesIntoChoice3() {
+        assertEquals(Choice3.a(UNIT), nothing().diverge());
+        assertEquals(Choice3.b(1), just(1).diverge());
+    }
+
+    @Test
+    public void projectsIntoTuple2() {
+        assertEquals(tuple(just(UNIT), nothing()), nothing().project());
+        assertEquals(tuple(nothing(), just(1)), just(1).project());
+    }
+
+    @Test
+    public void invertsIntoChoice2() {
+        assertEquals(Choice2.b(UNIT), nothing().invert());
+        assertEquals(Choice2.a(1), just(1).invert());
+    }
 }
