adding head() and find()

jnape · jnape · commit b783c73e288f · 2016-11-19T13:09:55.000-06:00
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Head.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn1/Head.java
@@ -0,0 +1,34 @@
+package com.jnape.palatable.lambda.functions.builtin.fn1;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+
+import java.util.Iterator;
+import java.util.Optional;
+
+/**
+ * Retrieve the head element of an <code>Iterable</code>, wrapped in an <code>Optional</code>. If the
+ * <code>Iterable</code> is empty, the result is <code>Optional.empty()</code>.
+ *
+ * @param <A> the Iterable element type
+ */
+public final class Head<A> implements Fn1<Iterable<A>, Optional<A>> {
+
+    private Head() {
+    }
+
+    @Override
+    public Optional<A> apply(Iterable<A> as) {
+        Iterator<A> iterator = as.iterator();
+        return iterator.hasNext()
+                ? Optional.of(iterator.next())
+                : Optional.empty();
+    }
+
+    public static <A> Head<A> head() {
+        return new Head<>();
+    }
+
+    public static <A> Optional<A> head(Iterable<A> as) {
+        return Head.<A>head().apply(as);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Find.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Find.java
@@ -0,0 +1,42 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
+import com.jnape.palatable.lambda.functions.specialized.Predicate;
+
+import java.util.Optional;
+import java.util.function.Function;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Head.head;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.DropWhile.dropWhile;
+
+/**
+ * Iterate the elements in an <code>Iterable</code>, applying a predicate to each one, returning the first element that
+ * matches the predicate, wrapped in an <code>Optional</code>. If no elements match the predicate, the result is
+ * <code>Optional.empty()</code>. This function short-circuits, and so is safe to use on potentially infinite
+ * <code>Iterable</code>s that guarantee to have an eventually matching element.
+ *
+ * @param <A> the Iterable element type
+ */
+public final class Find<A> implements Fn2<Function<? super A, Boolean>, Iterable<A>, Optional<A>> {
+
+    private Find() {
+    }
+
+    @Override
+    public Optional<A> apply(Function<? super A, Boolean> predicate, Iterable<A> as) {
+        return head(dropWhile(((Predicate<A>) predicate::apply).negate(), as));
+    }
+
+    public static <A> Find<A> find() {
+        return new Find<>();
+    }
+
+    public static <A> Fn1<Iterable<A>, Optional<A>> find(Function<? super A, Boolean> predicate) {
+        return Find.<A>find().apply(predicate);
+    }
+
+    public static <A> Optional<A> find(Function<? super A, Boolean> predicate, Iterable<A> as) {
+        return Find.<A>find(predicate).apply(as);
+    }
+}
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/HeadTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn1/HeadTest.java
@@ -0,0 +1,26 @@
+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 java.util.Optional;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Head.head;
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static org.junit.Assert.assertEquals;
+
+@RunWith(Traits.class)
+public class HeadTest {
+
+    @Test
+    public void returnsTheHeadOfNonEmptyIterable() {
+        assertEquals(Optional.of(1), head(asList(1, 2, 3)));
+    }
+
+    @Test
+    public void isEmptyForEmptyIterable() {
+        assertEquals(Optional.empty(), head(emptyList()));
+    }
+}
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/FindTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/FindTest.java
@@ -0,0 +1,32 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import org.junit.Test;
+
+import java.util.Optional;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Find.find;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Iterate.iterate;
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertEquals;
+
+public class FindTest {
+
+    @Test
+    public void findsFirstElementMatchingPredicate() {
+        assertEquals(Optional.of("three"),
+                     find(s -> s.length() > 3, asList("one", "two", "three", "four")));
+    }
+
+    @Test
+    public void isEmptyIfNoElementsMatchPredicate() {
+        assertEquals(Optional.empty(),
+                     find(s -> s.length() > 5, asList("one", "two", "three", "four")));
+    }
+
+    @Test
+    public void shortCircuitsOnMatch() {
+        assertEquals(Optional.of(0),
+                     find(constantly(true), iterate(x -> x + 1, 0)));
+    }
+}
