Liking cljdoc? Tell your friends :D

meander.syntax.delta


analyzeclj/s

(analyze node)
source

any-form?clj/s

(any-form? x)

true if x is a symbol beginning with _.

true if x is a symbol beginning with _.
sourceraw docstring

any-node?clj/s

(any-node? x)

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

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

childrenclj/smultimethod

(children node)

Return a sequential? of all children of node.

Return a sequential? of all children of node.
sourceraw docstring

consolidate-withclj/s

(consolidate-with node)

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

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

defsyntaxclj/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.delta :as r.match])

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

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
source (clj)source (cljs)raw docstring

expand-seqclj/smultimethod

(expand-seq seq env)
source

foldclj/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.

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.
sourceraw docstring

ground?clj/smultimethod

(ground? node)

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

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

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

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
sourceraw docstring

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 ?.

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

logic-variablesclj/s

(logic-variables node)

Return all :lvr nodes in node.

Return all :lvr nodes in node.
sourceraw docstring

lvr-node?clj/s

(lvr-node? x)
source

make-ref-mapclj/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.

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.
sourceraw docstring

match-bindingsclj/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}}

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}}
sourceraw docstring

max-lengthclj/smultimethod

(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.

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.
sourceraw docstring

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 !.

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

memory-variablesclj/s

(memory-variables node)

Return all :mvr nodes in node.

Return all :mvr nodes in node.
sourceraw docstring

min-lengthclj/smultimethod

(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.

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.
sourceraw docstring

mvr-node?clj/s

(mvr-node? x)
source

node?clj/s

(node? x)

true if x is an AST node.

true if x is an AST node.
sourceraw docstring

not-not?clj/s

(not-not? node)
source

parseclj/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 `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 []}}}
sourceraw docstring

parse-setclj/s

(parse-set s env)
source

postwalkclj/s

(postwalk f node)
source

postwalk-replaceclj/s

(postwalk-replace smap form)

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

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

prewalkclj/s

(prewalk f node)
source

prewalk-replaceclj/s

(prewalk-replace smap form)

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

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

proper-subnodesclj/s

(proper-subnodes node)

Return the all subnodes in node excluding node.

Return the all subnodes in node excluding node.
sourceraw docstring

ref-node?clj/s

(ref-node? x)

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

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

ref-sym?clj/s

(ref-sym? x)
source

referencesclj/s

(references node)

Return all :ref nodes in node.

Return all :ref nodes in node.
sourceraw docstring

rename-refsclj/s

(rename-refs node)

Give all distinct :ref nodes a unique :symbol.

Give all distinct :ref nodes a unique :symbol.
sourceraw docstring

search?clj/smultimethod

(search? node)

true if node represents a search, false otherwise.

true if node represents a search, false otherwise.
sourceraw docstring

subnodesclj/s

(subnodes node)

Return a sequence of all subnodes of node.

Return a sequence of all subnodes of node.
sourceraw docstring

substitute-refsclj/s

(substitute-refs node)
(substitute-refs node ref-map)

Given node and an optional ref-map

Given node and an optional ref-map 
sourceraw docstring

tagclj/s

(tag node)

Return the tag of node.

Return the tag of node.
sourceraw docstring

top-levelclj/s

(top-level node)
source

unparseclj/smultimethod

(unparse node)

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

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

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.

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.
sourceraw docstring

variable-node?clj/s

(variable-node? x)
source

variablesclj/s

(variables node)

Return all :lvr and :mvr nodes in node.

Return all :lvr and :mvr nodes in node.
sourceraw docstring

walkclj/smultimethod

(walk inner outer node)

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

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

with-node?clj/s

(with-node? x)
source

cljdoc is a website building & hosting documentation for Clojure/Script libraries

× close