anchor.diff:                   (when (next? term)
                      (consume)
                      (consume)))
  +               (establish-accum-var (kind initial-val)
  +                 (if accum-var
  +                     (error "PS-LOOP encountered illegal ~a: a ~a was previously declared, and there can only be one accumulation per loop." kind accum-kind)
  +                     (progn
  +                       (setf accum-var (ps-gensym kind)
  +                             accum-kind kind)
  +                       (push `(var ,accum-var ,initial-val) prologue))))
                  (body-clause (term)
                    (case term
                      ((:when :unless) (list (intern (symbol-name term))
                                             (consume)
                                             (body-clause (consume-atom))))
  -                   (:sum (let ((sum-expr (consume)))
  -                           (consume :into)
  -                           (let ((sum-var (consume-atom)))
  -                             (push `(var ,sum-var 0) prologue)
  -                             `(incf ,sum-var ,sum-expr))))
  +                   (:sum (establish-accum-var :sum 0)
  +                         `(incf ,accum-var ,(consume)))
  +                   (:collect (establish-accum-var :collect '(array))
  +                     `((@ ,accum-var :push) ,(consume)))
                      (:do (consume-progn))
  -                   (otherwise (err "a JS-LOOP keyword" term))))
  +                   (otherwise (err "a PS-LOOP keyword" term))))
                  (for-from (var)
                    (let ((start (consume))
                          (op '+)
  
positive.code:                      (:from (for-from var))
                       (:= (for-= var))
                       ((:in :across) (for-in var))
                       (otherwise (error "FOR ~s ~s is not valid in JS-LOOP." var term)))))
                 (clause ()
                   (let ((term (consume-atom)))
                     (case term
  
negative.code:       (find #\. (symbol-name expr))
        (consp expr)))
  
  (defvar *loop-keywords*
    '(:for :do :when :unless :initially :finally :first-time :last-time :while :until
      :from :to :below :downto :above :by :in :across :index := :then :sum :collect))
  
  (defun normalize-loop-keywords (args)
    (mapcar (lambda (x)
  