Adding First and Last, Optional monoids that choose the first or last present value, respectively

jnape · jnape · commit f3e89cd0eedc · 2017-02-05T17:00:25.000-06:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -8,6 +8,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - `ChoiceN` types, representing concrete coproduct implementations that are also `Functor` and `BiFunctor`
 - `toMap`, `last`, `cons`, `prependAll`, `intersperse`
 - `Tuple2/3/4#into`, for applying the values in a tuple as positional arguments to a function.
+- `First` and `Last` monoids over `Optional`
 
 ### Changed
 - `CoProductN.[a-e]()` static factory methods moved to equivalent `ChoiceN` class. Coproduct interfaces now solely represent methods, no longer have anonymous implementations, and no longer require a `Functor` constraint
diff --git a/src/main/java/com/jnape/palatable/lambda/monoid/builtin/First.java b/src/main/java/com/jnape/palatable/lambda/monoid/builtin/First.java
@@ -0,0 +1,47 @@
+package com.jnape.palatable.lambda.monoid.builtin;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.monoid.Monoid;
+
+import java.util.Optional;
+
+/**
+ * A {@link Monoid} instance formed by <code>{@link Optional}&lt;A&gt;</code>. The application to two {@link Optional}
+ * values produces the first non-empty value, or <code>Optional.empty()</code> if all values are empty.
+ *
+ * @param <A> the Optional value parameter type
+ * @see Last
+ * @see Present
+ * @see Monoid
+ * @see Optional
+ */
+public final class First<A> implements Monoid<Optional<A>> {
+
+    private static final First INSTANCE = new First();
+
+    private First() {
+    }
+
+    @Override
+    public Optional<A> identity() {
+        return Optional.empty();
+    }
+
+    @Override
+    public Optional<A> apply(Optional<A> x, Optional<A> y) {
+        return x.map(Optional::of).orElse(y);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A> First<A> first() {
+        return INSTANCE;
+    }
+
+    public static <A> Fn1<Optional<A>, Optional<A>> first(Optional<A> x) {
+        return First.<A>first().apply(x);
+    }
+
+    public static <A> Optional<A> first(Optional<A> x, Optional<A> y) {
+        return first(x).apply(y);
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/monoid/builtin/Last.java b/src/main/java/com/jnape/palatable/lambda/monoid/builtin/Last.java
@@ -0,0 +1,46 @@
+package com.jnape.palatable.lambda.monoid.builtin;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.monoid.Monoid;
+
+import java.util.Optional;
+
+/**
+ * A {@link Monoid} instance formed by <code>{@link Optional}&lt;A&gt;</code>. The application to two {@link Optional}
+ * values produces the last non-empty value, or <code>Optional.empty()</code> if all values are empty.
+ *
+ * @param <A> the Optional value parameter type
+ * @see First
+ * @see Present
+ * @see Monoid
+ * @see Optional
+ */
+public final class Last<A> implements Monoid<Optional<A>> {
+    private static final Last INSTANCE = new Last();
+
+    private Last() {
+    }
+
+    @Override
+    public Optional<A> identity() {
+        return Optional.empty();
+    }
+
+    @Override
+    public Optional<A> apply(Optional<A> x, Optional<A> y) {
+        return y.map(Optional::of).orElse(x);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A> Last<A> last() {
+        return INSTANCE;
+    }
+
+    public static <A> Fn1<Optional<A>, Optional<A>> last(Optional<A> x) {
+        return Last.<A>last().apply(x);
+    }
+
+    public static <A> Optional<A> last(Optional<A> x, Optional<A> y) {
+        return last(x).apply(y);
+    }
+}
diff --git a/src/test/java/com/jnape/palatable/lambda/monoid/builtin/FirstTest.java b/src/test/java/com/jnape/palatable/lambda/monoid/builtin/FirstTest.java
@@ -0,0 +1,25 @@
+package com.jnape.palatable.lambda.monoid.builtin;
+
+import org.junit.Test;
+
+import java.util.Optional;
+
+import static com.jnape.palatable.lambda.monoid.builtin.First.first;
+import static org.junit.Assert.assertEquals;
+
+public class FirstTest {
+
+    @Test
+    public void identity() {
+        assertEquals(Optional.empty(), first().identity());
+    }
+
+    @Test
+    public void monoid() {
+        First<Integer> first = first();
+        assertEquals(Optional.of(1), first.apply(Optional.of(1), Optional.of(2)));
+        assertEquals(Optional.of(1), first.apply(Optional.of(1), Optional.empty()));
+        assertEquals(Optional.of(2), first.apply(Optional.empty(), Optional.of(2)));
+        assertEquals(Optional.empty(), first.apply(Optional.empty(), Optional.empty()));
+    }
+}
diff --git a/src/test/java/com/jnape/palatable/lambda/monoid/builtin/LastTest.java b/src/test/java/com/jnape/palatable/lambda/monoid/builtin/LastTest.java
@@ -0,0 +1,25 @@
+package com.jnape.palatable.lambda.monoid.builtin;
+
+import org.junit.Test;
+
+import java.util.Optional;
+
+import static com.jnape.palatable.lambda.monoid.builtin.Last.last;
+import static org.junit.Assert.assertEquals;
+
+public class LastTest {
+
+    @Test
+    public void identity() {
+        assertEquals(Optional.empty(), last().identity());
+    }
+
+    @Test
+    public void monoid() {
+        Last<Integer> last = last();
+        assertEquals(Optional.of(2), last.apply(Optional.of(1), Optional.of(2)));
+        assertEquals(Optional.of(2), last.apply(Optional.empty(), Optional.of(2)));
+        assertEquals(Optional.of(1), last.apply(Optional.of(1), Optional.empty()));
+        assertEquals(Optional.empty(), last.apply(Optional.empty(), Optional.empty()));
+    }
+}
