Lens#both for dually focusing with two lenses at once

jnape · jnape · commit c72ef9199a15 · 2018-02-25T13:58:10.000-06:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -23,6 +23,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - `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
+- `Lens#both`, for dually focusing with two lenses at once
 
 ### Deprecated
 - `Either#trying` in favor of `Try#trying` 
diff --git a/src/main/java/com/jnape/palatable/lambda/lens/Lens.java b/src/main/java/com/jnape/palatable/lambda/lens/Lens.java
@@ -1,6 +1,9 @@
 package com.jnape.palatable.lambda.lens;
 
+import com.jnape.palatable.lambda.adt.hlist.Tuple2;
+import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
+import com.jnape.palatable.lambda.functions.builtin.fn2.Both;
 import com.jnape.palatable.lambda.functor.Applicative;
 import com.jnape.palatable.lambda.functor.Functor;
 import com.jnape.palatable.lambda.functor.Profunctor;
@@ -311,6 +314,23 @@ static <S, A> Lens.Simple<S, A> simpleLens(Function<? super S, ? extends A> gett
         return adapt(lens(getter, setter));
     }
 
+    /**
+     * Dually focus on two lenses at the same time. Requires <code>S</code> and <code>T</code> to be invariant between
+     * lenses.
+     *
+     * @param f   the first lens
+     * @param g   the second lens
+     * @param <S> both larger values
+     * @param <A> f's smaller viewing value
+     * @param <B> g's smaller viewing value
+     * @param <C> f's smaller setting value
+     * @param <D> g's smaller setting value
+     * @return the dual-focus lens
+     */
+    static <S, A, B, C, D> Lens<S, S, Tuple2<A, B>, Tuple2<C, D>> both(Lens<S, S, A, C> f, Lens<S, S, B, D> g) {
+        return lens(Both.both(view(f), view(g)), (s, cd) -> cd.biMap(set(f), set(g)).into(Fn1::compose).apply(s));
+    }
+
     /**
      * A convenience type with a simplified type signature for common lenses with both unified "larger" values and
      * unified "smaller" values.
@@ -335,11 +355,32 @@ default <B> Lens.Simple<S, B> andThen(Lens.Simple<A, B> f) {
             return f.compose(this);
         }
 
+        /**
+         * Adapt a {@link Lens} with the right variance to a {@link Lens.Simple}.
+         *
+         * @param lens the lens
+         * @param <S>  S/T
+         * @param <A>  A/B
+         * @return the simple lens
+         */
         @SuppressWarnings("unchecked")
         static <S, A> Simple<S, A> adapt(Lens<S, S, A, A> lens) {
             return lens::apply;
         }
 
+        /**
+         * Specialization of {@link Lens#both(Lens, Lens)} for simple lenses.
+         *
+         * @param f   the first lens
+         * @param g   the second lens
+         * @param <S> both lens larger values
+         * @param <A> both lens smaller values
+         * @return the dual-focus simple lens
+         */
+        static <S, A> Lens.Simple<S, Tuple2<A, A>> both(Lens<S, S, A, A> f, Lens<S, S, A, A> g) {
+            return adapt(Lens.both(f, g));
+        }
+
         /**
          * A convenience type with a simplified type signature for fixed simple lenses.
          *
diff --git a/src/test/java/com/jnape/palatable/lambda/lens/LensTest.java b/src/test/java/com/jnape/palatable/lambda/lens/LensTest.java
@@ -1,6 +1,7 @@
 package com.jnape.palatable.lambda.lens;
 
 import com.jnape.palatable.lambda.adt.Maybe;
+import com.jnape.palatable.lambda.adt.hlist.Tuple2;
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functor.builtin.Const;
 import com.jnape.palatable.lambda.functor.builtin.Identity;
@@ -18,7 +19,10 @@
 import java.util.Set;
 
 import static com.jnape.palatable.lambda.adt.Maybe.just;
+import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
+import static com.jnape.palatable.lambda.lens.Lens.both;
 import static com.jnape.palatable.lambda.lens.Lens.lens;
+import static com.jnape.palatable.lambda.lens.Lens.simpleLens;
 import static com.jnape.palatable.lambda.lens.functions.Set.set;
 import static com.jnape.palatable.lambda.lens.functions.View.view;
 import static java.lang.Integer.parseInt;
@@ -89,4 +93,14 @@ public void andThenComposesInReverse() {
         assertEquals("one", view(EARLIER_LENS.andThen(LENS), map));
         assertEquals(singletonMap("foo", singleton(1)), set(EARLIER_LENS.andThen(LENS), 1, map));
     }
+
+    @Test
+    public void bothSplitsFocusBetweenLenses() {
+        Lens<String, String, Character, Character> firstChar = simpleLens(s -> s.charAt(0), (s, c) -> c + s.substring(1));
+        Lens<String, String, Integer, Integer> length = simpleLens(String::length, (s, k) -> s.substring(0, k));
+        Lens<String, String, Tuple2<Character, Integer>, Tuple2<Character, Integer>> both = both(firstChar, length);
+
+        assertEquals(tuple('a', 3), view(both, "abc"));
+        assertEquals("zb", set(both, tuple('z', 2), "abc"));
+    }
 }
