Adding Future.recover(Class<X> exceptionType, Function) (#2671)

Author: sleepytomcat

src/main/java/io/vavr/concurrent/Future.java

@@ -1078,6 +1078,30 @@ default Future<T> recover(Function<? super Throwable, ? extends T> f) {
         return transformValue(t -> t.recover(f));
     }
 
+    /**
+     * Handles a failure of this Future by returning another result.
+     * <p>
+     * Returns this, if this is a Success or this is a Failure and the cause is not assignable from {@code exceptionType}.
+     * Otherwise tries to recover the exception of the failure with {@code f}.
+     * <p>
+     * Example:
+     * <pre><code>
+     * // = "oh!"
+     * Future.of(() -&gt; new Error("oh!")).recover(Error.class, Throwable::getMessage);
+     * </code></pre>
+     *
+     * @param <X> The type of exception type to recover
+     * @param exceptionType {@code Class<X>} object defining exception class.
+     * @param f A function which takes the exception of a failure and returns a new value.
+     * @return A new Future.
+     * @throws NullPointerException if {@code f} is null
+     */
+    default <X extends Throwable> Future<T> recover(Class<X> exceptionType, Function<? super X, ? extends T> f) {
+        Objects.requireNonNull(exceptionType, "exceptionType is null");
+        Objects.requireNonNull(f, "f is null");
+        return transformValue(t -> t.recover(exceptionType, f));
+    }
+
     /**
      * Handles a failure of this Future by returning the result of another Future.
      * <p>

src/test/java/io/vavr/concurrent/FutureTest.java

@@ -952,6 +952,21 @@ public void shouldRecoverFailedFuture() {
         assertThat(recovered.get()).isEqualTo(42);
     }
 
+    @Test
+    public void shouldRecoverFailedFutureWithSpecificCause() {
+        final Future<Integer> recovered = Future.<Integer> of(zZz(new Error())).recover(Error.class, t -> 42);
+        waitUntil(recovered::isCompleted);
+        assertThat(recovered.isSuccess()).isTrue();
+        assertThat(recovered.get()).isEqualTo(42);
+    }
+
+    @Test
+    public void shouldNotRecoverFailedFutureWithMismatchingCause() {
+        final Future<Integer> recovered = Future.<Integer> of(zZz(new Error())).recover(ArithmeticException.class, t -> 42);
+        waitUntil(recovered::isCompleted);
+        assertThat(recovered.isFailure()).isTrue();
+    }
+
     @Test
     public void shouldNotCrashWhenRecoverFails() {
         final Future<Integer> recovered = Future.<Integer> of(zZz(new Error())).recover(t -> {
@@ -962,6 +977,16 @@ public void shouldNotCrashWhenRecoverFails() {
         assertThat(recovered.getCause().get().getClass()).isEqualTo(ArithmeticException.class);
     }
 
+    @Test
+    public void shouldNotCrashWhenRecoverFailsWithSpecificCause() {
+        final Future<Integer> recovered = Future.<Integer> of(zZz(new Error())).recover(Error.class, t -> {
+            throw new ArithmeticException();
+        });
+        waitUntil(recovered::isCompleted);
+        waitUntil(recovered::isFailure);
+        assertThat(recovered.getCause().get().getClass()).isEqualTo(ArithmeticException.class);
+    }
+
     // -- recoverWith()
 
     @Test