Implement CompletionStage exceptionally

Author: cosineblast

src/manifold/deferred.clj

@@ -68,7 +68,8 @@
 
          then-compose then-compose-async
 
-         then-handle then-handle-async)
+         then-handle then-handle-async
+         then-exceptionally)
 
 ;; The potemkin abstract type for
 ;; implementations such as CompletionStage
@@ -149,7 +150,10 @@
   (handleAsync [this operator]
     (then-handle-async this operator))
   (handleAsync [this operator executor]
-    (then-handle-async this operator executor)))
+    (then-handle-async this operator executor))
+
+  (exceptionally [this operator]
+    (then-exceptionally this operator)))
 
 (definline realized?
   "Returns true if the manifold deferred is realized."
@@ -1617,7 +1621,9 @@
 (def ^:private then-handle-async (async-for then-handle))
 
 
-
+(defn- then-exceptionally [this ^java.util.function.Function operator]
+  (assert-some operator)
+  (catch this #(.apply operator %)))
 
 ;;;
 

test/manifold/deferred_stage_test.clj

@@ -420,11 +420,37 @@
     (let [ex (RuntimeException.)
           d1 ^CompletionStage (d/error-deferred ex)
           d2 (.handleAsync d1 (fn->BiFunction
-                          (fn [x error]
+                          (fn [x ^Throwable error]
                             (is (nil? x))
-                            (is (#{ex (.getCause ex)} error))
+                            (is (#{error (.getCause error)} ex))
                             2
                             )))]
 
       (is (thrown? RuntimeException @d1))
       (is (= 2 @d2)))))
+
+(deftest test-exceptionally
+  (testing ".exceptionally success"
+    (let [d1 ^CompletionStage (d/success-deferred 1)
+          d2 (.exceptionally
+              d1
+              (fn->Function
+               (fn [_]
+                 (throw (RuntimeException.
+                         "This should not run")))))]
+
+      (is (= 1 @d1))
+      (is (= 1 @d2))))
+
+  (testing ".exceptionally failure"
+    (let [base-error (RuntimeException.)
+          d1 ^CompletionStage (d/error-deferred base-error)
+          d2 (.exceptionally
+              d1
+              (fn->Function
+               (fn [^Throwable error]
+                 (is (#{error (.getCause error)} base-error))
+                 2)))]
+
+      (is (thrown? RuntimeException @d1))
+      (is (= 2 @d2)))))