anchor.diff:              D.Make(d.ReadsJson, d.QueryParams, fun p ->
                   d.Decode p |> Option.map mkSuccess)
           else
  -        let d = Dictionary<string, Map<option<Http.Method>, int>>()
  +        let d = Dictionary<string, Map<option<Http.Method>, list<int>>>()
           let ds =
               cs |> Array.mapi (fun i c ->
                   let allowedMeths = getUnionCaseMethods c
  
positive.code:                 let sb = System.Text.StringBuilder 128
                  if input = null then None else
                      let parts = input.Split '/'
                      let e = (parts :> seq<string>).GetEnumerator()
                      let n () = if e.MoveNext() then Some e.Current else None
                      let parsed = d.Decode { Request = req; Read = n }
                      // Checking that we are at the end of the url,
                      // at worst with an extra / (ie. an extra empty segment)
                      if e.MoveNext() && not (e.Current = "" && not (e.MoveNext()))
                      then None
                      else parsed
              show = fun value ->
                  let sb = System.Text.StringBuilder 128
                  let q = List()
  
negative.code:             )
          let json() = ds |> Array.exists (fun d -> d.ReadsJson())
          D.Make(json, (fun () -> Set.empty), fun p ->
              let tryDecode(ks) =
                  (ks, None) ||> List.foldBack (fun k s ->
                      match s with
                      | Some (Success _, _) -> s
                      | _ ->
                          let p' = { p with Pos = p.Pos }
                          ds.[k].Decode p' |> Option.map (fun r -> r, p'))
                  |> Option.map (fun (r, p') ->
                      p.Pos <- p'.Pos
                      r)
              p.Read () |> Option.bind (fun name ->
                  match d.TryGetValue name with
                  | true, d ->
                      // Try to find a union case for the exact method searched
                      match d.TryFind (Some p.Request.Method) with
                      | Some ks -> tryDecode ks
                      | None ->
                          // Try to find None, ie. a non-method-specific union case
                          match d.TryFind None with
                          | Some ks -> tryDecode ks
                          | None ->
                              // This action doesn't parse, but try to find another action
                              // with the same name to pass to InvalidMethod
                              d |> Map.tryPick (fun _ -> function [] -> None | (k :: _) -> ds.[k].Decode p)
                              |> Option.map (function
                                  | Success a
                                  | MissingQueryParameter (a, _)
  