functionaljava · jbgi · Oct 7, 2018 · Oct 7, 2018 · Oct 7, 2018
diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
@@ -17,6 +17,7 @@
 import static fj.data.List.nil;
 import static fj.data.Natural.natural;
 import static fj.data.Option.none;
+import static fj.data.Option.some;
 import static fj.data.Stream.iterableStream;
 
 import java.math.BigInteger;
@@ -867,6 +868,36 @@ public List<A> sum(F0<Stream<List<A>>> as) {
     });
   }
 
+  /**
+   * Lift a {@code Semigroup<A>} for A to a {@code Monoid<Option<A>>}, using Option.none() as zero.
+   *
+   * @return A monoid for option.
+   */
+  public static <A> Monoid<Option<A>> optionMonoid(Semigroup<A> aSemigroup) {
+    return monoidDef(new Monoid.Definition<Option<A>>() {
+      @Override
+      public Option<A> empty() {
+        return none();
+      }
+
+      @Override
+      public Option<A> append(Option<A> a1, Option<A> a2) {
+        return a1.liftM2(a2, aSemigroup::sum).orElse(a1).orElse(a2);
+      }
+
+      @Override
+      public Option<A> multiply(int n, Option<A> oa) {
+        return n > 0 ? oa.map(a -> aSemigroup.multiply1p(n - 1, a)) : none();
+      }
+
+      @Override
+      public Option<A> sum(F0<Stream<Option<A>>> oas) {
+        Stream<A> as = oas.f().bind(Option::toStream);
+        return as.uncons(none(), h -> tail ->  some(aSemigroup.sumStream(h, tail::_1)));
+      }
+    });
+  }
+
   /**
    * A monoid for options.
    * @deprecated since 4.7. Use {@link #firstOptionMonoid()}.

diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
@@ -172,29 +172,7 @@ public Semigroup<A> dual() {
    * Lifts the semigroup to obtain a trivial monoid.
    */
   public Monoid<Option<A>> lift() {
-    Definition<A> def = this.def;
-    return monoidDef(new Monoid.Definition<Option<A>>() {
-      @Override
-      public Option<A> empty() {
-        return none();
-      }
-
-      @Override
-      public Option<A> append(Option<A> a1, Option<A> a2) {
-        return a1.liftM2(a1, def::append).orElse(a1).orElse(a2);
-      }
-
-      @Override
-      public Option<A> multiply(int n, Option<A> oa) {
-        return n > 0 ? oa.map(a -> def.multiply1p(n - 1, a)) : none();
-      }
-
-      @Override
-      public Option<A> sum(F0<Stream<Option<A>>> oas) {
-        Stream<A> as = oas.f().bind(Option::toStream);
-        return as.uncons(none(), h -> tail ->  some(def.sum(h, tail::_1)));
-      }
-    });
+    return Monoid.optionMonoid(this);
   }
 
   /**

diff --git a/core/src/main/java/fj/control/Trampoline.java b/core/src/main/java/fj/control/Trampoline.java
@@ -46,7 +46,7 @@ public <R> R fold(final F<Normal<A>, R> n,
     // The monadic bind constructs a new Codense whose subcomputation is still `sub`, and Kleisli-composes the
     // continuations.
     public <B> Trampoline<B> bind(final F<A, Trampoline<B>> f) {
-      return codense(sub, o -> suspend(P.lazy(() -> cont.f(o).bind(f))));
+      return codense(sub, o -> suspend(() -> cont.f(o).bind(f)));
     }
 
     // The resumption of a Codense is the resumption of its subcomputation. If that computation is done, its result
@@ -126,6 +126,16 @@ public static <A> Trampoline<A> pure(final A a) {
     return new Pure<>(a);
   }
 
+  /**
+   * Suspends the given computation in a thunk.
+   *
+   * @param a A trampoline suspended in a thunk.
+   * @return A trampoline whose next step runs the given thunk.
+   */
+  public static <A> Trampoline<A> suspend(final F0<Trampoline<A>> a) {
+    return new Suspend<>(P.lazy(a));
+  }
+
   /**
    * Suspends the given computation in a thunk.
    *
@@ -136,6 +146,7 @@ public static <A> Trampoline<A> suspend(final P1<Trampoline<A>> a) {
     return new Suspend<>(a);
   }
 
+
   /**
    * @return The first-class version of `suspend`.
    */
