anchor.diff:          ((stringp s) s)
           (t (format nil "~A" s))))
   
  +(assert (equal (to-string nil) ""))
  +(assert (equal (to-string :foo) "foo"))
  +(assert (equal (to-string "hello") "hello"))
  +(assert (equal (to-string "Hello, world!") "Hello, world!"))
  +
   (defun tag-equal? (a b)
     "This is a comparator for two tags."
  -  (string-equal (to-string a) (to-string b)))
  +  (string= (to-string a) (to-string b)))
  +
  +(assert (tag-equal? :foo :foo))
  +(assert (not (tag-equal? :foo :bar)))
  +(assert (tag-equal? :foo "foo"))
  +(assert (not (tag-equal? "foo" "Foo")))
   
   (defun multiline-tag? (tag)
     "This tests to see if this tag should be formatted over
  -  multiple lines in the actual HTML output."
  +multiple lines in the actual HTML output."
     (member tag '(html head script body form p div ul ol dl table)
             :test #'tag-equal?))
   
   (defun newline-tag? (tag)
     "This tests to see if this tag should be on a line by itself in the actual
  -  HTML output."
  +HTML output."
     (or (multiline-tag? tag)
         (member tag '(title h1 h2 h3 h4 h5 h6 br hr li dd dt input tr td)
                 :test #'tag-equal?)))
   
   (defun tag-must-close? (tag)
     "This predicate indicates if the tag passed in must have a closing tag
  -  instead of just self-closing.  That is, you MUST do <tag></tag> even if
  -  there isn't any body contained in the tag, and you can't just do <tag/>.
  -  As far as I know only the 'link' and 'script' tags are this stupid."
  +instead of just self-closing.  That is, you MUST do <tag></tag> even if
  +there isn't any body contained in the tag, and you can't just do <tag/>.
  +As far as I know only the 'link' and 'script' tags are this stupid."
     (member tag '(link script) :test #'tag-equal?))
   
   (defun html (tag &rest rest)
  -  ;; TODO?: (html :tag . fred # bob rest)
  -  ;; should do . --> class
  -  ;;           # --> id
  -  ;; Both should be optional, and order shouldn't matter, but both before 
  -  ;; any of the rest is done.  This is loosly based on HAML in Ruby.  Should
  -  ;; we do this?
     (let ((args nil)
           (args-count 0)
           (body nil)
  
positive.code:                                  (to-string (second arg)))))
                    (setf arg (to-string arg))))
                args)
        (when (or (multiline-tag? tag)
                  (newline-tag? tag))
          (html-format "~%"))
        (html-format "<~A" tag)
        (when args
  
negative.code:                                   (second v)
                                    v))
                            (checked? (and checked-value
                                           (string= value checked-value))))
                       (radio-input name value :text text :checked checked?)))
                   values)))
  
  