anchor.diff:                      this.RenderElementWithSelfClosingTag element.Name element.Attributes
                   | contents ->
                       this.RenderElementWithContent element.Name element.Attributes contents
  -
  -//                for a in element.Attributes do
  -//                    writer.AddAttribute(a.Name, a.Value, true)
  -//                writer.RenderBeginTag element.Name
  -//                let mutable isEmpty = true
  -//                for content in element.Contents do
  -//                    this.Write content
  -//                    isEmpty <- false
  -//                writer.RenderEndTag()
  -                
               | TextContent text ->
                   writer.WriteEncodedText text
               | VerbatimContent text ->
  
positive.code:                 writer.WriteAttribute(a.Name, a.Value)
              writer.Write(HtmlTextWriter.SelfClosingTagEnd)
  
          // Renders tag with content. 
          // E.g. <div class="c">...</div>
          member private this.RenderElementWithContent    name
                                              (attrs: list<Attribute<'T>>) 
                                              (contents : list<Element<'T>>) =
              writer.WriteBeginTag(name)
              for a in attrs do
                  writer.WriteAttribute(a.Name, a.Value)
              writer.Write(HtmlTextWriter.TagRightChar)
          
              // Render contents
              for content in contents do
                  this.Write content
  
negative.code:     type Document<'T> =
          {
              Annotations : Map<Id,'T>
              Body : Element<unit>
          }
  
      /// Resolves the annotations by giving them HTML identifiers. The function
      /// `isUsed` tests if a given identifier should not be used by the document.
      let Resolve (isUsed: Id -> bool) (document: TagContent<'T>) =
          let ids = Dictionary<Id,unit>()
          let annotations = Dictionary<Id,'T>()
          let showId (k: int) = String.Format("id{0:x}", k)
          let newId () =
              let mutable k  = ids.Count
              let mutable id = showId k
              while ids.ContainsKey id || isUsed id do
                  k <- k + 1
                  id <- showId k
              ids.[id] <- ()
              id
          let rec transform (element: TagContent<'T>) =
              let mutable attributes = []
              let mutable id = None
              for x in element.Attributes do
                  match x.Name.ToLower() with
                  | "id" -> ids.[x.Value] <- (); id <- Some x.Value
                  | _ -> ()
                  let attribute = { Name = x.Name; Value = x.Value }
                  attributes <- attribute :: attributes
              match element.Annotation with
              | None -> ()
              | Some a ->
                  let id =
                      match id with
                      | Some id   -> id
  