adding MapLens#mappingValues, a lens over a map with mapped values

jnape · jnape · commit 03c2949e76ac · 2017-01-08T16:16:20.000-06:00
diff --git a/src/main/java/com/jnape/palatable/lambda/lens/lenses/MapLens.java b/src/main/java/com/jnape/palatable/lambda/lens/lenses/MapLens.java
@@ -1,5 +1,6 @@
 package com.jnape.palatable.lambda.lens.lenses;
 
+import com.jnape.palatable.lambda.functions.builtin.fn2.Filter;
 import com.jnape.palatable.lambda.lens.Lens;
 
 import java.util.Collection;
@@ -8,11 +9,16 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.function.Function;
 
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Eq.eq;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Map.map;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.ToCollection.toCollection;
 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.View.view;
 import static com.jnape.palatable.lambda.lens.lenses.OptionalLens.unLiftA;
+import static java.util.stream.Collectors.toMap;
 import static java.util.stream.Collectors.toSet;
 
 /**
@@ -24,8 +30,7 @@ private MapLens() {
     }
 
     /**
-     * Convenience static factory method for creating a lens that focuses on a copy of a Map. Useful for composition to
-     * avoid mutating a map reference.
+     * A lens that focuses on a copy of a Map. Useful for composition to avoid mutating a map reference.
      *
      * @param <K> the key type
      * @param <V> the value type
@@ -36,8 +41,7 @@ public static <K, V> Lens.Simple<Map<K, V>, Map<K, V>> asCopy() {
     }
 
     /**
-     * Convenience static factory method for creating a lens that focuses on a value at a key in a map, as an {@link
-     * Optional}.
+     * A lens that focuses on a value at a key in a map, as an {@link Optional}.
      *
      * @param k   the key to focus on
      * @param <K> the key type
@@ -52,8 +56,7 @@ public static <K, V> Lens<Map<K, V>, Map<K, V>, Optional<V>, V> valueAt(K k) {
     }
 
     /**
-     * Convenience static factory method for creating a lens that focuses on a value at a key in a map, falling back to
-     * <code>defaultV</code> if the value is missing.
+     * A lens that focuses on a value at a key in a map, falling back to <code>defaultV</code> if the value is missing.
      *
      * @param k            the key to focus on
      * @param defaultValue the default value to use in case of a missing value at key
@@ -67,7 +70,7 @@ public static <K, V> Lens.Simple<Map<K, V>, V> valueAt(K k, V defaultValue) {
     }
 
     /**
-     * Convenience static factory method for creating a lens that focuses on the keys of a map.
+     * A lens that focuses on the keys of a map.
      *
      * @param <K> the key type
      * @param <V> the value type
@@ -84,8 +87,8 @@ public static <K, V> Lens.Simple<Map<K, V>, Set<K>> keys() {
     }
 
     /**
-     * Convenience static factory method for creating a lens that focuses on the values of a map. In the case of
-     * updating the map, only the entries with a value listed in the update collection of values are kept.
+     * A lens that focuses on the values of a map. In the case of updating the map, only the entries with a value listed
+     * in the update collection of values are kept.
      *
      * @param <K> the key type
      * @param <V> the value type
@@ -104,8 +107,8 @@ public static <K, V> Lens.Simple<Map<K, V>, Collection<V>> values() {
     }
 
     /**
-     * Convenience static factory method for creating a lens that focuses on the inverse of a map (keys and values
-     * swapped). In the case of multiple equal values becoming keys, the last one wins.
+     * A lens that focuses on the inverse of a map (keys and values swapped). In the case of multiple equal values
+     * becoming keys, the last one wins.
      *
      * @param <K> the key type
      * @param <V> the value type
@@ -122,4 +125,27 @@ public static <K, V> Lens.Simple<Map<K, V>, Map<V, K>> inverted() {
             return m;
         });
     }
+
+    /**
+     * A lens that focuses on a map while mapping its values with the mapping function.
+     *
+     * @param fn   the mapping function
+     * @param <K>  the key type
+     * @param <V>  the unfocused map value type
+     * @param <V2> the focused map value type
+     * @return a lens that focuses on a map while mapping its values
+     */
+    public static <K, V, V2> Lens.Simple<Map<K, V>, Map<K, V2>> mappingValues(Function<? super V, ? extends V2> fn) {
+        return Lens.simpleLens(m -> m.entrySet().stream().collect(toMap(Map.Entry::getKey, kv -> fn.apply(kv.getValue()))),
+                               (s, b) -> {
+                                   //todo: remove this madness upon arrival of either invertible functions or Iso<V,V2>
+                                   Set<K> retainKeys = Filter.<Map.Entry<K, V>>filter(kv -> eq(fn.apply(kv.getValue()), b.get(kv.getKey())))
+                                           .andThen(map(Map.Entry::getKey))
+                                           .andThen(toCollection(HashSet::new))
+                                           .apply(s.entrySet());
+                                   Map<K, V> copy = new HashMap<>(s);
+                                   copy.keySet().retainAll(retainKeys);
+                                   return copy;
+                               });
+    }
 }
diff --git a/src/test/java/com/jnape/palatable/lambda/lens/lenses/MapLensTest.java b/src/test/java/com/jnape/palatable/lambda/lens/lenses/MapLensTest.java
@@ -14,8 +14,11 @@
 import static com.jnape.palatable.lambda.lens.functions.Set.set;
 import static com.jnape.palatable.lambda.lens.functions.View.view;
 import static com.jnape.palatable.lambda.lens.lenses.MapLens.keys;
+import static com.jnape.palatable.lambda.lens.lenses.MapLens.mappingValues;
 import static java.util.Arrays.asList;
 import static java.util.Collections.emptyMap;
+import static java.util.Collections.singletonMap;
+import static java.util.Collections.unmodifiableMap;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertSame;
@@ -134,4 +137,27 @@ public void invertedFocusesOnMapWithKeysAndValuesSwitched() {
             put(1, "foo");
         }}, view(inverted, withDuplicateValues));
     }
+
+    @Test
+    public void mappingValuesRetainsMapStructureWithMappedValues() {
+        Map<String, String> m = unmodifiableMap(new HashMap<String, String>() {{
+            put("foo", "1");
+            put("bar", "2");
+            put("baz", "3");
+        }});
+        Lens.Simple<Map<String, String>, Map<String, Integer>> mappingValues = mappingValues(Integer::parseInt);
+
+        assertEquals(new HashMap<String, Integer>() {{
+            put("foo", 1);
+            put("bar", 2);
+            put("baz", 3);
+        }}, view(mappingValues, m));
+
+        Map<String, String> updated = set(mappingValues, unmodifiableMap(new HashMap<String, Integer>() {{
+            put("foo", 2);
+            put("bar", 1);
+            put("baz", 3);
+        }}), m);
+        assertEquals(singletonMap("baz", "3"), updated);
+    }
 }
