All values in Common Lisp are, conceptually at least, references to objects.4 Consequently, assigning a variable a new value changes what object the variable refers to but has no effect on the previously referenced object. However, if a variable holds a reference to a mutable object, you can use that reference to modify the object, and the modification will be visible to any code that has a reference to the same object.

One way to introduce new variables you’ve already used is to define function parameters. As you saw in the previous chapter, when you define a function with **DEFUN**, the parameter list defines the variables that will hold the function’s arguments when it’s called. For example, this function defines three variables—x, y, and z--to hold its arguments.

Each time a function is called, Lisp creates new bindings to hold the arguments passed by the function’s caller. A binding is the runtime manifestation of a variable. A single variable—the thing you can point to in the program’s source code—can have many different bindings during a run of the program. A single variable can even have multiple bindings at the same time; parameters to a recursive function, for example, are rebound for each call to the function.

As with all Common Lisp variables, function parameters hold object references.5 Thus, you can assign a new value to a function parameter within the body of the function, and it will not affect the bindings created for another call to the same function. But if the object passed to a function is mutable and you change it in the function, the changes will be visible to the caller since both the caller and the callee will be referencing the same object.

(let (variable*)
  body-form*)

where each variable is a variable initialization form. Each initialization form is either a list containing a variable name and an initial value form or—as a shorthand for initializing the variable to **NIL**--a plain variable name. The following **LET** form, for example, binds the three variables x, y, and z with initial values 10, 20, and **NIL**:

(let ((x 10) (y 20) z)
  ...)

When the **LET** form is evaluated, all the initial value forms are first evaluated. Then new bindings are created and initialized to the appropriate initial values before the body forms are executed. Within the body of the , the variable names refer to the newly created bindings. After the **LET**, the names refer to whatever, if anything, they referred to before the **LET**.

The value of the last expression in the body is returned as the value of the **LET** expression. Like function parameters, variables introduced with **LET** are rebound each time the **LET** is entered.6

The scope of function parameters and **LET** variables—the area of the program where the variable name can be used to refer to the variable’s binding—is delimited by the form that introduces the variable. This form—the function definition or the **LET**--is called the binding form. As you’ll see in a bit, the two types of variables—lexical and dynamic—use two slightly different scoping mechanisms, but in both cases the scope is delimited by the binding form.

Each reference to x will refer to the binding with the smallest enclosing scope. Once control leaves the scope of one binding form, the binding from the immediately enclosing scope is unshadowed and x refers to it instead. Thus, calling foo results in this output:

CL-USER> (foo 1)
Outer LET: 2
Inner LET: 3
Parameter: 1
NIL

In future chapters I’ll discuss other constructs that also serve as binding forms—any construct that introduces a new variable name that’s usable only within the construct is a binding form.

For instance, in Chapter 7 you’ll meet the **DOTIMES** loop, a basic counting loop. It introduces a variable that holds the value of a counter that’s incremented each time through the loop. The following loop, for example, which prints the numbers from 0 to 9, binds the variable x:

Another binding form is a variant of **LET**, **LET***. The difference is that in a **LET**, the variable names can be used only in the body of the **LET**--the part of the **LET** after the variables list—but in a **LET***, the initial value forms for each variable can refer to variables introduced earlier in the variables list. Thus, you can write the following:

(let ((x 10)
      (y (+ x 10)))
  (list x y))

However, you could achieve the same result with nested **LET**s.

(let ((x 10))
  (let ((y (+ x 10)))