cloroutine-based async/await

asyncawait.clj

(ns asyncawait
  (:refer-clojure :exclude [await])
  (:require [cloroutine.core :refer [cr]]))

(defmacro async [& body]
  `(js/Promise. (fn [s# f#]
                  (spawn (cr {await thunk}
                           (try (s# (do ~@body))
                                (catch :default e# (f# e#))))))))

asyncawait.cljs

(ns asyncawait)

(def ^:dynamic *success*)
(def ^:dynamic *failure*)
(def ^:dynamic *status*)
(def ^:dynamic *result*)

(defn await [p]
  (.then p *success* *failure*))

(defn thunk []
  (if *status* *result* (throw *result*)))

(defn spawn [c]
  (letfn [(run []
            (binding [*success* success
                      *failure* failure]
              (c)))
          (success [x]
            (binding [*status* true
                      *result* x] (run)))
          (failure [x]
            (binding [*status* false
                      *result* x] (run)))]
    (run)))