Adding Span

jnape · jnape · commit b62b2a0d380e · 2018-02-18T14:31:51.000-06:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -18,7 +18,8 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - `CheckedRunnable`, the `Runnable` counterpart to `CheckedSupplier` that can throw checked exceptions
 - `Unit`, the lambda analog to `Void`, except actually inhabited by a singleton instance 
 - `Kleisli`, the abstract representation of a `Kleisli` arrow (`Monad#flatMap`) as an `Fn1` 
-- `These`, a `CoProduct3` of `A`, `B`, or `Tuple2<A,B>` 
+- `These`, a `CoProduct3` of `A`, `B`, or `Tuple2<A,B>`
+- `Span`, for splitting an `Iterable` into contiguous elements matching a predicate
 
 ### Deprecated
 - `Either#trying` in favor of `Try#trying` 
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Span.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Span.java
@@ -0,0 +1,43 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import com.jnape.palatable.lambda.adt.hlist.Tuple2;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
+
+import java.util.function.Function;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn2.DropWhile.dropWhile;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.TakeWhile.takeWhile;
+
+/**
+ * Given a predicate, return a {@link Tuple2} where the first slot is the front contiguous elements of an {@link
+ * Iterable} matching the predicate and the second slot is all the remaining elements.
+ *
+ * @param <A> the {@link Iterable} element type
+ */
+public final class Span<A> implements Fn2<Function<? super A, Boolean>, Iterable<A>, Tuple2<Iterable<A>, Iterable<A>>> {
+
+    private static final Span INSTANCE = new Span();
+
+    private Span() {
+    }
+
+    @Override
+    public Tuple2<Iterable<A>, Iterable<A>> apply(Function<? super A, Boolean> predicate, Iterable<A> as) {
+        return Tuple2.fill(as).biMap(takeWhile(predicate), dropWhile(predicate));
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A> Span<A> span() {
+        return INSTANCE;
+    }
+
+    public static <A> Fn1<Iterable<A>, Tuple2<Iterable<A>, Iterable<A>>> span(Function<? super A, Boolean> predicate) {
+        return Span.<A>span().apply(predicate);
+    }
+
+    public static <A> Tuple2<Iterable<A>, Iterable<A>> span(Function<? super A, Boolean> predicate,
+                                                            Iterable<A> as) {
+        return Span.<A>span(predicate).apply(as);
+    }
+}
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/SpanTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/SpanTest.java
@@ -0,0 +1,37 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import com.jnape.palatable.lambda.adt.hlist.Tuple2;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.monoid.builtin.Concat;
+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.fn2.Eq.eq;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Into.into;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Span.span;
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertThat;
+import static testsupport.matchers.IterableMatcher.iterates;
+
+@RunWith(Traits.class)
+public class SpanTest {
+
+    @TestTraits({EmptyIterableSupport.class, InfiniteIterableSupport.class, FiniteIteration.class, ImmutableIteration.class, Laziness.class})
+    public Fn1<Iterable<Integer>, Iterable<Integer>> testSubject() {
+        return span(eq(0)).fmap(into(Concat::concat));
+    }
+
+    @Test
+    public void splitsIterableAfterPredicateFailure() {
+        Tuple2<Iterable<Integer>, Iterable<Integer>> spanned = span(eq(1), asList(1, 1, 1, 2, 3, 1));
+        assertThat(spanned._1(), iterates(1, 1, 1));
+        assertThat(spanned._2(), iterates(2, 3, 1));
+    }
+}
