meander.match.ir.delta — meander/delta 0.0.137

Functions for working with the Meander's match compiler intermediate representation (IR).

branch? clj/s

(branch? node)

true if node has any children, false otherwise.

can-merge? clj/s multimethod deprecated

DEPRECATED: true if two nodes a and b can be merged, false otherwise.

check? clj/s

(check? x)

children clj/s

(children node)

Return the child nodes of node, a sequence of ::node.

compile clj/s

(compile ir fail kind)

(compile ir fail kind env)

compile* clj/s multimethod

(compile* ir fail kind)

def-remove-unused clj/s

(def-remove-unused node)

defop clj/s≠ macro

clj

(defop symbol op params & body)

cljs

(defop &form &env symbol op params & body)

do-merge clj/s

(do-merge a b then)

(do-merge a b then else)

Attempts to merge two nodes a and b into a new node. If the merge is successful the function then is invoked with the new node. If the merge fails and the optional function else was passed, then else is invoked with a and b. If the merge fails and else was not passed, then the value ::merge-fail is returned.

drop-form clj/s

(drop-form n target-form kind)

FAIL clj/s

Special value signaling a match failure. Generated code will often utilize this value as for control flow purposes.

fail-form clj/s

(fail-form kind)

Returns (list FAIL) if kind is :search,FAIL otherwise. This is used when compiling :def nodes to ensure the correct type of data is returned to code compiled for :call nodes.

fail? clj/s

(fail? x)

height clj/s

(height node)

Return the height of node.

js-array-equals-form clj/s

(js-array-equals-form a b)

Form used to test if two arrays a and b are equal in ClojureScript.

make-node clj/s

(make-node node new-children)

merge clj/s multimethod

(merge a b)

Attempt to merge the nodes a and b. Returns the result of the merge if the merge succeeds. Returns a :branch node with :arms [a b] if the merge fails.

merge* clj/s multimethod

(merge* node-a node-b)

Attempts to merge two nodes into one node returning node* if successful and ::merge-fail otherwise.

merge-all clj/s

(merge-all nodes)

Attempts to successively merge all nodes in nodes from left to right.

node? clj/s

(node? x)

true if x is a ::node, false otherwise.

nodes clj/s

(nodes node)

Return all subnodes of node, a sequence of ::node.

op clj/s

(op node)

Return the ::op of node.

op-apply clj/s

(op-apply target fn-expr body-fn)

op-bind clj/s

(op-bind symbol value then)

op-branch clj/s

(op-branch arms)

op-case clj/s

(op-case target clauses else)

op-check clj/s

(op-check test then)

op-check-array clj/s

(op-check-array target then)

op-check-array-equals clj/s

(op-check-array-equals target-1 target-2 then)

op-check-boolean clj/s

(op-check-boolean test then)

op-check-bounds clj/s

(op-check-bounds target length kind then)

op-check-empty clj/s

(op-check-empty target then)

op-check-equal clj/s

(op-check-equal target-1 target-2 then)

op-check-lit clj/s

(op-check-lit target value then)

op-check-map clj/s

(op-check-map target then)

op-check-seq clj/s

(op-check-seq target then)

op-check-set clj/s

(op-check-set target then)

op-check-vector clj/s

(op-check-vector target then)

op-drop clj/s

(op-drop target n kind)

op-eval clj/s

(op-eval form)

op-fail clj/s

(op-fail)

op-fail? clj/s

(op-fail? x)

op-find clj/s

(op-find symbol value body)

op-load clj/s

(op-load id)

op-lookup clj/s

(op-lookup target key)

op-lvr-bind clj/s

(op-lvr-bind symbol target then)

op-lvr-check clj/s

(op-lvr-check symbol target then)

op-mut-bind clj/s

(op-mut-bind symbol target then)

op-mvr-append clj/s

(op-mvr-append symbol target then)

op-mvr-bind clj/s

(op-mvr-bind symbol target then)

op-mvr-init clj/s

(op-mvr-init symbol then)

op-nth clj/s

(op-nth target index)

op-pass clj/s

(op-pass then)

op-plus clj/s

(op-plus input n m kind return-symbols body-fn then)

op-return clj/s

(op-return value)

op-save clj/s

(op-save id body-1 body-2)

op-search clj/s

(op-search symbol value body)

op-star clj/s

(op-star input n kind return-symbols body-fn then)

op-take clj/s

(op-take target n kind)

op= clj/s

(op= node op)

postwalk clj/s

(postwalk f node)

prewalk clj/s

(prewalk f node)

rewrite clj/s

(rewrite node)

rewrite* clj/s

(rewrite* node)

rewrite-branch-check-lits-to-case clj/s

(rewrite-branch-check-lits-to-case node)

rewrite-case-duplicate-actions clj/s

(rewrite-case-duplicate-actions node)

rewrite-move-mvr-init-to-top-level clj/s

(rewrite-move-mvr-init-to-top-level node)

run-find clj/s

(run-find space body-f fail-f)

run-star-js-array clj/s

(run-star-js-array coll rets n body-f then-f)

run-star-js-array-search clj/s

(run-star-js-array-search coll rets n body-f then-f)

run-star-seq clj/s

(run-star-seq coll rets n body-f then-f)

run-star-seq-search clj/s

(run-star-seq-search coll rets n body-f then-f)

run-star-vec clj/s

(run-star-vec coll rets n body-f then-f)

run-star-vec-search clj/s

(run-star-vec-search coll rets n body-f then-f)

take-form clj/s

(take-form n target-form kind)

walk clj/s

(walk inner outer node)

zipper clj/s

(zipper node)