Make Promise implement all default methods without delegation to the same methods of ConfigurableDependentPromise, make ConfigurableDependentPromise merely wraps results;

 Fix JDK 12 exceptional methods in *Wrapper classes
Create concrete CompletionStageDecorator & ExecutorBoundCompletionStage classes
Implement thenFilterAsync in AbstractCompletableTask

Author: vsilaev

examples/net/tascalate/concurrent/ExecutorBoundCompletionStage.java

@@ -43,6 +43,7 @@
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
 import java.util.function.Function;
+import java.util.function.Predicate;
 
 /**
  * Base superclass for both root and intermediate {@link Promise}-s that
@@ -345,11 +346,10 @@ public Promise<T> exceptionallyComposeAsync(Function<Throwable, ? extends Comple
         return nextStage;
     }
 
-    // Default operation in Promise is ok - it just delegates to thenCompose[Async]
-    /*
     @Override
     public Promise<T> thenFilterAsync(Predicate<? super T> predicate, Function<? super T, Throwable> errorSupplier, Executor executor) {
-    */
+        return thenApplyAsync(r -> predicate.test(r) ? r : forwardException(errorSupplier.apply(r)), executor);
+    }
 
     @Override
     public Promise<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action, Executor executor) {

src/main/java/net/tascalate/concurrent/AbstractCompletableTask.java

@@ -22,8 +22,7 @@
 
 import net.tascalate.concurrent.decorators.CompletableFutureDecorator;
 
-public class CompletableFutureWrapper<T> 
-    extends CompletableFutureDecorator<T> {
+public class CompletableFutureWrapper<T> extends CompletableFutureDecorator<T> {
 
     protected CompletableFutureWrapper() {
         super();
@@ -76,27 +75,37 @@ public <U> Promise<U> thenComposeAsync(Function<? super T, ? extends CompletionS
 
     @Override
     public <U> Promise<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn, 
-                                                    Executor executor) {
+                                           Executor executor) {
         CompletionStageRef<U> ref = new CompletionStageRef<>();
         return super.thenComposeAsync(ref.captureResult(fn), executor).onCancel(ref.cancel);        
     }
 
+    // Default CompletionStage API implementation for exceptionallyAsync / exceptionallyCompose[Async]
+    // doesn't handle cancellation well due to numerous orchestrated calls (handle->handleAsync->thenCompose
+    // Use own implementation here for safety
+    @Override
+    public Promise<T> exceptionallyAsync(Function<Throwable, ? extends T> fn) {
+        return PromiseHelper.exceptionallyAsync(this, fn);
+    }
+    
+    @Override
+    public Promise<T> exceptionallyAsync(Function<Throwable, ? extends T> fn, Executor executor) {
+        return PromiseHelper.exceptionallyAsync(this, fn, executor);
+    }
+    
     @Override
     public Promise<T> exceptionallyCompose(Function<Throwable, ? extends CompletionStage<T>> fn) {
-        CompletionStageRef<T> ref = new CompletionStageRef<>();
-        return super.exceptionallyCompose(ref.captureResult(fn)).onCancel(ref.cancel);
+        return PromiseHelper.exceptionallyCompose(this, fn);
     }
 
     @Override
     public Promise<T> exceptionallyComposeAsync(Function<Throwable, ? extends CompletionStage<T>> fn) {
-        CompletionStageRef<T> ref = new CompletionStageRef<>();
-        return super.exceptionallyComposeAsync(ref.captureResult(fn)).onCancel(ref.cancel);
+        return PromiseHelper.exceptionallyComposeAsync(this, fn);
     }
 
     @Override
     public Promise<T> exceptionallyComposeAsync(Function<Throwable, ? extends CompletionStage<T>> fn, 
                                                 Executor executor) {
-        CompletionStageRef<T> ref = new CompletionStageRef<>();
-        return super.exceptionallyComposeAsync(ref.captureResult(fn), executor).onCancel(ref.cancel);        
-    }
+        return PromiseHelper.exceptionallyComposeAsync(this, fn, executor);
+    }   
 }

src/main/java/net/tascalate/concurrent/CompletableFutureWrapper.java

@@ -94,6 +94,7 @@ public CompletablePromise<T> copy() {
 
     public Promise<T> minimalPromise() {
         CompletableFutureWrapper<T> result = new CompletableFutureWrapper<>();
+        // Should we cancel result along this?
         if (isDone()) {
             try {
                 result.success(join());