adding adapt methods for Fn1 and Fn2 from Function and BiFunction, respectively

Author: jnape

src/main/java/com/jnape/palatable/lambda/functions/Fn1.java

@@ -113,4 +113,17 @@ default <Z> Fn1<Z, B> compose(Function<? super Z, ? extends A> before) {
     default <C> Fn1<A, C> andThen(Function<? super B, ? extends C> after) {
         return a -> after.apply(apply(a));
     }
+
+    /**
+     * Static factory method for wrapping a {@link Function} in an {@link Fn1}. Useful for avoid explicit casting when
+     * using method references as {@link Fn1}s.
+     *
+     * @param function the function to adapt
+     * @param <A>      the input argument type
+     * @param <B>      the output type
+     * @return the Fn1
+     */
+    static <A, B> Fn1<A, B> adapt(Function<A, B> function) {
+        return function::apply;
+    }
 }

src/main/java/com/jnape/palatable/lambda/functions/Fn2.java

@@ -65,4 +65,18 @@ default Fn1<Tuple2<A, B>, C> uncurry() {
     default BiFunction<A, B, C> toBiFunction() {
         return this::apply;
     }
+
+    /**
+     * Static factory method for wrapping a {@link BiFunction} in an {@link Fn2}. Useful for avoid explicit casting when
+     * using method references as {@link Fn2}s.
+     *
+     * @param biFunction the biFunction to adapt
+     * @param <A>        the first input argument type
+     * @param <B>        the second input argument type
+     * @param <C>        the output type
+     * @return the Fn2
+     */
+    static <A, B, C> Fn2<A, B, C> adapt(BiFunction<A, B, C> biFunction) {
+        return biFunction::apply;
+    }
 }

src/test/java/com/jnape/palatable/lambda/functions/Fn1Test.java

@@ -3,6 +3,8 @@
 import org.hamcrest.MatcherAssert;
 import org.junit.Test;
 
+import java.util.function.Function;
+
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertEquals;
 
@@ -32,4 +34,10 @@ public void thenIsJustAnAliasForFmap() {
 
         MatcherAssert.assertThat(add2.then(toString).apply(2), is(toString.apply(add2.apply(2))));
     }
+
+    @Test
+    public void adapt() {
+        Function<String, Integer> parseInt = Integer::parseInt;
+        assertEquals((Integer) 1, Fn1.adapt(parseInt).apply("1"));
+    }
 }

src/test/java/com/jnape/palatable/lambda/functions/Fn2Test.java

@@ -34,4 +34,10 @@ public void toBiFunction() {
         BiFunction<String, Integer, Boolean> biFunction = CHECK_LENGTH.toBiFunction();
         assertEquals(true, biFunction.apply("abc", 3));
     }
+
+    @Test
+    public void adapt() {
+        BiFunction<String, String, String> format = String::format;
+        assertEquals("foo bar", Fn2.adapt(format).apply("foo %s", "bar"));
+    }
 }