11. Binding

Binding is lexically scoped assignment. It happens to the variables in a function's parameter list whenever the function is called: the formal parameters are bound to the actual parameters for the duration of the function call. You can bind variables anywhere in a program with the let special form, which looks like this:

(let ((var1 val1)
      (var2 val2)
      ...
     )
    body)

(It's considered bad style to leave a single ``)'' on a line)

Let binds var1 to val1, var2 to val2, and so forth; then it executes the statements in its body. The body of a let follows exactly the same rules that a function body does. Some examples:

> (let ((a 3)) (+ a 1))
4
> (let ((a 2) 
        (b 3)
        (c 0))
    (setq c (+ a b))
    c)
5
> (setq c 4)
4                     ;and a warning from CMUCL, ignore it    
> (let ((c 5)) c)
5
> c
4

Instead of (let ((a nil) (b nil)) ...), you can write (let (a b) ...).

The val1, val2, etc. inside a let cannot reference the variables var1, var2, etc. that the let is binding. For example,

> (let ((x 1)
        (y (+ x 1)))
    y)
Error: Attempt to take the value of the unbound symbol X
                      ;in CMUCL:

In: LET ((X 1) (Y (+ X 1)))
  (LET ((X 1) (Y #))
    Y)
Warning: Variable X defined but never used.


Warning: This variable is undefined:
  X

Error in KERNEL::UNBOUND-SYMBOL-ERROR-HANDLER:  the variable X is
unbound.

Restarts:
  0: [ABORT] Return to Top-Level.

Debug  (type H for help)

(EVAL::LEAF-VALUE
 #<C::REF #x9009B15  LEAF= #<C::GLOBAL-VAR #x9009AD5  NAME= X  KIND=
 :GLOBAL>>
 0
 #())
0]

If the symbol x already has a global value, stranger happenings will result:

> (setq x 7)
7                     ;again a warning in CMUCL:
Warning:  Declaring X special.
                      ;x is automaticly declared special
> (let ((x 1)
        (y (+ x 1)))
    y
  )
8

The let* special form is just like let except that it allows values to reference variables defined earlier in the let*. For example,

> (setq x 7)
7
> (let* ((x 1)
         (y (+ x 1)))
    y
  )
2

The form

(let* ((x a)
       (y b))
       ...
) 

is equivalent to

(let ((x a))
     (let ((y b))
          ...
) )