anchor.diff:      let fs = getObjectFields t
       let ms = fs |> Array.map (fun x -> x :> System.Reflection.MemberInfo)
       let es = fs |> Array.map (fun f -> (f.Name, dE f.FieldType))
  -    fun (i: M.Info) (x: obj) ->
  +    fun (i: FormatSettings) (x: obj) ->
           match x with
           | null ->
               EncodedNull
  
positive.code: let tupleDecoder dD (t: System.Type) =
      let e = Array.map dD (FST.GetTupleElements t)
      let c = FSV.PreComputeTupleConstructor t
      fun (i: M.Info) (x: Value) ->
          match x with
          | Array xs ->
              let xs = List.toArray xs
  
negative.code:                     d
      get
  
  module M = IntelliFactory.WebSharper.Core.Metadata
  
  module TypedProviderInternals =
  
      let addTag (i: M.Info) (t: System.Type) (v: Encoded) =
          let mt = R.TypeDefinition.FromType t
          match i.GetAddress mt with
          | None -> v
          | Some a ->
              match v with
              | EncodedObject fs -> EncodedInstance (a, fs)
              | _ -> v
  
      let pack encoded =
          let dict = Dictionary()
          let encT x =
              match dict.TryGetValue x with
              | true, y -> Number (string y)
              | _ ->
                  let y = dict.Count
                  dict.[x] <- y
                  Number (string y)
          let rec pk = function
              | EncodedNull -> Null
              | EncodedTrue -> True
              | EncodedFalse -> False
              | EncodedNumber x -> Number x
              | EncodedString x -> String x
              | EncodedArray xs -> Array (List.map pk xs)
              | EncodedObject xs -> Object [VALUE, pko xs]
              | EncodedInstance (a, x) -> Object [TYPE, encT a; VALUE, pko x]
          and pko xs =
              Object (List.map (fun (a, b) -> (a, pk b)) xs)
          let data = pk encoded
          let rec encA acc x =
              match x with
              | P.Global x -> Array (String x :: acc)
              | P.Local (x, y) -> encA (String y :: acc) x
          let types =
              Array (List.ofSeq (Seq.map (encA []) dict.Keys))
          Object [
              TYPES, types
              DATA, data
          ]
  
      let format info =
          {
              AddTag = addTag info
              GetEncodedRecordFieldName = info.GetFieldName
              Pack = pack
          }
  
  module PlainProviderInternals =
  
      let rec flatten encoded =
          let rec pk = function
              | EncodedNull -> Null
              | EncodedTrue -> True
              | EncodedFalse -> False
              | EncodedNumber x -> Number x
              | EncodedString x -> String x
              | EncodedArray xs -> Array (List.map pk xs)
              | EncodedObject xs -> pko xs
              | EncodedInstance (_, xs) -> pko xs
          and pko xs =
              Object (List.map (fun (a, b) -> (a, pk b)) xs)
          pk encoded
  
      let format =
          {
              AddTag = fun _ -> id
              GetEncodedRecordFieldName = fun _ -> id
              Pack = flatten
          }
  
  [<Sealed>]
  type Provider(fo: FormatSettings) =
      let decoders = Dictionary()
      let encoders = Dictionary()
  
      let getDecoder =
          getEncoding (fun {Decode=x} -> x)
              arrayDecoder
              tupleDecoder
              unionDecoder
              recordDecoder
              enumDecoder
              mapDecoder
              setDecoder
              objectDecoder
              decoders
          >> function
              | Choice1Of2 x -> Decoder (x fo)
              | Choice2Of2 x -> raise (NoDecoderException x)
  
      let getEncoder =
          getEncoding (fun {Encode=x} -> x)
              arrayEncoder
              tupleEncoder
              unionEncoder
              recordEncoder
              enumEncoder
              mapEncoder
              setEncoder
              objectEncoder
              encoders
          >> function
              | Choice1Of2 x -> Encoder (x fo)
              | Choice2Of2 x -> raise (NoEncoderException x)
  
      static member Create() =
          Provider PlainProviderInternals.format
  
      static member CreateTyped (info: M.Info) =
          Provider (TypedProviderInternals.format info)
  
      member this.GetDecoder(t: System.Type) : Decoder =
          getDecoder t
  
      member this.GetEncoder(t: System.Type) : Encoder =
          getEncoder t
  
      member this.GetDecoder<'T>() : Decoder<'T> =
          let d = this.GetDecoder typeof<'T>
  