Converted fj.control to use lambdas

mperry · mperry · commit c270d4acc28a · 2015-08-25T21:56:41.000+10:00
diff --git a/core/src/main/java/fj/control/db/DB.java b/core/src/main/java/fj/control/db/DB.java
@@ -41,15 +41,7 @@ public A run(final Connection c) {
    * @return The callable-valued function which is isomorphic to this database action.
    */
   public final F<Connection, Callable<A>> asFunction() {
-    return new F<Connection, Callable<A>>() {
-      public Callable<A> f(final Connection c) {
-        return new Callable<A>() {
-          public A call() throws Exception {
-            return run(c);
-          }
-        };
-      }
-    };
+    return c -> () -> run(c);
   }
 
   /**
@@ -73,11 +65,7 @@ public B run(final Connection c) throws SQLException {
    * @return A function equivalent to the given one, which operates on values in the database.
    */
   public static <A, B> F<DB<A>, DB<B>> liftM(final F<A, B> f) {
-    return new F<DB<A>, DB<B>>() {
-      public DB<B> f(final DB<A> a) {
-        return a.map(f);
-      }
-    };
+    return a -> a.map(f);
   }
 
   /**
diff --git a/core/src/main/java/fj/control/parallel/ParModule.java b/core/src/main/java/fj/control/parallel/ParModule.java
@@ -452,11 +452,7 @@ public <A, B, C> Promise<Stream<C>> parZipWith(final Stream<A> as, final Stream<
    * @return A Promise of a new array with the results of applying the given function across the two arrays, stepwise.
    */
   public <A, B, C> Promise<Array<C>> parZipWith(final Array<A> as, final Array<B> bs, final F<A, F<B, C>> f) {
-    return parZipWith(as.toStream(), bs.toStream(), f).fmap(new F<Stream<C>, Array<C>>() {
-      public Array<C> f(final Stream<C> stream) {
-        return stream.toArray();
-      }
-    });
+    return parZipWith(as.toStream(), bs.toStream(), f).fmap(stream -> stream.toArray());
   }
 
   /**
@@ -500,11 +496,7 @@ public <A, B> Promise<B> parFoldMap(final Stream<A> as, final F<A, B> map, final
    */
   public <A, B> Promise<B> parFoldMap(final Stream<A> as, final F<A, B> map, final Monoid<B> reduce,
                                       final F<Stream<A>, P2<Stream<A>, Stream<A>>> chunking) {
-    return parMap(Stream.unfold(stream -> stream.isEmpty() ? Option.<P2<Stream<A>, Stream<A>>>none() : some(chunking.f(stream)), as), Stream.<A, B>map_().f(map)).bind(new F<Stream<Stream<B>>, Promise<B>>() {
-      public Promise<B> f(final Stream<Stream<B>> stream) {
-        return parMap(stream, reduce.sumLeftS()).fmap(reduce.sumLeftS());
-      }
-    });
+    return parMap(Stream.unfold(stream -> stream.isEmpty() ? Option.<P2<Stream<A>, Stream<A>>>none() : some(chunking.f(stream)), as), Stream.<A, B>map_().f(map)).bind(stream -> parMap(stream, reduce.sumLeftS()).fmap(reduce.sumLeftS()));
   }
 
   /**
diff --git a/core/src/main/java/fj/control/parallel/Promise.java b/core/src/main/java/fj/control/parallel/Promise.java
@@ -86,11 +86,7 @@ public static <A> Promise<A> promise(final Strategy<Unit> s, final P1<A> a) {
    * @return A function that, given a 1-product, yields a promise of that product's value.
    */
   public static <A> F<P1<A>, Promise<A>> promise(final Strategy<Unit> s) {
-    return new F<P1<A>, Promise<A>>() {
-      public Promise<A> f(final P1<A> a) {
-        return promise(s, a);
-      }
-    };
+    return a -> promise(s, a);
   }
 
   /**
@@ -117,11 +113,7 @@ public Callable<A> _1() {
    * @return The given function transformed into a function that returns a promise.
    */
   public static <A, B> F<A, Promise<B>> promise(final Strategy<Unit> s, final F<A, B> f) {
-    return new F<A, Promise<B>>() {
-      public Promise<B> f(final A a) {
-        return promise(s, P1.curry(f).f(a));
-      }
-    };
+    return a -> promise(s, P1.curry(f).f(a));
   }
 
   /**
@@ -150,11 +142,7 @@ public <B> Promise<B> fmap(final F<A, B> f) {
    * @return That function lifted to a function on Promises.
    */
   public static <A, B> F<Promise<A>, Promise<B>> fmap_(final F<A, B> f) {
-    return new F<Promise<A>, Promise<B>>() {
-      public Promise<B> f(final Promise<A> a) {
-        return a.fmap(f);
-      }
-    };
+    return a -> a.fmap(f);
   }
 
   /**
@@ -206,11 +194,7 @@ public void f(final B b) {
    * @return A new promise after applying the given promised function to this promise.
    */
   public <B> Promise<B> apply(final Promise<F<A, B>> pf) {
-    return pf.bind(new F<F<A, B>, Promise<B>>() {
-      public Promise<B> f(final F<A, B> f) {
-        return fmap(f);
-      }
-    });
+    return pf.bind(f -> fmap(f));
   }
 
   /**
@@ -267,11 +251,7 @@ public static <A> Promise<List<A>> sequence(final Strategy<Unit> s, final List<P
    * @return A function that turns a list of promises into a single promise of a list.
    */
   public static <A> F<List<Promise<A>>, Promise<List<A>>> sequence(final Strategy<Unit> s) {
-    return new F<List<Promise<A>>, Promise<List<A>>>() {
-      public Promise<List<A>> f(final List<Promise<A>> as) {
-        return sequence(s, as);
-      }
-    };
+    return as -> sequence(s, as);
   }
 
   /**
@@ -282,15 +262,7 @@ public Promise<List<A>> f(final List<Promise<A>> as) {
    * @return A single promise for the given Stream.
    */
   public static <A> Promise<Stream<A>> sequence(final Strategy<Unit> s, final Stream<Promise<A>> as) {
-    return join(foldRightS(s, curry(new F2<Promise<A>, P1<Promise<Stream<A>>>, Promise<Stream<A>>>() {
-      public Promise<Stream<A>> f(final Promise<A> o, final P1<Promise<Stream<A>>> p) {
-        return o.bind(new F<A, Promise<Stream<A>>>() {
-          public Promise<Stream<A>> f(final A a) {
-            return p._1().fmap(Stream.<A>cons_().f(a));
-          }
-        });
-      }
-    }), promise(s, P.p(Stream.<A>nil()))).f(as));
+    return join(foldRightS(s, curry((Promise<A> o, P1<Promise<Stream<A>>> p) -> o.bind(a -> p._1().fmap(Stream.<A>cons_().f(a)))), promise(s, P.p(Stream.<A>nil()))).f(as));
   }
 
   /**
@@ -300,11 +272,7 @@ public Promise<Stream<A>> f(final A a) {
    * @return A function that turns a list of promises into a single promise of a Stream..
    */
   public static <A> F<List<Promise<A>>, Promise<List<A>>> sequenceS(final Strategy<Unit> s) {
-    return new F<List<Promise<A>>, Promise<List<A>>>() {
-      public Promise<List<A>> f(final List<Promise<A>> as) {
-        return sequence(s, as);
-      }
-    };
+    return as -> sequence(s, as);
   }
 
   /**
