anchor.diff:        (:until (push `(when ,(eat state) break) (body state)))
         (:initially (push (eat state :progn) (initially state)))
         (:finally (push (eat state :progn) (finally state)))
  -      (:first-time (first-time-clause state))
  -      (:last-time (last-time-clause state))
         (otherwise (push (body-clause term state) (body state))))))
   
   (defun parse-ps-loop (terms)
  
positive.code: 
  (defun for-in (var bindings state)
    (with-local-var (arr (eat state) state)
      (let ((index (or (eat state :if :index) (ps-gensym))))
        (push-tokens state `(,index :from 0 :below (length ,arr)
                                    ,var := (aref ,arr ,index)))
        (for-clause state)
  
negative.code:             `((destructuring-bind ,it ,(first (car iterations)) ,@forms))
              forms))))
  
  (defun wrap-with-initially-and-finally (loop form)
    `(progn
       ,@(initially loop)
       ,form
       ,@(finally loop)))
  
  (defun loop-form-with-alternating-tests (loop)
    (let ((form `(while t
                   ,@(append (body loop)
                             (loop :for (var bindings nil step test) :in (iterations loop)
                               :collect `(setf ,var ,step)
                               :when bindings :collect `(dset ,bindings ,var)
                               :when test :collect `(when ,test (break)))))))
      ;; Preface the whole thing with alternating inits and tests prior
      ;; to first executing the loop; this way, as in CL LOOP, we refrain
      ;; from initializing subsequent clauses if a test fails.
  