anchor.diff:              )
   
       let renderApiDoc (writer:TextWriter) doc headline = 
  -        doc.Summary >>= processInlines writer 
  +        doc.Summary >>= renderInlines writer 
   
  -        doc.Params >>= processParameters writer headline
  -        doc.Returns >>= processReturns writer headline
  -        doc.Exceptions >>= processExceptions writer headline
  -        doc.Remarks >>= processRemarks writer headline
  -        doc.Example >>= processExample writer headline
  -        doc.Permissions >>= processPermissions writer headline
  +        let renderSection renderItems headlineText items =
  +            headline headlineText
  +            items |> renderItems writer 
   
  -        doc |> processSeeAlso writer headline
  +        doc.Params >>= renderSection renderCRefDescriptions "Parameters"
  +        doc.Returns >>= renderSection renderInlines "Return value"
  +        doc.Exceptions >>= renderSection renderCRefDescriptions "Exceptions"
  +        doc.Remarks >>= renderSection renderInlines "Remarks"
  +        doc.Example >>= renderSection renderInlines "Example"
  +        doc.Permissions >>= renderSection renderCRefDescriptions "Permissions"
  +
  +        doc |> renderSeeAlso writer headline
                     
       let renderMembersOfKind (writer:TextWriter) (headline : string) level members = 
           writer.WriteLine()
  
positive.code: 
      let (>>=) m f = ifNotEmpty(m,f)
  
      let processText txt =
          // TODO: insert NewLine after e.g. 100 characters
          normalizeSpace txt  
  
      let processSee (cref:string) =
          sprintf "*See:* %s" (cref.Trim())
  
      let processParameterRef (name:string) =
          sprintf "*%s*" name
  
      let processTypeParameterRef (name:string) =
          sprintf "_%s_" name
  
      let processC (str:string) =
          sprintf "`%s`" (str.Trim())
  
      let processCode (str:string) =
          sprintf "%s```%s%s%s```%s" nl nl (str.Trim()) nl nl
  
      let processPara (str:string) =
          sprintf "%s%s%s" nl (processText str) nl
  
      let processInline inl =
          match inl with
          | Text x -> processText x
          | C x -> processC x  
          | Code x -> processCode x  
          | Para x -> processPara x  
          | ParamRef x -> let (CRef cref) = x  
                          processParameterRef cref
          | TypeParamRef x -> let (CRef cref) = x  
                              processTypeParameterRef cref
          | See x -> let (CRef cref) = x  
                     processSee cref
          | SeeAlso x -> String.Empty // ignore here - will be processed later
  
      let processInlines (writer:TextWriter) (items:Inline list) =
          writer.WriteLine ()
  
          items
          |> Seq.map processInline
          |> Seq.iter(fun x -> x.TrimEnd() >>= writer.WriteLine)
      
      let renderHeadline (writer:TextWriter) level headline =
          writer.WriteLine ()
  
  
negative.code:             writer.WriteLine x.description
          )
  
      let renderSeeAlso (writer:TextWriter) headline (doc:ApiDoc) =
          let seeAlso = [ doc.Summary
                          doc.Remarks
                          doc.Returns
  