anchor.diff:      (push-binding parser 
                     (lambda (token)
                       (and (indentation-p token) (= (spaces token) 0)))
  -                  (lambda (parser token)
  +                  (lambda (token)
                       (declare (ignore token))
                       (pop-bindings parser frame-marker)
                       (close-element parser subdocument)))))
  
positive.code:     (push-binding parser 
                    (lambda (token)
                      (and (indentation-p token) (> (spaces token) indentation)))
                    (lambda (parser token)
                      (setf current-indentation (spaces token))
                      (loop repeat (- (spaces token) indentation) do (add-text parser #\Space))))
  
      (push-binding parser #'characterp #'add-text)
      (push-binding parser :blank (lambda (parser token)
                                    (declare (ignore token))
                                    (add-text parser #\Newline)
                                    (add-text parser #\Newline)))
  
      (push-binding parser #\Newline (lambda (parser token)
                                       (add-text parser #\Newline)
                                       (loop repeat (- current-indentation indentation) do (add-text parser #\Space))))
      ))
      
  
  (defun make-header-handler ()
    (let ((level 1))
      (lambda (parser token)
        (declare (ignore token))
        (let ((frame-marker (open-frame parser)))
          (push-binding parser t #'illegal-token)
          (push-binding parser #\* (lambda (parser token) (declare (ignore parser token)) (incf level)))
          (push-binding parser #\Space (lambda (parser token)
                                         (declare (ignore token))
                                         (pop-bindings parser frame-marker)
                                         (open-paragraph parser (format nil "h~d" level))))))))
  
  (defun slash-handler (parser token)
    (declare (ignore token))
    (let ((frame-marker (open-frame parser)))
      (push-binding parser "\\{}*[]" (lambda (parser token)
                                       (pop-bindings parser frame-marker)
                                       (add-text parser token)))
      (push-binding parser #'tag-name-char-p 
                    (let ((name (make-text-buffer)))
                      (lambda (parser token)
                        (push-binding parser #\{
                                      (lambda (parser token)
                                        (declare (ignore token))
                                        (unless (plusp (length name))
                                          (error "Empty names not allowed."))
                                        (pop-bindings parser frame-marker)
                                        (open-block parser name)))
                        (append-text name token))))))
        
  
  
  
negative.code: 
  (defun indentation-p (x) (typep x 'indentation))
  
  (defmethod print-object ((object element) stream)
    (print-unreadable-object (object stream)
      (format stream "tag: ~a" (tag object))))
  