anchor.diff:      '(:named :for :repeat :with :while :until :initially :finally
         :from :to :below :downto :above :by :in :across :on := :then
         :when :unless :if :else :end :do :return
  -      :sum :collect :append :count :minimize :maximize :into))
  +      :sum :collect :append :count :minimize :maximize :map :into))
   
     (defun as-keyword (key)
       (intern (symbol-name key) :keyword)))
  
positive.code:   (let ((initial (loop-case kind
                         ((:sum :count) 0)
                         ((:maximize :minimize) nil)
                         ((:collect :append) '(array)))))
      (prevar var initial state))
    (loop-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))
          (:append `(setf ,var (append ,var ,term)))))
  
  (defun repeat-clause (state)
    (let ((index (ps-gensym)))
  
negative.code:                     (progn ,@(reverse alts))))))
          ((:sum :collect :append :count :minimize :maximize)
           (accumulate term (eat state) (eat state :if :into) state))
          (:map (let ((key (eat state)))
                  (multiple-value-bind (val valp)
                      (eat state :if :to)
                    (unless valp
                      (error "MAP must be followed by a TO to specify value."))
                    (accumulate :map (list key val) (eat state :if :into) state))))
          (:do (eat state :progn))
          (:return `(return-from ,(name state) ,(eat state)))
          (otherwise (err "a PS-LOOP keyword" term))))
  