anchor.diff:          ;; set the end-test
           (setf (fifth this-iteration) `(or (null ,var) (= (length ,var) 0)))))))
   
  -(defun for-clause (state)
  +(defun var-or-bindings (state)
     (let* ((place (eat state))
            (var (when (atom place) place))
  -         (bindings (unless var place))
  -         (term (eat state :atom)))
  -    (when bindings
  -      (when (eq term :from)
  -        (err "an atom after FROM" bindings))
  -      (setf var (ps-gensym)))
  -    (case term
  -      (:from (for-from var state))
  -      (:= (for-= var bindings state))
  -      ((:in :across) (for-in var bindings state))
  -      (:on (for-on var bindings state))
  -      (otherwise (error "FOR ~s ~s is not valid in PS-LOOP." var term)))))
  +         (bindings (unless var place)))
  +    (values var bindings)))
  +
  +(defun for-clause (state)
  +  (multiple-value-bind (var bindings)
  +      (var-or-bindings state)
  +    (let ((term (eat state :atom)))
  +      (when bindings
  +        (when (eq term :from)
  +          (err "an atom after FROM" bindings))
  +        (setf var (ps-gensym)))
  +      (case term
  +        (:from (for-from var state))
  +        (:= (for-= var bindings state))
  +        ((:in :across) (for-in var bindings state))
  +        (:on (for-on var bindings state))
  +        (otherwise (error "FOR ~s ~s is not valid in PS-LOOP." var term))))))
  +
  +(defun a-with-clause (state) ;; so named to avoid with-xxx macro convention
  +  (multiple-value-bind (var bindings)
  +      (var-or-bindings state)
  +    (eat state :=)
  +    (let ((expr (eat state)))
  +      (if var
  +          (prevar var expr state)
  +          (prebind bindings expr state)))))
   
   (defun accumulate (kind term var state)
     (when (null var)
  
positive.code:                  tok))))
  
  (defun prevar (var expr state)
    (pushnew (list 'var var expr) (prologue state) :key #'second)
    var)
  
  (defmacro with-local-var ((name expr state) &body body)
    (once-only (expr)
  
negative.code:          x))
     args))
  
  (defun turn-lisp-style-function-name-to-ordinary-js-name (sym)
    (if (and (consp sym) (eq 'function (first sym)))
        (second sym)
        sym))
  