Adding Effect, Fn1<A, Unit>

jnape · jnape · commit 3490ab1aa5fb · 2018-07-15T18:01:59.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -20,7 +20,9 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - `Absent`, a monoid over `Maybe` that is absence biased
 - `RateLimit`, a function that iterates elements from an `Iterable` according to some rate limit
 - `Try#withResources`, `Try`'s expression analog to Java 7's try-with-resources statement 
-- `Occurrences`, for counting the occurrences of the members of an `Iterable` 
+- `Occurrences`, for counting the occurrences of the members of an `Iterable`
+- `Effect`, an `Fn0` returning `UNIT` 
+- `Noop`, a no-op `Effect` 
 
 ### Changed
 - `Tuple2-8` now implement `Product2-8`
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Effect.java b/src/main/java/com/jnape/palatable/lambda/functions/Effect.java
@@ -0,0 +1,54 @@
+package com.jnape.palatable.lambda.functions;
+
+import com.jnape.palatable.lambda.adt.Unit;
+import com.jnape.palatable.lambda.functor.Applicative;
+
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+import static com.jnape.palatable.lambda.adt.Unit.UNIT;
+
+/**
+ * A function taking "no arguments", implemented as an <code>{@link Fn1}&lt;{@link Unit}, A&gt;</code>.
+ *
+ * @param <A> the result type
+ * @see Fn1
+ * @see Supplier
+ */
+@FunctionalInterface
+public interface Effect<A> extends Fn1<A, Unit>, Consumer<A> {
+
+    @Override
+    default void accept(A a) {
+        apply(a);
+    }
+
+    @Override
+    default <Z> Effect<Z> diMapL(Function<? super Z, ? extends A> fn) {
+        return Fn1.super.diMapL(fn)::apply;
+    }
+
+    @Override
+    default <Z> Effect<Z> contraMap(Function<? super Z, ? extends A> fn) {
+        return Fn1.super.contraMap(fn)::apply;
+    }
+
+    @Override
+    default <Z> Effect<Z> compose(Function<? super Z, ? extends A> before) {
+        return Fn1.super.compose(before)::apply;
+    }
+
+    @Override
+    default <C> Effect<A> discardR(Applicative<C, Fn1<A, ?>> appB) {
+        return Fn1.super.discardR(appB)::apply;
+    }
+
+    @Override
+    default Effect<A> andThen(Consumer<? super A> after) {
+        return a -> {
+            Consumer.super.andThen(after).accept(a);
+            return UNIT;
+        };
+    }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/specialized/Noop.java b/src/main/java/com/jnape/palatable/lambda/functions/specialized/Noop.java
@@ -0,0 +1,34 @@
+package com.jnape.palatable.lambda.functions.specialized;
+
+import com.jnape.palatable.lambda.adt.Unit;
+import com.jnape.palatable.lambda.functions.Effect;
+
+import static com.jnape.palatable.lambda.adt.Unit.UNIT;
+
+/**
+ * As the name might suggest, this is an {@link Effect} that, *ahem*, has no effect.
+ *
+ * @param <A> the argument type
+ */
+public final class Noop<A> implements Effect<A> {
+    private static final Noop INSTANCE = new Noop();
+
+    private Noop() {
+    }
+
+    @Override
+    public Unit apply(A a) {
+        return UNIT;
+    }
+
+    /**
+     * Static factory method that returns the singleton {@link Noop} instance.
+     *
+     * @param <A> the argument type
+     * @return the singleton {@link Noop} instance
+     */
+    @SuppressWarnings("unchecked")
+    public static <A> Noop<A> noop() {
+        return INSTANCE;
+    }
+}
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/EffectTest.java b/src/test/java/com/jnape/palatable/lambda/functions/EffectTest.java
@@ -0,0 +1,22 @@
+package com.jnape.palatable.lambda.functions;
+
+import org.junit.Test;
+
+import java.util.function.Consumer;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
+import static com.jnape.palatable.lambda.functions.specialized.Noop.noop;
+
+public class EffectTest {
+
+    @Test
+    @SuppressWarnings("unused")
+    public void covariantReturns() {
+        Effect<String> effect = noop();
+        Effect<Object> diMapL = effect.diMapL(constantly("1"));
+        Effect<Object> contraMap = effect.contraMap(constantly("1"));
+        Effect<Object> compose = effect.compose(constantly("1"));
+        Effect<String> stringEffect = effect.discardR(constantly("1"));
+        Effect<String> andThen = effect.andThen((Consumer<? super String>) noop());
+    }
+}
