constructs a blocking seq

checks that object implements IBLocking

(blocking? (q/queue)) => true

writes to a flux

(collect-flux (flux) identity (range 5))

constructs a flux

checks if object is a flux

(flux? (flux)) => true

constructs an async transducer

(->> (sequence (i:async inc) (range 5)) (map deref)) => ’(1 2 3 4 5)

constructs a guard transducer

constructs a step transducer

true for promise and future

(ipending? (promise)) => true

constructs a mono

(mono {:future (f/completed 1) :data (atom {:name “hello”}) :parent (mono)}) => mono?

checks if object is a mono

(mono? (mono))

constructs the next stage

@(next-stage (mono {:future (f/completed 1)}) inc {}) => 2

chains monos together

@(process-mono (mono) inc 1 {}) => 2

takes from a flux

(map realized? (take 2 (produce-flux (flux)))) => ’(false false)

retrieves linked future result

(realize (f/future (f/future (f/future 3)))) => 3

checks if all linked futures are realized

(realized? (f/completed (f/completed 1))) => true

returns the unwrapped result

(stage-realize (f/future (Thread/sleep 10) 1)) => 1

checks if unwrapped result is realized

(stage-realized? (mono {:future (f/completed (f/completed 1))})) => true

returns the base future unit

(stage-unit (mono {:future |f|})) => |f|

checks if object implements IStage

(stage? (f/completed 1)) => true

takes an element from a queue

wrap collectors given async function

helper for unwrapping nested futures

@@((wrap-stage inc) (f/completed (f/completed 1))) => 2

wraps timing given the output

((wrap-time inc) 1) => (contains number? 2)