throw/catch is much more important than auto-suppression

jnape · jnape · commit dea2016b1673 · 2019-08-19T11:43:41.000-05:00
diff --git a/src/main/java/com/jnape/palatable/lambda/io/IO.java b/src/main/java/com/jnape/palatable/lambda/io/IO.java
@@ -17,8 +17,6 @@
 import java.util.concurrent.Executor;
 
 import static com.jnape.palatable.lambda.adt.Either.left;
-import static com.jnape.palatable.lambda.adt.Try.failure;
-import static com.jnape.palatable.lambda.adt.Try.trying;
 import static com.jnape.palatable.lambda.adt.Unit.UNIT;
 import static com.jnape.palatable.lambda.adt.choice.Choice2.a;
 import static com.jnape.palatable.lambda.adt.choice.Choice2.b;
@@ -190,28 +188,17 @@ public final IO<A> catchError(Fn1<? super Throwable, ? extends Monad<A, IO<?>>>
         return new IO<A>() {
             @Override
             public A unsafePerformIO() {
-                return trying(fn0(IO.this::unsafePerformIO))
-                        .recover(t -> trying(fn0(recoveryFn.apply(t).<IO<A>>coerce()::unsafePerformIO))
-                                .fmap(Try::success)
-                                .recover(t2 -> {
-                                    t.addSuppressed(t2);
-                                    return failure(t);
-                                })
-                                .orThrow());
+                return Try.trying(IO.this::unsafePerformIO)
+                        .catchError(t -> Try.trying(recoveryFn.apply(t).<IO<A>>coerce()::unsafePerformIO))
+                        .orThrow();
             }
 
             @Override
             public CompletableFuture<A> unsafePerformAsyncIO(Executor executor) {
                 return IO.this.unsafePerformAsyncIO(executor)
-                        .thenApply(CompletableFuture::completedFuture)
-                        .exceptionally(t -> recoveryFn.apply(t).<IO<A>>coerce().unsafePerformAsyncIO(executor)
-                                .thenApply(CompletableFuture::completedFuture)
-                                .exceptionally(t2 -> {
-                                    t.addSuppressed(t2);
-                                    return new CompletableFuture<A>() {{
-                                        completeExceptionally(t);
-                                    }};
-                                }).thenCompose(f -> f))
+                        .handle((a, t) -> t == null
+                                          ? completedFuture(a)
+                                          : recoveryFn.apply(t).<IO<A>>coerce().unsafePerformAsyncIO(executor))
                         .thenCompose(f -> f);
             }
         };
diff --git a/src/test/java/com/jnape/palatable/lambda/io/IOTest.java b/src/test/java/com/jnape/palatable/lambda/io/IOTest.java
@@ -20,6 +20,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
@@ -48,6 +49,7 @@
 import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 import static testsupport.Constants.STACK_EXPLODING_NUMBER;
@@ -149,16 +151,21 @@ public void catchError() {
     }
 
     @Test
-    public void catchErrorSuppressesSecondaryThrowable() {
-        Throwable foo = new UnsupportedOperationException("foo");
-        Throwable bar = new UnsupportedOperationException("bar");
+    public void catchAndRethrow() {
+        IllegalStateException expected = new IllegalStateException("expected");
+        IO<Object> catchAndRethrow = IO.throwing(expected)
+                .catchError(IO::throwing);
 
         try {
-            IO.throwing(foo).catchError(t -> IO.throwing(bar)).unsafePerformIO();
-            fail("Expected exception to have been thrown, but wasn't.");
-        } catch (UnsupportedOperationException expected) {
-            assertEquals(expected, foo);
-            assertArrayEquals(new Throwable[]{bar}, expected.getSuppressed());
+            catchAndRethrow.unsafePerformIO();
+        } catch (Exception actual) {
+            assertSame(expected, actual);
+        }
+
+        try {
+            catchAndRethrow.unsafePerformAsyncIO().join();
+        } catch (CompletionException actual) {
+            assertEquals(expected, actual.getCause());
         }
     }
 
