AppPattern

BindNode

FailNode

GuardPattern

LeafNode

LiteralPattern

MapKeyPattern

MapPattern

OrPattern

PatternMatrix

PatternRow

PredicatePattern

RestPattern

SeqPattern

SwitchNode

VectorPattern

WildcardPattern

*match-lookup*

Allow map matching syntax to check for IMatchLookup

*no-backtrack*

Flag to optimize performance over code size.

*recur-present*

In the presence of recur we cannot apply code size optimizations

*syntax-check*

Enable syntax check of match macros

*vector-type*

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

->AppPattern

Usage: (->AppPattern p form _meta)

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

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

->MapKeyPattern

Usage: (->MapKeyPattern p)

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

->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 named _meta)

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

backtrack

Pre-allocated exception used for backtracing

emit-matrix

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

No usage documentation available

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

No usage documentation available

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

groupable?

No usage documentation available

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

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->MapKeyPattern

Usage: (map->MapKeyPattern m#)

Factory function for class clojure.core.match.MapKeyPattern, 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.

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

matchm

Usage: (matchm vars & clauses)

Same as match but supports IMatchLookup when
matching maps.

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

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.

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

No usage documentation available

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

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)

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.