anchor.diff:    ((tokens :initarg :tokens :accessor tokens)
      (iterations :initform nil :accessor iterations)
      (prologue :initform nil :accessor prologue)
  -   (destructurings :initform nil :accessor destructurings)
      (initially :initform nil :accessor initially)
      (finally :initform nil :accessor finally)
      (during-first :initform nil :accessor during-first)
  
positive.code:   (> (length (iterations loop)) 1))
  
  (defun inits (loop)
    (mapcar (lambda (x) (subseq x 0 2)) (iterations loop)))
  
  (defun steps (loop)
    (mapcar (lambda (x) `(setf ,(first x) ,(third x))) (iterations loop)))
  
  (defun end-test (loop)
    (aif (loop :for (nil nil nil test) :in (iterations loop)
           :when test :collect test)
         (if (cdr it)
             (list 'not (cons 'or it))
             (cons 'not it))
         t))
  
  (defun inner-body (loop)
    (if (multiple-fors? loop)
        (append (body loop)
                (loop :for (var nil step test) :in (iterations loop)
                  :collect `(setf ,var ,step)
                  :when test :collect `(when ,test (break))))
        (body loop)))
  
  (defun the-actual-loop (loop)
    (let ((body `(,@(awhen (during-first loop)
                           `((when ,(first-guard loop)
                               ,@it
                               (setf ,(first-guard loop) nil))))
                    ,@(inner-body loop)
                    ,@(when (during-last loop)
                            `((setf ,(last-guard loop) t))))))
      (if (multiple-fors? loop)
          `(while t ,@body)
          `(for ,(inits loop) (,(end-test loop)) ,(steps loop) ,@body))))
  
  (defun the-loop-form (loop)
    (let ((form `(progn
  
negative.code:                  ,@(awhen (during-last loop)
                            `((when ,(last-guard loop) ,@it)))
                   ,@(finally loop))))
      (if (multiple-fors? loop)
          (init-and-test (iterations loop) form)
          form)))
  
  (defpsmacro loop (&rest args)
    (let ((loop (parse-ps-loop (normalize-loop-keywords args))))
  