anchor.diff:                                       (string-right-trim " " child)
                                        child)))))
   
  -(defmethod to-sexp ((string string)) string)
   
   (defun make-element (parent tag &rest format-args)
     (let ((e (make-instance 'element :tag (intern (string-upcase (apply #'format nil tag format-args)) :keyword))))
  
positive.code: 
  (defun indentation-p (x) (typep x 'indentation))
  
  (defgeneric to-sexp (thing))
  
  (defmethod print-object ((object element) stream)
    (print-unreadable-object (object stream)
      (format stream "tag: ~a" (tag object))))
  
negative.code:     (push-binding parser 
                    (lambda (token)
                      (and (indentation-p token) (> (spaces token) indentation)))
                    (lambda (token)
                      (setf current-indentation (spaces token))
                      (loop repeat (- (spaces token) indentation) do (add-text parser #\Space))))
  
      (push-binding parser #'characterp (lambda (token) (add-text parser token)))
      (push-binding parser :blank (lambda (token)
                                    (declare (ignore token))
                                    (add-text parser #\Newline)
                                    (add-text parser #\Newline)))
  
      (push-binding parser #\Newline (lambda (token)
                                       (declare (ignore token))
                                       (add-text parser #\Newline)
                                       (loop repeat (- current-indentation indentation) do (add-text parser #\Space))))
      ))
      
  
  (defun make-header-handler (parser)
    (let ((level 1))
      (lambda (token)
        (declare (ignore token))
        (let ((frame-marker (open-frame parser)))
          (push-binding parser t (lambda (token) (illegal-token token)))
          (push-binding parser #\* (lambda (token) (declare (ignore token)) (incf level)))
          (push-binding parser #\Space (lambda (token)
                                         (declare (ignore token))
                                         (pop-bindings parser frame-marker)
                                         (open-paragraph parser (format nil "h~d" level))))))))
  
  (defun make-slash-handler (parser)
    (lambda (token)
      (declare (ignore token))
      (let ((frame-marker (open-frame parser)))
        (push-binding parser "\\{}*[]" (lambda (token)
                                         (pop-bindings parser frame-marker)
                                         (add-text parser token)))
        (push-binding parser #'tag-name-char-p 
                      (let ((name (make-text-buffer)))
                        (lambda (token)
                          (push-binding parser #\{
                                        (lambda (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)))))))
        
  
  
  