PlumpMath
diff --git a/‎.idea/inspectionProfiles/Project_Default.xml‎
Lines changed: 4 additions & 3 deletions b/‎.idea/inspectionProfiles/Project_Default.xml‎
Lines changed: 4 additions & 3 deletions
diff --git a/‎.idea/scopes/scope_settings.xml‎
Lines changed: 5 additions & 0 deletions b/‎.idea/scopes/scope_settings.xml‎
Lines changed: 5 additions & 0 deletions
diff --git a/‎core/src/main/java/fj/control/Trampoline.java‎
Lines changed: 47 additions & 0 deletions b/‎core/src/main/java/fj/control/Trampoline.java‎
Lines changed: 47 additions & 0 deletions
diff --git a/‎core/src/main/java/fj/data/List.java‎
Lines changed: 39 additions & 3 deletions b/‎core/src/main/java/fj/data/List.java‎
Lines changed: 39 additions & 3 deletions
@@ -1,9 +1,14 @@
 package fj.control;
 
 import fj.F;
+import fj.F2;
 import fj.P1;
 import fj.data.Either;
 
+import java.util.Iterator;
+
+import static fj.Function.constant;
+import static fj.Function.curry;
 import static fj.data.Either.left;
 import static fj.data.Either.right;
 
@@ -256,4 +261,46 @@ public A run() {
       }
     }
   }
+
+  /**
+   * Performs function application within a Trampoline (applicative functor pattern).
+   *
+   * @param lf A Trampoline resulting in the function to apply.
+   * @return A new Trampoline after applying the given function through this Trampoline.
+   */
+  public final <B> Trampoline<B> apply(final Trampoline<F<A, B>> lf) {
+    return lf.bind(new F<F<A, B>, Trampoline<B>>() {
+      public Trampoline<B> f(final F<A, B> f) {
+        return map(f);
+      }
+    });
+  }
+  
+  /**
+   * Binds the given function across the result of this Trampoline and the given Trampoline.
+   *
+   * @param lb A given Trampoline to bind the given function with.
+   * @param f  The function to combine the results of this Trampoline and the given Trampoline.
+   * @return A new Trampoline combining the results of the two trampolines with the given function.
+   */
+  public final <B, C> Trampoline<C> bind(final Trampoline<B> lb, final F<A, F<B, C>> f) {
+    return lb.apply(map(f));
+  }
+  
+
+  /**
+   * Promotes the given function of arity-2 to a function on Trampolines.
+   *
+   * @param f The function to promote to a function on Trampolines.
+   * @return The given function, promoted to operate on Trampolines.
+   */
+  public static <A, B, C> F<Trampoline<A>, F<Trampoline<B>, Trampoline<C>>> liftM2(final F<A, F<B, C>> f) {
+    return curry(new F2<Trampoline<A>, Trampoline<B>, Trampoline<C>>() {
+      public Trampoline<C> f(final Trampoline<A> as, final Trampoline<B> bs) {
+        return as.bind(bs, f);
+      }
+    });
+  }
+  
+
 }
@@ -20,7 +20,6 @@
 import static fj.P.p;
 import static fj.P.p2;
 import static fj.Unit.unit;
-import static fj.data.Array.array;
 import static fj.data.Array.mkArray;
 import static fj.data.List.Buffer.*;
 import static fj.data.Option.none;
@@ -30,6 +29,7 @@
 import static fj.Ord.intOrd;
 
 import fj.Ordering;
+import fj.control.Trampoline;
 
 import java.util.AbstractCollection;
 import java.util.Collection;
@@ -458,7 +458,7 @@ public final <B, C> List<C> bind(final List<B> lb, final F2<A, B, C> f) {
   /**
    * Promotes the given function of arity-2 to a function on lists.
    *
-   * @param f The functio to promote to a function on lists.
+   * @param f The function to promote to a function on lists.
    * @return The given function, promoted to operate on lists.
    */
   public static <A, B, C> F<List<A>, F<List<B>, List<C>>> liftM2(final F<A, F<B, C>> f) {
@@ -626,6 +626,20 @@ public final <B> B foldRight(final F2<A, B, B> f, final B b) {
     return foldRight(curry(f), b);
   }
 
+  /**
+   * Performs a right-fold reduction across this list in O(1) stack space.
+   * @param f The function to apply on each element of the list.
+   * @param b The beginning value to start the application from.
+   * @return A Trampoline containing the final result after the right-fold reduction.
+   */
+  public final <B> Trampoline<B> foldRightC(final F2<A, B, B> f, final B b) {
+    return Trampoline.suspend(new P1<Trampoline<B>>() {
+      public Trampoline<B> _1() {
+        return isEmpty() ? Trampoline.pure(b) : tail().foldRightC(f, b).map(f.f(head()));
+      }
+    });
+  }
+
   /**
    * Performs a left-fold reduction across this list. This function runs in constant space.
    *
@@ -1080,7 +1094,7 @@ public final <B, C> F<B, List<C>> mapM(final F<A, F<B, C>> f) {
   /**
    * Maps the given function across this list by binding through the Option monad.
    *
-   * @param f Thefunction to apply through the this list.
+   * @param f The function to apply through the this list.
    * @return A possible list of values after binding through the Option monad.
    */
   public final <B> Option<List<B>> mapMOption(final F<A, Option<B>> f) {
@@ -1099,6 +1113,28 @@ public List<B> f(final List<B> bbs) {
     }, Option.<List<B>>some(List.<B>nil()));
   }
 
+  /**
+   * Maps the given function across this list by binding through the Trampoline monad.
+   *
+   * @param f The function to apply through the this list.
+   * @return A list of values in the Trampoline monad.
+   */
+  public final <B> Trampoline<List<B>> mapMTrampoline(final F<A, Trampoline<B>> f) {
+    return foldRight(new F2<A, Trampoline<List<B>>, Trampoline<List<B>>>() {
+      public Trampoline<List<B>> f(final A a, final Trampoline<List<B>> bs) {
+        return f.f(a).bind(new F<B, Trampoline<List<B>>>() {
+          public Trampoline<List<B>> f(final B b) {
+            return bs.map(new F<List<B>, List<B>>() {
+              public List<B> f(final List<B> bbs) {
+                return bbs.cons(b);
+              }
+            });
+          }
+        });
+      }
+    }, Trampoline.<List<B>>pure(List.<B>nil()));
+  }
+
   /**
    * Returns the index of the first element in this list which is equal (by the given equality) to the
    * query element, or None if there is no such element.