anchor.diff:  
   (defun production (p)
     "A parser is made up of productions."
  -  (let ((name nil)
  -        (extra-args nil))
  -    (destructuring-bind (x &rest body) p
  -        (typecase x
  -          (cons
  -           (setq name (car x))
  -           (setq extra-args (cdr x)))
  -          (symbol
  -           (setq name x))
  -          (t (error "Name must be SYMBOL or LIST.")))
  -      `(:name ,name :args ,extra-args :body ,body))))
  +  (destructuring-bind ((name &rest args) &rest body) p
  +    `(:name ,name :args ,args :body ,body)))
   
   (defun grammar-p (name names)
     (or (member name names) (get name 'parser-function)))
   
  -(defun compile-progn (body txt st pos names)
  +(defun compile-progn (body txt st pos names result)
     "Compile the forms in an PROGN so that the PROGN matches if each of
   the elements matches in sequence."
     (unless (null body)
  
positive.code:          ,(or continuation `(values t ,result ,s ,p))
           ,failure)))
  
  (defun compile-or (body txt st pos names)
    "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)
  
negative.code:         (values t s state end)
          (values nil nil state position))))
  
  (defun compile-match (parser txt s p)
    `(funcall ,parser ,txt ,s ,p))
  
  (defun compile-parser-call (exp names txt s p)
    (destructuring-bind (name &rest args) (rewrite-form exp names)
      (flet ((comp (x) (compile-expression x names)))
        `(,name ,@(mapcar #'comp args) ,txt ,s ,p))))
  
  