anchor.diff:  ///
   /// **Output**
   ///
  -/// A Giraffe `HttpHandler` function which can be composed into a bigger web application.
  -///
  +/// A Giraffe <see cref="HttpHandler" /> function which can be composed into a bigger web application.
  +
  +/// <summary>
  +/// Writes a byte array to the body of the HTTP response and sets the HTTP Content-Length header accordingly.
  +/// </summary>
  +/// <param name="bytes">The byte array to be send back to the client.</param>
  +/// <param name="ctx"></param>
  +/// <returns>A Giraffe <see cref="HttpHandler" /> function which can be composed into a bigger web application.</returns>
   let setBody (bytes : byte array) : HttpHandler =
       fun (_ : HttpFunc) (ctx : HttpContext) ->
           ctx.WriteBytesAsync bytes
   
  -/// **Description**
  -///
  -/// Writes an UTF-8 encoded string to the body of the HTTP response and sets the HTTP `Content-Length` header accordingly.
  -///
  -/// **Parameters**
  -///
  -/// `str`: The string value to be send back to the client.
  -///
  -/// **Output**
  -///
  -/// A Giraffe `HttpHandler` function which can be composed into a bigger web application.
  -///
  +/// <summary>
  +/// Writes an UTF-8 encoded string to the body of the HTTP response and sets the HTTP Content-Length header accordingly.
  +/// </summary>
  +/// <param name="str">The string value to be send back to the client.</param>
  +/// <returns>A Giraffe <see cref="HttpHandler" /> function which can be composed into a bigger web application.</returns>
   let setBodyFromString (str : string) : HttpHandler =
       let bytes = Encoding.UTF8.GetBytes str
       fun (_ : HttpFunc) (ctx : HttpContext) ->
           ctx.WriteBytesAsync bytes
   
  -/// **Description**
  -///
  -/// Writes an UTF-8 encoded string to the body of the HTTP response and sets the HTTP `Content-Length` header accordingly, as well as the `Content-Type` header to `text/plain`.
  -///
  -/// **Parameters**
  -///
  -/// `str`: The string value to be send back to the client.
  -///
  -/// **Output**
  -///
  -/// A Giraffe `HttpHandler` function which can be composed into a bigger web application.
  -///
  +/// <summary>
  +/// Writes an UTF-8 encoded string to the body of the HTTP response and sets the HTTP Content-Length header accordingly, as well as the Content-Type header to text/plain.
  +/// </summary>
  +/// <param name="str">The string value to be send back to the client.</param>
  +/// <returns>A Giraffe <see cref="HttpHandler" /> function which can be composed into a bigger web application.</returns>
   let text (str : string) : HttpHandler =
       let bytes = Encoding.UTF8.GetBytes str
       fun (_ : HttpFunc) (ctx : HttpContext) ->
           ctx.SetContentType "text/plain; charset=utf-8"
           ctx.WriteBytesAsync bytes
   
  -/// **Description**
  -///
  +/// <summary>
   /// Serializes an object to JSON and writes the output to the body of the HTTP response.
  -///
  -/// It also sets the HTTP `Content-Type` header to `application/json` and sets the `Content-Length` header accordingly.
  -///
  -/// The JSON serializer can be configured in the ASP.NET Core startup code by registering a custom class of type `IJsonSerializer`.
  -///
  -/// **Parameters**
  -///
  -/// `dataObj`: The object to be send back to the client.
  -///
  -/// **Output**
  -///
  -/// A Giraffe `HttpHandler` function which can be composed into a bigger web application.
  -///
  +/// It also sets the HTTP Content-Type header to application/json and sets the Content-Length header accordingly.
  +/// The JSON serializer can be configured in the ASP.NET Core startup code by registering a custom class of type <see cref="IJsonSerializer"/>.
  +/// </summary>
  +/// <param name="dataObj">The object to be send back to the client.</param>
  +/// <param name="ctx"></param>
  +/// <typeparam name="'T"></typeparam>
  +/// <returns>A Giraffe <see cref="HttpHandler" /> function which can be composed into a bigger web application.</returns>
   let json<'T> (dataObj : 'T) : HttpHandler =
       fun (_ : HttpFunc) (ctx : HttpContext) ->
           ctx.WriteJsonAsync dataObj
   
  -/// **Description**
  -///
  +/// <summary>
   /// Serializes an object to JSON and writes the output to the body of the HTTP response using chunked transfer encoding.
  -///
  -/// It also sets the HTTP `Content-Type` header to `application/json` and sets the `Transfer-Encoding` header to `chunked`.
  -///
  -/// The JSON serializer can be configured in the ASP.NET Core startup code by registering a custom class of type `IJsonSerializer`.
  -///
  -/// **Parameters**
  -///
  -/// `dataObj`: The object to be send back to the client.
  -///
  -/// **Output**
  -///
  -/// A Giraffe `HttpHandler` function which can be composed into a bigger web application.
  -///
  +/// It also sets the HTTP Content-Type header to application/json and sets the Transfer-Encoding header to chunked.
  +/// The JSON serializer can be configured in the ASP.NET Core startup code by registering a custom class of type <see cref="IJsonSerializer"/>.
  +/// </summary>
  +/// <param name="dataObj">The object to be send back to the client.</param>
  +/// <param name="ctx"></param>
  +/// <returns>A Giraffe <see cref="HttpHandler" /> function which can be composed into a bigger web application.</returns>
   let jsonChunked<'T> (dataObj : 'T) : HttpHandler =
       fun (_ : HttpFunc) (ctx : HttpContext) ->
           ctx.WriteJsonChunkedAsync dataObj
   
  -/// **Description**
  -///
  +/// <summary>
   /// Serializes an object to XML and writes the output to the body of the HTTP response.
  -///
  -/// It also sets the HTTP `Content-Type` header to `application/xml` and sets the `Content-Length` header accordingly.
  -///
  -/// The JSON serializer can be configured in the ASP.NET Core startup code by registering a custom class of type `IXmlSerializer`.
  -///
  -/// **Parameters**
  -///
  -/// `dataObj`: The object to be send back to the client.
  -///
  -/// **Output**
  -///
  -/// A Giraffe `HttpHandler` function which can be composed into a bigger web application.
  -///
  +/// It also sets the HTTP Content-Type header to application/xml and sets the Content-Length header accordingly.
  +/// The JSON serializer can be configured in the ASP.NET Core startup code by registering a custom class of type <see cref="IXmlSerializer"/>.
  +/// </summary>
  +/// <param name="dataObj">The object to be send back to the client.</param>
  +/// <param name="ctx"></param>
  +/// <returns>A Giraffe <see cref="HttpHandler" /> function which can be composed into a bigger web application.</returns>
   let xml (dataObj : obj) : HttpHandler =
       fun (_ : HttpFunc) (ctx : HttpContext) ->
           ctx.WriteXmlAsync dataObj
   
  -/// **Description**
  -///
  +/// <summary>
   /// Reads a HTML file from disk and writes its contents to the body of the HTTP response.
  -///
  -/// It also sets the HTTP header `Content-Type` to `text/html` and sets the `Content-Length` header accordingly.
  -///
  -/// **Parameters**
  -///
  -/// `filePath`: A relative or absolute file path to the HTML file.
  -///
  -/// **Output**
  -///
  -/// A Giraffe `HttpHandler` function which can be composed into a bigger web application.
  -///
  +/// It also sets the HTTP header Content-Type to text/html and sets the Content-Length header accordingly.
  +/// </summary>
  +/// <param name="filePath">A relative or absolute file path to the HTML file.</param>
  +/// <param name="ctx"></param>
  +/// <returns>A Giraffe <see cref="HttpHandler" /> function which can be composed into a bigger web application.</returns>
   let htmlFile (filePath : string) : HttpHandler =
       fun (_ : HttpFunc) (ctx : HttpContext) ->
           ctx.WriteHtmlFileAsync filePath
   
  -/// **Description**
  -///
  +/// <summary>
   /// Writes a HTML string to the body of the HTTP response.
  -///
  -/// It also sets the HTTP header `Content-Type` to `text/html` and sets the `Content-Length` header accordingly.
  -///
  -/// **Parameters**
  -///
  -/// `html`: The HTML string to be send back to the client.
  -///
  -/// **Output**
  -///
  -/// A Giraffe `HttpHandler` function which can be composed into a bigger web application.
  -///
  +/// It also sets the HTTP header Content-Type to text/html and sets the Content-Length header accordingly.
  +/// </summary>
  +/// <param name="html">The HTML string to be send back to the client.</param>
  +/// <returns>A Giraffe <see cref="HttpHandler" /> function which can be composed into a bigger web application.</returns>
   let htmlString (html : string) : HttpHandler =
       let bytes = Encoding.UTF8.GetBytes html
       fun (_ : HttpFunc) (ctx : HttpContext) ->
  
