Use uncurried version of foldLeft as default implementation

jbgi · jbgi · commit 9983ab260fe7 · 2016-06-21T22:23:31.000+02:00
to avoid creation of closures in tight loop.
diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
@@ -751,13 +751,7 @@ public final <B> Trampoline<B> foldRightC(final F2<A, B, B> f, final B b) {
    * @return The final result after the left-fold reduction.
    */
   public final <B> B foldLeft(final F<B, F<A, B>> f, final B b) {
-    B x = b;
-
-    for (List<A> xs = this; !xs.isEmpty(); xs = xs.tail()) {
-      x = f.f(x).f(xs.head());
-    }
-
-    return x;
+    return foldLeft(uncurryF2(f), b);
   }
 
   /**
@@ -768,7 +762,13 @@ public final <B> B foldLeft(final F<B, F<A, B>> f, final B b) {
    * @return The final result after the left-fold reduction.
    */
   public final <B> B foldLeft(final F2<B, A, B> f, final B b) {
-    return foldLeft(curry(f), b);
+    B x = b;
+
+    for (List<A> xs = this; !xs.isEmpty(); xs = xs.tail()) {
+      x = f.f(x, xs.head());
+    }
+
+    return x;
   }
 
   /**
@@ -779,7 +779,9 @@ public final <B> B foldLeft(final F2<B, A, B> f, final B b) {
    * @return The final result after the left-fold reduction.
    */
   public final A foldLeft1(final F2<A, A, A> f) {
-    return foldLeft1(curry(f));
+    if (isEmpty())
+      throw error("Undefined: foldLeft1 on empty list");
+    return tail().foldLeft(f, head());
   }
 
   /**
@@ -790,9 +792,7 @@ public final A foldLeft1(final F2<A, A, A> f) {
    * @return The final result after the left-fold reduction.
    */
   public final A foldLeft1(final F<A, F<A, A>> f) {
-    if (isEmpty())
-      throw error("Undefined: foldLeft1 on empty list");
-    return tail().foldLeft(f, head());
+    return foldLeft1(uncurryF2(f));
   }
 
   /**
@@ -801,7 +801,7 @@ public final A foldLeft1(final F<A, F<A, A>> f) {
    * @return A new list that is the reverse of this one.
    */
   public final List<A> reverse() {
-    return foldLeft(as -> a -> cons(a, as), List.nil());
+    return foldLeft((as, a) -> cons(a, as), nil());
   }
 
   /**
@@ -904,7 +904,7 @@ public final List<List<A>> partition(final int n) {
    * @param f Predicate function.
    */
   public final P2<List<A>, List<A>> partition(F<A, Boolean> f) {
-    P2<List<A>, List<A>> p2 = foldLeft(acc -> a ->
+    P2<List<A>, List<A>> p2 = foldLeft((acc, a) ->
       f.f(a) ? p(acc._1().cons(a), acc._2()) : p(acc._1(), acc._2().cons(a)),
       p(nil(), nil())
     );
@@ -1393,7 +1393,7 @@ public final <B, C, D> TreeMap<B, D> groupBy(
       final D groupingIdentity,
       final F2<C, D, D> groupingAcc,
       final Ord<B> keyOrd) {
-    return this.foldLeft(map -> element -> {
+    return this.foldLeft((map, element) -> {
           final B key = keyFunction.f(element);
           final C value = valueFunction.f(element);
           return map.set(key, map.get(key)
diff --git a/core/src/main/java/fj/data/PriorityQueue.java b/core/src/main/java/fj/data/PriorityQueue.java
@@ -117,7 +117,7 @@ public PriorityQueue<K, A> enqueue(K k, A a) {
      * Adds nodes using the list of products with priority k and value a.  This operation takes O(list.length()).
      */
     public PriorityQueue<K, A> enqueue(List<P2<K, A>> list) {
-        return list.foldLeft(pq -> p -> pq.enqueue(p._1(), p._2()), this);
+        return list.foldLeft((pq, p) -> pq.enqueue(p._1(), p._2()), this);
     }
 
     /**
diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
@@ -22,11 +22,7 @@
 import java.util.*;
 
 import static fj.Bottom.error;
-import static fj.Function.compose;
-import static fj.Function.constant;
-import static fj.Function.curry;
-import static fj.Function.flip;
-import static fj.Function.identity;
+import static fj.Function.*;
 import static fj.P.p;
 import static fj.P.p2;
 import static fj.Unit.unit;
@@ -167,12 +163,7 @@ public final <B> B foldRight1(final F2<A, B, B> f, final B b) {
    * @return The final result after the left-fold reduction.
    */
   public final <B> B foldLeft(final F<B, F<A, B>> f, final B b) {
-    B x = b;
-
-    for (Stream<A> xs = this; !xs.isEmpty(); xs = xs.tail()._1())
-      x = f.f(x).f(xs.head());
-
-    return x;
+    return foldLeft(uncurryF2(f), b);
   }
 
   /**
@@ -183,7 +174,12 @@ public final <B> B foldLeft(final F<B, F<A, B>> f, final B b) {
    * @return The final result after the left-fold reduction.
    */
   public final <B> B foldLeft(final F2<B, A, B> f, final B b) {
-    return foldLeft(curry(f), b);
+    B x = b;
+
+    for (Stream<A> xs = this; !xs.isEmpty(); xs = xs.tail()._1())
+      x = f.f(x, xs.head());
+
+    return x;
   }
 
   /**
@@ -194,7 +190,9 @@ public final <B> B foldLeft(final F2<B, A, B> f, final B b) {
    * @return The final result after the left-fold reduction.
    */
   public final A foldLeft1(final F2<A, A, A> f) {
-    return foldLeft1(curry(f));
+    if (isEmpty())
+      throw error("Undefined: foldLeft1 on empty list");
+    return tail()._1().foldLeft(f, head());
   }
 
   /**
@@ -205,9 +203,7 @@ public final A foldLeft1(final F2<A, A, A> f) {
    * @return The final result after the left-fold reduction.
    */
   public final A foldLeft1(final F<A, F<A, A>> f) {
-    if (isEmpty())
-      throw error("Undefined: foldLeft1 on empty list");
-    return tail()._1().foldLeft(f, head());
+    return foldLeft1(uncurryF2(f));
   }
 
   /**
@@ -1188,7 +1184,7 @@ public final P2<Stream<A>, Stream<A>> split(final F<A, Boolean> p) {
    * @return A new stream that is the reverse of this one.
    */
   public final Stream<A> reverse() {
-    return foldLeft(as -> a -> cons(a, () -> as), Stream.nil());
+    return foldLeft((as, a) -> cons(a, () -> as), Stream.nil());
   }
 
   /**

Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@ public PriorityQueue<K, A> enqueue(K k, A a) {`
`117`	`117`	`* Adds nodes using the list of products with priority k and value a. This operation takes O(list.length()).`
`118`	`118`	`*/`
`119`	`119`	`public PriorityQueue<K, A> enqueue(List<P2<K, A>> list) {`
`120`		`- return list.foldLeft(pq -> p -> pq.enqueue(p._1(), p._2()), this);`
	`120`	`+ return list.foldLeft((pq, p) -> pq.enqueue(p._1(), p._2()), this);`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`/**`