MonadRec implementation for Choice5

nomicflux · jnape · commit ad16a7575a22 · 2019-09-10T15:41:15.000-05:00
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice5.java b/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice5.java
@@ -6,16 +6,20 @@
 import com.jnape.palatable.lambda.adt.hlist.HList;
 import com.jnape.palatable.lambda.adt.hlist.Tuple5;
 import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.recursion.RecursiveResult;
 import com.jnape.palatable.lambda.functions.specialized.Pure;
 import com.jnape.palatable.lambda.functor.Applicative;
 import com.jnape.palatable.lambda.functor.Bifunctor;
 import com.jnape.palatable.lambda.functor.builtin.Lazy;
 import com.jnape.palatable.lambda.monad.Monad;
+import com.jnape.palatable.lambda.monad.MonadRec;
 import com.jnape.palatable.lambda.traversable.Traversable;
 
 import java.util.Objects;
 
 import static com.jnape.palatable.lambda.functions.builtin.fn2.Into5.into5;
+import static com.jnape.palatable.lambda.functions.recursion.RecursiveResult.terminate;
+import static com.jnape.palatable.lambda.functions.recursion.Trampoline.trampoline;
 import static com.jnape.palatable.lambda.functor.builtin.Lazy.lazy;
 
 /**
@@ -31,7 +35,7 @@
  */
 public abstract class Choice5<A, B, C, D, E> implements
         CoProduct5<A, B, C, D, E, Choice5<A, B, C, D, E>>,
-        Monad<E, Choice5<A, B, C, D, ?>>,
+        MonadRec<E, Choice5<A, B, C, D, ?>>,
         Bifunctor<D, E, Choice5<A, B, C, ?, ?>>,
         Traversable<E, Choice5<A, B, C, D, ?>> {
 
@@ -70,7 +74,7 @@ public Choice4<A, B, C, D> converge(Fn1<? super E, ? extends CoProduct4<A, B, C,
      */
     @Override
     public <F> Choice5<A, B, C, D, F> fmap(Fn1<? super E, ? extends F> fn) {
-        return Monad.super.<F>fmap(fn).coerce();
+        return MonadRec.super.<F>fmap(fn).coerce();
     }
 
     /**
@@ -111,7 +115,7 @@ public <F> Choice5<A, B, C, D, F> pure(F f) {
      */
     @Override
     public <F> Choice5<A, B, C, D, F> zip(Applicative<Fn1<? super E, ? extends F>, Choice5<A, B, C, D, ?>> appFn) {
-        return Monad.super.zip(appFn).coerce();
+        return MonadRec.super.zip(appFn).coerce();
     }
 
     /**
@@ -132,15 +136,15 @@ public <F> Lazy<Choice5<A, B, C, D, F>> lazyZip(
      */
     @Override
     public <F> Choice5<A, B, C, D, F> discardL(Applicative<F, Choice5<A, B, C, D, ?>> appB) {
-        return Monad.super.discardL(appB).coerce();
+        return MonadRec.super.discardL(appB).coerce();
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public <F> Choice5<A, B, C, D, E> discardR(Applicative<F, Choice5<A, B, C, D, ?>> appB) {
-        return Monad.super.discardR(appB).coerce();
+        return MonadRec.super.discardR(appB).coerce();
     }
 
     /**
@@ -151,6 +155,23 @@ public <F> Choice5<A, B, C, D, F> flatMap(Fn1<? super E, ? extends Monad<F, Choi
         return match(Choice5::a, Choice5::b, Choice5::c, Choice5::d, e -> f.apply(e).coerce());
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public <F> Choice5<A, B, C, D, F> trampolineM(Fn1<? super E, ? extends MonadRec<RecursiveResult<E, F>, Choice5<A, B, C, D, ?>>> fn) {
+        return match(Choice5::a,
+                     Choice5::b,
+                     Choice5::c,
+                     Choice5::d,
+                     trampoline(e -> fn.apply(e).<Choice5<A, B, C, D, RecursiveResult<E, F>>>coerce().match(
+                                a -> terminate(Choice5.a(a)),
+                                b -> terminate(Choice5.b(b)),
+                                c -> terminate(Choice5.c(c)),
+                                d -> terminate(Choice5.d(d)),
+                                eRec -> eRec.fmap(Choice5::e))));
+    }
+
     /**
      * {@inheritDoc}
      */
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/choice/Choice5Test.java b/src/test/java/com/jnape/palatable/lambda/adt/choice/Choice5Test.java
@@ -6,17 +6,9 @@
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
-import testsupport.traits.ApplicativeLaws;
-import testsupport.traits.BifunctorLaws;
-import testsupport.traits.FunctorLaws;
-import testsupport.traits.MonadLaws;
-import testsupport.traits.TraversableLaws;
+import testsupport.traits.*;
 
-import static com.jnape.palatable.lambda.adt.choice.Choice5.a;
-import static com.jnape.palatable.lambda.adt.choice.Choice5.b;
-import static com.jnape.palatable.lambda.adt.choice.Choice5.c;
-import static com.jnape.palatable.lambda.adt.choice.Choice5.d;
-import static com.jnape.palatable.lambda.adt.choice.Choice5.e;
+import static com.jnape.palatable.lambda.adt.choice.Choice5.*;
 import static com.jnape.palatable.lambda.functor.builtin.Lazy.lazy;
 import static com.jnape.palatable.traitor.framework.Subjects.subjects;
 import static org.junit.Assert.assertEquals;
@@ -39,7 +31,12 @@ public void setUp() {
         e = e('z');
     }
 
-    @TestTraits({FunctorLaws.class, ApplicativeLaws.class, MonadLaws.class, BifunctorLaws.class, TraversableLaws.class})
+    @TestTraits({FunctorLaws.class,
+                 ApplicativeLaws.class,
+                 MonadLaws.class,
+                 BifunctorLaws.class,
+                 TraversableLaws.class,
+                 MonadRecLaws.class})
     public Subjects<Choice5<String, Integer, Boolean, Character, Double>> testSubjects() {
         return subjects(Choice5.a("foo"), Choice5.b(1), Choice5.c(true), Choice5.d('a'), Choice5.e(2d));
     }
