 
 
 
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))
          ...
) )
 
 
