meander.syntax.epsilon — meander/epsilon 0.0.168

*env* clj/s

*form* clj/s

any-node? clj/s

(any-node? x)

children clj/s multimethod

(children node)

Return a sequential? of all children of node.

consolidate-with clj/s

(consolidate-with node)

Collapse all :wth nodes into a single :wth node.

default-env clj/s

defsyntax clj/s≠ macro

clj

(defsyntax name doc-string? attr-map? [params*] prepost-map? body)

(defsyntax name doc-string? attr-map? ([params*] prepost-map? body) + attr-map?)

cljs

(defsyntax & defn-args)

empty-cat-node? clj/s

(empty-cat-node? x)

expand-form clj/s

(expand-form form env)

Expand form with respect to env if possible. Returns the result of expanding form or form unchanged.

expand-seq clj/s multimethod

(expand-seq seq env)

expander-registry clj/s

(expander-registry env)

Return the ::expander-registry of the environment env or nil if it cannot be found.

fold clj/s

(fold f value node)

Same as clojure.core/reduce but specifically for ASTs. f must be a binary (arity 2) function and will receive as arguments the current accumulated value and an AST node. fold is eager and will visit each subnode in node.

global-expander-registry clj/s

global-parser-registry clj/s

ground? clj/s multimethod

(ground? node)

true if node is ground i.e. it contains no variables or is not a match operator.

lit-form clj/s

(lit-form node)

literal? clj/s

(literal? node)

true if node is ground and does not contain :map or :set subnodes, false otherwise.

The constraint that node may not contain :map or :set subnodes is due to the semantics of map and set patterns: they express submap and subsets respectively. Compiling these patterns to literals as part of an equality check would result in false negative matches.

logic-variables clj/s

(logic-variables node)

Return all :lvr nodes in node.

lvr-node? clj/s

(lvr-node? x)

make-ref-map clj/s

(make-ref-map node)

If node is a node repesenting a with pattern, return a map from reference to pattern node derived from it's bindings, otherwise return an empty map.

make-variable-rename-map clj/s

(make-variable-rename-map node)

max-length clj/s multimethod

(max-length node)

The maximum possible length the pattern described by node can be. Note, this multimethod will throw an error whenever node does not have a method to handle it. This behavior is intentional as the implementations should only exist for things which have can have length. The max-length? predicate can be used to detect if node implements max-length.

max-length? clj/s

(max-length? x)

true if x implements max-length, false otherwise.

memory-variables clj/s

(memory-variables node)

Return all :mvr nodes in node.

min-length clj/s multimethod

(min-length node)

The minimum possible length the pattern described by node can be. Note, this multimethod will throw an error whenever node does not have a method to handle it. This behavior is intentional as the implementations should only exist for things which have can have length. The min-length? predicate can be used to detect if node implements min-length.

min-length? clj/s

(min-length? x)

true if x implements min-length, false otherwise.

mvr-node? clj/s

(mvr-node? x)

node? clj/s

(node? x)

true if x is an AST node.

parse clj/s

(parse form)

(parse form env)

Parse form into an abstract syntax tree (AST) optionally with respect to the environment env.

(parse '(?x1 ?x2 :as ?xs)) ;; => {:tag :seq :as {:tag :lvr :symbol ?xs} :prt {:tag :prt :left {:tag :cat :elements ({:tag :lvr :symbol ?x1} {:tag :lvr :symbol ?x2})} :right {:tag :cat :elements []}}}

parse-all clj/s

(parse-all forms env)

Apply parse to all forms in the sequence forms.

parse-seq clj/s

(parse-seq xs env)

Parses a seq? into a :meander.syntax.epsilon/node.

seqs? of the following form are handled specially, all other seqs are parsed as :seq nodes.

(quote <form>) (clojure.core/unquote <form>) (clojure.core/unquote-splicig <form>) (<symbol*> <form_0> ... <form_n>)

where symbol* is a fully qualified symbol with respect to the current namespace.

parse-set clj/s

(parse-set s env)

parser-registry clj/s

(parser-registry env)

Return the ::parser-registry of the environment env or nil if it cannot be found.

partition-node? clj/s

(partition-node? x)

postwalk clj/s

(postwalk f node)

postwalk-replace clj/s

(postwalk-replace smap form)

Same as clojure.walk/postwal-replace but for AST nodes.

prewalk clj/s

(prewalk f node)

prewalk-replace clj/s

(prewalk-replace smap form)

Same as clojure.walk/prewalk-replace but for AST nodes.

proper-subnodes clj/s

(proper-subnodes node)

Return the all subnodes in node excluding node.

ref-node? clj/s

(ref-node? x)

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

references clj/s

(references node)

Return all :ref nodes in node.

register-expander clj/s

(register-expander symbol f)

register-parser clj/s

(register-parser symbol f)

rename-refs clj/s

(rename-refs node)

Give all distinct :ref nodes a unique :symbol.

resolve-expander clj/s

(resolve-expander sym env)

Return the ::expander associated with sym with respect to the environment env.

resolve-parser clj/s

(resolve-parser sym env)

Return the ::parser associated with sym with respect to the environment env.

search? clj/s multimethod

(search? node)

true if node represents a search, false otherwise.

subnodes clj/s

(subnodes node)

Return a sequence of all subnodes of node.

substitute-refs clj/s

(substitute-refs node)

(substitute-refs node ref-map)

Given node and an optional ref-map

tag clj/s

(tag node)

Return the tag of node.

tail-node? clj/s

(tail-node? x)

top-level clj/s

(top-level node)

unparse clj/s multimethod

(unparse node)

In pre-order fashion rewrite a node into a Clojure form.

variable-length? clj/s

(variable-length? node)

true if node may have a variable length, false otherwise. Note this function will throw an error if node does not implement methods for both min-length and max-length.

variable-node? clj/s

(variable-node? x)

variables clj/s

(variables node)

Return all :lvr and :mvr nodes in node.

walk clj/s multimethod

(walk inner outer node)

Same as clojure.walk/walk but for AST nodes.

window clj/s

(window node)

with-node? clj/s

(with-node? x)