clojure.core.match — bronsa/core.match 0.3.0-alpha4

*backtrack-stack* clj

*clojurescript* clj

*line* clj

*locals* clj

*match-lookup* clj

Allow map matching syntax to check for IMatchLookup

*no-backtrack* clj

Flag to optimize performance over code size.

*recur-present* clj

In the presence of recur we cannot apply code size optimizations

*root* clj

*syntax-check* clj

Enable syntax check of match macros

*vector-type* clj

Default vector type. Can be rebound allowing emission of custom inline code for vector patterns, for example type-hinted primitive array operations

*warned* clj

action-for-row clj

(action-for-row {rows :rows} j)

all-wildcards? clj

(all-wildcards? prow)

app-pattern clj

(app-pattern p form)

app-pattern-matrix-ocrs clj

(app-pattern-matrix-ocrs [focr :as ocrs] form)

app-pattern? clj

(app-pattern? x)

array-tag clj

(array-tag x)

as-pattern clj

backtrack clj

Pre-allocated exception used for backtracing

backtrack-expr clj

(backtrack-expr)

backtrack-sym clj

(backtrack-sym)

bind-node clj

(bind-node bindings node)

bind-variables clj

(bind-variables ocrs)

calc-rest?-and-min-size clj

(calc-rest?-and-min-size rows env)

cases clj

(cases matrix)

catch-error clj

(catch-error & body)

check-matrix-args clj

(check-matrix-args vars clauses)

check-pattern clj

(check-pattern pat vars nvars rownum)

check-size? clj multimethod

choose-column clj

(choose-column matrix)

clj-form clj

(clj-form vars clauses)

column clj

(column {rows :rows} i)

column-splitter clj

(column-splitter col)

compile clj

(compile {:keys [rows ocrs] :as pm})

constructor? clj

(constructor? p)

constructors-above? clj

(constructors-above? pm i j)

count-inline clj multimethod

dag-clause-to-clj clj

(dag-clause-to-clj occurrence pattern action)

default-case clj

(default-case matrix)

default-specialize-matrix clj

(default-specialize-matrix p matrix)

defpred clj macro

(defpred name)

(defpred name f)

dim clj

(dim pm)

drop-nth-bind clj

(drop-nth-bind prow n ocr)

emit-matrix clj

(emit-matrix vars clauses)

(emit-matrix vars clauses default)

Take the list of vars and sequence of unprocessed clauses and return the pattern matrix. The pattern matrix contains the processed pattern rows and the list of vars originally specified. Inserts a last match - :else if provided by the user or a default match that throws.

emit-pattern clj multimethod

Returns the corresponding pattern for the given syntax. Dispatches on the class of its argument. For example, [(:or 1 2) 2] is dispatched as clojure.lang.IPersistentVector

emit-pattern-for-syntax clj multimethod

