anchor.diff:  (defun clause (state)
     (let ((term (eat state :atom)))
       (case term
  +      (:with (a-with-clause state))
         (:for (for-clause state))
         (:repeat (repeat-clause state))
         (:while (push `(unless ,(eat state) break) (body state)))
  
positive.code:         ;; set the end-test
          (setf (fifth this-iteration) `(or (null ,var) (= (length ,var) 0)))))))
  
  (defun for-clause (state)
    (let* ((place (eat state))
           (var (when (atom place) place))
           (bindings (unless var place))
           (term (eat state :atom)))
      (when bindings
        (when (eq 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)))))
  
  (defun accumulate (kind term var state)
    (when (null var)
  
negative.code:       (consp expr)))
  
  (defvar *loop-keywords*
    '(:for :do :repeat :with :when :unless :while :until :initially :finally
      :from :to :below :downto :above :by :in :across :on := :then
      :sum :collect :count :minimize :maximize :into))
  
  (defun normalize-loop-keywords (args)
    (mapcar
  