IMatchLookup

Allows arbitrary objects to act like a map-like object when pattern
matched. Avoid extending this directly for Java Beans, see
`match.java/bean-match`.

Usage: (val-at this k not-found)

BindNode

FailNode

GuardPattern

LeafNode

LiteralPattern

MapPattern

OrPattern

PatternMatrix

PatternRow

PredicatePattern

RestPattern

SeqPattern

SwitchNode

VectorPattern

WildcardPattern

*backtrack-with-errors*

Enable backtracking diagnostics

*breadcrumbs*

Enable breadcrumb diagnostics with fail nodes

*recur-present*

In the presence of recur we cannot apply code size optimizations

*syntax-check*

Enable syntax check of match macros

*trace*

Enable pattern compile time tracing

*vector-type*

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

->BindNode

Usage: (->BindNode bindings node)

Positional factory function for class clojure.core.match.BindNode.

->FailNode

Usage: (->FailNode)

Positional factory function for class clojure.core.match.FailNode.

->GuardPattern

Usage: (->GuardPattern p gs _meta)

Positional factory function for class clojure.core.match.GuardPattern.

->LeafNode

Usage: (->LeafNode value bindings)

Positional factory function for class clojure.core.match.LeafNode.

->LiteralPattern

Usage: (->LiteralPattern l _meta)

Positional factory function for class clojure.core.match.LiteralPattern.

->MapPattern

Usage: (->MapPattern m _meta)

Positional factory function for class clojure.core.match.MapPattern.

->OrPattern

Usage: (->OrPattern ps _meta)

Positional factory function for class clojure.core.match.OrPattern.

->PatternMatrix

Usage: (->PatternMatrix rows ocrs)

Positional factory function for class clojure.core.match.PatternMatrix.

->PatternRow

Usage: (->PatternRow ps action bindings)

Positional factory function for class clojure.core.match.PatternRow.

->PredicatePattern

Usage: (->PredicatePattern p gs _meta)

Positional factory function for class clojure.core.match.PredicatePattern.

->RestPattern

Usage: (->RestPattern p)

Positional factory function for class clojure.core.match.RestPattern.

->SeqPattern

Usage: (->SeqPattern s _meta)

Positional factory function for class clojure.core.match.SeqPattern.

->SwitchNode

Usage: (->SwitchNode occurrence cases default)

Positional factory function for class clojure.core.match.SwitchNode.

->VectorPattern

Usage: (->VectorPattern v t size offset rest? _meta)

Positional factory function for class clojure.core.match.VectorPattern.

->WildcardPattern

Usage: (->WildcardPattern sym)

Positional factory function for class clojure.core.match.WildcardPattern.

backtrack

Pre-allocated exception used for backtracing

comparable?

Returns true if it is possible to tell at compile time whether two
different versions of the same object can never match the same
object.

emit-matrix

Usage: (emit-matrix vars clauses)

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

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

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.

empty-rows-case

Usage: (empty-rows-case)

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

first-column-chosen-case

Usage: (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-row-empty-case

Usage: (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

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

group-keywords

Usage: (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?)].

map->BindNode

Usage: (map->BindNode m#)

Factory function for class clojure.core.match.BindNode, taking a map of keywords to field values.

map->FailNode

Usage: (map->FailNode m#)

Factory function for class clojure.core.match.FailNode, taking a map of keywords to field values.

map->LeafNode

Usage: (map->LeafNode m#)

Factory function for class clojure.core.match.LeafNode, taking a map of keywords to field values.

map->PatternMatrix

Usage: (map->PatternMatrix m#)

Factory function for class clojure.core.match.PatternMatrix, taking a map of keywords to field values.

map->RestPattern

Usage: (map->RestPattern m#)

Factory function for class clojure.core.match.RestPattern, taking a map of keywords to field values.

map->SwitchNode

Usage: (map->SwitchNode m#)

Factory function for class clojure.core.match.SwitchNode, taking a map of keywords to field values.

map->WildcardPattern

Usage: (map->WildcardPattern m#)

Factory function for class clojure.core.match.WildcardPattern, taking a map of keywords to field values.

match

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

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

other-column-chosen-case

Usage: (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-compare

Like `clojure.core/compare` but for comparing patterns

process-vars

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

safe-pattern-compare

Like pattern-compare but not affected by *recur-present*

to-pattern-row

Usage: (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

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.

wildcards-and-duplicates

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

bean-match

Usage: (bean-match class)

Generate an implementation of match.core/IMatchLookup for a Java bean.
Accessor method names are mapped to keys like this:

  isVisible       -> :visible?
  getText         -> :text
  getAbsolutePath -> :absolute-path 
  isFUD           -> :fud?
  getFUDFactor    -> :fud-factor

DispMatrix

->DispMatrix

Usage: (->DispMatrix dispatches)

Positional factory function for class clojure.core.match.pred.DispMatrix.

subsumes

Usage: (subsumes super sub)

Declares super as a strict superset of sub

RegexPattern

->RegexPattern

Usage: (->RegexPattern regex)

Positional factory function for class clojure.core.match.regex.RegexPattern.

map->RegexPattern

Usage: (map->RegexPattern m#)

Factory function for class clojure.core.match.regex.RegexPattern, taking a map of keywords to field values.