anchor.diff:  
       let transformTypeInfo (com: IPythonCompiler) ctx r (genMap: Map<string, Expression>) t: Expression * Statement list =
           let primitiveTypeInfo name =
  -           typingHint com ctx name []
  -
  -        let literalTypeInfo genArgs =
  -            typingHint com ctx "Literal" genArgs
  -
  -        let getNumberKindName kind =
  -            match kind with
  -            | Int8 | UInt8 | Int16 | UInt16 | Int32 | UInt32 -> "int"
  -            | Float32 | Float64 -> "float"
  -
  -        let resolveGenerics generics: Expression list * Statement list =
  -            generics |> Array.map (transformTypeInfo com ctx r genMap) |> List.ofArray |> Helpers.unzipArgs
  -
  -        let fableModulesTypeInfo moduleName memberName genArgs =
  -            let resolved, stmts = resolveGenerics genArgs
  -            fableModuleHint com ctx moduleName memberName resolved, stmts
  -
  +           libValue com ctx "Reflection" (name + "_type")
           let numberInfo kind =
  -            Expression.name (getNumberKindName kind)
  +            getNumberKindName kind
  +            |> primitiveTypeInfo
           let nonGenericTypeInfo fullname =
               [ Expression.constant(fullname) ]
               |> libReflectionCall com ctx None "class"
  +        let resolveGenerics generics: Expression list * Statement list =
  +            generics |> Array.map (transformTypeInfo com ctx r genMap) |> List.ofArray |> Helpers.unzipArgs
  +        let genericTypeInfo name genArgs =
  +            let resolved, stmts = resolveGenerics genArgs
  +            libReflectionCall com ctx None name resolved, stmts
           let genericEntity (fullname: string) (generics: Expression list) =
               libReflectionCall com ctx None "class" [
                   Expression.constant(fullname)
                   if not(List.isEmpty generics) then
                       Expression.list(generics)
               ]
  -        let genericTypeInfo name genArgs =
  -            let resolved, stmts = resolveGenerics genArgs
  -            typingHint com ctx name resolved, stmts
  -
           match t with
           | Fable.Measure _
  -        | Fable.Any -> primitiveTypeInfo "Any", []
  +        | Fable.Any -> primitiveTypeInfo "obj", []
           | Fable.GenericParam(name,_) ->
  -            com.GetImportExpr(ctx, "typing", "TypeVar") |> ignore
  -            let name = Helpers.clean name
  -            com.AddTypeVar name
               match Map.tryFind name genMap with
               | Some t -> t, []
  -            | None -> Expression.name(name), []
  -        | Fable.Unit    -> Expression.none, []
  -        | Fable.Boolean -> Expression.name "bool", []
  -        | Fable.Char    -> Expression.name "str", []
  -        | Fable.String  -> Expression.name "str", []
  +            | None ->
  +                Replacements.genericTypeInfoError name |> addError com [] r
  +                Expression.none, []
  +        | Fable.Unit    -> primitiveTypeInfo "unit", []
  +        | Fable.Boolean -> primitiveTypeInfo "bool", []
  +        | Fable.Char    -> primitiveTypeInfo "char", []
  +        | Fable.String  -> primitiveTypeInfo "string", []
           | Fable.Enum entRef ->
               let ent = com.GetEntity(entRef)
               let mutable numberKind = Int32
  
positive.code: 
          //printfn "Arsg: %A" args
          let name = com.GetIdentifier(ctx, membName)
          let returns, _ = transformTypeInfo com ctx None Map.empty body.Type
          let stmt = FunctionDef.Create(name = name, args = args, body = body', returns=returns)
          let expr = Expression.name (name)
          info.Attributes
  
negative.code:                 |> Expression.list
              [ Expression.constant(entRef.FullName); numberInfo numberKind; cases ]
              |> libReflectionCall com ctx None "enum", []
          | Fable.Number(kind,_) ->
              numberInfo kind, []
          | Fable.LambdaType(argType, returnType) ->
              genericTypeInfo "lambda" [|argType; returnType|]
          | Fable.DelegateType(argTypes, returnType) ->
              genericTypeInfo "delegate" ([|yield! argTypes; yield returnType|])
          | Fable.Tuple(genArgs,_)   -> genericTypeInfo "tuple" (List.toArray genArgs)
          | Fable.Option(genArg,_)   -> genericTypeInfo "option" [|genArg|]
          | Fable.Array genArg    -> genericTypeInfo "array" [|genArg|]
          | Fable.List genArg     -> genericTypeInfo "list" [|genArg|]
          | Fable.Regex           -> nonGenericTypeInfo Types.regex, []
          | Fable.MetaType        -> nonGenericTypeInfo Types.type_, []
          | Fable.AnonymousRecordType(fieldNames, genArgs) ->
  