Fixups for making the map binding work

1. Exposing detail::is_copy_assignable and detail::is_copy_assignable_v in nanobind/stl/detail/traits.h;
2. Exposing detail::is_copy_constructible_v in core nanobind (nanobind/nb_class.h);
3. Switching implementations to detail::is_copy{constructible,assignable}_v in bind_map.h;

Author: nicholasjng

include/nanobind/nb_class.h

@@ -239,6 +239,9 @@ template <op_id id, op_type ot, typename L = undefined_t, typename R = undefined
 template <typename T, typename SFINAE = int>
 struct is_copy_constructible : std::is_copy_constructible<T> { };
 
+template <typename T>
+constexpr bool is_copy_constructible_v = is_copy_constructible<T>::value;
+
 NAMESPACE_END(detail)
 
 template <typename T, typename... Ts>
@@ -275,7 +278,7 @@ class class_ : public object {
         if constexpr (!std::is_same_v<Alias, T>)
             d.flags |= (uint32_t) detail::type_flags::is_trampoline;
 
-        if constexpr (detail::is_copy_constructible<T>::value) {
+        if constexpr (detail::is_copy_constructible_v<T>) {
             d.flags |= (uint32_t) detail::type_flags::is_copy_constructible;
 
             if constexpr (!std::is_trivially_copy_constructible_v<T>) {

include/nanobind/stl/bind_map.h

@@ -9,6 +9,7 @@
 
 #include <nanobind/nanobind.h>
 #include <nanobind/make_iterator.h>
+#include <nanobind/stl/detail/traits.h>
 
 NAMESPACE_BEGIN(NB_NAMESPACE)
 NAMESPACE_BEGIN(detail)
@@ -139,10 +140,10 @@ class_<Map> bind_map(handle scope, const char *name, Args &&...args)
     cl.def("__contains__", [](const Map &, handle) -> bool { return false; });
 
     // Assignment provided only if the type is copyable
-    if constexpr(std::is_copy_assignable_v<MappedType> ||
-                 std::is_copy_constructible_v<MappedType>){
+    if constexpr(detail::is_copy_assignable_v<MappedType> ||
+                 detail::is_copy_constructible_v<MappedType>){
         // Map assignment when copy-assignable: just copy the value
-        if constexpr(std::is_copy_assignable_v<MappedType>){
+        if constexpr(detail::is_copy_assignable_v<MappedType>){
             cl.def("__setitem__", [](Map &m, const KeyType &k, const MappedType &v)
             {
                 auto it = m.find(k);

include/nanobind/stl/detail/traits.h

@@ -31,13 +31,34 @@ struct is_copy_constructible<
         is_copy_constructible<typename T::value_type>::value;
 };
 
+// std::pair is copy-constructible <=> both constituents are copy-constructible
 template <typename T1, typename T2>
 struct is_copy_constructible<std::pair<T1, T2>> {
     static constexpr bool value =
-        is_copy_constructible<T1>::value ||
+        is_copy_constructible<T1>::value &&
         is_copy_constructible<T2>::value;
 };
 
+// The header file include/nanobind/stl/detail/traits.h extends this type trait
+template <typename T, typename SFINAE = int>
+struct is_copy_assignable : std::is_copy_assignable<T> { };
+
+template <typename T>
+struct is_copy_assignable<T,
+                          enable_if_t<std::is_copy_assignable_v<T> &&
+                                      std::is_same_v<typename T::value_type &,
+                                                     typename T::reference>>> {
+    static constexpr bool value = is_copy_assignable<typename T::value_type>::value;
+};
+
+template <typename T1, typename T2>
+struct is_copy_assignable<std::pair<T1, T2>> {
+    static constexpr bool value = is_copy_assignable<T1>::value && is_copy_assignable<T2>::value;
+};
+
+template <typename T>
+constexpr bool is_copy_assignable_v = is_copy_assignable<T>::value;
+
 NAMESPACE_END(detail)
 NAMESPACE_END(NB_NAMESPACE)