Converted anonymous F2 classes to use lambdas

mperry · mperry · commit b438b1b89705 · 2015-08-27T20:55:02.000+10:00
diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
@@ -118,11 +118,7 @@ public A sumRight(final List<A> as) {
    * @return The sum of the given values.
    */
   public A sumRight(final Stream<A> as) {
-    return as.foldRight(new F2<A, P1<A>, A>() {
-      public A f(final A a, final P1<A> ap1) {
-        return sum(a, ap1._1());
-      }
-    }, zero);
+    return as.foldRight((a, ap1) -> sum(a, ap1._1()), zero);
   }
 
   /**
diff --git a/core/src/main/java/fj/control/parallel/Promise.java b/core/src/main/java/fj/control/parallel/Promise.java
@@ -222,11 +222,7 @@ public <B, C> Promise<C> bind(final P1<Promise<B>> p, final F<A, F<B, C>> f) {
    * @return A function of arity-2 promoted to map over promises.
    */
   public static <A, B, C> F<Promise<A>, F<Promise<B>, Promise<C>>> liftM2(final F<A, F<B, C>> f) {
-    return curry(new F2<Promise<A>, Promise<B>, Promise<C>>() {
-      public Promise<C> f(final Promise<A> ca, final Promise<B> cb) {
-        return ca.bind(cb, f);
-      }
-    });
+    return curry((ca, cb) -> ca.bind(cb, f));
   }
 
   /**
diff --git a/core/src/main/java/fj/data/Array.java b/core/src/main/java/fj/data/Array.java
@@ -600,11 +600,7 @@ public static <A> F<A[], Array<A>> wrap() {
    * @return A function that maps a given function across a given array.
    */
   public static <A, B> F<F<A, B>, F<Array<A>, Array<B>>> map() {
-    return curry(new F2<F<A, B>, Array<A>, Array<B>>() {
-      public Array<B> f(final F<A, B> abf, final Array<A> array) {
-        return array.map(abf);
-      }
-    });
+    return curry((abf, array) -> array.map(abf));
   }
 
   /**
diff --git a/core/src/main/java/fj/data/Enumerator.java b/core/src/main/java/fj/data/Enumerator.java
@@ -236,8 +236,7 @@ public static <A> Enumerator<A> enumerator(final F<A, Option<A>> successor, fina
    */
   public static <A> Enumerator<A> enumerator(final F<A, Option<A>> successor, final F<A, Option<A>> predecessor,
                                              final Option<A> max, final Option<A> min, final Ord<A> order) {
-    return new Enumerator<A>(successor, predecessor, max, min, order, curry(new F2<A, Long, Option<A>>() {
-      public Option<A> f(final A a, final Long l) {
+    return new Enumerator<A>(successor, predecessor, max, min, order, curry((a, l) -> {
         if (l == 0L)
           return some(a);
         else if (l < 0L) {
@@ -261,7 +260,6 @@ else if (l < 0L) {
           }
           return some(aa);
         }
-      }
     }));
   }
 
diff --git a/core/src/main/java/fj/data/Option.java b/core/src/main/java/fj/data/Option.java
@@ -512,11 +512,7 @@ public final <X> Validation<X, A> toValidation(final X x) {
    *         return in left.
    */
   public static <A, X> F<Option<A>, F<X, Either<X, A>>> toEither() {
-    return curry(new F2<Option<A>, X, Either<X, A>>() {
-      public Either<X, A> f(final Option<A> a, final X x) {
-        return a.toEither(x);
-      }
-    });
+    return curry((a, x) -> a.toEither(x));
   }
 
   /**
diff --git a/core/src/main/java/fj/data/fingertrees/Digit.java b/core/src/main/java/fj/data/fingertrees/Digit.java
@@ -121,11 +121,7 @@ public abstract <B> B match(final F<One<V, A>, B> one, final F<Two<V, A>, B> two
    * @return the sum of the measurements of this digit according to the monoid.
    */
   public final V measure() {
-    return foldLeft(Function.curry(new F2<V, A, V>() {
-      public V f(final V v, final A a) {
-        return m.sum(v, m.measure(a));
-      }
-    }), m.zero());
+    return foldLeft(Function.curry((v, a) -> m.sum(v, m.measure(a))), m.zero());
   }
 
   /**
diff --git a/core/src/main/java/fj/data/fingertrees/Node.java b/core/src/main/java/fj/data/fingertrees/Node.java
@@ -20,15 +20,11 @@ public abstract class Node<V, A> {
   public abstract <B> B foldLeft(final F<B, F<A, B>> f, final B z);
 
   public static <V, A, B> F<B, F<Node<V, A>, B>> foldLeft_(final F<B, F<A, B>> bff) {
-    return curry(new F2<B, Node<V, A>, B>() {
-      public B f(final B b, final Node<V, A> node) { return node.foldLeft(bff, b); }
-    });
+    return curry((b, node) -> node.foldLeft(bff, b));
   }
 
   public static <V, A, B> F<B, F<Node<V, A>, B>> foldRight_(final F<A, F<B, B>> aff) {
-    return curry(new F2<B, Node<V, A>, B>() {
-      public B f(final B b, final Node<V, A> node) { return node.foldRight(aff, b); }
-    });
+    return curry((b, node) -> node.foldRight(aff, b));
   }
 
   public final <B> Node<V, B> map(final F<A, B> f, final Measured<V, B> m) {
diff --git a/core/src/main/java/fj/data/hlist/HList.java b/core/src/main/java/fj/data/hlist/HList.java
@@ -91,11 +91,7 @@ public C append(final A a, final B b) {
      * @return a method for concatenating lists to the empty list.
      */
     public static <L extends HList<L>> HAppend<HNil, L, L> append() {
-      return new HAppend<HNil, L, L>(new F2<HNil, L, L>() {
-        public L f(final HNil hNil, final L l) {
-          return l;
-        }
-      });
+      return new HAppend<HNil, L, L>((hNil, l) -> l);
     }
 
     /**
@@ -106,11 +102,7 @@ public L f(final HNil hNil, final L l) {
      */
     public static <X, A extends HList<A>, B, C extends HList<C>, H extends HAppend<A, B, C>>
     HAppend<HCons<X, A>, B, HCons<X, C>> append(final H h) {
-      return new HAppend<HCons<X, A>, B, HCons<X, C>>(new F2<HCons<X, A>, B, HCons<X, C>>() {
-        public HCons<X, C> f(final HCons<X, A> c, final B l) {
-          return cons(c.head(), h.append(c.tail(), l));
-        }
-      });
+      return new HAppend<HCons<X, A>, B, HCons<X, C>>((c, l) -> cons(c.head(), h.append(c.tail(), l)));
     }
   }
 
diff --git a/core/src/main/java/fj/function/Integers.java b/core/src/main/java/fj/function/Integers.java
@@ -37,11 +37,7 @@ private Integers() {
   /**
    * Curried Integer subtraction.
    */
-  public static final F<Integer, F<Integer, Integer>> subtract = curry(new F2<Integer, Integer, Integer>() {
-    public Integer f(final Integer x, final Integer y) {
-      return x - y;
-    }
-  });
+  public static final F<Integer, F<Integer, Integer>> subtract = curry((x, y) -> x - y);
 
   /**
    * Negation.
diff --git a/core/src/main/java/fj/function/Visitor.java b/core/src/main/java/fj/function/Visitor.java
@@ -83,11 +83,7 @@ public static <A, B> B nullableVisitor(final List<F<A, B>> visitors, final F0<B>
    * @return A function that can be applied to a default value (there is no association) and an associated key.
    */
   public static <A, B> F<B, F<A, B>> association(final List<P2<A, B>> x, final Equal<A> eq) {
-    return curry(new F2<B, A, B>() {
-      public B f(final B def, final A a) {
-        return lookup(eq, x, a).orSome(def);
-      }
-    });
+    return curry((def, a) -> lookup(eq, x, a).orSome(def));
   }
 
   /**
@@ -99,10 +95,6 @@ public B f(final B def, final A a) {
    * @return A function that can be applied to a default value (there is no association) and an associated key.
    */
   public static <A, B> F<P1<B>, F<A, B>> associationLazy(final List<P2<A, B>> x, final Equal<A> eq) {
-    return curry(new F2<P1<B>, A, B>() {
-      public B f(final P1<B> def, final A a) {
-        return lookup(eq, x, a).orSome(def);
-      }
-    });
+    return curry((def, a) -> lookup(eq, x, a).orSome(def));
   }
 }
diff --git a/demo/src/main/java/fj/demo/test/AdditionCommutes.java b/demo/src/main/java/fj/demo/test/AdditionCommutes.java
@@ -13,11 +13,7 @@
 */
 public final class AdditionCommutes {
   public static void main(final String[] args) {
-    final Property p = property(arbInteger, arbInteger, new F2<Integer, Integer, Property>() {
-      public Property f(final Integer a, final Integer b) {
-        return prop(a + b == b + a);
-      }
-    });
+    final Property p = property(arbInteger, arbInteger, (a, b) -> prop(a + b == b + a));
     summary.println(p.check()); // OK, passed 100 tests.
   }
 }
diff --git a/demo/src/main/java/fj/demo/test/AdditionCommutesParallel.java b/demo/src/main/java/fj/demo/test/AdditionCommutesParallel.java
@@ -20,11 +20,7 @@ public final class AdditionCommutesParallel {
   public static void main(final String[] args) {
     final ExecutorService pool = Executors.newFixedThreadPool(8);
     final Strategy<Property> s = Strategy.executorStrategy(pool);
-    final Property p = propertyP(arbInteger, arbInteger, new F2<Integer, Integer, P1<Property>>() {
-      public P1<Property> f(final Integer a, final Integer b) {
-        return s.par(P.lazy(() -> prop(a + b == b + a)));
-      }
-    });
+    final Property p = propertyP(arbInteger, arbInteger, (a, b) -> s.par(P.lazy(() -> prop(a + b == b + a))));
     summary.println(p.check(1000000, 5000000, 0, 100)); // OK, passed 1000000 tests.
     pool.shutdown();
   }
diff --git a/demo/src/main/java/fj/demo/test/EqualsHashCode.java b/demo/src/main/java/fj/demo/test/EqualsHashCode.java
@@ -69,19 +69,11 @@ public String f(final Character c1, final Character c2, final Character c3) {
 
     // Arbitrary for MyClass that uses the restrictive arbitraries above.
     // We are using the monad pattern (bind) to make this a trivial exercise. 
-    final Arbitrary<MyClass> arbMyClass = arbitrary(arbByteR.gen.bind(arbStringR.gen, curry(new F2<Byte, String, MyClass>() {
-      public MyClass f(final Byte b, final String s) {
-        return new MyClass(b, s);
-      }
-    })));
+    final Arbitrary<MyClass> arbMyClass = arbitrary(arbByteR.gen.bind(arbStringR.gen, curry((b, s) -> new MyClass(b, s))));
 
     // Finally the property.
     // if m1 equals m2, then this implies that m1's hashCode is equal to m2's hashCode.
-    final Property p = property(arbMyClass, arbMyClass, new F2<MyClass, MyClass, Property>() {
-      public Property f(final MyClass m1, final MyClass m2) {
-        return bool(m1.equals(m2)).implies(m1.hashCode() == m2.hashCode());
-      }
-    });
+    final Property p = property(arbMyClass, arbMyClass, (m1, m2) -> bool(m1.equals(m2)).implies(m1.hashCode() == m2.hashCode()));
     // at least 100 from 10,000 should satisfy the premise (m1.equals(m2))  
     summary.println(p.check(100, 10000, 0, 100)); // OK, passed 100 tests (4776 discarded).
   }
diff --git a/demo/src/main/java/fj/demo/test/IntegerOverflow.java b/demo/src/main/java/fj/demo/test/IntegerOverflow.java
@@ -16,11 +16,7 @@
 public final class IntegerOverflow {
   public static void main(final String[] args) {
     final Property p = property(arbIntegerBoundaries, arbIntegerBoundaries, shrinkInteger, shrinkInteger,
-        new F2<Integer, Integer, Property>() {
-      public Property f(final Integer a, final Integer b) {
-        return bool(a > 0 && b > 0).implies(a + b > 0);
-      }
-    });
+            (a, b) -> bool(a > 0 && b > 0).implies(a + b > 0));
     summary.println(p.check()); // Falsified after 4 passed tests with arguments: [8,2147483647]
   }
 }
diff --git a/demo/src/main/java/fj/demo/test/JavaLinkedList.java b/demo/src/main/java/fj/demo/test/JavaLinkedList.java
@@ -17,12 +17,10 @@
 public final class JavaLinkedList {
   public static void main(final String[] args) {
     final Property p = property(arbLinkedList(arbInteger), arbLinkedList(arbInteger),
-        new F2<LinkedList<Integer>, LinkedList<Integer>, Property>() {
-      public Property f(final LinkedList<Integer> x, final LinkedList<Integer> y) {
+            (x, y) -> {
         final LinkedList<Integer> xy = new LinkedList<Integer>(x);
         xy.addAll(y);
         return prop(xy.size() == x.size() + y.size());
-      }
     });
     summary.println(p.check()); // OK, passed 100 tests.
   }
diff --git a/demo/src/main/java/fj/demo/test/OptionMonadFunctorLaw.java b/demo/src/main/java/fj/demo/test/OptionMonadFunctorLaw.java
@@ -21,11 +21,7 @@ For any Option (o) and any function (f), then calling flatMap on o with a
 */
 public final class OptionMonadFunctorLaw {
   public static void main(final String[] args) {
-    final Property unitMap = property(arbOption(arbInteger), Arbitrary.<Integer, String>arbFInvariant(arbString), new F2<Option<Integer>, F<Integer, String>, Property>() {
-      public Property f(final Option<Integer> o, final F<Integer, String> f) {
-        return prop(optionEqual(stringEqual).eq(o.bind(andThen(f, Option.<String>some_())), o.map(f)));
-      }
-    });
+    final Property unitMap = property(arbOption(arbInteger), Arbitrary.<Integer, String>arbFInvariant(arbString), (o, f) -> prop(optionEqual(stringEqual).eq(o.bind(andThen(f, Option.<String>some_())), o.map(f))));
     summary.println(unitMap.minSuccessful(500)); // OK, passed 500 tests.     
   }
 }
diff --git a/quickcheck/src/main/java/fj/test/Gen.java b/quickcheck/src/main/java/fj/test/Gen.java
@@ -125,16 +125,14 @@ public B f(final Rand r) {
    * @return A generator that produces values that meet the given predicate.
    */
   public Gen<A> filter(final F<A, Boolean> f) {
-    return gen(curry(new F2<Integer, Rand, A>() {
-      public A f(final Integer i, final Rand r) {
+    return gen(curry((i, r) -> {
         A a;
 
         do {
           a = gen(i, r);
         } while(!f.f(a));
 
         return a;
-      }
     }));
   }
 
@@ -359,11 +357,7 @@ public static <A> Gen<List<A>> sequenceN(final int n, final Gen<A> g) {
    * @return A new generator.
    */
   public static <A> Gen<A> parameterised(final F<Integer, F<Rand, Gen<A>>> f) {
-    return new Gen<A>(curry(new F2<Integer, Rand, A>() {
-      public A f(final Integer i, final Rand r) {
-        return f.f(i).f(r).gen(i, r);
-      }
-    }));
+    return new Gen<A>(curry((i, r) -> f.f(i).f(r).gen(i, r)));
   }
 
   /**
@@ -404,11 +398,7 @@ public A f(final Rand r) {
   public static Gen<Integer> choose(final int from, final int to) {
     final int f = min(from, to);
     final int t = max(from, to);
-    return parameterised(curry(new F2<Integer, Rand, Gen<Integer>>() {
-      public Gen<Integer> f(final Integer i, final Rand r) {
-        return value(r.choose(f, t));
-      }
-    }));
+    return parameterised(curry((i, r) -> value(r.choose(f, t))));
   }
 
   /**

Original file line number	Diff line number	Diff line change
`@@ -236,8 +236,7 @@ public static <A> Enumerator<A> enumerator(final F<A, Option<A>> successor, fina`
`236`	`236`	`*/`
`237`	`237`	`public static <A> Enumerator<A> enumerator(final F<A, Option<A>> successor, final F<A, Option<A>> predecessor,`
`238`	`238`	`final Option<A> max, final Option<A> min, final Ord<A> order) {`
`239`		`- return new Enumerator<A>(successor, predecessor, max, min, order, curry(new F2<A, Long, Option<A>>() {`
`240`		`- public Option<A> f(final A a, final Long l) {`
	`239`	`+ return new Enumerator<A>(successor, predecessor, max, min, order, curry((a, l) -> {`
`241`	`240`	`if (l == 0L)`
`242`	`241`	`return some(a);`
`243`	`242`	`else if (l < 0L) {`
`@@ -261,7 +260,6 @@ else if (l < 0L) {`
`261`	`260`	`}`
`262`	`261`	`return some(aa);`
`263`	`262`	`}`
`264`		`- }`
`265`	`263`	`}));`
`266`	`264`	`}`
`267`	`265`