anchor.diff:  (defun create-bindings-returner ()
     "Return a function that does nothing but return its BINDINGS,
   effectively ending matching."
  -  (lambda (source bindings k)
  -    (declare (ignore source k))
  +  (lambda (source bindings)
  +    (declare (ignore source))
       (nreverse bindings)))
   
   (defmacro catching-xml-errors (&body body)
  
positive.code:       (string
         (let ((*current-element-name* operator))
           (create-element-start-matcher *current-element-name*
                                         (create-binder (rest form) k))))
        (null
         (create-element-end-matcher *current-element-name*
                                     k))
        (cons
         (create-binder operator (create-binder (rest form) k)))
        (symbol
         (create-special-processor operator form k)))))
  
  (defun xml-source (source)
    (typecase source
  
negative.code:      (xml-binding-error (c)
         (values nil c))))
  
  (defun create-sequence-binder (key forms next-fun)
    "Return a function that creates a list of sub-bindings based on a
  sub-matcher, with KEY as the key."
    (let ((binder (create-binder forms (create-bindings-returner))))
      (lambda (source bindings)
        (let ((sub-bindings '()))
          (loop
            (skip-characters source)
            (multiple-value-bind (sub-binding failure)
                (catching-xml-errors
                  (funcall binder source nil))
              (if failure
                  (return (funcall next-fun
                                   source
                                   (acons key
                                          (nreverse sub-bindings)
                                          bindings)))
                  (push sub-binding sub-bindings))))))))
  
  (defun create-alist-binder (key next-fun)
    "Return a function that returns the rest of SOURCE as an alist of
  element-name/element-content data."
    (lambda (source bindings)
      (funcall next-fun source
               (acons key (collect-rest-alist source) bindings))))
  
  (defun create-optional-binder (subforms next-fun)
    (let ((binder (create-binder subforms next-fun)))
      (lambda (source bindings)
        (skip-characters source)
        (multiple-value-bind (optional-bindings failure)
            (catching-xml-errors (funcall binder source bindings))
          (if failure
              (funcall next-fun source bindings)
              optional-bindings)))))
  
  (defun create-alternate-binder (subforms next-fun)
    (let ((binders (mapcar (lambda (form) (create-binder form next-fun))
                           subforms)))
      (lambda (source bindings)
        ;; FIXME: This xml-binding-error needs :expected and :action
        ;; ooptions. Can get actual with peeking and expected by getting
        ;; the cl:cars of subforms...maybe.
        (dolist (binder binders (error 'xml-binding-error))
          (multiple-value-bind (alt-bindings failure)
              (catching-xml-errors (funcall binder source bindings))
            (unless failure
              (return alt-bindings)))))))
  
  (defun create-sub-binder-binder (binder-name next-fun)
    (lambda (source bindings)
      (let ((binder (find-binder binder-name)))
        (let ((sub-bindings (funcall (closure binder) source)))
          (funcall next-fun source (append sub-bindings bindings))))))
  
  (defun create-special-processor (operator form next-fun)
    "Handle special pattern processing forms like BIND, SKIP-REST, SEQUENCE,
  etc."
    (ecase operator
      (include (create-sub-binder-binder (second form) next-fun))
      (alternate (create-alternate-binder (rest form) next-fun))
      (bind (create-bindings-extender (second form) next-fun))
      (optional (create-optional-binder (second form) next-fun))
      (skip-rest (create-skipper *current-element-name* next-fun))
      (sequence
       (destructuring-bind (key subforms)
           (rest form)
         (create-sequence-binder key subforms next-fun)))
      (elements-alist
       (create-alist-binder (second form) next-fun))))
  
  (defun create-binder (form &optional (next-fun (create-bindings-returner)))
    "Process FORM as an XML binder pattern and return a closure to
  process an XML source."
    (let ((operator (first form)))
  