anchor.diff:  
   (defun compile-match (parser input)
     `(funcall ,parser ,input))
  +
  +(defun compile-if (body input names state)
  +  (flet ((comp (x) (new-compile-form x input names state)))
  +    (destructuring-bind (test then else) body
  +      `(if ,test ,(comp then) ,(comp else)))))
  +
  +(defun compile-tracer (form input names state)
  +  (new-compile-form `(tracer ,(cadr form) ',(cadr form)) input names state))
   
   (defun compile-parser-call (exp names input state)
     (destructuring-bind (name &rest args) (rewrite-form exp names)
  
positive.code:                   (return-from ,and nil)))))))))
  
  (defun new-rewrite-and-body (body)
    (let (variables result)
      (flet ((rewrite (x)
               (cond
                 ((form-p '-> x)
                  (destructuring-bind (-> expr var) x
                    (declare (ignore ->))
                    (push var variables)
                    `(-> ,expr ,var)))
                 ((form-p '=> x)
                  (if result (error "Two => forms in body: ~s" body))
                  (destructuring-bind (=> expr &optional var) x
                    (declare (ignore =>))
                    (setq result (or var '_))
                    (push '_ variables)
                    `(-> ,expr _)))
                 (t x))))
        (let ((new-body (mapcar #'rewrite body)))
          (values
           (if result `(,@new-body ,result) body)
           variables)))))
  
  (defun new-compile-or (body input names state)
    (let ((state-bindings (save-state-bindings state)))
      (with-gensyms (ok result next-input or good)
        (flet ((comp (x)
                 `(if (setf (values ,ok ,result ,next-input) ,(new-compile-form x input names state))
                      (go ,good)
                      (progn ,@(restore-state state-bindings)))))
          `(block ,or
             (let (,@state-bindings ,ok ,result ,next-input)
               (tagbody
                  ,@(mapcar #'comp body)
                  (return-from ,or nil)
                ,good
                  (return-from ,or (values ,ok ,result ,next-input)))))))))
  
  (defun new-compile-form (form input names state)
    (flet ((self (exp) (new-compile-form exp input names state)))
      (cond
        ((parser-function-invocation-p form names)
         (compile-parser-call form names input state))
  
        ((form-p 'and form)
         (new-compile-and (rest form) input names state))
  
        ((form-p 'or form)
         (new-compile-or (rest form) input names state))
  
        ((form-p 'if form)
         (destructuring-bind (test then else) (cdr form)
           `(if ,test ,(self then) ,(self else))))
  
        ((form-p 'match form)
         (compile-match (cadr form) input))
  
        ((form-p 'trace form)
         (self `(tracer ,(cadr form) ',(cadr form))))
  
        ((stringp form)
         (compile-string form input))
  
        ((characterp form)
         (compile-character form input))
  
        (t `(good ,form ,input)))))
  
  ;;; Common compiler functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
  
negative.code: parser function."
    (or (not (null (member name names))) (get name 'parser-function)))
  
  (defun new-compile-production (p names state)
    "Compile a production into a function definition appropriate for a LABELS
  binding."
    (with-gensyms (input)
      (destructuring-bind ((name &rest args) &rest body) p
        `(,name (,@args ,input) ,(new-compile-and body input names state)))))
  
  (defun new-compile-and (body input names state)
    "Compile the forms in an AND so that the AND matches if each of the elements
  matches in sequence."
    (with-gensyms (ok result next-input and fail)
      (labels ((wrap (x var)
                 `(or
  