anchor.diff:    (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-)))
  -           (bestendsym (gensym (symbol-name :bestend-)))
  -           (bestvalsym (gensym (symbol-name :bestval-)))
  +           (retlist (cpf-return-list context))
  +           (bestretlist (cpf-return-list context))
              (inner
  -            `(let* (,endsym ,valsym (,bestendsym ,start) ,bestvalsym)))
  +             `(let* (,@(return-list-binding retlist context) ,@bestretlist)))
              (last (last inner 1)))
         (dolist (f args)
           (pushback
  -         `(setf (values ,endsym ,valsym) ,(cpf f context env))
  +         `(setf (values ,retlist) ,(cpf f context env))
            last)
           (pushback
  -         `(when (and ,endsym (> ,endsym ,bestendsym))
  -            (setf ,bestendsym ,endsym
  -                  ,bestvalsym ,valsym))
  +         ;; assumes (car retlist) is a value indicating progress...
  +         `(when (and ,(car retlist) (> ,(car retlist) ,(car bestretlist)))
  +            (setf (values ,bestretlist) (values ,retlist)))
            last))
         (pushback
  -       `(when ,bestendsym
  -          (values ,bestendsym ,bestvalsym))
  +       `(when ,(car bestretlist)
  +          (values ,@bestretlist))
          last)
         `(block ,blocksym ,inner))))
   
  
positive.code:                (string= prefix string :start2 start :end2 stop))
        (values stop prefix))))
  
  (defmethod cpf ((form string) context env)
    (declare (ignore env))
    (values
     (typecase context
       (string-context
        (with-slots (string start end) context
          `(starts-with ,string ,start ,end ,form)))
       (array-context
        (with-slots (array start) context
          `(when (string= (aref ,array ,start) ,form)
             (values ,form (`+ ,start))))))
     t))
  
  (defmethod cpf ((form character) context env)
    (declare (ignore env))
    (values
     (with-slots (string start end) context
  
negative.code:             ;; what to do here should depend on the context...
              (if (eql form t)
                  ;; special-case: t always matches without consuming input
                  (trivial-match context)
                  (error "do not know how to expand symbol ~A" form)))))))
  
  (defmethod cpf ((form null) context env)
  