Renaming current fn2 sfm to curried, and new fn2 just aids inference

jnape · jnape · commit a6636d5c2345 · 2019-05-15T17:48:38.000-05:00
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java
@@ -12,7 +12,7 @@
 
 import java.util.function.Function;
 
-import static com.jnape.palatable.lambda.functions.Fn2.fn2;
+import static com.jnape.palatable.lambda.functions.Fn2.curried;
 import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
 
 /**
@@ -69,7 +69,7 @@ default Fn0<B> thunk(A a) {
      * @return the widened function
      */
     default <Z> Fn2<Z, A, B> widen() {
-        return fn2(constantly(this));
+        return curried(constantly(this));
     }
 
     /**
@@ -246,7 +246,7 @@ default <Z> Fn1<Z, B> contraMap(Fn1<? super Z, ? extends A> fn) {
      * @return an {@link Fn2}&lt;Y, Z, B&gt;
      */
     default <Y, Z> Fn2<Y, Z, B> compose(Fn2<? super Y, ? super Z, ? extends A> before) {
-        return fn2(before.fmap(this::contraMap))::apply;
+        return curried(before.fmap(this::contraMap))::apply;
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java
@@ -100,23 +100,23 @@ default BiFunction<A, B, C> toBiFunction() {
      */
     @Override
     default <D> Fn2<A, B, C> discardR(Applicative<D, Fn1<A, ?>> appB) {
-        return fn2(Fn1.super.discardR(appB));
+        return curried(Fn1.super.discardR(appB));
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     default <Z> Fn2<Z, B, C> diMapL(Fn1<? super Z, ? extends A> fn) {
-        return fn2(Fn1.super.diMapL(fn));
+        return curried(Fn1.super.diMapL(fn));
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     default <Z> Fn2<Z, B, C> contraMap(Fn1<? super Z, ? extends A> fn) {
-        return fn2(Fn1.super.contraMap(fn));
+        return curried(Fn1.super.contraMap(fn));
     }
 
     /**
@@ -149,7 +149,12 @@ static <A, B, C> Fn2<A, B, C> fromBiFunction(BiFunction<? super A, ? super B, ?
      * @param <C>        the output type
      * @return the {@link Fn2}
      */
-    static <A, B, C> Fn2<A, B, C> fn2(Fn1<A, Fn1<B, C>> curriedFn1) {
+    static <A, B, C> Fn2<A, B, C> curried(Fn1<A, Fn1<B, C>> curriedFn1) {
         return (a, b) -> curriedFn1.apply(a).apply(b);
     }
+
+    static <A, B, C> Fn2<A, B, C> fn2(Fn2<A, B, C> fn2) {
+        return fn2;
+    }
+
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/monoid/builtin/Endo.java b/src/main/java/com/jnape/palatable/lambda/monoid/builtin/Endo.java
@@ -4,7 +4,7 @@
 import com.jnape.palatable.lambda.functions.Fn2;
 import com.jnape.palatable.lambda.monoid.Monoid;
 
-import static com.jnape.palatable.lambda.functions.Fn2.fn2;
+import static com.jnape.palatable.lambda.functions.Fn2.curried;
 import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
 
 /**
@@ -35,7 +35,7 @@ public Fn1<A, A> checkedApply(Fn1<A, A> f, Fn1<A, A> g) {
 
     @Override
     public Fn2<Fn1<A, A>, A, A> apply(Fn1<A, A> f) {
-        return fn2(Monoid.super.apply(f));
+        return curried(Monoid.super.apply(f));
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/com/jnape/palatable/lambda/optics/Iso.java b/src/main/java/com/jnape/palatable/lambda/optics/Iso.java
@@ -137,7 +137,7 @@ default <U> Iso<S, T, A, B> discardR(Applicative<U, Iso<S, ?, A, B>> appB) {
     @Override
     default <U> Iso<S, U, A, B> flatMap(Fn1<? super T, ? extends Monad<U, Iso<S, ?, A, B>>> fn) {
         //noinspection RedundantTypeArguments
-        return unIso().fmap(bt -> Fn2.<B, B, U>fn2(
+        return unIso().fmap(bt -> Fn2.<B, B, U>curried(
                 fn1(bt.fmap(fn.<Iso<S, U, A, B>>fmap(Monad<U, Iso<S, ?, A, B>>::coerce))
                             .fmap(Iso::unIso)
                             .fmap(Tuple2::_2)
diff --git a/src/main/java/com/jnape/palatable/lambda/optics/lenses/IterableLens.java b/src/main/java/com/jnape/palatable/lambda/optics/lenses/IterableLens.java
@@ -6,7 +6,7 @@
 import com.jnape.palatable.lambda.optics.Iso;
 import com.jnape.palatable.lambda.optics.Lens;
 
-import static com.jnape.palatable.lambda.functions.Fn2.fn2;
+import static com.jnape.palatable.lambda.functions.Fn2.curried;
 import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
 import static com.jnape.palatable.lambda.functions.builtin.fn2.Cons.cons;
 import static com.jnape.palatable.lambda.functions.builtin.fn2.Map.map;
@@ -45,7 +45,7 @@ public static <A> Lens.Simple<Iterable<A>, Maybe<A>> head() {
      * @return a lens focusing on the tail of an {@link Iterable}
      */
     public static <A> Lens.Simple<Iterable<A>, Iterable<A>> tail() {
-        return simpleLens(Tail::tail, fn2(Head.<A>head().fmap(o -> o.fmap(cons()).orElse(id()))));
+        return simpleLens(Tail::tail, curried(Head.<A>head().fmap(o -> o.fmap(cons()).orElse(id()))));
     }
 
     /**
diff --git a/src/main/java/com/jnape/palatable/lambda/traversable/LambdaMap.java b/src/main/java/com/jnape/palatable/lambda/traversable/LambdaMap.java
@@ -10,7 +10,7 @@
 import java.util.Objects;
 
 import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
-import static com.jnape.palatable.lambda.functions.Fn2.fn2;
+import static com.jnape.palatable.lambda.functions.Fn2.curried;
 import static com.jnape.palatable.lambda.functions.builtin.fn2.Into.into;
 import static com.jnape.palatable.lambda.functions.builtin.fn2.Map.map;
 import static com.jnape.palatable.lambda.functions.builtin.fn2.ToMap.toMap;
@@ -50,7 +50,7 @@ public <C> LambdaMap<A, C> fmap(Fn1<? super B, ? extends C> fn) {
             AppC extends Applicative<C, App>,
             AppTrav extends Applicative<TravC, App>> AppTrav traverse(Fn1<? super B, ? extends AppC> fn,
                                                                       Fn1<? super TravC, ? extends AppTrav> pure) {
-        return foldLeft(fn2(appTrav -> into((k, appV) -> (AppTrav) appTrav.<TravC>zip(appV.fmap(v -> m -> {
+        return foldLeft(curried(appTrav -> into((k, appV) -> (AppTrav) appTrav.<TravC>zip(appV.fmap(v -> m -> {
                             ((LambdaMap<A, C>) m).unwrap().put(k, v);
                             return m;
                         })))),
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/Fn2Test.java b/src/test/java/com/jnape/palatable/lambda/functions/Fn2Test.java
@@ -36,9 +36,15 @@ public void toBiFunction() {
     }
 
     @Test
-    public void fn2() {
+    public void curried() {
         Fn1<String, Fn1<String, String>> curriedFn1 = (x) -> (y) -> String.format(x, y);
-        assertEquals("foo bar", Fn2.fn2(curriedFn1).apply("foo %s", "bar"));
+        assertEquals("foo bar", Fn2.curried(curriedFn1).apply("foo %s", "bar"));
+    }
+
+    @Test
+    public void fn2() {
+        Fn2<String, String, String> fn2 = Fn2.fn2(String::format);
+        assertEquals("foo bar", fn2.apply("foo %s", "bar"));
     }
 
     @Test
