   ([t] (delay t nil))
   ([t v]
    #?(:cljs (promise (fn [resolve reject]
-                       (schedule t #(resolve v))))
-
-      :clj  (let [p (CompletableFuture.)]
+                       (exec/schedule t #(resolve v))))
+
+      :clj  (c/let [p (CompletableFuture.)]
               (exec/schedule t #(.complete p v))
               p))))
 
 #?(:clj
-   (defmacro do*
+   (defmacro do!
+     "Execute potentially side effect-ful code and return a promise
+     resolved to the last expression. Always awaiting the result of each
+     expression."
      [& exprs]
      `(p/bind nil (fn [_#]
                     ~(condp = (count exprs)

                                    `(bind ~r (fn [~l] ~acc)))
                                  `(pt/-promise (do ~@body))))))))

#?(:clj
   (defmacro plet
     "A parallel let; executes all the bindings in parallel and
     when all bindings are resolved, executes the body."
     [bindings & body]
     `(p/bind nil (fn [_#]
                    ~(let [bindings (partition 2 bindings)]
                       `(all ~(mapv second bindings)
                             (fn [[~@(mapv first bindings)]]
                               ~@body)))))))

  (pt/-promise v))

#?(:clj
   (defmacro let
     "A `let` alternative that always returns promise and waits for
     all the promises on the bindings."
     [bindings & body]
     `(p/bind nil (fn [_#]
                    ~(->> (reverse (partition 2 bindings))
