add none_caster<T> as a base of three type_casters:

type_caster<std::nullptr_t>
type_caster<std::monostate>
type_caster<std::nullopt_t>

Author: wojdyr

include/nanobind/nb_cast.h

@@ -238,20 +238,22 @@ template <> struct type_caster<void> {
     }
 };
 
-template <> struct type_caster<std::nullptr_t> {
+template <typename T> struct none_caster {
     bool from_python(handle src, uint8_t, cleanup_list *) noexcept {
         if (src.is_none())
             return true;
         return false;
     }
 
-    static handle from_cpp(std::nullptr_t, rv_policy, cleanup_list *) noexcept {
+    static handle from_cpp(T, rv_policy, cleanup_list *) noexcept {
         return none().release();
     }
 
-    NB_TYPE_CASTER(std::nullptr_t, const_name("None"))
+    NB_TYPE_CASTER(T, const_name("None"))
 };
 
+template <> struct type_caster<std::nullptr_t> : none_caster<std::nullptr_t> { };
+
 template <> struct type_caster<bool> {
     bool from_python(handle src, uint8_t, cleanup_list *) noexcept {
         if (src.ptr() == Py_True) {

include/nanobind/stl/optional.h

@@ -21,19 +21,7 @@ template <typename T> struct remove_opt_mono<std::optional<T>>
 template <typename T>
 struct type_caster<std::optional<T>> : optional_caster<std::optional<T>> {};
 
-template <> struct type_caster<std::nullopt_t> {
-    bool from_python(handle src, uint8_t, cleanup_list *) noexcept {
-        if (src.is_none())
-            return true;
-        return false;
-    }
-
-    static handle from_cpp(std::nullopt_t, rv_policy, cleanup_list *) noexcept {
-        return none().release();
-    }
-
-    NB_TYPE_CASTER(std::nullopt_t, const_name("None"))
-};
+template <> struct type_caster<std::nullopt_t> : none_caster<std::nullopt_t> { };
 
 NAMESPACE_END(detail)
 NAMESPACE_END(NB_NAMESPACE)

include/nanobind/stl/variant.h

@@ -24,18 +24,7 @@ struct concat_variant<std::variant<Ts1...>, std::variant<Ts2...>, Ts3...>
 template <typename... Ts> struct remove_opt_mono<std::variant<Ts...>>
     : concat_variant<std::conditional_t<std::is_same_v<std::monostate, Ts>, std::variant<>, std::variant<remove_opt_mono_t<Ts>>>...> {};
 
-template <> struct type_caster<std::monostate> {
-    NB_TYPE_CASTER(std::monostate, const_name("None"))
-
-    bool from_python(handle src, uint8_t, cleanup_list *) noexcept {
-        return src.is_none();
-    }
-
-    static handle from_cpp(const std::monostate &, rv_policy,
-                           cleanup_list *) noexcept {
-        return none().release();
-    }
-};
+template <> struct type_caster<std::monostate> : none_caster<std::monostate> { };
 
 template <typename... Ts> struct type_caster<std::variant<Ts...>> {
     NB_TYPE_CASTER(std::variant<Ts...>, union_name(make_caster<Ts>::Name...))