Guard Patterns

Use (? predicate) to match values satisfying a condition:

(match x
  ((? positive? n) (format "positive: ~a" n))
  ((? negative? n) (format "negative: ~a" n))
  (_ "zero"))

Combining Patterns

Use and, or, and not to combine patterns:

;; All conditions must match
(match n
  ((and (? integer?) (? positive?)) "positive integer")
  (_ "other"))

;; Any condition can match
(match color
  ((or 'red 'green 'blue) "primary")
  (_ "other"))

;; Negation
(match lst
  ((not ()) "non-empty")
  (() "empty"))

Transform Patterns

Use (= proc pat) to transform a value before matching:

(match str
  ((= string-length 0) "empty")
  ((= string-length 1) "single char")
  (_ "multiple chars"))

Record Patterns (SRFI-9)

Use ($ type fields ...) to match SRFI-9 record types positionally:

(define-record-type <point>
  (make-point x y) point?
  (x point-x) (y point-y))

(match p
  (($ <point> x y) (+ x y)))

Struct Patterns (Sigil)

Use (: type field: ...) to match Sigil structs by field name:

(define-struct point (x) (y))

(match p
  ((: point x: y:) (+ x y))        ; shorthand: binds x and y
  ((: point x: px y: py) ...))     ; explicit binding names

;; Match only specific fields
(match p
  ((: point y:) y))                ; only match y field

Dict Patterns

Use #{ key: pat ... } or (dict key: ...) to match dicts by key:

(match config
  (#{ host: port: } (connect host port))
  ((dict debug:) debug))

;; Type check only
(match val
  ((dict) 'is-dict)
  (_ 'other))

Convenience Forms

;; match-lambda: anonymous function with pattern matching
(define get-x (match-lambda ((x . _) x)))
(get-x '(1 2 3))  ; => 1

;; match-lambda*: match all arguments as a list
(define add-pair
  (match-lambda* ((a b) (+ a b))))
(add-pair 3 4)  ; => 7

;; match-let: destructuring let
(match-let (((x y) '(1 2))
            ((a . b) '(3 4 5)))
  (list x y a b))
; => (1 2 3 (4 5))

Exports

• match - Main matching macro
• match-lambda - Single-argument matching lambda
• match-lambda* - Multi-argument matching lambda
• match-let - Destructuring let with patterns
• match-pattern - Low-level pattern matching (used internally)

Dependencies

• sigil-stdlib

Building

sigil deps install
sigil build
sigil test

License

BSD-3-Clause