   ## 18. Iteration

The simplest iteration construct in LISP is `loop`: a `loop` construct repeatedly executes its body until it hits a `return` special form. For example,

``` > (setq a 4) 4 > (loop (setq a (+ a 1)) (when (> a 7) (return a))) 8 > (loop (setq a (- a 1)) (when (< a 3) (return))) NIL ```

The next simplest is `dolist`: `dolist` binds a variable to the elements of a list in order and stops when it hits the end of the list.

``` > (dolist (x '(a b c)) (print x)) A B C NIL ```

`Dolist` always returns `nil`. Note that the value of `x` in the above example was never `nil`: the` NIL` below the C was the value that `dolist` returned, printed by the read-eval-print loop.

The most complicated iteration primitive is called `do`. A `do` statement looks like this:

``` > (do ((x 1 (+ x 1)) (y 1 (* y 2))) ((> x 5) y) (print y) (print 'working) ) 1 WORKING 2 WORKING 4 WORKING 8 WORKING 16 WORKING 32 ```

The first part of a `do` specifies what variables to bind, what their initial values are, and how to update them. The second part specifies a termination condition and a return value. The last part is the body. A do form binds its variables to their initial values like a `let`, then checks the termination condition. As long as the condition is false, it executes the body repeatedly; when the condition becomes true, it returns the value of the return-value form.

The `do`* form is to `do` as `let`* is to `let`.   