Adding both, for dually applying two functions invariant in the argument

jnape · jnape · commit 6a1ca16fb8ca · 2018-02-25T13:58:07.000-06:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -22,6 +22,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - `These`, a `CoProduct3` of `A`, `B`, or `Tuple2<A,B>`
 - `Span`, for splitting an `Iterable` into contiguous elements matching a predicate
 - `MagnetizeBy` and `Magnetize`, for grouping elements by pairwise predicate tests
+- `Both`, for dually applying two functions and producing a `Tuple2` of their results
 
 ### Deprecated
 - `Either#trying` in favor of `Try#trying` 
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Both.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Both.java
@@ -0,0 +1,51 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import com.jnape.palatable.lambda.adt.hlist.Tuple2;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn3;
+
+import java.util.function.Function;
+
+/**
+ * Given two functions <code>f</code> and <code>g</code>, produce a
+ * <code>{@link Fn1}&lt;A, {@link Tuple2}&lt;B, C&gt;&gt;</code> (the dual application of both functions).
+ *
+ * @param <A> both function's input type
+ * @param <B> the first function return type
+ * @param <C> the second function return type
+ */
+public final class Both<A, B, C> implements Fn3<Function<? super A, ? extends B>, Function<? super A, ? extends C>, A, Tuple2<B, C>> {
+
+    private static final Both INSTANCE = new Both();
+
+    private Both() {
+    }
+
+    @Override
+    public Tuple2<B, C> apply(Function<? super A, ? extends B> f,
+                              Function<? super A, ? extends C> g,
+                              A a) {
+        return Tuple2.fill(a).biMap(f, g);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A, B, C> Both<A, B, C> both() {
+        return INSTANCE;
+    }
+
+    public static <A, B, C> Fn1<Function<? super A, ? extends C>, Fn1<A, Tuple2<B, C>>> both(
+            Function<? super A, ? extends B> f) {
+        return Both.<A, B, C>both().apply(f);
+    }
+
+    public static <A, B, C> Fn1<A, Tuple2<B, C>> both(Function<? super A, ? extends B> f,
+                                                      Function<? super A, ? extends C> g) {
+        return Both.<A, B, C>both(f).apply(g);
+    }
+
+    public static <A, B, C> Tuple2<B, C> both(Function<? super A, ? extends B> f,
+                                              Function<? super A, ? extends C> g,
+                                              A a) {
+        return Both.<A, B, C>both(f, g).apply(a);
+    }
+}
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/BothTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/BothTest.java
@@ -0,0 +1,15 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import org.junit.Test;
+
+import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Both.both;
+import static org.junit.Assert.assertEquals;
+
+public class BothTest {
+
+    @Test
+    public void duallyAppliesTwoFunctionsToSameInput() {
+        assertEquals(tuple(1, -1), both(x -> x + 1, x -> x - 1, 0));
+    }
+}
