anchor.diff:              Expression.subscript(expr, Expression.tuple(args))
   
       let private typingHint (com: IPythonCompiler) ctx memberName args =
  -        pythonModuleHint com ctx "typing"  memberName args
  -
  -
  -    let transformTypeHint (com: IPythonCompiler) ctx r (genMap: Map<string, Expression>) t: Expression * Statement list =
  +        pythonModuleAnnotation com ctx "typing"  memberName args
  +
  +    let makeGenTypeParamInst com ctx (genArgs: Fable.Type list) =
  +        match genArgs with
  +        | [] -> []
  +        | _  ->
  +            genArgs
  +            |> List.map (typeAnnotation com ctx)
  +            |> List.map fst
  +
  +    let makeGenericTypeAnnotation (com: IPythonCompiler) ctx (genArgs: Fable.Type list) (id: string) =
  +        pythonModuleAnnotation com ctx "__future__" "annotations" [] |> ignore
  +
  +        let typeParamInst = makeGenTypeParamInst com ctx genArgs
  +        let name = Expression.name id
  +        if typeParamInst.IsEmpty then
  +            name
  +        else
  +            Expression.subscript(name, Expression.tuple typeParamInst)
  +
  +    let typeAnnotation (com: IPythonCompiler) ctx t: Expression * Statement list =
           let literalTypeInfo genArgs =
               typingHint com ctx "Literal" genArgs
   
  
positive.code:                 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 -> typingModuleTypeHint "Any" [||]
          | 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", []
  
negative.code:             |> libReflectionCall com ctx None "enum", []
          | Fable.Number(kind,_) -> numberInfo kind, []
          | Fable.LambdaType(argType, returnType) ->
              genericTypeAnnotation "Callable" [ argType; returnType ]
          | Fable.Option(genArg,_)   -> genericTypeAnnotation "Optional" [ genArg ]
          | Fable.Tuple(genArgs,_)   -> genericTypeAnnotation "Tuple" genArgs
          | Fable.Array genArg ->
              match genArg with
              | Fable.Type.Number(UInt8, _) -> typingModuleTypeHint "ByteString" []
              | Fable.Type.Number(Int8, _)
              | Fable.Type.Number(Int16, _)
              | Fable.Type.Number(UInt16, _)
              | Fable.Type.Number(Int32, _)
              | Fable.Type.Number(UInt32, _)
              | Fable.Type.Number(Float32, _)
              | Fable.Type.Number(Float64, _) -> pythonModuleTypeHint "array" "array" []
              | _ -> typingModuleTypeHint "List" [ genArg ]
          | Fable.List genArg     -> fableModuleTypeInfo "list" "FSharpList" [ genArg ]
          | Fable.AnonymousRecordType _ ->
              Expression.name("dict"), [] // TODO: use TypedDict?
          | Fable.DeclaredType(ent, genArgs) ->
              //match ent.FullName with
              match ent.FullName, genArgs with
              | Replacements.BuiltinEntity kind ->
                  match kind with
                  | Replacements.BclDecimal ->
                      pythonModuleTypeHint "decimal" "Decimal" [ ]
                  | _ -> typingModuleTypeHint "Any" []
  (*
                  | Replacements.BclGuid
                  | Replacements.BclTimeSpan
                  | Replacements.BclDateTime
  