▼ |  | Unstable: May Change Without Warning

1 | Guidelines for Developing unstable Libraries
2 | Automata: Compiling State Machines
3 | Bytes
4 | Contracts
5 | Contracts for Macro Subexpressions
6 | Debugging
7 | Definitions
8 | Errors
9 | Futures
10 | Functions
11 | Hash Tables
12 | Interface-Oriented Programming for Classes
13 | Lazy Require
14 | Lists
15 | Logging
16 | Macro Testing
17 | Mark Parameters
18 | Match
19 | Open place expressions
20 | Options
21 | Parameter Groups
22 | Pretty-Printing
23 | Re-Contracting Identifiers
24 | Sandbox
25 | Sequences
26 | Strings
27 | Structs
28 | Struct Printing
29 | Syntax
30 | Temporal Contracts: Explicit Contract Monitors
31 | Unix Domain Sockets
32 | 2D Syntax

On this page:

match?
as
match*?
object

5.92
top ← prev up next →

### 18`` Match

This library is unstable; compatibility will not be maintained. See Unstable: May Change Without Warning for more information.

(require unstable/match) | package: typed-racket-lib

> > > The subsequent bindings were added by Carl Eastlund <cce@racket-lang.org>.

> syntax (match? val-expr pat ...)

Returns #t if the result of val-expr matches any of pat, and returns #f otherwise.

Examples:
> > (match? (list 1 2 3)
> (list a b c)
> (vector x y z))
> #t
> > (match? (vector 1 2 3)
> (list a b c)
> (vector x y z))
> #t
> > (match? (+ 1 2 3)
> (list a b c)
> (vector x y z))
> #f

> syntax (as ([lhs-id rhs-expr] ...) pat ...)

As a match expander, binds each lhs-id as a pattern variable with the result value of rhs-expr, and continues matching each subsequent pat.

Example:
> > (match (list 1 2 3)
> [(as ([a 0]) (list b c d)) (list a b c d)])
> '(0 1 2 3)

> > > The subsequent bindings were added by Asumu Takikawa <asumu@racket-lang.org>.

> syntax (match*? (val-expr ...) (pat ...) ...)

Similar to match?, but uses match* and accepts multiple val-expr and corresponding pat in each clause to match on.

Examples:
> > (match*? (1 2 3)
> (a b c)
> (x #f z))
> #t
> > (match*? (1 2 3)
> (a (? odd?) c)
> (x y z))
> #t
> > (match*? (#f #f #f)
> (1 2 3)
> (4 5 6))
> #f

> syntax (object maybe-class field-clause ...)
> maybe-class |  | = |  |
> |  | | |  | class-expr
> field-clause |  | = |  | (field field-id maybe-pat)
> maybe-pat |  | = |  |
> |  | | |  | pat

A match expander that checks if the matched value is an object and contains the fields named by the field-ids. If pats are provided, the value in each field is matched to its corresponding pat. If a pat is not provided, it defaults to the name of the field.

If class-expr is provided, the match expander will also check that the supplied object is an instance of the class that the given expression evaluates to.

Examples:
> (define point%
> (class object%
> (super-new)
> (init-field x y)))
> > (match (make-object point% 3 5)
> [(object point% (field x) (field y))
> (sqrt (+ (* x x) (* y y)))])
> 5.830951894845301
> > (match (make-object point% 0 0)
> [(object (field x (? zero?))
> (field y (? zero?)))
> 'origin])
> 'origin
> > (match (make-object object%)
> [(object (field x) (field y))
> 'ok]
> [_ 'fail])
> 'fail

top ← prev up next →