:match

6.2.901.900

top ← prev up next →

:match

package: colon-match

syntax
(:match val-expr clause ...)

clause = [pat body ...+]
| [pat (=> id) body ...+]
| [pat #:when cond-expr body ...+]

like match, except that it allowes identifiers with colons in patterns to specify types.

For example the pattern x:num is equivalent to the pattern (? number? x).

(:match val-expr [pat body-stuff ...] ...) expands to (match val-expr [(:pat pat) body-stuff ...] ...).

Examples:

> (require colon-match)
> (:match 1 [n:num n])
1
> (:match 'x [n:num n] [_ #f])
#f
> (:match '(1 2 3) [(list a:num b:num c:num) (+ a b c)])
6
> (:match '(sym "str" 3) [(list-no-order n:num str:str sym:sym) (list n str sym)])
'(3 "str" sym)

match expander
(:pat pat)

a match expander that rewrites pat to change all of the identifiers written in colon notation to a pattern that checks the type.

A pattern of the form id:type is rewritten to (type id), and then type is is a match expander that expands to something like (? type? id). This means that you can define your own ":match classes" by defining them as match expanders.

Examples:

> (require colon-match racket/match racket/contract/base (for-syntax racket/base))
> (match '(1 2 3) [(:pat (list a:num b:num c:num)) (+ a b c)])
6
> (match '(1 2 3) [(list (:pat a:num) _ _) a])
1
> (define-match-expander pos-num
(syntax-rules ()
[(pos-num id) (? (and/c number? positive?) id)]))
> (match 1 [(:pat x:pos-num) x])
1
> (match -1 [(:pat x:pos-num) x] [_ #f])
#f
> (:match 1 [x:pos-num x])
1

syntax
(define-:match-class id pred-expr)

defines id as a match expander that checks that the pattern satisfies pred-expr. id can then be used in a colon-notation pattern.

Examples:

> (require colon-match racket/contract/base)
> (define-:match-class pos-num (and/c number? positive?))
> (:match 1 [x:pos-num x])
1

top ← prev up next →