 
 
 
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.
 
 
