anchor.diff:  
   (defun for-in (var bindings state)
     (with-local-var (arr (eat state) state)
  -    (let ((index (or (eat state :if :index) (ps-gensym))))
  +    (let ((index (ps-gensym)))
         (push-tokens state `(,index :from 0 :below (length ,arr)
                                     ,var := (aref ,arr ,index)))
         (for-clause state)
  
positive.code:             `((destructuring-bind ,it ,(first (car iterations)) ,@forms))
              forms))))
  
  (defun wrap-with-first-and-last-guards (loop forms)
    (append (awhen (during-first loop)
              `((when ,(first-guard loop)
                  ,@it
                  (setf ,(first-guard loop) nil))))
            forms
            (when (during-last loop)
              `((setf ,(last-guard loop) t)))))
  
  (defun wrap-with-initially-and-finally (loop form)
    `(progn
       ,@(initially loop)
       ,form
       ,@(awhen (during-last loop)
                `((when ,(last-guard loop) ,@it)))
       ,@(finally loop)))
  
  (defun loop-form-with-alternating-tests (loop)
    (let ((form `(while t
                   ,@(wrap-with-first-and-last-guards
                      loop
                      (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.
  
negative.code:       (consp expr)))
  
  (defvar *loop-keywords*
    '(:for :do :when :unless :initially :finally :while :until
      :from :to :below :downto :above :by :in :across :on := :then :sum :collect
      :count :minimize :maximize :into :repeat))
  
  (defun normalize-loop-keywords (args)
  