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

Local Binding in The Racket Guide introduces local binding.

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

Example:

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

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

Example:

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

Example:

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

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

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.

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

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

Like let-syntax, except that each id is also bound within all trans-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, 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.