anchor.diff:                                (if ok
                                     (values t res s pos)
                                     (values nil nil state pos)))
  -                            (value nil nil state pos)))
  +                            (values nil nil state pos)))
                         (values nil nil state pos))))
                 text state position))
   
  
positive.code:       (compile-wrapped-form
         #'or-wrapper
         (first body)
         txt st pos s p names
         (compile-or (rest body) txt s p names)))))
  
  (defun or-wrapper (expr ok result s p continuation failure)
    `(multiple-value-bind (,ok ,result ,s ,p) ,expr
       (if ,ok
           (value t ,result ,s ,p)
           ,(or continuation failure))))
  
  (defun compile-wrapped-form (wrapper form text orig-state orig-position s p names continuation)
    (with-gensyms (ok)
      (let ((failure `(values nil nil ,orig-state ,orig-position)))
        (labels ((wrap (expr result)
                   (funcall wrapper expr ok result s p continuation failure))
                 (comp (form result)
                   (wrap
                    (compile-parser-function-invocation
                     (rewrite-form form names) names text orig-state orig-position)
                    result)))
            (cond
              ((parser-function-invocation-p form names)  (comp form (gensym "R")))
              ((binding-form-p form) (comp (cadr form) (caddr form)))
              ((stringp form) (wrap (compile-string form text s p) (gensym "R")))
              (t form))))))
  
  (defun compile-expression (exp names)
    (with-gensyms (text state position)
      (cond
        ((parser-function-invocation-p exp names)
         (compile-parser-function-expression (rewrite-form exp names) names))
        ((and (consp exp) (eql (car exp) 'progn))
         `(lambda (,text ,state ,position)
            ,(compile-progn (rest exp) text state position names)))
        ((and (consp exp) (eql (car exp) 'or))
         `(lambda (,text ,state ,position)
            ,(compile-or (rest exp) text state position names)))
        ((stringp exp) (thunk (compile-string exp text state position) text state position))
        (t exp))))
  
  (defun thunk (exp text state position)
    `(lambda (,text ,state ,position) ,exp))
  
  (defun compile-string (str text state position)
    `(matching ,str ,(length str) ,text ,state ,position))
  
negative.code:          ,(or continuation `(values t ,result ,s ,p))
           ,failure)))
  
  (defun compile-or (body txt st pos names result)
    "Compile the forms in an OR so that the OR matches if any of the
  elements matches, returning the result from the first match."
    (unless (null body)
  