Guard Statements🔗 i

jackfirth

This package provides a Racket syntax for guard statements. A guard statement ensures that condition is true before executing statements after the guard. Boolean conditions can be checked with guard , and pattern matching conditions can be checked with guard-match . Guard statements can only be used within guarded blocks, which are either uses of the guarded-block macro or bodies of functions defined with define/guard .

Guard statements allow writing code linearly when it would ordinarily require deep nesting of forms like cond and match . Compare the following two function definitions, one of which uses traditional Racket forms and the other of which uses guard statements.

Traditional approach:

(define (lists-equal?xsys)
(cond
[(empty? xs)(empty? ys)]
[(empty? ys)#false]
[else
(match-define (cons xrest-xs)xs)
(match-define (cons yrest-ys)ys)
(and (equal? xy)(lists-equal?rest-xsrest-ys))]))

Using guard statements:

(define/guard (lists-equal?xsys)
(guard-match (cons xrest-xs)xs#:else(empty? ys))
(guard-match (cons yrest-ys)ys#:else#false)
(and (equal? xy)(lists-equal?rest-xsrest-ys)))

Guard statements cooperate with macro expansion. Macros can expand into uses of guard and guard-match . Such user-defined guard statements are recognized by guarded-block and define/guard via local expansion.

syntax
( guard condition-expr#:elsefail-body...+)

condition-expr : any/c

A guard statement that ensures that condition-expr evaluates to a non-false value. If it’s false, the surrounding guarded block short circuits evaluation with the result of executing fail-body... .

Examples:

(define/guard (add-positivexy)
(guard (positive? x)#:else'nonpositive-x)
(guard (positive? y)#:else'nonpositive-y)
(+ xy))

> (add-positive-47)

'nonpositive-x
> (add-positive4-7)

'nonpositive-y
> (add-positive47)

11

syntax
( guard-match match-patternexpr#:elsefail-body...+)

expr : any/c

A guard statement that evaluates expr and ensures that its result matches match-pattern. If the result does not match the given pattern, the surrounding guarded block short circuits evaluation with the result of executing fail-body... . Upon successful matching, the bindings in match-pattern are made available to the surrounding definition context. This form is similar to match-define , except that the fail-body... branch is taken if the match fails.

Examples:

(define/guard (zip-listszipperxsys)
(guard-match (cons xrest-xs)xs#:else'())
(guard-match (cons yrest-ys)ys#:else'())
(cons (zipperxy)(zip-listszipperrest-xsrest-ys)))

> (zip-lists(λ (actionanimal)(format "~a, ~a!"actionanimal))
(list "jump""dig""hop")
(list "dog""mole""rabbit"))

'("jump, dog!" "dig, mole!" "hop, rabbit!")

Additionally, multiple patterns may be given in place of match-pattern using values . This causes the guard to expect expr to evaluate to multiple values, one per given pattern, or else an error is raised. Each value is matched against the corresponding pattern, and if any of them do not match, the fail-body... branch is taken. This form is similar to match-define-values .

Examples:

(define/guard (zip-listszipperxsys)
(guard-match (values (cons xrest-xs)(cons yrest-ys))(values xsys)
#:else'())
(cons (zipperxy)(zip-listszipperrest-xsrest-ys)))

> (zip-lists(λ (actionanimal)(format "~a, ~a!"actionanimal))
(list "jump""dig""hop")
(list "dog""mole""rabbit"))

'("jump, dog!" "dig, mole!" "hop, rabbit!")

syntax
( define/guard (headargs)body...+)

head = id
| (headargs)

args = arg...
| arg....rest-id

arg = arg-id
| [arg-iddefault-expr]
| keywordarg-id
| keyword[arg-iddefault-expr]

Defines a function like define , but where the function body is wrapped in guarded-block .

Examples:

(define/guard (filter-and-double-numbersxs)
(guard-match (cons xrest-xs)xs#:else'())
(guard (number? x)#:else
(filter-and-double-numbersrest-xs))
(cons (* x2)(filter-and-double-numbersrest-xs)))

> (filter-and-double-numbers(list 12'apple3'banana45))

'(2 4 6 8 10)

syntax
( guarded-block body...+)

Evaluates each body, except that any guard statements are treated specially. When a guard statement fails, it short circuits the evaluation of the entire enclosing guarded-block .

Examples:

(define (double-numbers-onlyxs)
(for/list ([x(in-list xs)])
(guarded-block
(guard (number? x)#:elsex)
(* x2))))

> (double-numbers-only(list 12'apple3'banana45))

'(2 4 apple 6 banana 8 10)

top ← prev up next →