Either#trying that supports CheckedRunnable

jnape · jnape · commit b2d598e28866 · 2018-04-26T16:26:33.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -43,6 +43,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - `Under`, the inverse of `Over` for `Iso`
 - `TypeSafeKey` is an `Iso` and supports mapping
 - `TypeSafeKey.Simple`, the single parameter version of `TypeSafeKey`
+- `Either#trying` overloads that accept `CheckedRunnable`
 
 ### Deprecated
 - `MapLens#mappingValues(Function)` is now deprecated in favor of the overload that takes an <code>Iso</code>
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/Either.java b/src/main/java/com/jnape/palatable/lambda/adt/Either.java
@@ -4,6 +4,7 @@
 import com.jnape.palatable.lambda.functions.builtin.fn2.Peek;
 import com.jnape.palatable.lambda.functions.builtin.fn2.Peek2;
 import com.jnape.palatable.lambda.functions.specialized.checked.CheckedFn1;
+import com.jnape.palatable.lambda.functions.specialized.checked.CheckedRunnable;
 import com.jnape.palatable.lambda.functions.specialized.checked.CheckedSupplier;
 import com.jnape.palatable.lambda.functor.Applicative;
 import com.jnape.palatable.lambda.functor.Bifunctor;
@@ -21,9 +22,9 @@
 import static java.util.Arrays.asList;
 
 /**
- * The binary tagged union. General semantics tend to connote "success" values via the right value and "failure" values
- * via the left values. <code>Either</code>s are both <code>Functor</code>s over their right value and
- * <code>Bifunctor</code>s over both values.
+ * The binary tagged union, implemented as a specialized {@link CoProduct2}. General semantics tend to connote "success"
+ * values via the right value and "failure" values via the left values. {@link Either}s are both {@link Monad}s and
+ * {@link Traversable}s over their right value and are {@link Bifunctor}s over both values.
  *
  * @param <L> The left parameter type
  * @param <R> The right parameter type
@@ -305,6 +306,33 @@ public static <E extends Exception, R> Either<E, R> trying(CheckedSupplier<E, R>
         return trying(supplier, id());
     }
 
+    /**
+     * Attempt to execute the {@link CheckedRunnable}, returning {@link Unit} in a right value. If the runnable throws
+     * an exception, apply <code>leftFn</code> to it, wrap it in a left value, and return it.
+     *
+     * @param runnable the runnable
+     * @param leftFn   a function mapping E to L
+     * @param <E>      the most contravariant exception that the runnable might throw
+     * @param <L>      the left parameter type
+     * @return {@link Unit} as a right value, or leftFn's mapping result as a left value
+     */
+    public static <E extends Exception, L> Either<L, Unit> trying(CheckedRunnable<E> runnable,
+                                                                  Function<? super E, ? extends L> leftFn) {
+        return Try.trying(runnable).toEither(leftFn);
+    }
+
+    /**
+     * Attempt to execute the {@link CheckedRunnable}, returning {@link Unit} in a right value. If the runnable throws
+     * exception, wrap it in a left value and return it.
+     *
+     * @param runnable the runnable
+     * @param <E>      the left parameter type (the most contravariant exception that runnable might throw)
+     * @return {@link Unit} as a right value, or a left value of the thrown exception
+     */
+    public static <E extends Exception> Either<E, Unit> trying(CheckedRunnable<E> runnable) {
+        return trying(runnable, id());
+    }
+
     /**
      * Static factory method for creating a left value.
      *
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/EitherTest.java b/src/test/java/com/jnape/palatable/lambda/adt/EitherTest.java
@@ -22,6 +22,7 @@
 import static com.jnape.palatable.lambda.adt.Either.right;
 import static com.jnape.palatable.lambda.adt.Maybe.just;
 import static com.jnape.palatable.lambda.adt.Maybe.nothing;
+import static com.jnape.palatable.lambda.adt.Unit.UNIT;
 import static com.jnape.palatable.traitor.framework.Subjects.subjects;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertEquals;
@@ -186,6 +187,21 @@ public void dyadicTryingLiftsCheckedSupplierMappingAnyThrownExceptions() {
         }, Throwable::getMessage));
     }
 
+    @Test
+    public void dyadicTryingWithRunnable() {
+        assertEquals(right(UNIT), Either.trying(() -> {}, Throwable::getMessage));
+        assertEquals(left("expected"), Either.trying(() -> {
+            throw new IllegalStateException("expected");
+        }, Throwable::getMessage));
+    }
+
+    @Test
+    public void monadTryingWithRunnable() {
+        assertEquals(right(UNIT), Either.trying(() -> {}));
+        IllegalStateException expected = new IllegalStateException("expected");
+        assertEquals(left(expected), Either.trying(() -> {throw expected;}));
+    }
+
     @Test
     public void monadicPeekLiftsIOToTheRight() {
         Either<String, Integer> left = left("foo");
