anchor.diff:            (cond
               ((parser-function-invocation-p form names)  (comp form (gensym "R")))
               ((binding-form-p form) (comp (rewrite-form (cadr form) names) (caddr form)))
  +            ((stringp form)
  +             (with-gensyms (r)
  +               `(multiple-value-bind (,ok ,r ,s ,p) ,(compile-string form text s p)
  +                  (if ,ok
  +                      ,(or continuation `(values t ,r ,s ,p))
  +                      ,failure))))
               (t form))))))
   
   (defun compile-or (body txt st pos names)
  
positive.code:       `(,name ,@(mapcar #'comp args) ,txt ,s ,p))))
  
  (defun rewrite-form (form names)
    (cond
      ((parser-function-symbol-invocation-p form names) (list form))
      (t form)))
  
  (defun parser-function-symbol-invocation-p (form names)
    (and (symbolp form) (grammar-p form names)))
  
  (defun parser-function-invocation-p (form names)
    (and (consp form) (symbolp (car form)) (grammar-p (car form) names)))
  
  (defun binding-form-p (form)
    (and (consp form) (eql (car form) '->)))
  
  
  
  (defun uniq-names (form)
    (cond
      ((consp form)
       (sort (delete-duplicates
              (let ((s (car form))
                    (rest (mapcan #'uniq-names (remove-if (complement #'consp) (cdr form)))))
                (if (and (symbolp s) (not (keywordp s)))
                    (cons (car s) rest)
                    rest)))
             #'string<))
      (t nil)))
  
  
  (defun call-parser (p text state position)
    (funcall p text state position))
  
  
  (defmacro defparserfun (name (&rest args) &body body)
  
negative.code: (defparserfun not-followed-by (p text state position)
    "Match only if not followed by P."
    (multiple-value-bind (ok r s pos)
        (funcall p text state position)
      (declare (ignore r s pos))
      (values (not ok) text state position)))
  
  (defparserfun optional (p text state position)
    "Match P if we can. Doesn't return anything. Only fails if P
  consumes input before failing."
    (multiple-value-bind (ok r s pos) (funcall p text state position)
      (declare (ignore ok r))
      (values (= pos position) t nil s pos)))
  
  