anchor.diff:              |> List.map (typeAnnotation com ctx)
               |> List.map fst
   
  -    let makeGenericTypeAnnotation (com: IPythonCompiler) ctx (genArgs: Fable.Type list) (id: string) =
  +    let makeGenericTypeAnnotation (com: IPythonCompiler) ctx (id: string) (genArgs: Fable.Type list)  =
           pythonModuleAnnotation com ctx "__future__" "annotations" [] |> ignore
   
           let typeParamInst = makeGenTypeParamInst com ctx genArgs
  
positive.code:                             | "string" -> StringTypeAnnotation
                              | _ -> AnyTypeAnnotation*)
                          | Expression.Name {Id = Identifier id } ->
                              makeGenericTypeAnnotation com ctx genArgs id, []
                          // TODO: Resolve references to types in nested modules
                          | _ -> typingModuleTypeHint "Any" []
                      | None -> typingModuleTypeHint "Any" []
  
  
          | _ ->
              typingModuleTypeHint "Any" []
  
  
  module Util =
      open Lib
  
negative.code:                     None, Alias.alias(Identifier(moduleName), ?asname=im.LocalIdent))
              |> List.groupBy fst
              |> List.map (fun (a, b) -> a, List.map snd b)
              |> List.sortBy (fun name ->
                  let name =
                      match name with
                      | Some moduleName, _ -> moduleName.ToLower()
                      | None, { Name=name }::_ -> name.Name
                      | _ -> ""
                  match name with
                  | name when name.StartsWith("__") -> "A" + name
                  | name when name.StartsWith("fable") -> "C" + name
                  | name when name.StartsWith(".") -> "D" + name
                  | _ -> "B" + name
                  )
  
          [
              for moduleName, aliases in imports do
  