adding CatMaybes to unwrap an Iterable<Maybe<A>> to Iterable<A>

jnape · jnape · commit 44db57ec8e69 · 2017-11-12T13:39:19.000-06:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -31,6 +31,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - `Tails`, for iterating all the tail element subsequences of an `Iterable`
 - `Inits`, for iterating all the initial element subsequences of an `Iterable`  
 - `Init`, for iterating all but the last element of an `Iterable`
+- `CatMaybes`, for unwrapping the present values in an `Iterable<Maybe<A>>` to produce an `Iterable<A>`
 
 ### Removed
 - `Fn1#then(Function<? super B, ? extends C>)`, deprecated in previous release 
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/CatMaybes.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/CatMaybes.java
@@ -0,0 +1,37 @@
+package com.jnape.palatable.lambda.functions.builtin.fn1;
+
+import com.jnape.palatable.lambda.adt.Maybe;
+import com.jnape.palatable.lambda.functions.Fn1;
+
+import java.util.Collections;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Flatten.flatten;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Map.map;
+
+/**
+ * Given an <code>{@link Iterable}&lt;{@link Maybe}&lt;A&gt;&gt;</code>, return an
+ * <code>{@link Iterable}&lt;A&gt;</code> of only the present values.
+ *
+ * @param <A> the {@link Maybe} element type, as well as the resulting {@link Iterable} element type
+ */
+public final class CatMaybes<A> implements Fn1<Iterable<Maybe<A>>, Iterable<A>> {
+    private static final CatMaybes INSTANCE = new CatMaybes();
+
+    private CatMaybes() {
+    }
+
+    @Override
+    public Iterable<A> apply(Iterable<Maybe<A>> maybes) {
+        return flatten(map(m -> m.<Iterable<A>>fmap(Collections::singletonList)
+                .orElse(Collections::emptyIterator), maybes));
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A> CatMaybes<A> catMaybes() {
+        return INSTANCE;
+    }
+
+    public static <A> Iterable<A> catMaybes(Iterable<Maybe<A>> as) {
+        return CatMaybes.<A>catMaybes().apply(as);
+    }
+}
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/CatMaybesTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/CatMaybesTest.java
@@ -0,0 +1,40 @@
+package com.jnape.palatable.lambda.functions.builtin.fn1;
+
+import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static com.jnape.palatable.lambda.adt.Maybe.just;
+import static com.jnape.palatable.lambda.adt.Maybe.nothing;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.CatMaybes.catMaybes;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Repeat.repeat;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Take.take;
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static org.junit.Assert.assertThat;
+import static testsupport.matchers.IterableMatcher.isEmpty;
+import static testsupport.matchers.IterableMatcher.iterates;
+
+@RunWith(Traits.class)
+public class CatMaybesTest {
+
+    @Test
+    public void empty() {
+        assertThat(catMaybes(emptyList()), isEmpty());
+    }
+
+    @Test
+    public void onlyNothingsIsEquivalentToEmpty() {
+        assertThat(catMaybes(asList(nothing(), nothing(), nothing())), isEmpty());
+    }
+
+    @Test
+    public void nonEmpty() {
+        assertThat(catMaybes(asList(nothing(), just(1), just(2), nothing(), just(3))), iterates(1, 2, 3));
+    }
+
+    @Test
+    public void infiniteIterableSupport() {
+        assertThat(take(3, catMaybes(repeat(just(1)))), iterates(1, 1, 1));
+    }
+}
