kitchen-async.promise — mhuebert/kitchen-async 0.1.0

-> clj/s macro

(-> x & forms)

->> clj/s macro

(->> x & forms)

->promise cljs

(->promise x)

all cljs

(all ps)

catch clj/s macro

(catch classname name & expr*)

catch* cljs

(catch* p f)

do clj/s macro

(do & body)

finally clj/s macro

(finally & expr*)

finally* cljs

(finally* p f)

let clj/s macro

(let bindings & body)

loop clj/s macro

(loop bindings & body)

plet clj/s macro

(plet bindings & body)

promise clj/s macro

(promise [resolve reject] & body)

promise-impl cljs

(promise-impl)

promisify cljs

(promisify f)

Given a fn that takes a callback fn as its last arg, and returns a modified version of that fn that returns a promise instead of calling the callback

race cljs

(race ps)

recur clj/s macro

(recur & args)

reject cljs

(reject x)

resolve cljs

(resolve x)

set-promise-impl! cljs

(set-promise-impl! impl)

some-> clj/s macro

(some-> expr & forms)

some->> clj/s macro

(some->> expr & forms)

then cljs

(then p f)

(then p f g)

timeout cljs

(timeout ms)

(timeout ms v)

try clj/s macro

(try & body)

while clj/s macro

(while cond & body)