Try#orThrow can declare checked exceptions for catching purposes

jnape · jnape · commit f240f84ed122 · 2019-05-05T21:35:59.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -14,8 +14,9 @@ might need to be reworked, and subtyping is obviously no longer supported.
 - ***Breaking Change***: `Strong` is now called `Cartesian` to better reflect the type of strength
 - ***Breaking Change***: new Optic type hierarchy more faithfully encodes profunctor constraints on optics, new `Optic`
                          type is now the supertype of `Lens` and `Iso`, and `lens` package has been moved to `optics`
-- ***Breaking Change***: Try and Either no longer preserve `Throwable` type since it was inherently not type-safe 
-                         anyway; Try is therefore no longer a `Bifunctor` 
+- ***Breaking Change***: `Try` and `Either` no longer preserve `Throwable` type since it was inherently not type-safe 
+                         anyway; Try is therefore no longer a `Bifunctor`, and `orThrow` can be used to declare checked
+                         exceptions that could be caught by corresponding catch blocks 
 - `IO` is now stack-safe, regardless of whether the composition nests linearly or recursively
 
 ### Added
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/Try.java b/src/main/java/com/jnape/palatable/lambda/adt/Try.java
@@ -108,7 +108,7 @@ public final Throwable forfeit(Function<? super A, ? extends Throwable> fn) {
      *
      * @return possibly the success value
      */
-    public abstract A orThrow();
+    public abstract <T extends Throwable> A orThrow() throws T;
 
     /**
      * If this is a success, wrap the value in a {@link Maybe#just} and return it. Otherwise, return {@link
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/TryTest.java b/src/test/java/com/jnape/palatable/lambda/adt/TryTest.java
@@ -36,6 +36,7 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 import static testsupport.matchers.LeftMatcher.isLeftThat;
 
 @RunWith(Traits.class)
@@ -219,4 +220,17 @@ public void lazyZip() {
             throw new AssertionError();
         })).value());
     }
+
+    @Test
+    public void orThrowCanStillThrowCheckedExceptions() {
+        try {
+            Try.trying(() -> {
+                throw new RuntimeException();
+            }).<IOException>orThrow();
+            fail("Expected RuntimeException to be thrown, but nothing was");
+        } catch (IOException ioException) {
+            fail("Expected thrown exception to not be IOException, but merely proving it can still be caught");
+        } catch (Exception expected) {
+        }
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ public final Throwable forfeit(Function<? super A, ? extends Throwable> fn) {`
`108`	`108`	`*`
`109`	`109`	`* @return possibly the success value`
`110`	`110`	`*/`
`111`		`- public abstract A orThrow();`
	`111`	`+ public abstract <T extends Throwable> A orThrow() throws T;`
`112`	`112`
`113`	`113`	`/**`
`114`	`114`	`* If this is a success, wrap the value in a {@link Maybe#just} and return it. Otherwise, return {@link`