anchor.diff:  (defun 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
  -                 (setf (values ,ok ,var ,next-input) ,(compile-form x next-input names state))
  -                 (go ,fail)))
  -             (comp (x)
  -               (cond
  -                 ((form-p '-> x) (wrap (second x) (third x)))
  -                 (t (wrap x result)))))
  -      (let ((state-bindings (save-state-bindings state)))
  -        (multiple-value-bind (body variables) (rewrite-and-body body)
  -          `(block ,and
  -             (let (,@state-bindings ,@variables ,ok ,result (,next-input ,input))
  -               (tagbody
  -                  ,@(mapcar #'comp body)
  -                  (return-from ,and (values ,ok ,result ,next-input))
  -                ,fail
  -                  ,@(restore-state state-bindings)
  -                  (return-from ,and nil)))))))))
  -
  -(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)
       (labels ((inner (exprs)
                  (if exprs
                      (multiple-value-bind (form var) (form-and-variable (car exprs))
                        `(multiple-value-bind (,ok ,(or var result) ,input)
  -                          ,(new-compile-form form input names state)
  +                          ,(compile-form form input names state)
                           ,@(when (not var) `((declare (ignorable ,result))))
                           (when ,ok ,(inner (rest exprs)))))
                      `(values ,ok ,result ,input))))
  
positive.code:            (setf (get ',name 'parser-function) t))
           (defun ,name (,@args ,input)
             ,@(when docstring (list docstring))
             ,(new-compile-and body input (list name) nil))))))
  
  ;;; Compiler ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
  
negative.code:         (values (if result `(,@new-body ,result) body) variables)))))
  
  (defun compile-or (body input names state)
    (with-gensyms (ok result next-input)
      (if body
          `(multiple-value-bind (,ok ,result ,next-input)
               ,(compile-form (car body) input names state)
             (if ,ok
                 (values ,ok ,result ,next-input)
                 ,(compile-or (rest body) input names state)))
          nil)))
  
  (defun compile-if (body comp)
    (destructuring-bind (test then else) body
  