#### 6.1.2.15 Local Variable Initializations

When a loop form is executed, the local variables are bound and are initialized to some value. These local variables exist until loop iteration terminates, at which point they cease to exist. Implicit variables are also established by iteration control clauses and the `into` preposition of accumulation clauses.

The `with` construct initializes variables that are local to a loop. The variables are initialized one time only. If the optional type-spec argument is supplied for the variable var, but there is no related expression to be evaluated, var is initialized to an appropriate default value for its type. For example, for the types t, number, and float, the default values are nil, `0`, and `0.0` respectively. The consequences are undefined if a type-spec argument is supplied for var if the related expression returns a value that is not of the supplied type. By default, the `with` construct initializes variables sequentially; that is, one variable is assigned a value before the next expression is evaluated. However, by using the loop keyword `and` to join several `with` clauses, initializations can be forced to occur in parallel; that is, all of the supplied forms are evaluated, and the results are bound to the respective variables simultaneously.

Sequential binding is used when it is desireable for the initialization of some variables to depend on the values of previously bound variables. For example, suppose the variables `a`, `b`, and `c` are to be bound in sequence:

     (loop with a = 1
           with b = (+ a 2)
           with c = (+ b 3)
           return (list a b c))
    ⇒  (1 3 6)

The execution of the above loop is equivalent to the execution of the following code:

     (block nil
       (let* ((a 1)
              (b (+ a 2))
              (c (+ b 3)))
         (tagbody
             (next-loop (return (list a b c))
                        (go next-loop)
                        end-loop))))

If the values of previously bound variables are not needed for the initialization of other local variables, an `and` clause can be used to specify that the bindings are to occur in parallel:

     (loop with a = 1
           and b = 2
           and c = 3
           return (list a b c))
    ⇒  (1 2 3)

The execution of the above loop is equivalent to the execution of the following code:

     (block nil
       (let ((a 1)
             (b 2)
             (c 3))
         (tagbody
             (next-loop (return (list a b c))
                        (go next-loop)
                        end-loop))))