anchor.diff:  let route
       (path     : string)
       (handler  : HttpHandler) : Endpoint =
  -    SimpleEndpoint (HttpVerb.NotSpecified, path, handler)
  +    SimpleEndpoint (HttpVerb.NotSpecified, path, handler, [])
   
   let routef
       (path         : PrintfFormat<_,_,_,_, 'T>)
  
positive.code: 
  type IEndpointRouteBuilder with
  
      member private this.MapSingleEndpoint (singleEndpoint : HttpVerb * RouteTemplate * RequestDelegate) =
          let verb, routeTemplate, requestDelegate = singleEndpoint
          match verb with
          | NotSpecified  -> this.Map(routeTemplate, requestDelegate) |> ignore
          | _             -> this.MapMethods(routeTemplate, [ verb.ToString() ], requestDelegate) |> ignore
  
      member private this.MapNestedEndpoint (nestedEndpoint : RouteTemplate * Endpoint list) =
          let subRouteTemplate, endpoints = nestedEndpoint
          let routeTemplate = sprintf "%s%s" subRouteTemplate
          endpoints
          |> List.iter (
              fun endpoint ->
                  match endpoint with
                  | SimpleEndpoint (v, t, h) ->
                      let d = RequestDelegateBuilder.createRequestDelegate h
                      this.MapSingleEndpoint(v, routeTemplate t, d)
                  | TemplateEndpoint(v, t, m, h) ->
                      let d = RequestDelegateBuilder.createTokenizedRequestDelegate m h
                      this.MapSingleEndpoint(v, routeTemplate t, d)
                  | NestedEndpoint (t, e) ->
                      this.MapNestedEndpoint(routeTemplate t, e)
          )
  
      member this.MapGiraffeEndpoints (endpoints : Endpoint list) =
  
negative.code:     let boxedHandler (o : obj) =
          let t = o :?> 'T
          routeHandler t
      TemplateEndpoint (HttpVerb.NotSpecified, template, mappings, boxedHandler, [])
  
  let subRoute
      (path      : string)
      (endpoints : Endpoint list) : Endpoint =
      NestedEndpoint (path, endpoints, [])
  
  let rec applyBefore
      (httpHandler  : HttpHandler)
      (endpoint     : Endpoint) =
      match endpoint with
      | SimpleEndpoint(v, p, h, ml)      -> SimpleEndpoint(v, p, httpHandler >=> h, ml)
      | TemplateEndpoint(v, p, m, h, ml) -> TemplateEndpoint(v, p, m, (fun (o: obj) -> httpHandler >=> h o), ml)
      | NestedEndpoint(t, lst, ml)       -> NestedEndpoint(t, List.map (applyBefore httpHandler) lst, ml)
  
  let rec applyAfter
      (httpHandler  : HttpHandler)
      (endpoint     : Endpoint) =
      match endpoint with
      | SimpleEndpoint(v, p, h, ml)      -> SimpleEndpoint(v, p, h >=> httpHandler, ml)
      | TemplateEndpoint(v, p, m, h, ml) -> TemplateEndpoint(v, p, m, (fun (o: obj) -> h o >=> httpHandler), ml)
      | NestedEndpoint(t, lst, ml)       -> NestedEndpoint(t, List.map (applyAfter httpHandler) lst, ml)
  
  let rec addMetadata
      (metadata: obj)
      (endpoint: Endpoint) =
      match endpoint with
      | SimpleEndpoint(v, p, h, ml)      -> SimpleEndpoint(v, p, h, metadata::ml)
      | TemplateEndpoint(v, p, m, h, ml) -> TemplateEndpoint(v, p, m, h, metadata::ml)
      | NestedEndpoint(t, lst, ml)       -> NestedEndpoint(t, lst, metadata::ml)
  
  // ---------------------------
  // Middleware Extension Methods
  