Fn1#widen, (a -> b) -> (z -> a -> b)

jnape · jnape · commit 124a44b2948f · 2018-07-15T18:13:51.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -23,6 +23,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - `Occurrences`, for counting the occurrences of the members of an `Iterable`
 - `Effect`, an `Fn0` returning `UNIT` 
 - `Noop`, a no-op `Effect` 
+- `Fn1#widen`, add an ignored argument to the beginning of any function to raise its arity by one 
 
 ### Changed
 - `Tuple2-8` now implement `Product2-8`
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn1.java
@@ -8,6 +8,7 @@
 import java.util.function.Function;
 
 import static com.jnape.palatable.lambda.functions.Fn2.fn2;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
 
 /**
  * A function taking a single argument. This is the core function type that all other function types extend and
@@ -38,6 +39,16 @@ default Fn0<B> thunk(A a) {
         return __ -> apply(a);
     }
 
+    /**
+     * Widen this function's argument list by prepending an ignored argument of any type to the front.
+     *
+     * @param <Z> the new first argument type
+     * @return the widened function
+     */
+    default <Z> Fn2<Z, A, B> widen() {
+        return fn2(constantly(this));
+    }
+
     @Override
     default <C> Fn1<A, C> flatMap(Function<? super B, ? extends Monad<C, Fn1<A, ?>>> f) {
         return a -> f.apply(apply(a)).<Fn1<A, C>>coerce().apply(a);
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn2.java
@@ -7,6 +7,7 @@
 import java.util.function.Function;
 
 import static com.jnape.palatable.lambda.functions.Fn3.fn3;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
 
 /**
  * A function taking two arguments.
@@ -31,6 +32,14 @@ public interface Fn2<A, B, C> extends Fn1<A, Fn1<B, C>> {
      */
     C apply(A a, B b);
 
+    /**
+     * @inheritDoc
+     */
+    @Override
+    default <Z> Fn3<Z, A, B, C> widen() {
+        return fn3(constantly(this));
+    }
+
     /**
      * Same as normal composition, except that the result is an instance of {@link Fn2} for convenience.
      *
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn3.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn3.java
@@ -7,6 +7,7 @@
 import java.util.function.Function;
 
 import static com.jnape.palatable.lambda.functions.Fn4.fn4;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
 
 /**
  * A function taking three arguments. Defined in terms of {@link Fn2}, so similarly auto-curried.
@@ -30,6 +31,14 @@ public interface Fn3<A, B, C, D> extends Fn2<A, B, Fn1<C, D>> {
      */
     D apply(A a, B b, C c);
 
+    /**
+     * @inheritDoc
+     */
+    @Override
+    default <Z> Fn4<Z, A, B, C, D> widen() {
+        return fn4(constantly(this));
+    }
+
     /**
      * Partially apply this function by taking its first argument.
      *
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn4.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn4.java
@@ -7,6 +7,7 @@
 import java.util.function.Function;
 
 import static com.jnape.palatable.lambda.functions.Fn5.fn5;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
 
 /**
  * A function taking four arguments. Defined in terms of {@link Fn3}, so similarly auto-curried.
@@ -32,6 +33,14 @@ public interface Fn4<A, B, C, D, E> extends Fn3<A, B, C, Fn1<D, E>> {
      */
     E apply(A a, B b, C c, D d);
 
+    /**
+     * @inheritDoc
+     */
+    @Override
+    default <Z> Fn5<Z, A, B, C, D, E> widen() {
+        return fn5(constantly(this));
+    }
+
     /**
      * Partially apply this function by taking its first argument.
      *
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn5.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn5.java
@@ -7,6 +7,7 @@
 import java.util.function.Function;
 
 import static com.jnape.palatable.lambda.functions.Fn6.fn6;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
 
 /**
  * A function taking five arguments. Defined in terms of {@link Fn4}, so similarly auto-curried.
@@ -34,6 +35,14 @@ public interface Fn5<A, B, C, D, E, F> extends Fn4<A, B, C, D, Fn1<E, F>> {
      */
     F apply(A a, B b, C c, D d, E e);
 
+    /**
+     * @inheritDoc
+     */
+    @Override
+    default <Z> Fn6<Z, A, B, C, D, E, F> widen() {
+        return fn6(constantly(this));
+    }
+
     /**
      * Partially apply this function by taking its first argument.
      *
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn6.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn6.java
@@ -7,6 +7,7 @@
 import java.util.function.Function;
 
 import static com.jnape.palatable.lambda.functions.Fn7.fn7;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
 
 /**
  * A function taking six arguments. Defined in terms of {@link Fn5}, so similarly auto-curried.
@@ -36,6 +37,14 @@ public interface Fn6<A, B, C, D, E, F, G> extends Fn5<A, B, C, D, E, Fn1<F, G>>
      */
     G apply(A a, B b, C c, D d, E e, F f);
 
+    /**
+     * @inheritDoc
+     */
+    @Override
+    default <Z> Fn7<Z, A, B, C, D, E, F, G> widen() {
+        return fn7(constantly(this));
+    }
+
     /**
      * Partially apply this function by taking its first argument.
      *
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Fn7.java b/src/main/java/com/jnape/palatable/lambda/functions/Fn7.java
@@ -7,6 +7,7 @@
 import java.util.function.Function;
 
 import static com.jnape.palatable.lambda.functions.Fn8.fn8;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
 
 /**
  * A function taking six arguments. Defined in terms of {@link Fn6}, so similarly auto-curried.
@@ -38,6 +39,14 @@ public interface Fn7<A, B, C, D, E, F, G, H> extends Fn6<A, B, C, D, E, F, Fn1<G
      */
     H apply(A a, B b, C c, D d, E e, F f, G g);
 
+    /**
+     * @inheritDoc
+     */
+    @Override
+    default <Z> Fn8<Z, A, B, C, D, E, F, G, H> widen() {
+        return fn8(constantly(this));
+    }
+
     /**
      * Partially apply this function by taking its first argument.
      *
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/Fn1Test.java b/src/test/java/com/jnape/palatable/lambda/functions/Fn1Test.java
@@ -11,6 +11,9 @@
 
 import java.util.function.Function;
 
+import static com.jnape.palatable.lambda.adt.Maybe.just;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.ReduceLeft.reduceLeft;
+import static java.util.Arrays.asList;
 import static org.junit.Assert.assertEquals;
 
 @RunWith(Traits.class)
@@ -41,4 +44,10 @@ public void thunk() {
         Fn1<Integer, String> toString = Object::toString;
         assertEquals("1", toString.thunk(1).apply());
     }
+
+    @Test
+    public void widen() {
+        Fn1<Integer, Integer> addOne = x -> x + 1;
+        assertEquals(just(4), reduceLeft(addOne.widen().toBiFunction(), asList(1, 2, 3)));
+    }
 }
