anchor.diff:      (setf (tokens state) (append `(,index :from 0 :below ,(eat state)) (tokens state)))
       (for-clause state)))
   
  +(flet ((while-or-until (tag var state)
  +         (let ((expr (eat state))
  +               (test (ecase tag
  +                       (:while `(not ,var))
  +                       (:until var))))
  +           (push (list var nil expr expr test tag) (iterations state)))))
  +
  +  (defun while-clause (state)
  +    (while-or-until :while (gensym) state))
  +
  +  (defun until-clause (state)
  +    (while-or-until :until (gensym) state)))
  +
   (defun body-clause (term state)
     (case term
       ((:when :unless)
  
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 :from) (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:       (:with (a-with-clause state))
        (:for (for-clause state))
        (:repeat (repeat-clause state))
        (:while (while-clause state))
        (:until (until-clause state))
        (:initially (push (eat state :progn) (initially state)))
        (:finally (push (eat state :progn) (finally state)))
        (otherwise (push (body-clause term state) (body state))))))
  