anchor.diff:                      ignore ()
                       read (index + 1) (data @ [value])
    
  -            return read 0 List.empty |> Array.ofList }
  -
  -    let readObject func keyType valueType =
  -        json {
  -            let! tokenType = flip tokenType
  -            let! ignore = flip ignore
  -            let! value = flip value
  -            let! deserialize = flip deserialize
  -
  -            let key =
  -                match keyType with
  -                | t when t = typeof<string> -> fun o -> box (string o)
  -                | t when t = typeof<Guid> -> fun o -> box (Guid (string o))
  -                | t when t = typeof<int> -> fun o -> box (System.Int32.Parse o)
  -                | _ -> failwith "key type not allowed"
  - 
  -            let rec read data =
  -                match tokenType () with
  -                | JsonToken.StartObject ->
  -                    ignore ()
  -                    read data
  -                | JsonToken.EndObject ->
  -                    data
  -                | _ ->
  -                    let k = key (string (value ()))
  -                    ignore ()
  -                    let v = deserialize valueType
  -                    ignore ()
  -                    read (func k v :: data)
  -            
  -            return read List.empty }
  +            return read 0 List.empty |> Array.ofList } 
    
       let writeObject (map: Map<string, obj>) =
           json {
  
positive.code: [<AutoOpen>]
  module internal Unions =
  
      let isUnion (t: Type) =
          FSharpType.IsUnion(t, goPastInterfaces)
   
      let readUnion (t: Type) =
          json {
  
negative.code:             let! caseName = value ()
              do! ignore ()
              
              let case =  FSharpType.GetUnionCases (t, flags) 
                              |> Array.find (fun x -> String.Equals (string caseName, x.Name, StringComparison.OrdinalIgnoreCase))
              let types = case.GetFields () |> Array.map (fun f -> f.PropertyType)
              let! array = readArray (fun i -> types.[i])
              let union = FSharpValue.MakeUnion (case, array, flags)
              
              do! ignore ()
              
  