anchor.diff:          | MissingQueryParameter (a, _)
           | MissingFormData (a, _) -> a
   
  +type ReadParameters =
  +    {
  +        Request : Http.Request
  +        Fragments : string[]
  +        Pos : int
  +    }
  +
  +    member this.Read() =
  +        if this.Pos < this.Fragments.Length then
  +            Some (this.Fragments.[this.Pos], { this with Pos = this.Pos + 1 })
  +        else None
  +
  +    member this.IsAtEnd =
  +        { this.Pos .. this.Fragments.Length - 1 }
  +        |> Seq.forall (fun i -> this.Fragments.[i] = "")
  +
  +    static member Make req frags =
  +        {
  +            Request = req
  +            Fragments = frags
  +            Pos = 0
  +        }
  +
   type DecodeResult =
  -
  -    static member map (f: 'a -> 'b) (x: option<DecodeResult<'a>>) : option<DecodeResult<'b>> =
  -        x |> Option.map (function
  -            | Success x -> Success (f x)
  -            | InvalidMethod (x, m) -> InvalidMethod (f x, m)
  -            | InvalidJson x -> InvalidJson (f x)
  -            | MissingQueryParameter (x, p) -> MissingQueryParameter (f x, p)
  -            | MissingFormData (x, p) -> MissingFormData (f x, p))
   
       static member unbox (x: DecodeResult<obj>) : DecodeResult<'b> =
           match x with
  
positive.code:         | Some parse ->
              D.Make(false, Set.singleton fn, fun p ->
                  match parse p.Request.Post.[fn] with
                  | Some (Success _) as x -> x
                  | _ -> Some (MissingFormData(defaultValue, fn)))
              |> Some
      else None
  
  
negative.code:                 | Wildcard.None ->
                      match tryParsePrimitiveField f false with
                      | Some parse ->
                          D.Make(false, Set.empty, fun (p: ReadParameters) ->
                              match p.Read() with
                              | None -> parse None |> ofOption p
                              | Some (x, p) -> parse (Some x) |> ofOption p)
                      | None -> getD f.Type
  
  let getD (getD: System.Type -> D) (t: System.Type) : D =
      let tryParse parse : D =
          D.Make(false, Set.empty, fun (p: ReadParameters) ->
              match p.Read () with
              | Some (s, p) ->
                  match parse s with
                  | true, x -> Just p (Success (x :> obj))
                  | _ -> Nothing
              | None -> Nothing)
      let parseInt = tryParse System.Int32.TryParse
      let parseTuple t mk (ds: D[]) : D =
          let k = Array.length ds
  