Adding static factory method to create an Effect from an Fn1

jnape · jnape · commit ed2e477a9127 · 2019-02-02T17:37:15.000-06:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -15,6 +15,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - `IO#externallyManaged`, for supplying an `IO` with externally-managed futures
 - test jar is now published
 - `Monad#join` static alias for `flatMap(id())`
+- `Effect#effect` static factory method taking `Fn1`
 
 ### Fixed
 - issue where certain ways to compose `Effect`s unintentionally nullified the effect 
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/Effect.java b/src/main/java/com/jnape/palatable/lambda/functions/Effect.java
@@ -8,6 +8,7 @@
 
 import static com.jnape.palatable.lambda.functions.Fn0.fn0;
 import static com.jnape.palatable.lambda.functions.IO.io;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
 
 /**
  * A function returning "no result", and therefore only useful as a side-effect.
@@ -26,22 +27,22 @@ default IO<Unit> apply(A a) {
 
     @Override
     default <Z> Effect<Z> diMapL(Function<? super Z, ? extends A> fn) {
-        return effect(z -> Fn1.super.diMapL(fn).apply(z).unsafePerformIO());
+        return effect(Fn1.super.diMapL(fn));
     }
 
     @Override
     default <Z> Effect<Z> contraMap(Function<? super Z, ? extends A> fn) {
-        return effect(z -> Fn1.super.contraMap(fn).apply(z).unsafePerformIO());
+        return effect(Fn1.super.contraMap(fn));
     }
 
     @Override
     default <Z> Effect<Z> compose(Function<? super Z, ? extends A> before) {
-        return effect(z -> Fn1.super.compose(before).apply(z).unsafePerformIO());
+        return effect(Fn1.super.compose(before));
     }
 
     @Override
     default <C> Effect<A> discardR(Applicative<C, Fn1<A, ?>> appB) {
-        return effect(a -> Fn1.super.discardR(appB).apply(a).unsafePerformIO());
+        return effect(Fn1.super.discardR(appB));
     }
 
     @Override
@@ -67,6 +68,17 @@ static <A> Effect<A> effect(Consumer<A> effect) {
      * @return the effect
      */
     static Effect<Unit> effect(Runnable runnable) {
-        return effect(__ -> runnable.run());
+        return effect(constantly(io(runnable)));
+    }
+
+    /**
+     * Create an {@link Effect} from an {@link Fn1} that yields an {@link IO}.
+     *
+     * @param fn  the function
+     * @param <A> the effect argument type
+     * @return the effect
+     */
+    static <A> Effect<A> effect(Fn1<A, ? extends IO<?>> fn) {
+        return a -> fn.apply(a).unsafePerformIO();
     }
 }
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/EffectTest.java b/src/test/java/com/jnape/palatable/lambda/functions/EffectTest.java
@@ -1,10 +1,14 @@
 package com.jnape.palatable.lambda.functions;
 
+import com.jnape.palatable.lambda.adt.Unit;
 import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
 
+import static com.jnape.palatable.lambda.adt.Unit.UNIT;
+import static com.jnape.palatable.lambda.functions.Effect.effect;
 import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertEquals;
@@ -31,4 +35,17 @@ public void covariantReturns() {
 
         assertEquals(asList("1", "2", "3", "4", "5", "6", "6"), results);
     }
+
+    @Test
+    public void staticFactoryMethods() {
+        AtomicInteger counter = new AtomicInteger();
+
+        Effect<Unit> runnableEffect = effect(counter::incrementAndGet);
+        runnableEffect.apply(UNIT).unsafePerformIO();
+        assertEquals(1, counter.get());
+
+        Effect<AtomicInteger> fnEffect = effect(AtomicInteger::incrementAndGet);
+        fnEffect.apply(counter).unsafePerformIO();
+        assertEquals(2, counter.get());
+    }
 }
