anchor.diff:          let f = parseArray eT eD
           D.Make(false, Set.empty, fun p ->
               f.Decode p
  -            |> DecodeResult.map (fun x -> sP.FromSequence (x :?> _)))
  +            |> ReadResult.map (fun x -> sP.FromSequence (x :?> _)))
       | Tuple (e, _, c) ->
           parseTuple t c (Array.map getD e)
       | Record (fs, _, c) ->
  
positive.code:         | Some parse ->
              D.Make(false, Set.singleton fn, fun p ->
                  match parse p.Request.Get.[fn] with
                  | Some (Success _) as x -> x
                  | _ -> Some (MissingQueryParameter(defaultValue, fn)))
              |> Some
      else None
  
  
negative.code:         | 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 unbox (x: DecodeResult<obj>) : DecodeResult<'b> =
          match x with
  