anchor.diff:                  else
                       transformClassWithCompilerGeneratedConstructor com ctx ent decl.Name classMembers
   
  -    let transformTypeVars (com: IPythonCompiler) (typeVars: HashSet<string>) =
  +    let transformTypeVars (com: IPythonCompiler) ctx (typeVars: HashSet<string>) =
           [
  +            if typeVars.Count > 0 then
  +                com.GetImportExpr(ctx, "typing", "TypeVar") |> ignore
  +
               for var in typeVars do
                   let targets = Expression.name(var) |> List.singleton
                   let func = Expression.name("TypeVar")
  
positive.code: 
      let declareClassType (com: IPythonCompiler) ctx (ent: Fable.Entity) entName (consArgs: Arguments) (consBody: Statement list) (baseExpr: Expression option) classMembers =
          // printfn "declareClassType: %A" consBody
          let classCons = makeClassConstructor consArgs consBody
          let classFields = Array.empty
          let classMembers = List.append [ classCons ] classMembers
  
negative.code:         | _ -> Some stmt
  
  // https://www.python.org/dev/peps/pep-0484/
  module Annotation =
      open Lib
  
      let getEntityGenParams (ent: Fable.Entity) =
          ent.GenericParameters
          |> Seq.map (fun x -> x.Name)
          |> Set.ofSeq
  
      let makeTypeParamDecl (com: IPythonCompiler) ctx (genParams: Set<string>) =
          if (Set.isEmpty genParams) then
              []
          else
              com.GetImportExpr(ctx, "typing", "Generic") |> ignore
              com.GetImportExpr(ctx, "typing", "TypeVar") |> ignore
  
              let genParams =
                  genParams
                  |> Set.toList
                  |> List.map (fun genParam ->
                      let arg = Util.getUniqueNameInRootScope (ctx: Context) genParam
                      com.AddTypeVar(arg)
                      Expression.name(arg))
  
              let generic = Expression.name "Generic"
              [ Expression.subscript(generic, Expression.tuple genParams) ]
  
      let private libReflectionCall (com: IPythonCompiler) ctx r memberName args =
          libCall com ctx r "reflection" (memberName + "_type") args
  