positive.code:             return Some this
          }
  
      /// **Description**
      ///
      /// Writes an UTF-8 encoded string to the body of the HTTP response and sets the HTTP `Content-Length` header accordingly.
      ///
      /// **Parameters**
      ///
      /// `str`: The string value to be send back to the client.
      ///
      /// **Output**
      ///
      /// Task of `Some HttpContext` after writing to the body of the response.
      ///
      member this.WriteStringAsync (str : string) =
          this.WriteBytesAsync(Encoding.UTF8.GetBytes str)
  
      /// **Description**
      ///
      /// Writes an UTF-8 encoded string to the body of the HTTP response and sets the HTTP `Content-Length` header accordingly, as well as the `Content-Type` header to `text/plain`.
      ///
      /// **Parameters**
      ///
      /// `str`: The string value to be send back to the client.
      ///
      /// **Output**
      ///
      /// Task of `Some HttpContext` after writing to the body of the response.
      ///
      member this.WriteTextAsync (str : string) =
          this.SetContentType "text/plain; charset=utf-8"
          this.WriteStringAsync str
  
      /// **Description**
      ///
      /// Serializes an object to JSON and writes the output to the body of the HTTP response.
      ///
      /// It also sets the HTTP `Content-Type` header to `application/json` and sets the `Content-Length` header accordingly.
      ///
      /// The JSON serializer can be configured in the ASP.NET Core startup code by registering a custom class of type `IJsonSerializer`.
      ///
      /// **Parameters**
      ///
      /// `dataObj`: The object to be send back to the client.
      ///
      /// **Output**
      ///
      /// Task of `Some HttpContext` after writing to the body of the response.
      ///
      member this.WriteJsonAsync<'T> (dataObj : 'T) =
          this.SetContentType "application/json; charset=utf-8"
          let serializer = this.GetJsonSerializer()
          serializer.SerializeToBytes dataObj
          |> this.WriteBytesAsync
  
      /// **Description**
      ///
      /// Serializes an object to JSON and writes the output to the body of the HTTP response using chunked transfer encoding.
      ///
      /// It also sets the HTTP `Content-Type` header to `application/json` and sets the `Transfer-Encoding` header to `chunked`.
      ///
      /// The JSON serializer can be configured in the ASP.NET Core startup code by registering a custom class of type `IJsonSerializer`.
      ///
      /// **Parameters**
      ///
      /// `dataObj`: The object to be send back to the client.
      ///
      /// **Output**
      ///
      /// Task of `Some HttpContext` after writing to the body of the response.
      ///
      member this.WriteJsonChunkedAsync<'T> (dataObj : 'T) =
          task {
              // Don't set the Transfer-Encoding to chunked manually.  If we do, we'll have to do the chunking manually
  
negative.code:                 do! serializer.SerializeToStreamAsync dataObj this.Response.Body
              return Some this
          }
      
      /// <summary>
      /// Serializes an object to XML and writes the output to the body of the HTTP response.
      /// It also sets the HTTP Content-Type header to application/xml and sets the Content-Length header accordingly.
      /// The JSON serializer can be configured in the ASP.NET Core startup code by registering a custom class of type <see cref="IXmlSerializer"/>.
      /// </summary>
      /// <param name="dataObj">The object to be send back to the client.</param>
      /// <returns>Task of Some HttpContext after writing to the body of the response.</returns>
      member this.WriteXmlAsync (dataObj : obj) =
          this.SetContentType "application/xml; charset=utf-8"
          let serializer = this.GetXmlSerializer()
          serializer.Serialize dataObj
          |> this.WriteBytesAsync
  
      /// <summary>
      /// Reads a HTML file from disk and writes its contents to the body of the HTTP response.
      /// It also sets the HTTP header Content-Type to text/html and sets the Content-Length header accordingly.
      /// </summary>
      /// <param name="filePath">A relative or absolute file path to the HTML file.</param>
      /// <returns>Task of Some HttpContext after writing to the body of the response.</returns>
      member this.WriteHtmlFileAsync (filePath : string) =
          task {
              let filePath =
  