@@ -255,15 +266,15 @@ public final <B, C> Trampoline<C> zipWith(final Trampoline<B> b, final F2<A, B,
     final Either<P1<Trampoline<B>>, B> eb = b.resume();
     for (final P1<Trampoline<A>> x : ea.left()) {
       for (final P1<Trampoline<B>> y : eb.left()) {
-        return suspend(x.bind(y, F2Functions.curry((ta, tb) -> suspend(P.lazy(() -> ta.zipWith(tb, f))))));
+        return suspend(x.bind(y, F2Functions.curry((ta, tb) -> suspend(() -> ta.zipWith(tb, f)))));
       }
       for (final B y : eb.right()) {
         return suspend(x.map(ta -> ta.map(F2Functions.f(F2Functions.flip(f), y))));
       }
     }
     for (final A x : ea.right()) {
       for (final B y : eb.right()) {
-        return suspend(P.lazy(() -> pure(f.f(x, y))));
+        return suspend(() -> pure(f.f(x, y)));
       }
       for (final P1<Trampoline<B>> y : eb.left()) {
         return suspend(y.map(liftM2(F2Functions.curry(f)).f(pure(x))));

diff --git a/core/src/main/java/fj/data/DList.java b/core/src/main/java/fj/data/DList.java
@@ -126,6 +126,6 @@ public DList<A> append(DList<A> other) {
     }
 
     private static <A,B,C> F<A,Trampoline<C>> kleisliTrampCompose(F<B,Trampoline<C>> bc, F<A,Trampoline<B>> ab) {
-        return (A a) -> ab.f(a).bind((B b) -> Trampoline.suspend(P.lazy(() -> bc.f(b))));
+        return (A a) -> ab.f(a).bind((B b) -> Trampoline.suspend(() -> bc.f(b)));
     }
 }
diff --git a/core/src/main/java/fj/data/Eval.java b/core/src/main/java/fj/data/Eval.java
@@ -204,7 +204,7 @@ private static final class PureTrampolineEval<A> extends TrampolineEval<A> {
 
     @Override
     protected final Trampoline<A> trampoline() {
-      return Trampoline.suspend(P.lazy(() -> Trampoline.pure(start.value())));
+      return Trampoline.suspend(() -> Trampoline.pure(start.value()));
     }
   }
 
@@ -219,7 +219,7 @@ private static final class BindTrampolineEval<A, B> extends TrampolineEval<B> {
 
     @Override
     protected final Trampoline<B> trampoline() {
-      return Trampoline.suspend(P.lazy(() -> next.trampoline().bind(v -> f.f(v).asTrampoline().trampoline())));
+      return Trampoline.suspend(() -> next.trampoline().bind(v -> f.f(v).asTrampoline().trampoline()));
     }
   }
 
@@ -232,7 +232,7 @@ private static final class DeferEval<A> extends TrampolineEval<A> {
 
     @Override
     protected final Trampoline<A> trampoline() {
-      return Trampoline.suspend(P.lazy(() -> memo._1().asTrampoline().trampoline()));
+      return Trampoline.suspend(() -> memo._1().asTrampoline().trampoline());
     }
   }
 }
diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
@@ -736,7 +736,7 @@ public final <B> B foldRight(final F2<A, B, B> f, final B b) {
    * @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(P.lazy(() -> isEmpty() ? Trampoline.pure(b) : tail().foldRightC(f, b).map(F2Functions.f(f, head()))));
+    return Trampoline.suspend(() -> isEmpty() ? Trampoline.pure(b) : tail().foldRightC(f, b).map(F2Functions.f(f, head())));
   }
 
   /**

diff --git a/core/src/main/java/fj/data/State.java b/core/src/main/java/fj/data/State.java
@@ -5,7 +5,6 @@
 import fj.Unit;
 import fj.control.Trampoline;
 
-import static fj.P.lazy;
 import static fj.P.p;
 import static fj.control.Trampoline.suspend;
 import static fj.data.List.cons;
@@ -75,7 +74,7 @@ public static <S, A, B> State<S, List<B>> traverse(List<A> list, F<A, State<S, B
   }
 
   private static <S, A> State<S, A> suspended(F<S, Trampoline<P2<S, A>>> runF) {
-    return new State<>(s -> suspend(lazy(() -> runF.f(s))));
+    return new State<>(s -> suspend(() -> runF.f(s)));
   }
 
   private final F<S, Trampoline<P2<S, A>>> runF;

diff --git a/core/src/test/java/fj/MonoidTest.java b/core/src/test/java/fj/MonoidTest.java
@@ -0,0 +1,19 @@
+package fj;
+
+import fj.data.Option;
+import fj.data.Stream;
+import org.junit.Test;
+
+import static fj.data.Option.some;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class MonoidTest {
+
+  @Test
+  public void lifted_sum_of_two_numbers() {
+    Monoid<Option<Integer>> optionMonoid = Semigroup.intAdditionSemigroup.lift();
+    assertThat(optionMonoid.sum(some(3), some(5)), is(some(8)));
+    assertThat(optionMonoid.sumLeft(Stream.arrayStream(some(3), some(5))), is(some(8)));
+  }
+}
diff --git a/quickcheck/src/main/java/fj/test/Gen.java b/quickcheck/src/main/java/fj/test/Gen.java
@@ -16,7 +16,6 @@
 import static fj.Function.flip;
 import static fj.Monoid.intAdditionMonoid;
 import static fj.Ord.intOrd;
-import static fj.P.lazy;
 import static fj.P2.__1;
 import static fj.control.Trampoline.pure;
 import static fj.control.Trampoline.suspend;
@@ -551,15 +550,15 @@ final class Tramp {
 
             // Picks elements in constant stack space
             private Trampoline<List<A>> tramp(List<A> remainAs, int remainN, int remainALength) {
-              return suspend(lazy(() ->
+              return suspend(() ->
                   (remainN == 0) ?
                       // We have picked N elements; stop
                       pure(nil()) :
                       // For M remaining elements of which N will be picked, pick remainAs.head() with probability N/M
                       (r.choose(0, remainALength - 1) < remainN) ?
                           tramp(remainAs.tail(), remainN - 1, remainALength - 1)
                               .map(pickedTail -> cons(remainAs.head(), pickedTail)) :
-                          tramp(remainAs.tail(), remainN, remainALength - 1)));
+                          tramp(remainAs.tail(), remainN, remainALength - 1));
             }
 
           }