3.9 Local Binding: let, let*, letrec, ...
Local Binding in The Racket Guide introduces local binding.
Examples: | ||||||||
|
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: | ||||||
|
Example: | |||||
|
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: | |||||||||
|
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 ...+)
Example: | ||||
|
syntax
(let*-values ([(id ...) val-expr] ...) body ...+)
Example: | |||||
|
syntax
(letrec-values ([(id ...) val-expr] ...) body ...+)
Example: | |||||||||||
|
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 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.
syntax
(letrec-syntax ([id trans-expr] ...) body ...+)
Like let-syntax, except that each id is also bound within all trans-exprs.
syntax
(let-syntaxes ([(id ...) trans-expr] ...) body ...+)
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 ...+)
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 ...+)
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, but letrec-syntaxes+values can appear in the result of local-expand with an empty stop list.
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.
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.