#### 3.3.4.1 Examples of Declaration Scope ¶

Here is an example illustrating the scope of bound declarations.

     (let ((x 1))                ;[1] 1st occurrence of x
       (declare (special x))     ;[2] 2nd occurrence of x
       (let ((x 2))              ;[3] 3rd occurrence of x
         (let ((old-x x)         ;[4] 4th occurrence of x
               (x 3))            ;[5] 5th occurrence of x
           (declare (special x)) ;[6] 6th occurrence of x
           (list old-x x))))     ;[7] 7th occurrence of x
    ⇒  (2 3)

The first occurrence of `x` establishes a dynamic binding of `x` because of the special declaration for `x` in the second line. The third occurrence of `x` establishes a lexical binding of `x` (because there is no special declaration in the corresponding let form). The fourth occurrence of `x` x is a reference to the lexical binding of `x` established in the third line. The fifth occurrence of `x` establishes a dynamic binding of x for the body of the let form that begins on that line because of the special declaration for `x` in the sixth line. The reference to `x` in the fourth line is not affected by the special declaration in the sixth line because that reference is not within the “would-be lexical scope” of the variable `x` in the fifth line. The reference to `x` in the seventh line is a reference to the dynamic binding of x established in the fifth line.

Here is another example, to illustrate the scope of a free declaration. In the following:

     (lambda (&optional (x (foo 1))) ;[1]
       (declare (notinline foo))     ;[2]
       (foo x))                      ;[3]

the call to `foo` in the first line might be compiled inline even though the call to `foo` in the third line must not be. This is because the notinline declaration for `foo` in the second line applies only to the body on the third line. In order to suppress inlining for both calls, one might write:

     (locally (declare (notinline foo)) ;[1]
       (lambda (&optional (x (foo 1)))  ;[2]
         (foo x)))                      ;[3]

or, alternatively:

     (lambda (&optional                               ;[1]
                (x (locally (declare (notinline foo)) ;[2]
                     (foo 1))))                       ;[3]
       (declare (notinline foo))                      ;[4]
       (foo x))                                       ;[5]

Finally, here is an example that shows the scope of declarations in an iteration form.

     (let ((x  1))                     ;[1]
       (declare (special x))           ;[2]
         (let ((x 2))                  ;[3]
           (dotimes (i x x)            ;[4]
             (declare (special x)))))  ;[5]
    ⇒  1

In this example, the first reference to `x` on the fourth line is to the lexical binding of `x` established on the third line. However, the second occurrence of `x` on the fourth line lies within the scope of the free declaration on the fifth line (because this is the result-form of the dotimes) and therefore refers to the dynamic binding of `x`.