anchor.diff:          (loop :while (tokens state) :do (clause state))
           (nreverse-loop-state state))))
   
  -(defun multiple-fors? (loop)
  -  (> (length (iterations loop)) 1))
  -
  -(defun inits (loop)
  -  (mapcar (lambda (x) (list (first x) (third x)))
  -          (iterations loop)))
  -
  -(defun steps (loop)
  -  (mapcar (lambda (x) `(setf ,(first x) ,(fourth x)))
  -          (iterations loop)))
  -
  -(defun end-test (loop)
  -  (aif (loop :for (nil nil nil nil test) :in (iterations loop)
  -         :when test :collect test)
  -       (if (cdr it)
  -           (list 'not (cons 'or it))
  -           (cons 'not it))
  -       t))
  -
   (defun wrap-with-destructurings (iterations forms)
     (if (null iterations)
         forms
  
positive.code:     (let ((test (when test-op
                    (with-local-var (v end state)
                      (list test-op var v)))))
        (push `(,var nil ,start (,op ,var ,(or by 1)) ,test) (iterations state)))))
  
  (defun for-= (var bindings state)
    (let ((start (eat state))
          (then (eat state :if :then)))
      (push (list var bindings start (or then start) nil) (iterations state))))
  
  (defun for-in (var bindings state)
    (with-local-var (arr (eat state) state)
  
negative.code:                    ((:sum :count) 0)
                     ((:maximize :minimize) nil)
                     (:collect '(array)))))
      (prevar var initial state))
    (case kind
      (:sum `(incf ,var ,term))
      (:count `(unless (null ,term) (incf ,var)))
  