9 Pattern Matching🔗ℹ

Pattern Matching in The Racket Guide introduces pattern matching.

The match form and related forms support general pattern matching on Racket values. See also Regular Expressions for information on regular-expression matching on strings, bytes, and streams.

To find a match, the clauses are tried in order. If no clause matches, then the exn:misc:match? exception is raised.

An optional #:when cond-expr specifies that the pattern should only match if cond-expr produces a true value. cond-expr is in the scope of all of the variables bound in pat. cond-expr must not mutate the object being matched before calling the failure procedure, otherwise the behavior of matching is unpredictable. See also failure-cont, which is a lower-level mechanism achieving the same ends.

An optional #:do [do-body ...] executes do-body forms. In particular, the forms may introduce definitions that are visible in the remaining options and the main clause body. Both #:when and #:do options may appear multiple times

An optional (=> id), which must appear immediately after pat, is bound to a failure procedure of zero arguments. id is visible in all clause options and the clause body. If this procedure is invoked, it escapes back to the pattern matching expression, and resumes the matching process as if the pattern had failed to match. The bodys must not mutate the object being matched before calling the failure procedure, otherwise the behavior of matching is unpredictable.

The grammar of pat is as follows, where non-italicized identifiers are recognized symbolically (i.e., not by binding).

In more detail, patterns match as follows:

