meander.strategy.alpha — meander/alpha 0.0.533

Rewrite strategy combinators.

A strategy is a unary function of a term (any object) and returns the term rewritten.

Notation:

t ∈ Term p, q, r, s ∈ Strategy

*fail* clj/s

(*fail* t)

Strategy which always fails.

*pass* clj/s

(*pass* t)

Strategy which returns t.

all clj/s

(all s)

all-bu clj/s

(all-bu s)

Apply the all strategy with s to every subterm in t from the bottom up.

all-td clj/s

(all-td s)

Apply the all strategy with s to every subterm in t from the top down.

at clj/s≠

clj

(at key)

(at key p)

(at key p q)

(at key p q & more)

cljs

(at k & ps)

Build a strategy which modifies t at key with p, then q, etc. Works with map?, vector?, and set?. For vector? and set? key must be present.

attempt clj/s

(attempt s)

Build a strategy which attempts apply s to a term. If s succeeds, it returns the result. If s fails return the original term.

bottom-up clj/s

(bottom-up s)

Build a strategy which applies s to each subterm of t from bottom to top.

branch clj/s

(branch p q r)

breadth-first clj/s

(breadth-first s)

build clj/s

(build t)

Build a strategy which always returns t.

choice clj/s≠

clj

(choice)

(choice p)

(choice p q)

(choice p q & more)

cljs

(choice)

(choice p)

(choice p q)

(choice p q r)

(choice p q r s)

(choice p q r s & more)

Build a strategy which applies p or q to t. If p rewrites, return the result, otherwise apply q.

extract clj/s

(extract s)

Return a sequence of all successful rewrites of s applied to all subterms of t.

fail clj/s

(fail t)

Strategy which always fails.

fail? clj/s

(fail? x)

true if x is *fail*, false otherwise.

find clj/s≠ macro

clj

(find & clauses)

cljs

(find &form &env & clauses)

Strategy version of meander.match.alpha/find that defaults to returning fail.

guard clj/s

(guard p s)

Build a strategy which applies s to t iff p is true for t.

iall? clj/s

(iall? x)

innermost clj/s

(innermost s)

Build a strategy which repeatedly applies s to t starting from the innermost subterm in t.

ione? clj/s

(ione? x)

iretain? clj/s

(iretain? x)

iseq-all-body clj/s macro

(iseq-all-body t s)

isome? clj/s

(isome? x)

match clj/s≠ macro

clj

(match & clauses)

cljs

(match &form &env & clauses)

Strategy version of match which defaults to returning fail.

once-bu clj/s

(once-bu s)

Apply the one strategy with s to every subterm in t from the bottom up.

once-td clj/s

(once-td s)

Apply the one strategy with s to every subterm in t from the top down.

one clj/s

(one s)

outermost clj/s

(outermost s)

Build a strategy which repeatedly applies s to t starting from the outermost subterm in t until it fails.

pass clj/s

(pass t)

Strategy which returns t.

pass? clj/s

(pass? x)

true if x is *pass*, false otherwise.

pipe clj/s≠

clj

(pipe)

(pipe p)

(pipe p q)

(pipe p q & more)

cljs

(pipe)

(pipe p)

(pipe p q)

(pipe p q r)

(pipe p q r s)

(pipe p q r s & more)

Build a strategy which applies p to t and then q iff p rewrites t. If p and q are successful, return the result, otherwise return *fail*.

pred clj/s

(pred p)

Build a strategy which returns t iff p is true for t and fails otherwise.

repeat clj/s

(repeat s)

Build a strategy which applies s to t repeatedly until failure. Note that, if used in conjunction with a strategy which never fails i.e. attempt, this will cause a stack overflow. To avoid this, use while or until.

Example:

((repeat (pipe (pred vector?) (fn [v] (if (seq v) (if (= (peek v) 2) fail (pop v)) fail)))) [1 2 3 4]) ;; => [1 2]

retain clj/s

(retain s)

(retain s t)

Return a strategy which retains subterms of t for which the strategy s succeeds.

rewrite clj/s≠ macro

clj

(rewrite & rules)

cljs

(rewrite &form &env & rules)

Returns strategy which symbolically transforms t in to t' via pattern matching and substitution.

Example:

(let [s (rewrite (let* [!bs !vs ..1] . !body ...) (let* [!bs !vs] (let* [!bs !vs ...] . !body ...)))] (s '(let* [b1 :v1, b2 :v2, b3 :v3] (vector b1 b2 b3))))

search clj/s≠ macro

clj

(search & clauses)

cljs

(search &form &env & clauses)

Strategy version of search.

some clj/s

(some s)

Build a strategy which applies s to as many direct subterms of t as possible. Succeeds if at least one application applies, fails otherwise.

some-bu clj/s

(some-bu s)

some-td clj/s

(some-td s)

spine-bu clj/s

(spine-bu s)

spine-td clj/s

(spine-td s)

spread clj/s

(spread f)

(spread f n)

Build a strategy which applies the first n values of t to f iff t is a coll. Behaves like apply if n is not supplied. Useful in conjunction with juxt.

((pipe (tuple (comp (some keyword) keys) vals) (spread zipmap 2)) {"foo" "bar" "baz" "quux"}) ;; => {:foo "bar" :baz "quux"}

top-down clj/s

(top-down s)

Build a strategy which applies s to each subterm of t from top to bottom.

top-down-until clj/s

(top-down-until pred s)

Build a strategy which applies s to each subterm of t from top to bottom until pred is false for some subterm of t.

top-down-while clj/s

(top-down-while pred s)

Build a strategy which applies s to each subterm of t from top to bottom so long as pred is true for some subterm of t.

trace clj/s

(trace s)

(trace s f)

Build a strategy which monitors the entry and exit values of s.

tuple clj/s≠

clj

(tuple)

(tuple p)

(tuple p q)

(tuple p q & more)

cljs

(tuple)

(tuple p)

(tuple p q)

(tuple p q r)

(tuple p q r s)

(tuple p q r s & more)

Build a strategy which behaves similarly to juxt but fails if any of the strategies which compose it fail.

until clj/s

(until pred s)

Build a strategy which repeatedly applies s to t so long as pred is false for t and t*.

((until = (rewrite ('let [!bs !vs ... ?b ?v] . !body ...) ('let [!bs !vs ...] (('fn [?b] . !body ...) ?v))

  ('let [] ?x)
  ?x))

'(let [a 1 b 2 c 3] (+ a b c))) ;; => ((fn [a] ((fn [b] ((fn [c] (+ a b c)) 3)) 2)) 1)

while clj/s

(while pred s)

Build a strategy which repeatedly applies s to t so long as pred is false for t and t*.

((while not= (rewrite ('let [!bs !vs ... ?b ?v] . !body ...) ('let [!bs !vs ...] (('fn [?b] . !body ...) ?v))

  ('let [] ?x)
  ?x))

'(let [a 1 b 2 c 3] (+ a b c))) ;; => ((fn [a] ((fn [b] ((fn [c] (+ a b c)) 3)) 2)) 1)