meander.syntax.gamma — meander/gamma 0.0.22

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.

defsyntax clj/s≠ macro

clj

(defsyntax name docstring? meta? arglist & body)

cljs

(defsyntax &form &env & 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.gamma :as r.match])

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

expand-seq clj/s multimethod

(expand-seq seq env)

fold clj/s multimethod

(fold f value node)

ground? clj/s multimethod

(ground? node)

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

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)

max-length clj/s multimethod

(max-length node)

The maximum possible length the pattern described by node can be.

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.

mvr-node? clj/s

(mvr-node? x)

node? clj/s

(node? x)

true if x is an AST 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 []}}}

postwalk clj/s

(postwalk f node)

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

postwalk-replace clj/s

(postwalk-replace smap form)

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

prewalk clj/s

(prewalk f node)

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

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.

re-matches? clj/s

(re-matches? re s)

ref-node? clj/s

(ref-node? x)

ref-sym? clj/s

(ref-sym? x)

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.

tag clj/s

(tag node)

Return the tag of 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.

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.