• id (excluding the reserved names _, ..., ___, ..k, and __k for non-negative integers k)

  Unlike in cond and case, else is not a keyword in match. Use the _ pattern for the “else” clause.

  or (var id) — matches anything, and binds id to the matching values. If an id is used multiple times within a pattern, the corresponding matches must be the same according to (match-equality-test), except that instances of an id in different or and not sub-patterns are independent. The binding for id is not available in other parts of the same pattern.
  Examples:

  > (match '(1 2 3)     [(list a b a) (list a b)]     [(list a b c) (list c b a)])

  '(3 2 1)

  > (match '(1 (x y z) 1)     [(list a b a) (list a b)]     [(list a b c) (list c b a)])

  '(1 (x y z))

  > (match #f     [else      (cond        [#f 'not-evaluated]        [else 'also-not-evaluated])])

• _ — matches anything, without binding any identifiers.

  Example:

  > (match '(1 2 3)     [(list _ _ a) a])

  3

• #t, #f, string, bytes, number, char, or (quote datum) — matches an equal? constant.

  Example:

  > (match "yes"     ["no" #f]     ["yes" #t])

  #t

• (list lvp ...) — matches a list of elements. In the case of (list pat ...), the pattern matches a list with as many elements as pats, and each element must match the corresponding pat. In the more general case, each lvp corresponds to a “spliced” list of greedy matches.

  For spliced lists, ... and ___ are aliases for zero or more matches. The ..k and __k forms are also aliases, specifying k or more matches. Pattern variables that precede these splicing operators are bound to lists of matching forms.

  Examples:

  > (match '(1 2 3)     [(list a b c) (list c b a)])

  '(3 2 1)

  > (match '(1 2 3)     [(list 1 a ...) a])

  '(2 3)

  > (match '(1 2 3)     [(list 1 a ..3) a]     [_ 'else])

  'else

  > (match '(1 2 3 4)     [(list 1 a ..3) a]     [_ 'else])

  '(2 3 4)

  > (match '(1 2 3 4 5)     [(list 1 a ..3 5) a]     [_ 'else])

  '(2 3 4)

  > (match '(1 (2) (2) (2) 5)     [(list 1 (list a) ..3 5) a]     [_ 'else])

  '(2 2 2)

• (list-rest lvp ... pat) or (list* lvp ... pat) — similar to a list pattern, but the final pat matches the “rest” of the list after the last lvp. In fact, the matched value can be a non-list chain of pairs (i.e., an “improper list”) if pat matches non-list values.

  Examples:

  > (match '(1 2 3 . 4)     [(list-rest a b c d) d])

  4

  > (match '(1 2 3 . 4)     [(list-rest a ... d) (list a d)])

  '((1 2 3) 4)

• (list-no-order pat ...) — similar to a list pattern, but the elements to match each pat can appear in the list in any order.

  Example:

  > (match '(1 2 3)     [(list-no-order 3 2 x) x])

  1

  Unlike other patterns, list-no-order doesn’t allow duplicate identifiers between subpatterns. For example the patterns (list-no-order x 1 x) and (list-no-order x 1 x ...) both produce syntax errors.

• (list-no-order pat ... lvp) — generalizes list-no-order to allow a pattern that matches multiple list elements that are interspersed in any order with matches for the other patterns.

  Example:

  > (match '(1 2 3 4 5 6)     [(list-no-order 6 2 y ...) y])

  '(1 3 4 5)

• (vector lvp ...) — like a list pattern, but matching a vector.

  Example:

  > (match #(1 (2) (2) (2) 5)     [(vector 1 (list a) ..3 5) a])

  '(2 2 2)

• (hash expr pat ... ... ht-opt) — matches against a hash table where expr matches a key and pat matches a corresponding value.

  Examples:

  > (match (hash "aa" 1 "b" 2)     [(hash "b" b (string-append "a" "a") a)      (list b a)])

  '(2 1)

  > (match (hash "aa" 1 "b" 2)     [(hash "b" _ "c" _) 'matched]     [_ 'not-matched])

  'not-matched

  The key matchings use the key comparator of the matching hash table.

  Examples:

  > (let ([k (string-append "a" "b")])     (match (hasheq "ab" 1)       [(hash k v) 'matched]       [_ 'not-matched]))

  'not-matched

  > (let ([k (string-append "a" "b")])     (match (hasheq k 1)       [(hash k v) 'matched]       [_ 'not-matched]))

  'matched

  The behavior of residue key-value entries in the hash table value depends on ht-opt.

  When ht-opt is not provided or when it is #:closed, all of the keys in the hash table value must be matched. I.e., the matching is closed to extension.

  Example:

  > (match (hash "a" 1 "b" 2)     [(hash "b" _) 'matched]     [_ 'not-matched])

  'not-matched

  When ht-opt is #:open, there can be keys in the hash table value that are not specified in the pattern. I.e., the matching is open to extension.

  Example:

  > (match (hash "a" 1 "b" 2)     [(hash "b" _ #:open) 'matched]     [_ 'not-matched])

  'matched

  When ht-opt is #:rest pat, pat is further matched against the residue hash table. If the matching hash table is immutable, this residue matching is efficient. Otherwise, the matching hash table will be copied, which could be expensive.

  Example:

  > (match (hash "a" 1 "b" 2)     [(hash "b" _ #:rest (hash "a" a)) a]     [_ #f])

  1

  Many key exprs could evaluate to the same value.

  Example:

  > (match (hash "a" 1 "b" 2)     [(hash "b" _ "b" 2 "a" _) 'matched]     [_ 'not-matched])

  'matched

• (hash* [expr pat kv-opt] ... ht-opt) — similar to hash, but with the following differences:

  • The key-value pattern must be grouped syntactically.

  • If ht-opt is not specified, it behaves like #:open (as opposed to #:closed).

  • If kv-opt is specified with #:default def-expr, and the key does not exist in the hash table value, then the default value from def-expr will be matched against the value pattern, instead of immediately failing to match.

  Examples:

  > (match (hash "a" 1 "b" 2)     [(hash* ["b" b] ["a" a]) (list b a)])

  '(2 1)

  > (match (hash "a" 1 "b" 2)     [(hash* ["b" b]) 'matched]     [_ 'not-matched])

  'matched

  > (match (hash "a" 1 "b" 2)     [(hash* ["a" a #:default 42] ["c" c #:default 100]) (list a c)]     [_ #f])

  '(1 100)

• (hash-table (pat pat) ...) — This pattern is deprecated because it can be incorrect. However, many programs rely on the incorrect behavior, so we still provide this pattern for backward compatibility reasons.

  Similar to list-no-order, but matching against hash table’s key–value pairs.

  Example:

  > (match #hash(("a" . 1) ("b" . 2))     [(hash-table ("b" b) ("a" a)) (list b a)])

  '(2 1)

• (hash-table (pat pat) ...+ ooo) — This pattern is deprecated because it can be incorrect. However, many programs rely on the incorrect behavior, so we still provide this pattern for backward compatibility reasons.

  Generalizes hash-table to support a final repeating pattern.

  Example:

  > (match #hash(("a" . 1) ("b" . 2))     [(hash-table (key val) ...) key])

  '("b" "a")

• (cons pat1 pat2) — matches a pair value.

  Example:

  > (match (cons 1 2)     [(cons a b) (+ a b)])

  3

• (mcons pat1 pat2) — matches a mutable pair value.

  Example:

  > (match (mcons 1 2)     [(cons a b) 'immutable]     [(mcons a b) 'mutable])

  'mutable

• (box pat) — matches a boxed value.

  Example:

  > (match #&1     [(box a) a])

  1

• (struct-id pat ...) or (struct struct-id (pat ...)) — matches an instance of a structure type named struct-id, where each field in the instance matches the corresponding pat. See also struct*.

  Usually, struct-id is defined with struct. More generally, struct-id must be bound to expansion-time information for a structure type (see Structure Type Transformer Binding), where the information includes at least a predicate binding and field accessor bindings corresponding to the number of field pats. In particular, a module import or a unit import with a signature containing a struct declaration can provide the structure type information.

  Examples:

  (struct tree (val left right))

  > (match (tree 0 (tree 1 #f #f) #f)     [(tree a (tree b  _ _) _) (list a b)])

  '(0 1)

• (struct struct-id _) — matches any instance of struct-id, without regard to contents of the fields of the instance.

• (regexp rx-expr) — matches a string that matches the regexp pattern produced by rx-expr, where rx-expr can be either a regexp, a pregexp, a byte-regexp, a byte-pregexp, a string, or a byte string. A string and byte string value is converted to a pattern using regexp and byte-regexp respectively. See Regular Expressions for more information about regexps.

  Examples:

  > (match "apple"     [(regexp #rx"p+") 'yes]     [_ 'no])

  'yes

  > (match "banana"     [(regexp #px"(na){2}") 'yes]     [_ 'no])

  'yes

  > (match "banana"     [(regexp "(na){2}") 'yes]     [_ 'no])

  'no

  > (match #"apple"     [(regexp #rx#"p+") 'yes]     [_ 'no])

  'yes

  > (match #"banana"     [(regexp #px#"(na){2}") 'yes]     [_ 'no])

  'yes

  > (match #"banana"     [(regexp #"(na){2}") 'yes]     [_ 'no])

  'no

• (regexp rx-expr pat) — extends the regexp form to further constrain the match where the result of regexp-match is matched against pat.

  Examples:

  > (match "apple"     [(regexp #rx"p+(.)" (list _ "l")) 'yes]     [_ 'no])

  'yes

  > (match "append"     [(regexp #rx"p+(.)" (list _ "l")) 'yes]     [_ 'no])

  'no

• (pregexp rx-expr) or (pregexp rx-expr pat) — like the regexp patterns, but rx-expr must be either a pregexp, a byte-pregexp, a string, or a byte string. A string and byte string value is converted to a pattern using pregexp and byte-pregexp respectively.

• (and pat ...) — matches if all of the pats match. This pattern is often used as (and id pat) to bind id to the entire value that matches pat. The pats are matched in the order that they appear.

  Example:

  > (match '(1 (2 3) 4)    [(list _ (and a (list _ ...)) _) a])

  '(2 3)

• (or pat ...) — matches if any of the pats match. Each pat must bind the same set of identifiers.

  Example:

  > (match '(1 2)    [(or (list a 1) (list a 2)) a])

  1

• (not pat ...) — matches when none of the pats match, and binds no identifiers.

  Examples:

  > (match '(1 2 3)    [(list (not 4) ...) 'yes]    [_ 'no])

  'yes

  > (match '(1 4 3)    [(list (not 4) ...) 'yes]    [_ 'no])

  'no

• (app expr pats ...) — applies expr to the value to be matched; each result of the application is matched against one of the pats, respectively.

  Examples:

  > (match '(1 2)    [(app length 2) 'yes])

  'yes

  > (match "3.14"    [(app string->number (? number? pi))     `(I got ,pi)])

  '(I got 3.14)

  > (match '(1 2)    [(app (lambda (v) (split-at v 1)) '(1) '(2)) 'yes])

  'yes

  > (match '(1 2 3)    [(app (λ (ls) (apply values ls)) x y (? odd? z))     (list 'yes x y z)])

  '(yes 1 2 3)

• (? expr pat ...) — applies expr to the value to be matched, and checks whether the result is a true value; the additional pats must also match; i.e., ? combines a predicate application and an and pattern. However, ?, unlike and, guarantees that expr is matched before any of the pats.

  The expr procedure may be called more than once on identical input (although this happens only rarely), and the order in which calls to expr are made should not be relied upon.

  Example:

  > (match '(1 3 5)    [(list (? odd?) ...) 'yes])

  'yes

• (quasiquote qp) — introduces a quasipattern, in which identifiers match symbols. Like the quasiquote expression form, unquote and unquote-splicing escape back to normal patterns.

  Example:

  > (match '(1 2 3)     [`(1 ,a ,(? odd? b)) (list a b)])

  '(2 3)

• derived-pattern — matches a pattern defined by a macro extension via define-match-expander.

Note that the matching process may destructure the input multiple times, and may evaluate expressions embedded in patterns such as (app expr pat) in arbitrary order, or multiple times. Therefore, such expressions must be safe to call multiple times, or in an order other than they appear in the original program.

Changed in version 8.9.0.5 of package base: Added a support for #:do.
Changed in version 8.11.1.10: Added the hash and hash* patterns.