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

3.9 Local Binding: let, let*, letrec, ...🔗ℹ

Local Binding in The Racket Guide introduces local binding.

syntax
(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, usually known as named let, 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

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

Like 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)

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

Like let, including left-to-right evaluation of the val-exprs, but the locations for all ids are created first, all ids are bound in all val-exprs as well as the bodys, and each id is initialized immediately after the corresponding val-expr is evaluated. The ids must be distinct according to bound-identifier=?.

Referencing or assigning to an id before its initialization raises exn:fail:contract:variable. If an id (i.e., the binding instance or id) has an 'undefined-error-name syntax property whose value is a symbol, the symbol is used as the name of the variable for error reporting, instead of the symbolic form of id.

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

Changed in version 6.0.1.2 of package base: Changed reference or assignment of an uninitialized id to an error.

syntax
(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)

syntax
(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)

syntax
(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 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

syntax
(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, Binding, and Scopes 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.

syntax
(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.

syntax
(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.

syntax
(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.

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

Combines letrec-syntaxes with a variant of 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-definition contexts expand to it. In a fully expanded expression (see Fully Expanded Programs), the trans-id bindings are discarded and the form reduces to a combination of letrec-values or let-values.

For variables bound by letrec-syntaxes+values, the location-creation rules differ slightly from letrec-values. The [(val-id ...) val-expr] binding clauses are partitioned into minimal sets of clauses that satisfy the following rule: if a clause has a val-id binding that is referenced (in a full expansion) by the val-expr of an earlier clause, the two clauses and all in between are in the same set. If a set consists of a single clause whose val-expr does not refer to any of the clause’s val-ids, then locations for the val-ids are created after the val-expr is evaluated. Otherwise, locations for all val-ids in a set are created just before the first val-expr in the set is evaluated. For the purposes of forming sets, a (quote-syntax datum #:local) form counts as a reference to all bindings in the letrec-syntaxes+values form

The end result of the location-creation rules is that scoping and evaluation order are the same as for letrec-values, but the compiler has more freedom to optimize away location creation. The rules also correspond to a nesting of let-values and letrec-values, which is how letrec-syntaxes+values for a fully-expanded expression.

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

1	Language Model
2	Notation for Documentation
3	Syntactic Forms
4	Datatypes
5	Structures
6	Classes and Objects
7	Units
8	Contracts
9	Pattern Matching
10	Control Flow
11	Concurrency and Parallelism
12	Macros
13	Input and Output
14	Reflection and Security
15	Operating System
16	Memory Management
17	Unsafe Operations
18	Running Racket
	Bibliography
	Index

3.1	Modules: module, module*, ...
3.2	Importing and Exporting: require and provide
3.3	Literals: quote and #%datum
3.4	Expression Wrapper: #%expression
3.5	Variable References and #%top
3.6	Locations: #%variable-reference
3.7	Procedure Applications and #%app
3.8	Procedure Expressions: lambda and case-lambda
3.9	Local Binding: let, let*, letrec, ...
3.10	Local Definitions: local
3.11	Constructing Graphs: shared
3.12	Conditionals: if, cond, and, and or
3.13	Dispatch: case
3.14	Definitions: define, define-syntax, ...
3.15	Sequencing: begin, begin0, and begin-for-syntax
3.16	Guarded Evaluation: when and unless
3.17	Assignment: set! and set!-values
3.18	Iterations and Comprehensions: for, for/ list, ...
3.19	Continuation Marks: with-continuation-mark
3.20	Quasiquoting: quasiquote, unquote, and unquote-splicing
3.21	Syntax Quoting: quote-syntax
3.22	Interaction Wrapper: #%top-interaction
3.23	Blocks: block
3.24	Internal-Definition Limiting: #%stratified-body
3.25	Performance Hints: begin-encourage-inline
3.26	Importing Modules Lazily: lazy-require