MonadRec implementation for Choice2

gshakhn · jnape · commit 83ed2c608fb2 · 2019-09-10T15:41:15.000-05:00
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice2.java b/src/main/java/com/jnape/palatable/lambda/adt/choice/Choice2.java
@@ -6,17 +6,21 @@
 import com.jnape.palatable.lambda.adt.hlist.HList;
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
 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.Functor;
 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.Into.into;
+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;
 
 /**
@@ -30,7 +34,7 @@
  */
 public abstract class Choice2<A, B> implements
         CoProduct2<A, B, Choice2<A, B>>,
-        Monad<B, Choice2<A, ?>>,
+        MonadRec<B, Choice2<A, ?>>,
         Bifunctor<A, B, Choice2<?, ?>>,
         Traversable<B, Choice2<A, ?>> {
 
@@ -68,7 +72,7 @@ public Choice2<B, A> invert() {
      */
     @Override
     public final <C> Choice2<A, C> fmap(Fn1<? super B, ? extends C> fn) {
-        return Monad.super.<C>fmap(fn).coerce();
+        return MonadRec.super.<C>fmap(fn).coerce();
     }
 
     /**
@@ -109,14 +113,14 @@ public <C> Choice2<A, C> pure(C c) {
      */
     @Override
     public <C> Choice2<A, C> zip(Applicative<Fn1<? super B, ? extends C>, Choice2<A, ?>> appFn) {
-        return Monad.super.zip(appFn).coerce();
+        return MonadRec.super.zip(appFn).coerce();
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public <C> Lazy<? extends Monad<C, Choice2<A, ?>>> lazyZip(
+    public <C> Lazy<Choice2<A, C>> lazyZip(
             Lazy<? extends Applicative<Fn1<? super B, ? extends C>, Choice2<A, ?>>> lazyAppFn) {
         return match(a -> lazy(a(a)),
                      b -> lazyAppFn.fmap(choiceF -> choiceF.<C>fmap(f -> f.apply(b)).coerce()));
@@ -127,15 +131,15 @@ public <C> Choice2<A, C> zip(Applicative<Fn1<? super B, ? extends C>, Choice2<A,
      */
     @Override
     public <C> Choice2<A, C> discardL(Applicative<C, Choice2<A, ?>> appB) {
-        return Monad.super.discardL(appB).coerce();
+        return MonadRec.super.discardL(appB).coerce();
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public <C> Choice2<A, B> discardR(Applicative<C, Choice2<A, ?>> appB) {
-        return Monad.super.discardR(appB).coerce();
+        return MonadRec.super.discardR(appB).coerce();
     }
 
     /**
@@ -146,6 +150,15 @@ public final <C> Choice2<A, C> flatMap(Fn1<? super B, ? extends Monad<C, Choice2
         return match(Choice2::a, b -> f.apply(b).coerce());
     }
 
+    @Override
+    public <C> Choice2<A, C> trampolineM(Fn1<? super B, ? extends MonadRec<RecursiveResult<B, C>, Choice2<A, ?>>> fn) {
+        return match(Choice2::a,
+                trampoline(b -> fn.apply(b)
+                        .<Choice2<A, RecursiveResult<B, C>>>coerce()
+                        .match(a -> terminate(a(a)),
+                                bOrC -> bOrC.fmap(Choice2::b))));
+    }
+
     /**
      * {@inheritDoc}
      */
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/choice/Choice2Test.java b/src/test/java/com/jnape/palatable/lambda/adt/choice/Choice2Test.java
@@ -6,11 +6,7 @@
 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.Choice2.a;
 import static com.jnape.palatable.lambda.adt.choice.Choice2.b;
@@ -30,15 +26,20 @@ public void setUp() {
         b = b(true);
     }
 
-    @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<Choice2<String, Integer>> testSubjects() {
         return subjects(a("foo"), b(1));
     }
 
     @Test
     public void divergeStaysInChoice() {
-        assertEquals(Choice3.a(1), a.diverge());
-        assertEquals(Choice3.b(true), b.diverge());
+        assertEquals(Choice3.<Integer, Boolean, Object>a(1), a.diverge());
+        assertEquals(Choice3.<Integer, Boolean, Object>b(true), b.diverge());
     }
 
     @Test
