RecursiveResult is now MonadRec

jnape · jnape · commit 5dd1fad7ee4c · 2019-09-16T15:13:03.000-05:00
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/recursion/RecursiveResult.java b/src/main/java/com/jnape/palatable/lambda/functions/recursion/RecursiveResult.java
@@ -6,10 +6,13 @@
 import com.jnape.palatable.lambda.functor.Applicative;
 import com.jnape.palatable.lambda.functor.Bifunctor;
 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.Sequence.sequence;
+
 /**
  * Specialized {@link CoProduct2} representing the possible results of a primitive recursive function.
  * Used by {@link Trampoline} to cheat around {@link CoProduct2#match} and quickly unpack values via
@@ -22,65 +25,107 @@
 public abstract class RecursiveResult<A, B> implements
         CoProduct2<A, B, RecursiveResult<A, B>>,
         Bifunctor<A, B, RecursiveResult<?, ?>>,
-        Monad<B, RecursiveResult<A, ?>>,
+        MonadRec<B, RecursiveResult<A, ?>>,
         Traversable<B, RecursiveResult<A, ?>> {
 
     private RecursiveResult() {
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public RecursiveResult<B, A> invert() {
         return match(RecursiveResult::terminate, RecursiveResult::recurse);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
-    @SuppressWarnings("unchecked")
     public <C> RecursiveResult<C, B> biMapL(Fn1<? super A, ? extends C> fn) {
-        return (RecursiveResult<C, B>) Bifunctor.super.biMapL(fn);
+        return (RecursiveResult<C, B>) Bifunctor.super.<C>biMapL(fn);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
-    @SuppressWarnings("unchecked")
     public <C> RecursiveResult<A, C> biMapR(Fn1<? super B, ? extends C> fn) {
-        return (RecursiveResult<A, C>) Bifunctor.super.biMapR(fn);
+        return (RecursiveResult<A, C>) Bifunctor.super.<C>biMapR(fn);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public <C, D> RecursiveResult<C, D> biMap(Fn1<? super A, ? extends C> lFn,
                                               Fn1<? super B, ? extends D> rFn) {
         return match(a -> recurse(lFn.apply(a)), b -> terminate(rFn.apply(b)));
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public <C> RecursiveResult<A, C> flatMap(Fn1<? super B, ? extends Monad<C, RecursiveResult<A, ?>>> f) {
         return match(RecursiveResult::recurse, b -> f.apply(b).coerce());
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public <C> RecursiveResult<A, C> pure(C c) {
         return terminate(c);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public <C> RecursiveResult<A, C> fmap(Fn1<? super B, ? extends C> fn) {
-        return Monad.super.<C>fmap(fn).coerce();
+        return MonadRec.super.<C>fmap(fn).coerce();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public <C> RecursiveResult<A, C> zip(Applicative<Fn1<? super B, ? extends C>, RecursiveResult<A, ?>> appFn) {
-        return Monad.super.zip(appFn).coerce();
+        return MonadRec.super.zip(appFn).coerce();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public <C> RecursiveResult<A, C> discardL(Applicative<C, RecursiveResult<A, ?>> appB) {
-        return Monad.super.discardL(appB).coerce();
+        return MonadRec.super.discardL(appB).coerce();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public <C> RecursiveResult<A, B> discardR(Applicative<C, RecursiveResult<A, ?>> appB) {
-        return Monad.super.discardR(appB).coerce();
+        return MonadRec.super.discardR(appB).coerce();
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public <C> RecursiveResult<A, C> trampolineM(
+            Fn1<? super B, ? extends MonadRec<RecursiveResult<B, C>, RecursiveResult<A, ?>>> fn) {
+        return flatMap(Trampoline.<B, RecursiveResult<A, C>>trampoline(
+                b -> sequence(fn.apply(b).<RecursiveResult<A, RecursiveResult<B, C>>>coerce(),
+                              RecursiveResult::terminate)));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public <C, App extends Applicative<?, App>, TravB extends Traversable<C, RecursiveResult<A, ?>>,
             AppTrav extends Applicative<TravB, App>> AppTrav traverse(Fn1<? super B, ? extends Applicative<C, App>> fn,
@@ -89,10 +134,26 @@ AppTrav extends Applicative<TravB, App>> AppTrav traverse(Fn1<? super B, ? exten
                      b -> fn.apply(b).fmap(this::pure).<TravB>fmap(RecursiveResult::coerce).coerce());
     }
 
+    /**
+     * Static factory method for creating a "recurse" value.
+     *
+     * @param a   the value
+     * @param <A> the recurse type
+     * @param <B> the terminate type
+     * @return the {@link RecursiveResult}
+     */
     public static <A, B> RecursiveResult<A, B> recurse(A a) {
         return new Recurse<>(a);
     }
 
+    /**
+     * Static factory method for creating a "terminate" value.
+     *
+     * @param b   the value
+     * @param <A> the recurse type
+     * @param <B> the terminate type
+     * @return the {@link RecursiveResult}
+     */
     public static <A, B> RecursiveResult<A, B> terminate(B b) {
         return new Terminate<>(b);
     }
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/recursion/RecursiveResultTest.java b/src/test/java/com/jnape/palatable/lambda/functions/recursion/RecursiveResultTest.java
@@ -8,6 +8,7 @@
 import testsupport.traits.ApplicativeLaws;
 import testsupport.traits.FunctorLaws;
 import testsupport.traits.MonadLaws;
+import testsupport.traits.MonadRecLaws;
 import testsupport.traits.TraversableLaws;
 
 import static com.jnape.palatable.lambda.functions.recursion.RecursiveResult.recurse;
@@ -18,7 +19,7 @@
 @RunWith(Traits.class)
 public class RecursiveResultTest {
 
-    @TestTraits({FunctorLaws.class, ApplicativeLaws.class, MonadLaws.class, TraversableLaws.class})
+    @TestTraits({FunctorLaws.class, ApplicativeLaws.class, MonadLaws.class, TraversableLaws.class, MonadRecLaws.class})
     public Subjects<RecursiveResult<String, Integer>> testSubject() {
         return subjects(recurse("foo"), terminate(1));
     }
