anchor.diff:                       (setf terms (append equiv terms))
                        (clause)
                        (clause))))
  +               (for-on (var)
  +                 (with-local-var (arr (consume))
  +                   (push `(or (null ,var) (= (length ,var) 0)) end-test-forms)
  +                   (let* ((by (aif (consume-if :by)
  +                                   `(,(reduce-function-symbol it) ,var)
  +                                   `((@ ,var :slice) 1)))
  +                          (equiv `(:for ,var := ,arr :then ,by)))
  +                     (setf terms (append equiv terms))
  +                     (clause))))
                  (for-clause ()
                    (let* ((place (consume))
                           (var (when (atom place) place))
  
positive.code:                         (term (consume-atom)))
                     (when varlist
                       (when (eq term :from)
                         (err "an atom after FROM" varlist))
                       (setf var (ps-gensym))
                       (push (list varlist var) destructurings))
                     (case term
                       (: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)))
  
negative.code:                   *loop-keywords*)
           x))
     args))
  
  (defun reduce-function-symbol (sym)
    (if (and (consp sym) (eq 'function (first sym)))
        (second sym)
        sym))
  
  (defun parse-ps-loop (terms)
    (let (prologue
  