anchor.diff:          show : obj -> option<string>
       }
   
  -    member this.Read(x, req) =
  -        this.read x req >>= function
  -            | (:? 'T as r) -> Some (Success r)
  -            | _ -> None
  +    member this.Read(x, req) : option<DecodeResult<'T>> =
  +        this.read x req
  +        |> Option.map DecodeResult.unbox
   
       member this.Show(x: 'T) =
           this.show (x :> obj)
  
positive.code:                 | Wildcard.None ->
                      match tryParsePrimitiveField f false with
                      | Some parse ->
                          D.Make(false, Set.empty, fun (p: Parameters) ->
                              parse <| p.Read())
                      | 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: Parameters) ->
              match p.Read () with
              | Some s ->
                  match parse s with
                  | true, x -> Some (Success (x :> obj))
                  | _ -> None
              | None -> None)
      let parseInt = tryParse System.Int32.TryParse
      let parseTuple t mk (ds: D[]) : D =
          let k = Array.length ds
  
negative.code:             with
                  | Json.ReadException
                  | Json.DecoderException -> InvalidJson defaultValue
              |> Just p)
          |> Some
      else None
  
  type Arr = System.Collections.ArrayList
  
  let parseRemainingStrings (eD: D) k (p: ReadParameters) =
      let rec loop (p: ReadParameters) (a: Arr) =
          if p.IsAtEnd then
              Just p (Success (box (k (a.ToArray()))))
          else
              eD.Decode p >>= fun p fragment ->
                  let a = a.Clone() :?> Arr
                  a.Add(fragment) |> ignore
                  loop p a
      loop p (new Arr())
  
  let parseWildcardSeq (eT: System.Type) (eD: D) (sP: ISequenceProcessor) : D =
      if eD.ReadsJson() then raise (NoFormatError eT)
  