qbits.auspex — cc.qbits/auspex 0.1.0-alpha3

This provides a clj friendly wrapper for CompletableFuture and adds a few utility functions to mimic manifold features. Shamelessly stole code/ideas from the awesome manifold library.

cancel! clj

canceled? clj

catch clj

chain clj

(chain x & fns)

Composes functions starting with x as argument triggering calls to fns for every step coercing the return values to deferreds if necessary and returns a deferred with the final result.

chain' clj

(chain' x & fns)

Like chain but assumes fns return raw values instead of potential futures

chain-futures clj

(chain-futures x & fs)

Like chain but takes a value and functions that will return futures

complete! clj

do-> clj macro

(do-> m-specs steps & body)

Utility macro to build monadic like constructs like let-flow

error! clj

error-future clj

(error-future x)

Returns a new CompletableFuture that is already completed exceptionally with the given exception.

error? clj

finally clj

fmap clj

future clj

(future)

(future f)

(future f executor)

No arg creates an empty/incomplete future, 1 arg creates a future that will get the return value of f as realized value on fork-join common pool, 2 arg creates a future that will be realized on ExecutorService supplied with return value of f as realized value.

The executor that is set at this stage will continue to be used for subsequent steps (then/chain etc) if another one is not specified at another level

future-m clj

future? clj

(future? x)

Returns true if x is a CompletableFuture

handle clj

let-flow clj macro

(let-flow steps & body)

Like let-flow but supports :when.

(let-flow [x (future (fn [] 0))
         :when (= x 0)
         y (+ x 1)
         z (future (fn [] (inc y)))]
[x y z])```

loop clj macro

(loop bindings & body)

A version of Clojure's loop which allows for asynchronous loops, via qbits.auspex/recur. loop will always return a CompletableFuture Value, even if the body is synchronous. Note that loop does not coerce values to deferreds, actual qbits.auspex/futures must be used.

(loop [i 1e6] (chain (future i) #(if (zero? %) % (recur (dec %)))))

one clj

(one & cfs)

Returns one value from a list of futures

realized? clj

recur clj

(recur & args)

Like recur, but to be used with qbits.auspex/loop

recur? clj

(recur? x)

success! clj

success-future clj

(success-future x)

Returns a new CompletableFuture that is already completed with the given value.

then clj

timeout! clj

when-complete clj

zip clj

(zip & xs)

Takes a list of values, some of which can be futures and returns a future that will contains a list of realized values

zip' clj

(zip' & fs)

Like zip but faster if you know you're only dealing with futures args