anchor.diff:                              | Failure f -> failwith "not supported yet"
                               | Success s -> s)
                       |> converter.changeListToType t 
  -                    |> Success
                   | _ -> Failure "Not a generic list type"
   
  -        match json with
  -        | JsonObject(obj) ->
  -            match targetType with
  -            | StringMap t -> 
  -                obj 
  -                |> Map.toList 
  -                |> bindList (fun (x,y) ->
  -                    match y |> coerceToType t with
  -                    | Success z -> Success (x,z)
  -                    | Failure z -> Failure z)
  -                |> TwoTrack.bind (converter.listToTypedMap t >> Success)
  -            | _ -> 
  -                let getValue name = 
  -                    name 
  -                    |> obj.TryFind
  -                    |> Result.FromOption (sprintf "could not find data for record value '%s'" name)
  -                
  -                let getConstructorArgument (arg: System.Reflection.ParameterInfo) =
  -                    getValue arg.Name
  -                    >>= coerceToType arg.ParameterType
  +            | JsonObject(obj) ->
  +                match targetType with
  +                | StringMap t -> 
  +                    obj 
  +                    |> Map.toList 
  +                    |> bindList (fun (x,y) ->
  +                        match y |> coerceToType t with
  +                        | Success z -> Success (x,z)
  +                        | Failure z -> Failure z)
  +                    >>= converter.listToTypedMap t
  +                | _ -> 
  +                    let getConstructorArgument (arg: System.Reflection.ParameterInfo) =
  +                        arg.Name
  +                        |> obj.TryFind
  +                        |> Result.FromOption (sprintf "could not find data for record value '%s'" arg.Name)
  +                        >>= coerceToType arg.ParameterType
   
  -                let ctor = targetType.GetConstructors().Single()
  -                ctor.GetParameters() 
  -                |> Array.toList
  -                |> bindList getConstructorArgument
  -                >>= invokeCtor targetType
  -        | x -> coerceToType targetType x
  +                    let ctor = targetType.GetConstructors().Single()
  +                    ctor.GetParameters() 
  +                    |> Array.toList
  +                    |> bindList getConstructorArgument
  +                    >>= invokeCtor targetType
   
       let targetType = typeof<'T>
       let mapType = typeof<Map<string,_>>
  -    match toInstanceOfType targetType json with
  +    match coerceToType targetType json with
       | Success(x) -> Success(x :?> 'T)
       | Failure(x) -> Failure(x)
  -
  
positive.code:                             match y with
                              | [] -> Failure "Not enough array elements"
                              | y::z -> 
                                  coerceToType targetType y |> TwoTrack.bind (fun b -> Success (b::x,z))
                      FSharpType.GetTupleElements t
                      |> Array.toList
                      |> pairWith arr
  
negative.code:         
      member self.listToTypedMap (targetType: System.Type) (l:(string*obj) list) =
          typeof<Converter>.GetMethod("toMap").MakeGenericMethod(targetType).Invoke(self, [|l|])
          |> Success
  
  let toInstance<'T> json =
      let changeType (targetType: System.Type) value = 
  