Handles patterns wrapped in the special list syntax. Dispatches on the first or second keyword in the list. For example, the pattern (:or 1 ...) is dispatches as :or, and(1 :as a)` is dispatched by :as.

emit-patterns clj

(emit-patterns ps t)

(emit-patterns ps t v)

empty-matrix? clj

(empty-matrix? pm)

empty-row? clj

(empty-row? row)

empty-rows-case clj

(empty-rows-case)

Case 1: If there are no pattern rows to match, then matching always fails

executable-form clj

(executable-form node)

existential-pattern? clj

(existential-pattern? x)

expand-matrix clj

(expand-matrix matrix col)

expression? clj

(expression? ocr)

fail-node clj

(fail-node)

find-duplicate-wildcards clj

(find-duplicate-wildcards pattern)

first-column-chosen-case clj

(first-column-chosen-case matrix col ocrs)

Case 3a: The first column is chosen. Compute and return a switch/bind node with a default matrix case

first-column? clj

(first-column? i)

first-row-empty-case clj

(first-row-empty-case rows ocr)

Case 2: If the first row is empty then matching always succeeds and yields the first action.

first-row-wildcards-case clj

(first-row-wildcards-case rows ocrs)

Case 2: If the first row is constituted by wildcards then matching matching always succeeds and yields the first action.

gen-map-pattern-ocr clj

(gen-map-pattern-ocr ocr k)

get-all-keys clj

(get-all-keys rows env)

get-loop-locals clj

(get-loop-locals)

get-ocr-map clj

(get-ocr-map p {:keys [only all-keys wc-map]})

group-keywords clj

(group-keywords pattern)

Returns a pattern with pattern-keywords (:when and :as) properly grouped. The original pattern may use the 'flattened' syntax. For example, a 'flattened' pattern row like [a b :when even?] is grouped as [a (b :when even?)].

group-rows clj

(group-rows cs rows)

groupable? clj multimethod

Determine if two patterns may be grouped together for simultaneous testing.

guard-pattern clj

guard-pattern? clj

(guard-pattern? x)

height clj

(height {rows :rows})

leaf-bind-expr clj multimethod

leaf-node clj

(leaf-node value)

(leaf-node value bindings)

literal-case-matrix-splitter clj

(literal-case-matrix-splitter matrix)

literal-pattern clj

(literal-pattern l)

literal-pattern? clj

(literal-pattern? x)

map-key-pattern clj

(map-key-pattern p)

map-key-pattern? clj

(map-key-pattern? x)

map-pattern clj

(map-pattern)

(map-pattern m)

map-pattern-matrix-ocr-sym clj

(map-pattern-matrix-ocr-sym k env)

map-pattern-matrix-ocrs clj

(map-pattern-matrix-ocrs ocrs env)

map-pattern? clj

(map-pattern? x)

match clj macro

(match vars & clauses)

Pattern match a row of occurrences. Take a vector of occurrences, vars. Clause question-answer syntax is like cond. Questions must be wrapped in a vector, with same arity as vars. Last question can be :else, which expands to a row of wildcards. Optionally may take a single var not wrapped in a vector, questions then need not be wrapped in a vector.

Example: (let [x 1 y 2] (match [x y 3] [1 2 3] :answer1 :else :default-answer))

match-let clj macro

(match-let bindings & body)

matchm clj macro

(matchm vars & clauses)

Same as match but supports IMatchLookup when matching maps.

matchv clj macro

(matchv type vars & clauses)

matrix-splitter clj

(matrix-splitter matrix)

named-wildcard-pattern? clj

(named-wildcard-pattern? x)

necessary-column clj

(necessary-column pm)

non-local-literal-pattern? clj

(non-local-literal-pattern? p)

nth-inline clj multimethod

nth-offset-inline clj multimethod

nthnext-inline clj multimethod

occurrences clj

(occurrences pm)

or-pattern clj

or-pattern? clj

(or-pattern? x)

other-column-chosen-case clj

(other-column-chosen-case matrix col)

Case 3b: A column other than the first is chosen. Swap column col with the first column and compile the result

pattern-at clj

(pattern-at {rows :rows} i j)

pattern-matrix clj

(pattern-matrix rows ocrs)

pattern-row clj

(pattern-row ps action)

(pattern-row ps action bindings)

pattern-score clj

(pattern-score pm i j)

predicate-pattern clj

predicate-pattern? clj

(predicate-pattern? x)

preds clj

process-vars clj

(process-vars vars)

Process the vars for the pattern matrix. If user provides an expression, create a var and annotate via metadata with the original expression.

pseudo-pattern? clj

(pseudo-pattern? x)

pseudo-patterns clj

(pseudo-patterns matrix i)

recur-present? clj

(recur-present? actions)

regroup-keywords clj

(regroup-keywords pattern)

rest-pattern clj

(rest-pattern p)

rest-pattern? clj

(rest-pattern? x)

return-split clj

(return-split S D)

root-bind-node clj

(root-bind-node matrix)

row clj

(row {rows :rows} j)

row-bindings clj

(row-bindings f ocrs)

row-keys clj

(row-keys row env)

rows clj

(rows {rows :rows})

score-column clj

(score-column i col)

select clj

(select pm)

seq-pattern clj

(seq-pattern s)

seq-pattern-matrix-ocrs clj

(seq-pattern-matrix-ocrs ocrs focr)

seq-pattern-matrix-rest-ocrs clj

(seq-pattern-matrix-rest-ocrs ocrs focr)

seq-pattern? clj

(seq-pattern? x)

specialize clj

(specialize matrix)

(specialize matrix p)

specialize-app-pattern-matrix clj

(specialize-app-pattern-matrix rows form)

specialize-guard-pattern-matrix clj

(specialize-guard-pattern-matrix rows)

specialize-map-key-pattern-matrix clj

(specialize-map-key-pattern-matrix rows)

specialize-map-pattern-matrix clj

(specialize-map-pattern-matrix rows env)

specialize-map-pattern-row clj

(specialize-map-pattern-row row {:keys [all-keys only? focr] :as env})

specialize-or-pattern-matrix clj

(specialize-or-pattern-matrix rows pat ps)

specialize-or-pattern-row clj

(specialize-or-pattern-row row pat ps)

specialize-predicate-pattern-matrix clj

(specialize-predicate-pattern-matrix rows)

specialize-seq-pattern-matrix clj

(specialize-seq-pattern-matrix rows focr)

specialize-seq-pattern-rest-matrix clj

(specialize-seq-pattern-rest-matrix rows focr)

specialize-seq-pattern-rest-row clj

(specialize-seq-pattern-rest-row focr row)

specialize-seq-pattern-row clj

(specialize-seq-pattern-row focr row)

specialize-vector-pattern-matrix clj

(specialize-vector-pattern-matrix rows env)

specialize-vector-pattern-row clj

(specialize-vector-pattern-row row {:keys [focr min-size]})

specialize-vector-pattern-row-non-rest clj

(specialize-vector-pattern-row-non-rest row {:keys [focr min-size]})

split-matrix clj

(split-matrix matrix)

subvec-inline clj multimethod

switch-node clj

(switch-node occurrence cases default)

tag clj multimethod

test-inline clj multimethod

test-with-min-size-inline clj multimethod

test-with-size-inline clj multimethod

to-pattern-row clj

(to-pattern-row pat action)

Take an unprocessed pattern expression and an action expression and return a pattern row of the processed pattern expression plus the action epxression.

to-source clj multimethod

Returns a Clojure form that, when executed, is truthy if the pattern matches the occurrence. Dispatches on the type of the pattern. For instance, a literal pattern might return (= ~(:pattern pattern) ~ocr), using = to test for a match.

update-pattern clj

(update-pattern prow i p)

useful-matrix clj

(useful-matrix pm)

val-at* clj

(val-at* m k)

(val-at* m k not-found)

val-at-expr clj

(val-at-expr & args)

vector-pattern clj

vector-pattern-matrix-ocrs clj

(vector-pattern-matrix-ocrs ocrs {:keys [focr tag min-size rest?] :as env})

vector-pattern-ocr-sym clj

(vector-pattern-ocr-sym {:keys [pat focr tag]} i)

vector-pattern? clj

(vector-pattern? x)

vector-type clj

(vector-type t & r)

warn clj

(warn msg)

width clj

(width {rows :rows})

wildcard-or-existential? clj

(wildcard-or-existential? x)

wildcard-pattern clj

(wildcard-pattern)

(wildcard-pattern sym)

wildcard-pattern? clj

(wildcard-pattern? x)

wildcards-and-duplicates clj

(wildcards-and-duplicates patterns)

Returns a vector of two elements: the set of all wildcards and the set of duplicate wildcards. The underbar _ is excluded from both.

with-tag clj

(with-tag t ocr)

wrap-values clj

(wrap-values m)