dar.async.go-machine — dar/async 0.2.0

-item-to-ssa clj multimethod

add-block clj

(add-block)

Adds a new block, returns its id, but does not change the current block (does not call set-block).

add-exception-frame clj

(add-exception-frame state
                     catch-block
                     catch-exception
                     finally-block
                     continue-block)

add-instruction clj

(add-instruction inst)

Appends an instruction to the current block.

aget-object clj

(aget-object arr idx)

all clj

(all itms)

Assumes that itms is a list of state monad function results, threads the state map through all of them. Returns a vector of all the results.

analyze clj

(analyze form env)

aset-all! clj macro

(aset-all! arr & more)

aset-object clj

(aset-object arr idx o)

assoc-in-plan clj

(assoc-in-plan path val)

Same as assoc-in, but for state hash map

async-custom-terminators clj

BINDINGS-IDX clj

collect-locals clj

(collect-locals ast)

count-persistent-values clj

(count-persistent-values index)

CURRENT-EXCEPTION clj

debug clj

(debug x)

deliver-promise clj

(deliver-promise state value)

EXCEPTION-FRAMES clj

finished? clj

(finished? state-array)

Returns true if the machine is in a finished state

FN-IDX clj

gen-plan clj macro

(gen-plan binds id-expr)

Allows a user to define a state monad binding plan.

(gen-plan [_ (assoc-in-plan [:foo :bar] 42) val (get-in-plan [:foo :bar])] val)

get-binding clj

(get-binding key)

Gets the value of the current binding for key

get-block clj

(get-block)

Gets the current block

get-in-plan clj

(get-in-plan path)

Same as get-in, but for a state hash map

get-plan clj

(get-plan f)

Returns the final [id state] from a plan.

go clj macro

(go & body)

id-for-inst clj

(id-for-inst m sym)

IEmittableInstruction clj protocol

emit-instruction clj

(emit-instruction this state-sym)

Returns the clojure code that this instruction represents

IInstruction clj protocol

block-references clj

(block-references this)

Returns all the blocks this instruction references

reads-from clj

(reads-from this)

Returns a list of instructions this instruction reads from

writes-to clj

(writes-to this)

Returns a list of instructions this instruction writes to

index-block clj

(index-block idx [blk-id blk])

index-instruction clj

(index-instruction blk-id idx inst)

index-state-machine clj

(index-state-machine machine)

instruction? clj

(instruction? x)

item-to-ssa clj

(item-to-ssa ast)

ITerminator clj protocol

terminate-block clj

(terminate-block this state-sym custom-terminators)

Emites the code to terminate a given block

terminator-code clj

(terminator-code this)

Returns a unique symbol for this instruction

let-binding-to-ssa clj

(let-binding-to-ssa {:keys [name init]})

make-env clj

(make-env input-env)

mark-transitions clj

(mark-transitions transitions {:keys [op fn] :as ast})

no-op clj

(no-op)

This function can be used inside a gen-plan when no operation is to be performed

parse-to-state-machine clj

(parse-to-state-machine body terminators)

Takes an sexpr and returns a hashmap that describes the execution flow of the sexpr as a series of SSA style blocks.

pdebug clj

(pdebug x)

persistent-value? clj

(persistent-value? index value)

Returns true if this value should be saved in the state hash map

pop-binding clj

(pop-binding key)

Removes the most recent binding for key

print-plan clj

(print-plan)

process-exception clj

(process-exception state)

propagate-recur clj

(propagate-recur ast)

propagate-transitions clj

(propagate-transitions {:keys [op] :as ast})

push-alter-binding clj

(push-alter-binding key f & args)

Pushes the result of (apply f old-value args) as current value of binding key

push-binding clj

(push-binding key value)

Sets the binding 'key' to value. This operation can be undone via pop-bindings. Bindings are stored in the state hashmap.

receive clj

(receive state blk p)

run-state-machine clj

(run-state-machine state)

run-state-machine-wrapped clj

(run-state-machine-wrapped state)

set-block clj

(set-block block-id)

Sets the current block being written to by the functions. The next add-instruction call will append to this block

STATE-IDX clj

state-machine clj

(state-machine body num-user-params env user-transitions)

update-in-plan clj

(update-in-plan path f & args)

Same as update-in, but for a state hash map

USER-START-IDX clj

VALUE-IDX clj

var-name clj

(var-name v)