functionaljava
diff --git a/‎core/src/main/java/fj/control/Trampoline.java‎
Lines changed: 8 additions & 10 deletions b/‎core/src/main/java/fj/control/Trampoline.java‎
Lines changed: 8 additions & 10 deletions
diff --git a/‎core/src/main/java/fj/control/parallel/Callables.java‎
Lines changed: 12 additions & 16 deletions b/‎core/src/main/java/fj/control/parallel/Callables.java‎
Lines changed: 12 additions & 16 deletions
diff --git a/‎core/src/main/java/fj/control/parallel/Strategy.java‎
Lines changed: 1 addition & 3 deletions b/‎core/src/main/java/fj/control/parallel/Strategy.java‎
Lines changed: 1 addition & 3 deletions
@@ -52,16 +52,14 @@ public <B> Trampoline<B> bind(final F<A, Trampoline<B>> f) {
     // The resumption of a Codense is the resumption of its subcomputation. If that computation is done, its result
     // gets shifted into the continuation.
     public Either<P1<Trampoline<A>>, A> resume() {
-      return left(sub.resume().either(p -> {
-        return p.map(ot -> {
-          // WARNING: In JDK 8, update 25 (current version) the following code is a
-          // workaround for an internal JDK compiler error, likely due to
-          // https:bugs.openjdk.java.net/browse/JDK-8062253.
-          F<Normal<Object>, Trampoline<A>> f = o -> o.foldNormal(cont::f, t -> t._1().bind(cont));
-          F<Codense<Object>, Trampoline<A>> g = c -> codense(c.sub, o -> c.cont.f(o).bind(cont));
-          return ot.fold(f, g);
-        });
-      }, o -> P.lazy(() -> cont.f(o))));
+      return left(sub.resume().either(p -> p.map(ot -> {
+        // WARNING: In JDK 8, update 25 (current version) the following code is a
+        // workaround for an internal JDK compiler error, likely due to
+        // https:bugs.openjdk.java.net/browse/JDK-8062253.
+        F<Normal<Object>, Trampoline<A>> f = o -> o.foldNormal(cont::f, t -> t._1().bind(cont));
+        F<Codense<Object>, Trampoline<A>> g = c -> codense(c.sub, o -> c.cont.f(o).bind(cont));
+        return ot.fold(f, g);
+      }), o -> P.lazy(() -> cont.f(o))));
     }
   }
 
 
@@ -216,14 +216,12 @@ public static <A> F<Callable<A>, P1<Either<Exception, A>>> either() {
    * @return A Callable equivalent to the given Either value.
    */
   public static <A> Callable<A> fromEither(final F0<Either<Exception, A>> e) {
-    return new Callable<A>() {
-      public A call() throws Exception {
-        final Either<Exception, A> e1 = e.f();
-        if (e1.isLeft())
-          throw e1.left().value();
-        else
-          return e1.right().value();
-      }
+    return () -> {
+      final Either<Exception, A> e1 = e.f();
+      if (e1.isLeft())
+        throw e1.left().value();
+      else
+        return e1.right().value();
     };
   }
 
@@ -243,14 +241,12 @@ public static <A> F<P1<Either<Exception, A>>, Callable<A>> fromEither() {
    * @return A Callable that yields some value or throws an exception in the case of no value.
    */
   public static <A> Callable<A> fromOption(final F0<Option<A>> o) {
-    return new Callable<A>() {
-      public A call() throws Exception {
-        final Option<A> o1 = o.f();
-        if (o1.isSome())
-          return o1.some();
-        else
-          throw new Exception("No value.");
-      }
+    return () -> {
+      final Option<A> o1 = o.f();
+      if (o1.isSome())
+        return o1.some();
+      else
+        throw new Exception("No value.");
     };
   }
 
 
@@ -339,9 +339,7 @@ public static <A> P1<A> obtain(final Future<A> t) {
    * @return An effect, which, given a Future, waits for it to obtain a value, discarding the value.
    */
   public static <A> Effect1<Future<A>> discard() {
-    return a -> {
-      Strategy.<A>obtain().f(a)._1();
-    };
+    return a -> Strategy.<A>obtain().f(a)._1();
   }
 
   /**