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 .
+Local Binding: let, let*, letrec, ... in The Racket Reference also documents let .
A let form binds a set of identifiers, each to the result of some expression, for use in the let body:
The ids 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 ids must be different from each other.
me)"Bob"
'("Bob" "Robert" "Bobby")
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:
'(3 "seesaw")
Occasionally, the parallel nature of let bindings is convenient for swapping or rearranging a set of bindings:
'("Jane" "Tarzan")
The characterization of let bindings as “parallel” is not meant to imply concurrent evaluation. The exprs are evaluated in order, even though the bindings are delayed until all exprs are evaluated.
+Local Binding: let, let*, letrec, ... in The Racket Reference also documents let* .
The syntax of let* is the same as let :
The difference is that each id is available for use in later exprs, as well as in the body. Furthermore, the ids need not be distinct, and the most recent binding is the visible one.
'(("Burroughs") ("Rice" "Burroughs") ("Edgar" "Rice" "Burroughs"))
'("Edgar" "Rice" "Burroughs")
In other words, a let* form is equivalent to nested let forms, each with a single binding:
name)))'("Edgar" "Rice" "Burroughs")
+Local Binding: let, let*, letrec, ... in The Racket Reference also documents letrec .
The syntax of letrec is also the same as let :
While let makes its bindings available only in the bodys, and let* makes its bindings available to any later binding expr, letrec makes its bindings available to all other exprs—even earlier ones. In other words, letrec bindings are recursive.
The exprs in a letrec form are most often lambda forms for recursive and mutually recursive functions:
(swing'(vinetarzanvinevine)))'(vine vine tarzan vine)
(tarzan-in-directory?pathdepth))))][tarzan-in-directory?(cond[else(tarzan-near-top-of-tree?"tmp"4))directory-list: could not open directory
path: /var/tmp/systemd-private-6ece068a469546499f5d592c840
5efe0-systemd-logind.service-6XAejJ
system error: Permission denied; errno=13
While the exprs 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.
quicksand)quicksand: undefined;
cannot use before initialization
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.
body...+)
A named let form is equivalent to
body...+)])proc-id)
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.
+Local Binding: let, let*, letrec, ... in The Racket Reference also documents multiple-value binding forms.
In the same way that define-values binds multiple results in a definition (see Multiple Values and define-values), let-values , let*-values , and letrec-values bind multiple results locally.
body...+)
body...+)
body...+)
Each expr must produce as many values as corresponding ids. The binding rules are the same for the forms without -values forms: the ids of let-values are bound only in the bodys, the ids of let*-values s are bound in exprs of later clauses, and the ids of letrec-values are bound for all exprs.
'(4 2)