Adding Try#orThrow

jnape · jnape · commit c87b7ddd026b · 2018-03-10T14:50:57.000-06:00
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/Try.java b/src/main/java/com/jnape/palatable/lambda/adt/Try.java
@@ -97,6 +97,14 @@ public final T forfeit(Function<? super A, ? extends T> fn) {
         return match(id(), fn);
     }
 
+    /**
+     * If this is a success value, return it. Otherwise, rethrow the captured failure.
+     *
+     * @return possibly the success value
+     * @throws T the possible failure
+     */
+    public abstract A orThrow() throws T;
+
     /**
      * If this is a success, wrap the value in a {@link Maybe#just} and return it. Otherwise, return {@link
      * Maybe#nothing()}.
@@ -245,6 +253,11 @@ private Failure(T t) {
             this.t = t;
         }
 
+        @Override
+        public A orThrow() throws T {
+            throw t;
+        }
+
         @Override
         public <R> R match(Function<? super T, ? extends R> aFn, Function<? super A, ? extends R> bFn) {
             return aFn.apply(t);
@@ -275,6 +288,11 @@ private Success(A a) {
             this.a = a;
         }
 
+        @Override
+        public A orThrow() throws T {
+            return a;
+        }
+
         @Override
         public <R> R match(Function<? super T, ? extends R> aFn, Function<? super A, ? extends R> bFn) {
             return bFn.apply(a);
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/TryTest.java b/src/test/java/com/jnape/palatable/lambda/adt/TryTest.java
@@ -3,7 +3,9 @@
 import com.jnape.palatable.traitor.annotations.TestTraits;
 import com.jnape.palatable.traitor.framework.Subjects;
 import com.jnape.palatable.traitor.runners.Traits;
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import testsupport.traits.ApplicativeLaws;
 import testsupport.traits.FunctorLaws;
@@ -18,8 +20,10 @@
 import static com.jnape.palatable.lambda.adt.Maybe.nothing;
 import static com.jnape.palatable.lambda.adt.Try.failure;
 import static com.jnape.palatable.lambda.adt.Try.success;
+import static com.jnape.palatable.lambda.adt.Try.trying;
 import static com.jnape.palatable.lambda.functions.builtin.fn1.Constantly.constantly;
 import static com.jnape.palatable.traitor.framework.Subjects.subjects;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.instanceOf;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThat;
@@ -28,6 +32,8 @@
 @RunWith(Traits.class)
 public class TryTest {
 
+    @Rule public ExpectedException thrown = ExpectedException.none();
+
     @TestTraits({FunctorLaws.class, ApplicativeLaws.class, MonadLaws.class, TraversableLaws.class})
     public Subjects<Try<Throwable, Integer>> testSubject() {
         return subjects(failure(new IllegalStateException()), success(1));
@@ -108,6 +114,15 @@ public void recoverEnsuresSuccess() {
         assertEquals((Integer) 1, Try.<RuntimeException, Integer>failure(new IllegalArgumentException()).recover(constantly(1)));
     }
 
+    @Test
+    public void orThrow() throws Throwable {
+        assertEquals((Integer) 1, trying(() -> 1).orThrow());
+
+        Throwable expected = new Exception("expected");
+        thrown.expect(equalTo(expected));
+        trying(() -> {throw expected;}).orThrow();
+    }
+
     @Test
     public void toMaybe() {
         assertEquals(just("foo"), Try.success("foo").toMaybe());
@@ -131,8 +146,8 @@ public void toEitherWithLeftMappingFunction() {
     @Test
     public void tryingCatchesAnyThrowableThrownDuringEvaluation() {
         IllegalStateException expected = new IllegalStateException();
-        assertEquals(failure(expected), Try.trying(() -> {throw expected;}));
+        assertEquals(failure(expected), trying(() -> {throw expected;}));
 
-        assertEquals(success("foo"), Try.trying(() -> "foo"));
+        assertEquals(success("foo"), trying(() -> "foo"));
     }
 }
