meander.syntax.delta — meander/delta 0.0.149

analyze clj/s

(analyze node)

any-form? clj/s

(any-form? x)

true if x is a symbol beginning with _.

any-node? clj/s

(any-node? x)

true if x is an :any node, false otherwise.

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.

defsyntax clj/s≠ macro

clj

(defsyntax name docstring? meta? arglist & body)

cljs

(defsyntax & args)

EXPERIMENTAL Like defn but for defining new pattern syntax by extending the parser. When parsing, if a seq is encountered starting with a symbol which can be resolved to the created var then the tail of the seq is applied to the var and the result is parsed.

Example

(defsyntax re [regex] `(~'pred (fn [s#] (and (string? s#) (re-matches ~regex s#)))))

(require '[meander.match.delta :as r.match])

(r.match/match "elf" (re #"[a-z]+") :okay!) ;; => :okay

expand-seq clj/s multimethod

(expand-seq seq env)

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.

ground? clj/s multimethod

(ground? node)

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

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.

See also: compile-ground

logic-variable-form? clj/s

(logic-variable-form? x)

true if x is in the form of a logic variable i.e. a simple symbol with a name beginning with ?.

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.

match-bindings clj/s

(match-bindings node)

Returns a set of variables which would be bound by a successful pattern match.

(match-bindings (parse '(not [?x]))) ;; => #{}

(match-bindings (parse '(not (not [?x])))) ;; => #{{:tag :lvr, :symbol ?x}}

max-length clj/s multimethod

(max-length node)

The maximum possible length the pattern described by node can be. Note, this mutlimethod will throw an error wheneven 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.

memory-variable-form? clj/s

(memory-variable-form? x)

true if x is in the form of a memory variable i.e. a simple symbol with a name beginning with !.

memory-variables clj/s

(memory-variables node)

Return all :mvr nodes in node.

min-length clj/s multimethod

(min-length node)

The maximum possible length the pattern described by node can be. Note, this mutlimethod will throw an error wheneven 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.

mvr-node? clj/s

(mvr-node? x)

node? clj/s

(node? x)

true if x is an AST node.

not-not? clj/s

(not-not? node)

parse clj/s

(parse x)

(parse x env)

Parse x 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-set clj/s

(parse-set s env)

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.

ref-sym? clj/s

(ref-sym? x)

references clj/s

(references node)

Return all :ref nodes in node.

rename-refs clj/s

(rename-refs node)

Give all distinct :ref nodes a unique :symbol.

scan-cat clj/s

(scan-cat node)

If node is a :prt node resembling the pattern

_ ... <p_1 ,,, p_n> . _ ...

then scan-cat will return the :cat node representing

<p_1 ,,, p_n>

Example:

(scan-cat '{:tag :prt, :left {:tag :drp, :symbol _}, :right {:tag :prt, :left {:tag :cat, :elements [{:tag :lvr, :symbol ?x} {:tag :lvr, :symbol ?y}]}, :right {:tag :prt, :left {:tag :drp, :symbol _}, :right {:tag :cat, :elements []}}}}) ;; => {:tag :cat, :elements [{:tag :lvr, :symbol ?x} {:tag :lvr, :symbol ?y}]}

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.

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)