LET

If the form above is executed in an environment in which x has the
value -2, then the result is '(4 -4).

Let expressions bind variables so that their ``local'' values, the
values they have when the ``body'' of the let is evaluated, are
possibly different than their ``global'' values, the values they
have in the context in which the let expression appears. In the let
expression above, the local variables bound by the let are x and y.
They are locally bound to the values delivered by the two forms
(* x x) and (* 2 x), respectively, that appear in the
``bindings'' of the let. The body of the let is (list x y).

Suppose that the let expression above occurs in a context in which x
has the value -2. (The global value of y is irrelevant to this
example.) For example, one might imagine that the let form above
occurs as the body of some function, fn, with the formal parameter x
and we are evaluating (fn -2).

To evaluate the let above in a context in which x is -2, we first
evaluate the two forms specifying the local values of the variables.
Thus, (* x x) is evaluated and produces 4 (because x is -2) and
(* 2 x) is evaluated and produces -4 (because x is -2).
Then x and y are bound to these values and the body of the let
is evaluated. Thus, when the body, (list x y) is evaluated, x
is 4 and y is -4. Thus, the body produces '(4 -4).

Note that the binding of y, which is written after the binding of x
and which mentions x, nevertheless uses the global value of x, not
the new local value. That is, the local variables of the let are
bound ``in parallel'' rather than ``sequentially.'' In contrast, if
the

Example LET* Form:
(let* ((x (* x x))
(y (* 2 x)))
(list x y))

is evaluated when the global value of x is -2, then the result is
'(4 8), because the local value of y is computed after x has been
bound to 4. Let* binds its local variables ``sequentially.''

where the vari are distinct variables, the termi are terms
involving only variables bound in the environment containing the
let, and body is a term involving only the vari plus the variables
bound in the environment containing the let. Each vari must be used
in body or else declared ignored.

A let form is evaluated by first evaluating each of the termi,
obtaining for each a vali. Then, each vari is bound to the
corresponding vali and body is evaluated.

Actually, let forms are just abbreviations for certain uses of
lambda notation. In particular

(let ((var1 term1) ... (varn termn)) (declare ...) body)

is equivalent to

((lambda (var1 ... varn)
(declare ...)
body)
term1 ... termn).

Let* forms are used when it is desired to bind the vari
sequentially, i.e., when the local values of preceding varj are to
be used in the computation of the local value for vari.

where the vari are variables (not necessarily distinct), the
termi are terms involving only variables bound in the environment
containing the let* and those varj such that j<i, and body is a
term involving only the vari plus the variables bound in the
environment containing the let*. Each vari must be used either in
some subsequent termj or in body, except that in the second form
above we make an exception when vari is among the xk, in which case
vari must not be thus used. Note that let* does not permit the
inclusion of any declare forms other than one as shown above. In the
second general form above, every xk must be among the vari, and
furthermore, xk may not equal vari and varj for distinct i, j.

Thus, the termi are evaluated successively and after each
evaluation the corresponding vali is bound to the value of termi.
The second let* is similarly expanded, except that each for each
vari that is among the (x1 ... xm), the form (declare (ignore vari))
is inserted immediately after (vari termi).

Each (vari termi) pair in a let or let* form is called a ``binding''
of vari and the vari are called the ``local variables'' of the let
or let*. The common use of let and let* is to save the values of
certain expressions (the termi) so that they may be referenced
several times in the body without suggesting their recomputation.

Let is part of Common Lisp. See any Common Lisp documentation
for more information.