rename `module` to `module_`.

include/pybind11/internal/module.h

@@ -4,38 +4,38 @@
 
 namespace pkbind {
 
-class module : public object {
-    PKBIND_TYPE_IMPL(object, module, tp_module)
+class module_ : public object {
+    PKBIND_TYPE_IMPL(object, module_, tp_module)
 
-    static module __main__() { return module(py_getmodule("__main__"), object::ref_t{}); }
+    static module_ __main__() { return module_(py_getmodule("__main__"), object::ref_t{}); }
 
-    static module import(const char* name) {
+    static module_ import(const char* name) {
         raise_call<py_import>(name);
-        return borrow<module>(py_retval());
+        return borrow<module_>(py_retval());
     }
 
-    static module create(const char* name) {
+    static module_ create(const char* name) {
         auto m = py_newmodule(name);
-        return steal<module>(m);
+        return steal<module_>(m);
     }
 
-    module def_submodule(const char* name, const char* doc = nullptr) {
+    module_ def_submodule(const char* name, const char* doc = nullptr) {
         // auto package = (attr("__package__").cast<std::string>() += ".") +=
         // attr("__name__").cast<std::string_view>();
         auto fname = (attr("__name__").cast<std::string>() += ".") += name;
         auto m = py_newmodule(fname.c_str());
         setattr(*this, name, m);
-        return module(m, object::ref_t{});
+        return module_(m, object::ref_t{});
     }
 
     template <typename Fn, typename... Extras>
-    module& def(const char* name, Fn&& fn, const Extras... extras) {
+    module_& def(const char* name, Fn&& fn, const Extras... extras) {
         impl::bind_function<false, false>(*this, name, std::forward<Fn>(fn), extras...);
         return *this;
     }
 };
 
-using module_ = module;
+using module = module_;
 
 #define PYBIND11_EMBEDDED_MODULE(name, variable)                                                   \
     static void _pkbind_register_##name(::pkbind::module& variable);                               \