|
|
# Local Binding
|
|
|
|
|
|
Although internal `define`s can be used for local binding, Racket
|
|
|
provides three forms that give the programmer more control over
|
|
|
bindings: `let`, `let*`, and `letrec`.
|
|
|
|
|
|
## 1. Parallel Binding: `let`
|
|
|
|
|
|
> +\[missing\] in \[missing\] also documents `let`.
|
|
|
|
|
|
A `let` form binds a set of identifiers, each to the result of some
|
|
|
expression, for use in the `let` body:
|
|
|
|
|
|
```racket
|
|
|
(let ([id expr] ...) body ...+)
|
|
|
```
|
|
|
|
|
|
The `id`s are bound “in parallel.” That is, no `id` is bound in the
|
|
|
right-hand side `expr` for any `id`, but all are available in the
|
|
|
`body`. The `id`s must be different from each other.
|
|
|
|
|
|
Examples:
|
|
|
|
|
|
```racket
|
|
|
> (let ([me "Bob"])
|
|
|
me)
|
|
|
"Bob"
|
|
|
> (let ([me "Bob"]
|
|
|
[myself "Robert"]
|
|
|
[I "Bobby"])
|
|
|
(list me myself I))
|
|
|
'("Bob" "Robert" "Bobby")
|
|
|
> (let ([me "Bob"]
|
|
|
[me "Robert"])
|
|
|
me)
|
|
|
eval:3:0: let: duplicate identifier
|
|
|
at: me
|
|
|
in: (let ((me "Bob") (me "Robert")) me)
|
|
|
```
|
|
|
|
|
|
The fact that an `id`’s `expr` does not see its own binding is often
|
|
|
useful for wrappers that must refer back to the old value:
|
|
|
|
|
|
```racket
|
|
|
> (let ([+ (lambda (x y)
|
|
|
(if (string? x)
|
|
|
(string-append x y)
|
|
|
(+ x y)))]) ; use original +
|
|
|
(list (+ 1 2)
|
|
|
(+ "see" "saw")))
|
|
|
'(3 "seesaw")
|
|
|
```
|
|
|
|
|
|
Occasionally, the parallel nature of `let` bindings is convenient for
|
|
|
swapping or rearranging a set of bindings:
|
|
|
|
|
|
```racket
|
|
|
> (let ([me "Tarzan"]
|
|
|
[you "Jane"])
|
|
|
(let ([me you]
|
|
|
[you me])
|
|
|
(list me you)))
|
|
|
'("Jane" "Tarzan")
|
|
|
```
|
|
|
|
|
|
The characterization of `let` bindings as “parallel” is not meant to
|
|
|
imply concurrent evaluation. The `expr`s are evaluated in order, even
|
|
|
though the bindings are delayed until all `expr`s are evaluated.
|
|
|
|
|
|
## 2. Sequential Binding: `let*`
|
|
|
|
|
|
> +\[missing\] in \[missing\] also documents `let*`.
|
|
|
|
|
|
The syntax of `let*` is the same as `let`:
|
|
|
|
|
|
```racket
|
|
|
(let* ([id expr] ...) body ...+)
|
|
|
```
|
|
|
|
|
|
The difference is that each `id` is available for use in later `expr`s,
|
|
|
as well as in the `body`. Furthermore, the `id`s need not be distinct,
|
|
|
and the most recent binding is the visible one.
|
|
|
|
|
|
Examples:
|
|
|
|
|
|
```racket
|
|
|
> (let* ([x (list "Burroughs")]
|
|
|
[y (cons "Rice" x)]
|
|
|
[z (cons "Edgar" y)])
|
|
|
(list x y z))
|
|
|
'(("Burroughs") ("Rice" "Burroughs") ("Edgar" "Rice" "Burroughs"))
|
|
|
> (let* ([name (list "Burroughs")]
|
|
|
[name (cons "Rice" name)]
|
|
|
[name (cons "Edgar" name)])
|
|
|
name)
|
|
|
'("Edgar" "Rice" "Burroughs")
|
|
|
```
|
|
|
|
|
|
In other words, a `let*` form is equivalent to nested `let` forms, each
|
|
|
with a single binding:
|
|
|
|
|
|
```racket
|
|
|
> (let ([name (list "Burroughs")])
|
|
|
(let ([name (cons "Rice" name)])
|
|
|
(let ([name (cons "Edgar" name)])
|
|
|
name)))
|
|
|
'("Edgar" "Rice" "Burroughs")
|
|
|
```
|
|
|
|
|
|
## 3. Recursive Binding: `letrec`
|
|
|
|
|
|
> +\[missing\] in \[missing\] also documents `letrec`.
|
|
|
|
|
|
The syntax of `letrec` is also the same as `let`:
|
|
|
|
|
|
```racket
|
|
|
(letrec ([id expr] ...) body ...+)
|
|
|
```
|
|
|
|
|
|
While `let` makes its bindings available only in the `body`s, and `let*`
|
|
|
makes its bindings available to any later binding `expr`, `letrec` makes
|
|
|
its bindings available to all other `expr`s—even earlier ones. In other
|
|
|
words, `letrec` bindings are recursive.
|
|
|
|
|
|
The `expr`s in a `letrec` form are most often `lambda` forms for
|
|
|
recursive and mutually recursive functions:
|
|
|
|
|
|
```racket
|
|
|
> (letrec ([swing
|
|
|
(lambda (t)
|
|
|
(if (eq? (car t) 'tarzan)
|
|
|
(cons 'vine
|
|
|
(cons 'tarzan (cddr t)))
|
|
|
(cons (car t)
|
|
|
(swing (cdr t)))))])
|
|
|
(swing '(vine tarzan vine vine)))
|
|
|
'(vine vine tarzan vine)
|
|
|
```
|
|
|
|
|
|
```racket
|
|
|
> (letrec ([tarzan-near-top-of-tree?
|
|
|
(lambda (name path depth)
|
|
|
(or (equal? name "tarzan")
|
|
|
(and (directory-exists? path)
|
|
|
(tarzan-in-directory? path depth))))]
|
|
|
[tarzan-in-directory?
|
|
|
(lambda (dir depth)
|
|
|
(cond
|
|
|
[(zero? depth) #f]
|
|
|
[else
|
|
|
(ormap
|
|
|
(λ (elem)
|
|
|
(tarzan-near-top-of-tree? (path-element->string elem)
|
|
|
(build-path dir elem)
|
|
|
(- depth 1)))
|
|
|
(directory-list dir))]))])
|
|
|
(tarzan-near-top-of-tree? "tmp"
|
|
|
(find-system-path 'temp-dir)
|
|
|
4))
|
|
|
#f
|
|
|
```
|
|
|
|
|
|
While the `expr`s of a `letrec` form are typically `lambda` expressions,
|
|
|
they can be any expression. The expressions are evaluated in order, and
|
|
|
after each value is obtained, it is immediately associated with its
|
|
|
corresponding `id`. If an `id` is referenced before its value is ready,
|
|
|
an error is raised, just as for internal definitions.
|
|
|
|
|
|
```racket
|
|
|
> (letrec ([quicksand quicksand])
|
|
|
quicksand)
|
|
|
quicksand: undefined;
|
|
|
cannot use before initialization
|
|
|
```
|
|
|
|
|
|
## 4. Named `let`
|
|
|
|
|
|
A named `let` is an iteration and recursion form. It uses the same
|
|
|
syntactic keyword `let` as for local binding, but an identifier after
|
|
|
the `let` \(instead of an immediate open parenthesis\) triggers a
|
|
|
different parsing.
|
|
|
|
|
|
```racket
|
|
|
(let proc-id ([arg-id init-expr] ...)
|
|
|
body ...+)
|
|
|
```
|
|
|
|
|
|
A named `let` form is equivalent to
|
|
|
|
|
|
```racket
|
|
|
(letrec ([proc-id (lambda (arg-id ...)
|
|
|
body ...+)])
|
|
|
(proc-id init-expr ...))
|
|
|
```
|
|
|
|
|
|
That is, a named `let` binds a function identifier that is visible only
|
|
|
in the function’s body, and it implicitly calls the function with the
|
|
|
values of some initial expressions.
|
|
|
|
|
|
Examples:
|
|
|
|
|
|
```racket
|
|
|
(define (duplicate pos lst)
|
|
|
(let dup ([i 0]
|
|
|
[lst lst])
|
|
|
(cond
|
|
|
[(= i pos) (cons (car lst) lst)]
|
|
|
[else (cons (car lst) (dup (+ i 1) (cdr lst)))])))
|
|
|
|
|
|
> (duplicate 1 (list "apple" "cheese burger!" "banana"))
|
|
|
'("apple" "cheese burger!" "cheese burger!" "banana")
|
|
|
```
|
|
|
|
|
|
## 5. Multiple Values: `let-values`, `let*-values`, `letrec-values`
|
|
|
|
|
|
> +\[missing\] in \[missing\] also documents multiple-value binding forms.
|
|
|
|
|
|
In the same way that `define-values` binds multiple results in a
|
|
|
definition \(see \[missing\]\), `let-values`, `let*-values`, and
|
|
|
`letrec-values` bind multiple results locally.
|
|
|
|
|
|
```racket
|
|
|
(let-values ([(id ...) expr] ...)
|
|
|
body ...+)
|
|
|
```
|
|
|
|
|
|
```racket
|
|
|
(let*-values ([(id ...) expr] ...)
|
|
|
body ...+)
|
|
|
```
|
|
|
|
|
|
```racket
|
|
|
(letrec-values ([(id ...) expr] ...)
|
|
|
body ...+)
|
|
|
```
|
|
|
|
|
|
Each `expr` must produce as many values as corresponding `id`s. The
|
|
|
binding rules are the same for the forms without `-values` forms: the
|
|
|
`id`s of `let-values` are bound only in the `body`s, the `id`s of
|
|
|
`let*-values`s are bound in `expr`s of later clauses, and the `id`s of
|
|
|
`letrec-value`s are bound for all `expr`s.
|
|
|
|
|
|
Example:
|
|
|
|
|
|
```racket
|
|
|
> (let-values ([(q r) (quotient/remainder 14 3)])
|
|
|
(list q r))
|
|
|
'(4 2)
|
|
|
```
|