Distinct, to produce an Iterable of distinct values in another Iterable

Author: jnape

CHANGELOG.md

@@ -15,6 +15,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - `LiftA2` to lift and apply a `Bifunction` to two `Applicative`s
 - `Flatten` to lazily flatten nested `Iterable<Iterable<A>>`s to `Iterable<A>`
 - `Replicate`, short-hand composition of `take` and `repeat`
+- `Distinct` to produce an `Iterable` of distinct values in another `Iterable` 
 
 ## [1.6.2] - 2017-08-20
 ### Fixed

src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Distinct.java

@@ -0,0 +1,34 @@
+package com.jnape.palatable.lambda.functions.builtin.fn1;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+
+import java.util.HashMap;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Filter.filter;
+
+/**
+ * Return an {@link Iterable} of the distinct values from the given input {@link Iterable}.
+ *
+ * @param <A> the Iterable element type
+ */
+public final class Distinct<A> implements Fn1<Iterable<A>, Iterable<A>> {
+    private static final Distinct INSTANCE = new Distinct();
+
+    private Distinct() {
+    }
+
+    @Override
+    public Iterable<A> apply(Iterable<A> as) {
+        HashMap<A, Boolean> known = new HashMap<>();
+        return filter(a -> known.putIfAbsent(a, true) == null, as);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A> Distinct<A> distinct() {
+        return INSTANCE;
+    }
+
+    public static <A> Iterable<A> distinct(Iterable<A> as) {
+        return Distinct.<A>distinct().apply(as);
+    }
+}

src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/DistinctTest.java

@@ -0,0 +1,30 @@
+package com.jnape.palatable.lambda.functions.builtin.fn1;
+
+import com.jnape.palatable.traitor.annotations.TestTraits;
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import testsupport.traits.EmptyIterableSupport;
+import testsupport.traits.FiniteIteration;
+import testsupport.traits.ImmutableIteration;
+import testsupport.traits.InfiniteIterableSupport;
+import testsupport.traits.Laziness;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Distinct.distinct;
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertThat;
+import static testsupport.matchers.IterableMatcher.iterates;
+
+@RunWith(Traits.class)
+public class DistinctTest {
+
+    @TestTraits({Laziness.class, InfiniteIterableSupport.class, EmptyIterableSupport.class, FiniteIteration.class, ImmutableIteration.class})
+    public Distinct testSubject() {
+        return distinct();
+    }
+
+    @Test
+    public void producesIterableOfOnlySingleElementOccurrences() {
+        assertThat(distinct(asList(1, 2, 2, 3, 3, 3)), iterates(1, 2, 3));
+    }
+}