Adding Either#trying back until I decide if I should deprecate it

jnape · jnape · commit d2e0c1dc8a9e · 2018-03-14T01:31:15.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -29,9 +29,6 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - `IfThenElse`, an expression form for `if` statements
 - `CheckedRunnable` and `CheckedSupplier` conversion and convenience methods
 
-### Deprecated
-- `Either#trying` in favor of `Try#trying` 
-
 ## [2.1.1] - 2018-01-16
 ### Changed
 - ***Breaking Change***: Moved `Trampoline` and `RecursiveResult` to better package
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/Either.java b/src/main/java/com/jnape/palatable/lambda/adt/Either.java
@@ -286,10 +286,7 @@ public static <L, R> Either<L, R> fromMaybe(Maybe<R> maybe, Supplier<L> leftFn)
      * @param <L>      the left parameter type
      * @param <R>      the right parameter type
      * @return the supplier result as a right value, or leftFn's mapping result as a left value
-     * @deprecated in favor of {@link Try#trying(CheckedSupplier)}
      */
-    @Deprecated
-    @SuppressWarnings("unchecked")
     public static <E extends Exception, L, R> Either<L, R> trying(CheckedSupplier<E, ? extends R> supplier,
                                                                   Function<? super E, ? extends L> leftFn) {
         return Try.<E, R>trying(supplier::get).toEither(leftFn);
@@ -303,9 +300,7 @@ public static <E extends Exception, L, R> Either<L, R> trying(CheckedSupplier<E,
      * @param <E>      the left parameter type (the most contravariant exception that supplier might throw)
      * @param <R>      the right parameter type
      * @return the supplier result as a right value, or a left value of the thrown exception
-     * @deprecated in favor of {@link Try#trying(CheckedSupplier)}
      */
-    @Deprecated
     public static <E extends Exception, R> Either<E, R> trying(CheckedSupplier<E, R> supplier) {
         return trying(supplier, id());
     }
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/Maybe.java b/src/main/java/com/jnape/palatable/lambda/adt/Maybe.java
@@ -14,8 +14,6 @@
 import java.util.function.Supplier;
 
 import static com.jnape.palatable.lambda.adt.Either.left;
-import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
-import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
 
 /**
  * The optional type, representing a potentially absent value. This is lambda's analog of {@link Optional}, supporting
@@ -153,7 +151,7 @@ public final Maybe<A> peek(Consumer<A> consumer) {
      * @return "Just" the right value, or nothing
      */
     public static <A> Maybe<A> fromEither(Either<?, A> either) {
-        return either.match(constantly(nothing()), Maybe::just);
+        return either.toMaybe();
     }
 
     /**
@@ -164,7 +162,7 @@ public static <A> Maybe<A> fromEither(Either<?, A> either) {
      * @return the equivalent Maybe instance
      */
     public static <A> Maybe<A> fromOptional(Optional<? extends A> optional) {
-        return optional.<A>map(id()).map(Maybe::just).orElse(Maybe.nothing());
+        return optional.map(Maybe::<A>just).orElse(Maybe.nothing());
     }
 
     /**
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/EitherTest.java b/src/test/java/com/jnape/palatable/lambda/adt/EitherTest.java
@@ -168,6 +168,24 @@ public void fromMaybeDoesNotEvaluateLeftFnForRight() {
         assertThat(atomicInteger.get(), is(0));
     }
 
+    @Test
+    public void monadicTryingLiftsCheckedSupplier() {
+        assertEquals(right(1), Either.trying(() -> 1));
+
+        Exception checkedException = new Exception("expected");
+        assertEquals(left(checkedException), Either.trying(() -> {
+            throw checkedException;
+        }));
+    }
+
+    @Test
+    public void dyadicTryingLiftsCheckedSupplierMappingAnyThrownExceptions() {
+        assertEquals(right(1), Either.trying(() -> 1, Throwable::getMessage));
+        assertEquals(left("expected"), Either.trying(() -> {
+            throw new Exception("expected");
+        }, Throwable::getMessage));
+    }
+
     @Test
     public void monadicPeekLiftsIOToTheRight() {
         Either<String, Integer> left = left("foo");
