Adding SetLens, lenses that operate on Sets

jnape · jnape · commit dfbc3faca965 · 2018-05-11T19:32:32.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -9,6 +9,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 ### Added
 - `Upcast` for safely casting up a type hierarchy
+- `SetLens`, lenses operating on `Set`s
 
 ## [3.0.0] - 2018-05-04
 ### Changed
diff --git a/src/main/java/com/jnape/palatable/lambda/lens/lenses/SetLens.java b/src/main/java/com/jnape/palatable/lambda/lens/lenses/SetLens.java
@@ -0,0 +1,51 @@
+package com.jnape.palatable.lambda.lens.lenses;
+
+import com.jnape.palatable.lambda.lens.Lens;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.function.Function;
+
+import static com.jnape.palatable.lambda.lens.Lens.simpleLens;
+
+/**
+ * Lenses that operate on {@link Set}s.
+ */
+public final class SetLens {
+
+    private SetLens() {
+    }
+
+    /**
+     * A lens that focuses on whether a {@link Set} contains some value <code>a</code>. Note that <code>copyFn</code> is
+     * used to avoid mutating the {@link Set} in question.
+     *
+     * @param copyFn the copy function
+     * @param a      the value in question
+     * @param <A>    the value type
+     * @param <SetA> the set to focus on
+     * @return a lens that focuses on a value's inclusion in a given {@link Set}
+     */
+    public static <A, SetA extends Set<A>> Lens.Simple<SetA, Boolean> contains(
+            Function<? super SetA, ? extends SetA> copyFn, A a) {
+        return simpleLens(setA -> setA.contains(a),
+                          (setA, include) -> {
+                              SetA copy = copyFn.apply(setA);
+                              if (include) copy.add(a);
+                              else copy.remove(a);
+                              return copy;
+                          });
+    }
+
+    /**
+     * A lens that focuses on whether a {@link Set} contains some value <code>a</code>. Like {@link #contains(Function,
+     * Object)} but with an implicit copy function that produces <code>{@link HashSet}s</code>.
+     *
+     * @param a   the value in question
+     * @param <A> the value type
+     * @return a lens that focuses on a value's inclusion in a given {@link Set}
+     */
+    public static <A> Lens.Simple<Set<A>, Boolean> contains(A a) {
+        return contains(HashSet::new, a);
+    }
+}
diff --git a/src/test/java/com/jnape/palatable/lambda/lens/lenses/SetLensTest.java b/src/test/java/com/jnape/palatable/lambda/lens/lenses/SetLensTest.java
@@ -0,0 +1,41 @@
+package com.jnape.palatable.lambda.lens.lenses;
+
+import org.junit.Test;
+
+import java.util.HashSet;
+import java.util.TreeSet;
+
+import static com.jnape.palatable.lambda.lens.functions.Set.set;
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptySet;
+import static java.util.Collections.singleton;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.junit.Assert.assertThat;
+import static testsupport.assertion.LensAssert.assertLensLawfulness;
+
+public class SetLensTest {
+
+    @Test
+    public void containsWithCopyFn() {
+        assertLensLawfulness(SetLens.contains(HashSet::new, 1),
+                             asList(emptySet(),
+                                    singleton(1),
+                                    singleton(2),
+                                    new HashSet<>(asList(1, 2)),
+                                    new HashSet<>(asList(2, 3))),
+                             asList(true, false));
+        assertThat(set(SetLens.contains(TreeSet::new, 1), true, emptySet()), instanceOf(TreeSet.class));
+    }
+
+    @Test
+    public void containsWithoutCopyFn() {
+        assertLensLawfulness(SetLens.contains(1),
+                             asList(emptySet(),
+                                    singleton(1),
+                                    singleton(2),
+                                    new HashSet<>(asList(1, 2)),
+                                    new HashSet<>(asList(2, 3))),
+                             asList(true, false));
+        assertThat(set(SetLens.contains(1), true, emptySet()), instanceOf(HashSet.class));
+    }
+}
