shortcut for :on/exception

creates a completed stage

creates a failed stage

fulfils the return with a function

(fulfil (incomplete) (fn [](+ 1 2 3)))

(fulfil (incomplete) (fn ))

constructs a completable future

@(future (Thread/sleep 100) 1) => 1

can create a future from a function or :init/future

@(future:call (fn [] 1)) => 1

@(-> (future:fn (fn [] 1)) (future:call)) => 1

cancels the execution of the future

checks if future has been cancelled

chains a set of functions

@(future:chain (completed 1) inc inc inc) => 4

@(future:chain (failed (ex-info “ERROR” {})) inc inc inc) => (throws)

checks that future has successfully completed

returns number of steps waiting on current result

helper macro for status functions

accesses the exception in the future

checks if future raised an exception

creates a future with :init/future props

forces a value or exception as completed future

check that future is incomplete

(-> (incomplete) (future:incomplete?)) => true

creates a future from a value

gets the value of a future at the current moment

like force but uses obtrude and obtrudeException

gets the result of the future

(future:result (completed 1)) => {:status :success, :data 1, :exception nil}

(future:result (failed (ex-info "" {}))) => (contains {:status :error :data nil :exception Throwable})

runs a function with additional settings

(future:run (fn [](Thread/sleep 100)) {:timeout 10 :default :ok :delay 100 :pool :async})

retrieves a status of either :success, :error or waiting

checks that future is successful

adds a timeout to the completed future

@(-> (future:call (fn [](Thread/sleep 100))) (future:timeout 10 :ok)) => :ok

checks if future errored due to timeout

gets the value of a future

waits for future to finish or

(-> (future:call (fn [](Thread/sleep 100))) (future:timeout 10 :ok) (future:wait) (future:now)) => :ok

checks if object is CompleteableFuture

(future? (future 1)) => true

creates an incomplete stage (like promise)

(incomplete) => (comp not future:complete?)

calls a function when all futures are complete

calls a function when any future is completed

processes a function on cancel

process both the value and exception

process a function on exception

processes another step given successful operation

processes a function on timeout

shortcut for :on/success and :on/complete