anchor.diff:                          init-step-forms end-test-forms
                           initially finally
                           first-time last-time
  +                        accum-var
                           body)
  -      (parse-js-loop (normalize-loop-keywords args))
  +      (parse-ps-loop (normalize-loop-keywords args))
       (let ((first-guard (and first-time (ps-gensym)))
             (last-guard (and last-time (ps-gensym))))
  -      `(progn ,@(when first-time `((var ,first-guard t)))
  -              ,@(when last-time `((var ,last-guard nil)))
  -              ,@prologue
  -              ,@initially
  -              (do* ,init-step-forms
  -                   ,end-test-forms
  -                ,@(when first-time
  -                        `((when ,first-guard
  -                            ,@first-time
  -                            (setf ,first-guard nil))))
  -                ,@body
  -                ,@(when last-time
  -                        `((setf ,last-guard t))))
  -              ,@(when last-time `((when ,last-guard ,@last-time)))
  -              ,@finally))))
  +      `(,@(if accum-var '(with-lambda ()) '(progn))
  +          ,@(when first-time `((var ,first-guard t)))
  +          ,@(when last-time `((var ,last-guard nil)))
  +          ,@prologue
  +          ,@initially
  +          (do* ,init-step-forms
  +               ,end-test-forms
  +            ,@(when first-time
  +                    `((when ,first-guard
  +                        ,@first-time
  +                        (setf ,first-guard nil))))
  +            ,@body
  +            ,@(when last-time
  +                    `((setf ,last-guard t))))
  +          ,@(when last-time `((when ,last-guard ,@last-time)))
  +          ,@finally
  +          ,@(when accum-var `((return ,accum-var)))))))
  
positive.code:                 x))
            args))
  
  (defun parse-js-loop (terms)
    (let (prologue
          init-step-forms end-test-forms
          initially finally
          first-time last-time
          body)
      (macrolet ((with-local-var ((name expr) &body body)
                   (once-only (expr)
  
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)
  