anchor.diff:        (var-or-bindings state)
       (let ((term (eat state :atom)))
         (when bindings
  -        (when (eq term :from)
  +        (when (loop-keyword? term :from)
             (err "an atom after FROM" bindings))
           (setf var (ps-gensym)))
  -      (case term
  -        (:from (for-from var state))
  -        (:= (for-= var bindings state))
  -        ((:in :across) (for-in var bindings state))
  -        (:on (for-on var bindings state))
  -        (otherwise (error "FOR ~s ~s is not valid in PS-LOOP." var term))))))
  +      (loop-case term
  +            (:from (for-from var state))
  +            (:= (for-= var bindings state))
  +            ((:in :across) (for-in var bindings state))
  +            (:on (for-on var bindings state))
  +            (otherwise (error "FOR ~s ~s is not valid in PS-LOOP." var term))))))
   
   (defun a-with-clause (state) ;; so named to avoid with-xxx macro convention
     (multiple-value-bind (var bindings)
  
positive.code:     (while-or-until :until (ps-gensym) state)))
  
  (defun body-clause (term state)
    (case term
      ((:when :unless)
       (list (intern (symbol-name term))
             (eat state)
             (body-clause (eat state :atom) state)))
      ((:sum :collect :append :count :minimize :maximize)
       (accumulate term (eat state) (eat state :if :into) state))
      (:do (eat state :progn))
      (otherwise (err "a PS-LOOP keyword" term))))
  
  (defun clause (state)
    (let ((term (eat state :atom)))
      (case term
        (: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))))))
  
  (defun parse-ps-loop (terms)
    (if (null terms)
  
negative.code:         (:dbind `(destructuring-bind ,@(cdr (car prologue))
                       (with-prologue (,(cdr prologue)) ,@body))))))
  
  (defpsmacro loop (&rest keywords-and-forms)
    (let* ((loop (parse-ps-loop keywords-and-forms))
           ;; Variable lifting to support initially/finally may
           ;; add to prologue, so compute main loop first.
           (main (or (parallel-form loop)
  