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:                 (nreverse finally)
                  (nreverse first-time)
                  (nreverse last-time)
                  (nreverse body))))))
  
  (defpsmacro loop (&rest args)
  
negative.code:                      (:from (for-from var))
                       (:= (for-= var))
                       ((:in :across) (for-in var))
                       (otherwise (error "FOR ~s ~s is not valid in PS-LOOP." var term)))))
                 (clause ()
                   (let ((term (consume-atom)))
                     (case term
  