Change the checked functional interfaces to throw Throwable

This commit changes the checked functional interfaces to throw Throwable rather than Exception. The reasons for this are:

- It allows execution failures, such as in ExecutionAttemptedEvent, to be propagated (rethrown) such as in a Fallback, and execution failures are already typed as Throwables.
- Helps unify the various failure handling APIs (in FailurePolicy), which currently accept Throwables.
- Aligns with precedent in CompletableFuture, which accepts Throwables (via completeExceptionally).

Author: jhalterman

src/main/java/net/jodah/failsafe/CircuitBreaker.java

@@ -434,7 +434,7 @@ private void transitionTo(State newState, CheckedRunnable listener, ExecutionCon
     if (transitioned && listener != null) {
       try {
         listener.run();
-      } catch (Exception ignore) {
+      } catch (Throwable ignore) {
       }
     }
   }

src/main/java/net/jodah/failsafe/Fallback.java

@@ -214,15 +214,15 @@ public boolean isAsync() {
   /**
    * Returns the applied fallback result.
    */
-  R apply(R result, Throwable failure, ExecutionContext context) throws Exception {
+  R apply(R result, Throwable failure, ExecutionContext context) throws Throwable {
     ExecutionAttemptedEvent<R> event = new ExecutionAttemptedEvent<>(result, failure, context);
     return fallback != null ? fallback.apply(event) : fallbackStage.apply(event).get();
   }
 
   /**
    * Returns a future applied fallback result.
    */
-  CompletableFuture<R> applyStage(R result, Throwable failure, ExecutionContext context) throws Exception {
+  CompletableFuture<R> applyStage(R result, Throwable failure, ExecutionContext context) throws Throwable {
     ExecutionAttemptedEvent<R> event = new ExecutionAttemptedEvent<>(result, failure, context);
     return fallback != null ? CompletableFuture.completedFuture(fallback.apply(event)) : fallbackStage.apply(event);
   }

src/main/java/net/jodah/failsafe/FallbackExecutor.java

@@ -34,8 +34,8 @@ protected ExecutionResult onFailure(ExecutionResult result) {
       return policy == Fallback.VOID ?
         result.withNonResult() :
         result.withResult(policy.apply(result.getResult(), result.getFailure(), execution.copy()));
-    } catch (Exception e) {
-      return ExecutionResult.failure(e);
+    } catch (Throwable t) {
+      return ExecutionResult.failure(t);
     }
   }
 
@@ -53,8 +53,8 @@ protected CompletableFuture<ExecutionResult> onFailureAsync(ExecutionResult resu
           ExecutionResult r = failure == null ? result.withResult(innerResult) : ExecutionResult.failure(failure);
           promise.complete(r);
         });
-      } catch (Exception e) {
-        promise.complete(ExecutionResult.failure(e));
+      } catch (Throwable t) {
+        promise.complete(ExecutionResult.failure(t));
       }
       return null;
     };

src/main/java/net/jodah/failsafe/function/CheckedConsumer.java

@@ -23,5 +23,5 @@
  */
 @FunctionalInterface
 public interface CheckedConsumer<T> {
-  void accept(T t) throws Exception;
+  void accept(T t) throws Throwable;
 }

src/main/java/net/jodah/failsafe/function/CheckedFunction.java

@@ -23,5 +23,5 @@
  */
 @FunctionalInterface
 public interface CheckedFunction<T, R> {
-  R apply(T t) throws Exception;
+  R apply(T t) throws Throwable;
 }

src/main/java/net/jodah/failsafe/function/CheckedRunnable.java

@@ -22,5 +22,5 @@
  */
 @FunctionalInterface
 public interface CheckedRunnable {
-  void run() throws Exception;
+  void run() throws Throwable;
 }

src/main/java/net/jodah/failsafe/function/CheckedSupplier.java

@@ -23,5 +23,5 @@
  */
 @FunctionalInterface
 public interface CheckedSupplier<T> {
-  T get() throws Exception;
+  T get() throws Throwable;
 }

src/main/java/net/jodah/failsafe/function/ContextualRunnable.java

@@ -24,5 +24,5 @@
  */
 @FunctionalInterface
 public interface ContextualRunnable {
-  void run(ExecutionContext context) throws Exception;
+  void run(ExecutionContext context) throws Throwable;
 }

src/main/java/net/jodah/failsafe/function/ContextualSupplier.java

@@ -25,5 +25,5 @@
  */
 @FunctionalInterface
 public interface ContextualSupplier<T> {
-  T get(ExecutionContext context) throws Exception;
+  T get(ExecutionContext context) throws Throwable;
 }

src/test/java/net/jodah/failsafe/Testing.java

@@ -50,7 +50,7 @@ public static Throwable getThrowable(CheckedRunnable runnable) {
   public static <T> T ignoreExceptions(CheckedSupplier<T> supplier) {
     try {
       return supplier.get();
-    } catch (Exception e) {
+    } catch (Throwable t) {
       return null;
     }
   }
@@ -116,8 +116,10 @@ public static <T> T unwrapExceptions(CheckedSupplier<T> supplier) {
     } catch (FailsafeException e) {
       sneakyThrow(e.getCause() == null ? e : e.getCause());
       return null;
-    } catch (Exception e) {
-      throw (RuntimeException) e;
+    } catch (RuntimeException | Error e) {
+      throw e;
+    } catch (Throwable t) {
+      throw new RuntimeException(t);
     }
   }