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

The bindings documented in this section are provided by the racket/match and racket libraries, but not racket/base

syntax (match val-expr clause ) clause = [ pat body ] | [ pat ( => id ) body ] | [ pat #:when cond-expr body ]

pat that matches the result of val-expr , and evaluates the corresponding body s with bindings introduced by pat (if any). Bindings introduced by pat are not available in other parts of pat . The last body in the matching clause is evaluated in tail position with respect to the match Finds the firstthat matches the result of, and evaluates the correspondings with bindings introduced by(if any). Bindings introduced byare not available in other parts of. The lastin the matching clause is evaluated in tail position with respect to theexpression.

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.

Examples:

> ( define ( m x ) ( match x [ ( list a b c ) #:when ( = 6 ( + a b c ) ) ' sum-is-six ] [ ( list a b c ) ' sum-is-not-six ] ) ) > ( m ' ( 1 2 3 ) ) 'sum-is-six > ( m ' ( 2 3 4 ) ) 'sum-is-not-six

An optional (=> id) between a pat and the bodys is bound to a failure procedure of zero arguments. 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.

Examples:

> ( define ( m x ) ( match x [ ( list a b c ) ( => exit ) ( f x exit ) ] [ ( list a b c ) ' sum-is-not-six ] ) ) > ( define ( f x exit ) ( if ( = 6 ( apply + x ) ) ' sum-is-six ( exit ) ) ) > ( m ' ( 1 2 3 ) ) 'sum-is-six > ( m ' ( 2 3 4 ) ) 'sum-is-not-six

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

pat ::= id match anything, bind identifier | (var id) match anything, bind identifier | _ match anything | literal match literal | (quote datum) match equal? value | (list lvp ...) match sequence of lvps | (list-rest lvp ... pat) match lvps consed onto a pat | (list* lvp ... pat) match lvps consed onto a pat | (list-no-order pat ...) match pats in any order | (list-no-order pat ... lvp) match pats in any order | (vector lvp ...) match vector of pats | (hash-table (pat pat) ...) match hash table | (hash-table (pat pat) ...+ ooo) match hash table | (cons pat pat) match pair of pats | (mcons pat pat) match mutable pair of pats | (box pat) match boxed pat | (struct-id pat ...) match struct-id instance | (struct struct-id (pat ...)) match struct-id instance | (regexp rx-expr) match string | (regexp rx-expr pat) match string, result with pat | (pregexp px-expr) match string | (pregexp px-expr pat) match string, result with pat | (and pat ...) match when all pats match | (or pat ...) match when any pat match | (not pat ...) match when no pat matches | (app expr pats ...) match (expr value) output values to pats | (? expr pat ...) match if (expr value) and pats | (quasiquote qp) match a quasipattern | derived-pattern match using extension literal ::= #t match true | #f match false | string match equal? string | bytes match equal? byte string | number match equal? number | char match equal? character | keyword match equal? keyword | regexp match equal? regexp literal | pregexp match equal? pregexp literal lvp ::= pat ooo greedily match pat instances | pat match pat qp ::= literal match literal | id match symbol | (qp ...) match sequences of qps | (qp ... . qp) match qps ending qp | (qp ooo . qp) match qps beginning with repeated qp | #(qp ...) match vector of qps | #&qp match boxed qp | #s(prefab-key qp ...) match prefab struct with qp fields | ,pat match pat | ,@(list lvp ...) match lvps, spliced | ,@(list-rest lvp ... pat) match lvps plus pat, spliced | ,@'qp match list-matching qp, spliced ooo ::= ... zero or more; ... is literal | ___ zero or more | ..k k or more | __k k or more

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. ( 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. ormatches anything, and bindsto the matching values. If anis used multiple times within a pattern, the corresponding matches must be the same according to, except that instances of anin differentandsub-patterns are independent. The binding foris 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 element 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-table (pat pat) ) — 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) — 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; see Regular Expressions for more information about regexps. Examples: > ( match "apple" [ ( regexp #rx"p+" ) ' yes ] [ _ ' no ] ) 'yes > ( match "banana" [ ( regexp #rx"p+" ) ' 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 if rx-expr produces a string, it is converted to a pattern using pregexp instead of regexp.

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

9.1 Additional Matching Forms

syntax (match* (val-expr ) clause* ) clause* = [ ( pat ) body ] | [ ( pat ) ( => id ) body ] | [ ( pat ) #:when cond-expr body ]

Matches a sequence of values against each clause in order, matching only when all patterns in a clause match. Each clause must have the same number of patterns as the number of val-expr s.

Examples:

> ( match* ( 1 2 3 ) [ ( _ ( ? number? ) x ) ( add1 x ) ] ) 4 > ( match* ( 15 17 ) [ ( ( ? number? a ) ( ? number? b ) ) #:when ( = ( + a 2 ) b ) ' diff-by-two ] ) 'diff-by-two

syntax (match/values expr clause clause )

If expr evaluates to n values, then match all n values against the patterns in clause . Each clause must contain exactly n patterns. At least one clause is required to determine how many values to expect from expr .

syntax ( define/match ( head args ) match*-clause ) head = id | ( head args ) args = arg | arg . rest-id arg = arg-id | [ arg-id default-expr ] | keyword arg-id | keyword [ arg-id default-expr ] match*-clause = [ ( pat ) body ] | [ ( pat ) ( => id ) body ] | [ ( pat ) #:when cond-expr body ]

id to a procedure that is defined by pattern matching clauses using match* Bindsto a procedure that is defined by pattern matching clauses using. Each clause takes a sequence of patterns that correspond to the arguments in the function header. The arguments are ordered as they appear in the function header for matching purposes.

Examples:

( define/match ( fact n ) [ ( 0 ) 1 ] [ ( n ) ( * n ( fact ( sub1 n ) ) ) ] ) > ( fact 5 ) 120

The function header may also contain optional or keyword arguments, may have curried arguments, and may also contain a rest argument.

Examples:

( define/match ( ( f x ) #:y [ y ' ( 1 2 3 ) ] ) [ ( ( regexp #rx"p+" ) ` ( , a 2 3 ) ) a ] [ ( _ _ ) #f ] ) > ( ( f "ape" ) #:y ' ( 5 2 3 ) ) 5 > ( ( f "dog" ) ) #f ( define/match ( g x y . rst ) [ ( 0 0 ' ( ) ) #t ] [ ( 5 5 ' ( 5 5 ) ) #t ] [ ( _ _ _ ) #f ] ) > ( g 0 0 ) #t > ( g 5 5 5 5 ) #t > ( g 1 2 ) #f

( lambda ( id ) ( match id clause ) ) . Equivalent to

( lambda lst ( match lst clause ) ) . Equivalent to

( lambda ( args ) ( match* ( args ) clause* ) ) , where the number of args is computed from the number of patterns appearing in each of the clause* . Equivalent to, where the number ofis computed from the number of patterns appearing in each of the

let expr is matched against its corresponding pat (the match must succeed), and the bindings that pat introduces are visible in the body s. Generalizesto support pattern bindings. Eachis matched against its corresponding(the match must succeed), and the bindings thatintroduces are visible in thes.

Example:

> ( match-let ( [ ( list a b ) ' ( 1 2 ) ] [ ( vector x ) # ( 1 2 3 4 ) ] ) ( list b a x ) ) '(2 1 (1 2 3 4))

match-let let* pat are available in each subsequent expr . Like, but generalizes, so that the bindings of eachare available in each subsequent

Example:

> ( match-let* ( [ ( list a b ) ' ( # ( 1 2 3 4 ) 2 ) ] [ ( vector x ) a ] ) x ) '(1 2 3 4)

match-let letrec Like, but generalizes

Added in version 6.1.1.8 of package base.

Defines the names bound by pat to the values produced by matching against the result of expr .

Examples:

> ( match-define ( list a b ) ' ( 1 2 ) ) > b 2

match-define Likebut for when expr produces multiple values. Like match/values, it requires at least one pattern to determine the number of values to expect.

Examples:

> ( match-define-values ( a b ) ( values 1 2 ) ) > b 2

A predicate for the exception raised in the case of a match failure.

=> not escape the current context, and thus should only be used in tail position with respect to the match Continues matching as if the current pattern failed. Note that unlike use of theform, this doesescape the current context, and thus should only be used in tail position with respect to theform.

id to a match expander . Bindsto a

The first proc-expr sub-expression must evaluate to a transformer that produces a pat for match. Whenever id appears as the beginning of a pattern, this transformer is given, at expansion time, a syntax object corresponding to the entire pattern (including id). The pattern is replaced with the result of the transformer.

A transformer produced by a second proc-expr sub-expression is used when id is used in an expression context. Using the second proc-expr, id can be given meaning both inside and outside patterns.

Match expanders are not invoked unless id appears in the first position in a sequence. Instead, identifiers bound by define-match-expander are used as binding identifiers (like any other identifier) when they appear anywhere except the first position in a sequence.

For example, to extend the pattern matcher and destructure syntax lists,

( define ( syntax-list? x ) ( and ( syntax? x ) ( list? ( syntax->list x ) ) ) ) ( define-match-expander syntax-list ( lambda ( stx ) ( syntax-case stx ( ) [ ( _ elts ) #' ( ? syntax-list? ( app syntax->list ( list elts ) ) ) ] ) ) ) ( define ( make-keyword-predicate keyword ) ( lambda ( stx ) ( and ( identifier? stx ) ( free-identifier=? stx keyword ) ) ) ) ( define or-keyword? ( make-keyword-predicate #' or ) ) ( define and-keyword? ( make-keyword-predicate #' and ) ) > ( match #' ( or 3 4 ) [ ( syntax-list ( ? or-keyword? ) b c ) ( list "OOORRR!" b c ) ] [ ( syntax-list ( ? and-keyword? ) b c ) ( list "AAANND!" b c ) ] ) '("OOORRR!" #<syntax:eval:69:0 3> #<syntax:eval:69:0 4>) > ( match #' ( and 5 6 ) [ ( syntax-list ( ? or-keyword? ) b c ) ( list "OOORRR!" b c ) ] [ ( syntax-list ( ? and-keyword? ) b c ) ( list "AAANND!" b c ) ] ) '("AAANND!" #<syntax:eval:70:0 5> #<syntax:eval:70:0 6>)

define-match-expander not treated specially unless they appear in the first position of pattern sequence. Consider this (incorrect) definition of a length function: And here is an example showing how-bound identifiers aretreated specially unless they appear in the first position of pattern sequence. Consider this (incorrect) definition of a length function:

( define-match-expander nil ( λ ( stx ) #' ' ( ) ) ( λ ( stx ) #' ' ( ) ) ) ( define ( len l ) ( match l [ nil 0 ] [ ( cons hd tl ) ( + 1 ( len tl ) ) ] ) )

Because there are no parenthesis around nil, match treats the first case as an identifier (which matches everything) instead of a use of the match expander and len always returns 0.

> ( len nil ) 0 > ( len ( cons 1 nil ) ) 0 > ( len ( cons 1 ( cons 2 nil ) ) ) 0

identifier? ( expander a b . rest ) . Match expanders accept any syntax pair whose first element is anbound to the expander. The following example shows a match expander which can be called with an improper syntax list of the form

( define-match-expander my-vector ( λ ( stx ) ( syntax-case stx ( ) [ ( _ pat ) #' ( vector pat ) ] [ ( _ pat . rest-pat ) #' ( app vector->list ( list-rest pat rest-pat ) ) ] ) ) ) > ( match # ( 1 2 3 4 5 ) [ ( my-vector a b . rest ) ( list->vector ( append rest ( list a b ) ) ) ] ) '#(3 4 5 1 2)

Changed in version 7.7.0.2 of package base: Match expanders now allowed any syntax pair whose first element is an identifier? bound to the expander. The example above did not work with previous versions.

The property value must be an exact non-negative integer or a procedure of one or two arguments. In the former case, the integer designates a field within the structure that should contain a procedure; the integer must be between 0 (inclusive) and the number of non-automatic fields in the structure type (exclusive, not counting supertype fields), and the designated field must also be specified as immutable.

If the property value is a procedure of one argument, then the procedure serves as the transformer for match expansion. If the property value is a procedure of two arguments, then the first argument is the structure whose type has prop:match-expander property, and the second argument is a syntax object as for a match expander..

If the property value is a assignment transformer, then the wrapped procedure is extracted with set!-transformer-procedure before it is called.

This binding is provided for-syntax.

prop:match-expander Like, but for the legacy match syntax.

This binding is provided for-syntax.

Predicates for values which implement the appropriate match expander properties.

syntax-local-introduce For backward compatibility only; equivalent to

Changed in version 6.90.0.29 of package base: Made equivalent to syntax-local-introduce.

equal? parameter that determines the comparison procedure used to check whether multiple uses of an identifier match the “same” value. The default is

match match* match-lambda match/derived match-lambda match Likeandrespectively, but includes a sub-expression to be used as the source for all syntax errors within the form. For example,expands toso that errors in the body of the form are reported in terms ofinstead of

9.3 Library Extensions

val when compared by comparator . If comparator is not provided, it defaults to equal? match expander which checks if the matched value is the same aswhen compared by. Ifis not provided, it defaults to

Examples:

> ( match ( list 1 2 3 ) [ ( == ( list 1 2 3 ) ) ' yes ] [ _ ' no ] ) 'yes > ( match ( list 1 2 3 ) [ ( == ( list 1 2 3 ) eq? ) ' yes ] [ _ ' no ] ) 'no > ( match ( list 1 2 3 ) [ ( list 1 2 ( == 3 = ) ) ' yes ] [ _ ' no ] ) 'yes

match struct-id , where the field field in the instance matches the corresponding pat . pattern form that matches an instance of a structure type named, where the fieldin the instance matches the corresponding

Any field of struct-id may be omitted, and such fields can occur in any order.

Examples: