anchor.diff:    (declare (ignore car))
     (unless (cdr form) ; style tweak, doesn't change runtime, mimics (cl:or)
       (return-from cpf-list nil))
  -  (with-slots (string start end) context
  -    (let* ((args (cdr form))
  -           (blocksym (gensym (symbol-name :or-)))
  -           (endsym (gensym (symbol-name :end-)))
  -           (valsym (gensym (symbol-name :val-)))
  -           (inner
  -            `(let* (,endsym ,valsym)))
  -           (last (last inner 1)))
  -      (dolist (f args)
  -        (pushback
  -         `(setf (values ,endsym ,valsym) ,(cpf f context env))
  -         last)
  -        (pushback
  -         `(when ,endsym
  -            (return-from ,blocksym (values ,endsym ,valsym)))
  -         last))
  -      `(block ,blocksym ,inner))))
  -
  +  (let* ((args (cdr form))
  +         (blocksym (gensym (symbol-name :or-)))
  +         (retlist (cpf-return-list context))
  +         (vlist (cons 'cl:values retlist))
  +         (inner
  +           `(let* ,retlist))
  +         (last (last inner 1)))
  +    (dolist (f args)
  +      (pushback
  +       `(setf ,vlist ,(cpf f context env))
  +       last)
  +      (pushback
  +       `(when ,(car retlist)
  +          (return-from ,blocksym ,vlist))
  +       last))
  +    `(block ,blocksym ,inner)))
  +
  +;; note: untested after converting to retlist/bestretlist
   (defmethod cpf-list ((car (eql 'or>)) form context env)
     "return the rule that has the longest match"
     (declare (ignore car))
  
positive.code:   (assert (= (length form) 3))
    (with-slots (string start end) context
      (destructuring-bind (pass fail) (cdr form)
        (let* ((e (gensym (symbol-name :end-)))
               (v (gensym (symbol-name :val-))))
          `(multiple-value-bind (,e ,v) ,(cpf pass context env)
             (when ,e
               (unless ,(cpf fail context env)
                 (values ,e ,v))))))))
  
  (defmethod cpf-list ((car (eql 'assert)) form context env)
    "(assert A) -> A or an exception if no match"
  
negative.code:                (string= prefix string :start2 start :end2 stop))
        (values stop prefix))))
  
  (defmethod cpf ((form string) (context string-context) env)
    (declare (ignore env))
    (values
     (with-slots (string start end) context
       `(starts-with ,string ,start ,end ,form))
     t))
  
  (defmethod cpf ((form string) (context array-context) env)
    (declare (ignore env))
    (values
     (with-slots (array start) context
       `(when (string= (aref ,array ,start) ,form)
          (values ,form (`+ ,start))))
     t))
  
  (defmethod cpf ((form character) (context string-context) env)
    (declare (ignore env))
    (values
     (with-slots (string start end) context
  