anchor.diff:    (let ((initial (case kind
                      ((:sum :count) 0)
                      ((:maximize :minimize) nil)
  -                   (:collect '(array)))))
  +                   ((:collect :append) '(array)))))
       (prevar var initial state))
     (case kind
       (:sum `(incf ,var ,term))
       (:count `(unless (null ,term) (incf ,var)))
       (:minimize `(setf ,var (if (null ,var) ,term (min ,var ,term))))
       (:maximize `(setf ,var (if (null ,var) ,term (max ,var ,term))))
  -    (:collect `((@ ,var :push) ,term))))
  +    (:collect `((@ ,var :push) ,term))
  +    (:append `(setf ,var (append ,var ,term)))))
   
   (defun repeat-clause (state)
     (let ((index (ps-gensym)))
  
positive.code: 
  (defun body-clause (term state)
    (case term
      ((:when :unless) (list (intern (symbol-name term))
                             (eat state)
                             (body-clause (eat state :atom) state)))
      ((:sum :collect :count :minimize :maximize) (accumulate term (eat state) (eat state :if :into) state))
      (:do (eat state :progn))
      (otherwise (err "a PS-LOOP keyword" term))))
  
  
negative.code: (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 :append :count :minimize :maximize :into))
  
  (defun normalize-loop-keywords (args)
    (mapcar
  