anchor.diff:            (not (eq (ps-macroexpand expr) expr)))
         (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 :append :count :minimize :maximize :into))
  -
  -(defun normalize-loop-keywords (args)
  -  (mapcar
  -   (lambda (x)
  -     (or (find-if (lambda (key) (and (symbolp x) (equal (symbol-name x) (symbol-name key))))
  -                  *loop-keywords*)
  -         x))
  -   args))
  +(eval-when (:compile-toplevel :load-toplevel :execute)
  +  (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 as-keyword (key)
  +    (intern (symbol-name key) :keyword)))
  +
  +(defmacro loop-case (key &body forms)
  +  (loop :for (match . nil) :in forms
  +    :for keys = (if (listp match) match (list match)) :do
  +    (loop :for k :in keys :do
  +      (assert (member k (append *loop-keywords* '(t otherwise)))
  +              nil "~a isn't a recognized loop keyword." k)))
  +  `(case (as-keyword ,key) ,@forms))
  +
  +(defun loop-keyword? (term &rest keys)
  +  (member (as-keyword term) keys))
   
   (defun turn-lisp-style-function-name-to-ordinary-js-name (sym)
     (if (and (consp sym) (eq 'function (first sym)))
  
positive.code:         (:dbind `(destructuring-bind ,@(cdr (car prologue))
                       (with-prologue (,(cdr prologue)) ,@body))))))
  
  (defpsmacro loop (&rest args)
    (let* ((loop (parse-ps-loop (normalize-loop-keywords args)))
           ;; Variable lifting to support initially/finally may
           ;; add to prologue, so compute main loop first.
           (main (or (parallel-form loop)
  
negative.code: 
  (defun eat (state &optional what tag)
    (case what
      (:if (when (loop-keyword? (peek state) tag)
             (eat state)
             (eat state)))
      (:progn (cons 'progn (loop :collect (if (consp (peek state))
  