►The Racket Reference
▼2 Syntactic Forms
On this page:
let
let*
letrec
let-values
let*-values
letrec-values
let-syntax
letrec-syntax
let-syntaxes
letrec-syntaxes
letrec-syntaxes+ values
  top← prev  up  next → 

2.9 Local Binding: let, let*, letrec, ...

+Local Binding in The Racket Guide introduces local binding.

(let ([id val-expr] ...) body ...+)
(let proc-id ([id init-expr] ...) body ...+)
The first form evaluates the val-exprs left-to-right, creates a new location for each id, and places the values into the locations. It then evaluates the bodys, in which the ids are bound. The last body expression is in tail position with respect to the let form. The ids must be distinct according to bound-identifier=?.

Examples:

> (let ([x 5]) x)

5

> (let ([x 5])
    (let ([x 2]
          [y x])
      (list y x)))

'(5 2)

The second form evaluates the init-exprs; the resulting values become arguments in an application of a procedure (lambda (id ...) body ...+), where proc-id is bound within the bodys to the procedure itself.

Example:

> (let fac ([n 10])
    (if (zero? n)
        1
        (* n (fac (sub1 n)))))

3628800

(let* ([id val-expr] ...) body ...+)
Similar to let, but evaluates the val-exprs one by one, creating a location for each id as soon as the value is available. The ids are bound in the remaining val-exprs as well as the bodys, and the ids need not be distinct; later bindings shadow earlier bindings.

Example:

> (let* ([x 1]
         [y (+ x 1)])
    (list y x))

'(2 1)

(letrec ([id val-expr] ...) body ...+)
Similar to let, but the locations for all ids are created first and filled with #<undefined>, and all ids are bound in all val-exprs as well as the bodys. The ids must be distinct according to bound-identifier=?.

Example:

> (letrec ([is-even? (lambda (n)
                       (or (zero? n)
                           (is-odd? (sub1 n))))]
           [is-odd? (lambda (n)
                      (and (not (zero? n))
                           (is-even? (sub1 n))))])
    (is-odd? 11))

#t

(let-values ([(id ...) val-expr] ...) body ...+)
Like let, except that each val-expr must produce as many values as corresponding ids, otherwise the exn:fail:contract exception is raised. A separate location is created for each id, all of which are bound in the bodys.

Example:

> (let-values ([(x y) (quotient/remainder 10 3)])
    (list y x))

'(1 3)

(let*-values ([(id ...) val-expr] ...) body ...+)
Like let*, except that each val-expr must produce as many values as corresponding ids. A separate location is created for each id, all of which are bound in the later val-exprs and in the bodys.

Example:

> (let*-values ([(x y) (quotient/remainder 10 3)]
                [(z) (list y x)])
    z)

'(1 3)

(letrec-values ([(id ...) val-expr] ...) body ...+)
Like letrec, except that each val-expr must produce as many values as corresponding ids. A separate location is created for each id, all of which are initialized to #<undefined> and bound in all val-exprs and in the bodys.

Example:

> (letrec-values ([(is-even? is-odd?)
                   (values
                     (lambda (n)
                       (or (zero? n)
                           (is-odd? (sub1 n))))
                     (lambda (n)
                       (or (= n 1)
                           (is-even? (sub1 n)))))])
    (is-odd? 11))

#t

(let-syntax ([id trans-expr] ...) body ...+)

+See also splicing-let-syntax.

Creates a transformer binding (see Transformer Bindings) of each id with the value of trans-expr, which is an expression at phase level 1 relative to the surrounding context. (See Identifiers and Binding for information on phase levels.)

The evaluation of each trans-expr is parameterized to set current-namespace to a namespace that shares bindings and variables with the namespace being used to expand the let-syntax form, except that its base phase is one greater.

Each id is bound in the bodys, and not in other trans-exprs.

(letrec-syntax ([id trans-expr] ...) body ...+)

+See also splicing-letrec-syntax.

Like let-syntax, except that each id is also bound within all trans-exprs.

(let-syntaxes ([(id ...) trans-expr] ...) body ...+)

+See also splicing-let-syntaxes.

Like let-syntax, but each trans-expr must produce as many values as corresponding ids, each of which is bound to the corresponding value.

(letrec-syntaxes ([(id ...) trans-expr] ...) body ...+)

+See also splicing-letrec-syntaxes.

Like let-syntax, except that each id is also bound within all trans-exprs.

(letrec-syntaxes+values ([(trans-id ...) trans-expr] ...)
                        ([(val-id ...) val-expr] ...)
   body ...+)
Combines letrec-syntaxes with letrec-values: each trans-id and val-id is bound in all trans-exprs and val-exprs.

The letrec-syntaxes+values form is the core form for local compile-time bindings, since forms like letrec-syntax and internal define-syntax expand to it. In a fully expanded expression (see Fully Expanded Programs), the trans-id bindings are discarded and the form reduces to letrec, but letrec-syntaxes+values can appear in the result of local-expand with an empty stop list.

See also local, which supports local bindings with define, define-syntax, and more.

  top← prev  up  next →