anchor.diff:              ((parser-function-invocation-p form names)
                (wrap (compile-parser-call form names text p-in state)))
   
  +            ((form-p 'progn form)
  +             (wrap (compile-progn (rest form) text p-in names r state)))
  +
  +            ((form-p 'or form)
  +             (wrap (compile-or (rest form) text p-in names r state)))
  +
  +            ((form-p 'if form)
  +             (destructuring-bind (test then else) (cdr form)
  +               (wrap `(if ,test ,(self then) ,(self else)))))
  +
               ((form-p '-> form)
                (destructuring-bind (expr var) (cdr form)
                  (funcall wrapper (self expr) ok var p continuation failure state)))
   
  -            ((form-p 'progn form)
  -             (wrap (compile-progn (rest form) text p-in names r state)))
  -
  -            ((form-p 'or form)
  -             (wrap (compile-or (rest form) text p-in names r state)))
  -
               ((form-p 'match form)
                (wrap (compile-match (cadr form) text p-in)))
   
  -            ((form-p 'if form)
  -             (destructuring-bind (test then else) (cdr form)
  -               (wrap `(if ,test ,(self then) ,(self else)))))
  -
               ((stringp form)
                (wrap (compile-string form text p-in)))
   
  
positive.code:         (bad position))))
  
  (defparserfun ! (p text position)
    (multiple-value-bind (ok r pos) (funcall p text position)
      (declare (ignore r pos))
      (if ok
          (values nil nil position)
          (values t (char text position) (1+ position)))))
  
  (defparserfun none-of (p text position)
    "P really should match a single character."
    (multiple-value-bind (ok r pos) (funcall p text position)
      (declare (ignore r pos))
      (if ok
          (values nil nil position)
          (values t (char text position) (1+ position)))))
  
  (defparserfun char-if (pred text position)
    (let ((c (char text position)))
      (if (funcall pred c)
          (good c (1+ position))
          (bad position))))
  
  
  ;;;; Tracing helpers ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
negative.code:         (t exp)))))
  
  (defun compile-string (str text position)
    `(matching-string ,str ,(length str) ,text ,position))
  
  (defun compile-character (char text position)
    `(matching-char ,char ,text ,position))
  
  (defun compile-match (parser txt p)
    `(funcall ,parser ,txt ,p))
  
  (defun compile-parser-call (exp names txt p state)
    (destructuring-bind (name &rest args) (rewrite-form exp names)
      (flet ((comp (x) (compile-parser-argument x names state)))
        `(,name ,@(mapcar #'comp args) ,txt ,p))))
  
  (defun rewrite-form (form names)
    "Rewrite bare symbols naming parser productions or parser functions
  into cannonical list from."
    (cond
      ((and (symbolp form) (grammar-p form names)) (list form))
      (t form)))
  
  (defun parser-function-invocation-p (form names)
    (or
     (and (symbolp form) (grammar-p form names))
     (and (consp form) (symbolp (car form)) (grammar-p (car form) names))))
  
  (defun form-p (what form)
    (and (consp form) (eql (car form) what)))
  
  
  ;;; Runtime functions used by compiled parsers ;;;;;;;;;;;;;;;;;;;;;;;
  
  (defun good (result position)
    "Return values indicating a parser succeeded."
    (values t result position))
  
  (defun bad (position)
    "Return values indicating a parser failed."
    (values nil nil position))
  
  (defun matching-string (s len text position)
    (let* ((end (+ len position))
           (ok (if (<= end (length text)) (string= s text :start2 position :end2 end))))
      (if ok
  