From 541c36003197808eb77c7eb5956b7f74c9bb96ba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Mon, 17 Apr 2023 15:25:01 +0200
Subject: [PATCH 01/16] Testing

---
 tests/test_stl_binders.cpp | 16 ++++++++++++++++
 tests/test_stl_binders.py  | 18 ++++++++++++++++++
 2 files changed, 34 insertions(+)

diff --git a/tests/test_stl_binders.cpp b/tests/test_stl_binders.cpp
index ca9630bd19..6d1f76e95c 100644
--- a/tests/test_stl_binders.cpp
+++ b/tests/test_stl_binders.cpp
@@ -70,6 +70,19 @@ NestMap *times_hundred(int n) {
     return m;
 }
 
+/*
+ * Recursive data structures as test for issue #4623
+ */
+struct RecursiveVector : std::vector<RecursiveVector> {
+    using Parent = std::vector<RecursiveVector>;
+    using Parent::Parent;
+};
+
+struct RecursiveMap : std::map<int, RecursiveMap> {
+    using Parent = std::map<int, RecursiveMap>;
+    using Parent::Parent;
+};
+
 TEST_SUBMODULE(stl_binders, m) {
     // test_vector_int
     py::bind_vector<std::vector<unsigned int>>(m, "VectorInt", py::buffer_protocol());
@@ -149,4 +162,7 @@ TEST_SUBMODULE(stl_binders, m) {
     m.def("get_vectorstruct", [] {
         return std::vector<VStruct>{{false, 5, 3.0, true}, {true, 30, -1e4, false}};
     });
+
+    py::bind_vector<RecursiveVector>(m, "RecursiveVector");
+    py::bind_map<RecursiveMap>(m, "RecursiveMap");
 }
diff --git a/tests/test_stl_binders.py b/tests/test_stl_binders.py
index 7dca742a9e..47d239a64d 100644
--- a/tests/test_stl_binders.py
+++ b/tests/test_stl_binders.py
@@ -335,3 +335,21 @@ def test_map_view_types():
     assert type(unordered_map_string_double.items()) is items_type
     assert type(map_string_double_const.items()) is items_type
     assert type(unordered_map_string_double_const.items()) is items_type
+
+
+def test_recursive_containers():
+    recursive_vector = m.RecursiveVector()
+    recursive_vector.append(m.RecursiveVector())
+    recursive_vector[0].append(m.RecursiveVector())
+    recursive_vector[0][0].append(m.RecursiveVector())
+    recursive_vector[0][0].append(m.RecursiveVector())
+    # Can't use len() since test_stl_binders.cpp does not include stl.h,
+    # so the necessary conversion is missing
+    assert recursive_vector[0][0].count(m.RecursiveVector()) == 2
+
+    recursive_map = m.RecursiveMap()
+    recursive_map[1] = m.RecursiveMap()
+    recursive_map[1][1] = m.RecursiveMap()
+    recursive_map[1][1][1] = m.RecursiveMap()
+    recursive_map[1][1][2] = m.RecursiveMap()
+    assert list(recursive_map[1][1].keys()) == [1, 2]

From 2c6002cf9fef5dd5266bf6b883ca5b3dfdceeee8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Mon, 17 Apr 2023 15:07:18 +0200
Subject: [PATCH 02/16] Similar fix for std::vector

---
 include/pybind11/stl_bind.h | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/include/pybind11/stl_bind.h b/include/pybind11/stl_bind.h
index 7cfd996dda..e1d26bf111 100644
--- a/include/pybind11/stl_bind.h
+++ b/include/pybind11/stl_bind.h
@@ -61,10 +61,21 @@ struct is_comparable<
 /* For a vector/map data structure, recursively check the value type
    (which is std::pair for maps) */
 template <typename T>
-struct is_comparable<T, enable_if_t<container_traits<T>::is_vector>> {
+struct is_comparable<T,
+                     enable_if_t<container_traits<T>::is_vector &&
+                                 // Avoid this instantiation if the type is recursive
+                                 negation<std::is_same<T, typename T::value_type>>::value>> {
     static constexpr const bool value = is_comparable<typename T::value_type>::value;
 };
 
+template <typename T>
+struct is_comparable<T,
+                     enable_if_t<container_traits<T>::is_vector &&
+                                 // Special case: The vector type is recursive
+                                 std::is_same<T, typename T::value_type>::value>> {
+    static constexpr const bool value = true;
+};
+
 /* For pairs, recursively check the two data types */
 template <typename T>
 struct is_comparable<T, enable_if_t<container_traits<T>::is_pair>> {

From 4c59860baafa8a33f9821729e96d733e00c764f0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Fri, 14 Apr 2023 10:37:24 +0200
Subject: [PATCH 03/16] Fix infinite recursion check:

1) Apply to is_copy_assignable additionally
2) Check infinite recursion for map-like types
---
 include/pybind11/detail/type_caster_base.h | 26 +++++++++++++++++++---
 1 file changed, 23 insertions(+), 3 deletions(-)

diff --git a/include/pybind11/detail/type_caster_base.h b/include/pybind11/detail/type_caster_base.h
index 34dcd26ce5..b98efacfaf 100644
--- a/include/pybind11/detail/type_caster_base.h
+++ b/include/pybind11/detail/type_caster_base.h
@@ -830,6 +830,20 @@ struct is_copy_constructible : std::is_copy_constructible<T> {};
 template <typename T, typename SFINAE = void>
 struct is_move_constructible : std::is_move_constructible<T> {};
 
+// True if Container has a dependent type mapped_type that is equivalent
+// to Container itself
+template<typename Container, typename MappedType = Container>
+struct map_self_referential
+{
+    constexpr static bool value = false;
+};
+
+template<typename Container>
+struct map_self_referential<Container, typename Container::mapped_type>
+{
+    constexpr static bool value = true;
+};
+
 // Specialization for types that appear to be copy constructible but also look like stl containers
 // (we specifically check for: has `value_type` and `reference` with `reference = value_type&`): if
 // so, copy constructability depends on whether the value_type is copy constructible.
@@ -839,8 +853,10 @@ struct is_copy_constructible<
     enable_if_t<
         all_of<std::is_copy_constructible<Container>,
                std::is_same<typename Container::value_type &, typename Container::reference>,
-               // Avoid infinite recursion
-               negation<std::is_same<Container, typename Container::value_type>>>::value>>
+               // Avoid infinite recursion (list types)
+               negation<std::is_same<Container, typename Container::value_type>>,
+               // Avoid infinite recursion (map types)
+               negation<map_self_referential<Container>>>::value>>
     : is_copy_constructible<typename Container::value_type> {};
 
 // Likewise for std::pair
@@ -858,7 +874,11 @@ template <typename Container>
 struct is_copy_assignable<Container,
                           enable_if_t<all_of<std::is_copy_assignable<Container>,
                                              std::is_same<typename Container::value_type &,
-                                                          typename Container::reference>>::value>>
+                                                          typename Container::reference>,
+                                            // Avoid infinite recursion (list types)
+                                            negation<std::is_same<Container, typename Container::value_type>>,
+                                            // Avoid infinite recursion (map types)
+                                            negation<map_self_referential<Container>>>::value>>
     : is_copy_assignable<typename Container::value_type> {};
 template <typename T1, typename T2>
 struct is_copy_assignable<std::pair<T1, T2>>

From 2c48ca975cd8f68f929a2464617824d9d9f9beb7 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Mon, 17 Apr 2023 13:28:21 +0000
Subject: [PATCH 04/16] style: pre-commit fixes

---
 include/pybind11/detail/type_caster_base.h | 27 +++++++++++-----------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/include/pybind11/detail/type_caster_base.h b/include/pybind11/detail/type_caster_base.h
index b98efacfaf..979b07a292 100644
--- a/include/pybind11/detail/type_caster_base.h
+++ b/include/pybind11/detail/type_caster_base.h
@@ -832,15 +832,13 @@ struct is_move_constructible : std::is_move_constructible<T> {};
 
 // True if Container has a dependent type mapped_type that is equivalent
 // to Container itself
-template<typename Container, typename MappedType = Container>
-struct map_self_referential
-{
+template <typename Container, typename MappedType = Container>
+struct map_self_referential {
     constexpr static bool value = false;
 };
 
-template<typename Container>
-struct map_self_referential<Container, typename Container::mapped_type>
-{
+template <typename Container>
+struct map_self_referential<Container, typename Container::mapped_type> {
     constexpr static bool value = true;
 };
 
@@ -871,14 +869,15 @@ struct is_copy_constructible<std::pair<T1, T2>>
 template <typename T, typename SFINAE = void>
 struct is_copy_assignable : std::is_copy_assignable<T> {};
 template <typename Container>
-struct is_copy_assignable<Container,
-                          enable_if_t<all_of<std::is_copy_assignable<Container>,
-                                             std::is_same<typename Container::value_type &,
-                                                          typename Container::reference>,
-                                            // Avoid infinite recursion (list types)
-                                            negation<std::is_same<Container, typename Container::value_type>>,
-                                            // Avoid infinite recursion (map types)
-                                            negation<map_self_referential<Container>>>::value>>
+struct is_copy_assignable<
+    Container,
+    enable_if_t<
+        all_of<std::is_copy_assignable<Container>,
+               std::is_same<typename Container::value_type &, typename Container::reference>,
+               // Avoid infinite recursion (list types)
+               negation<std::is_same<Container, typename Container::value_type>>,
+               // Avoid infinite recursion (map types)
+               negation<map_self_referential<Container>>>::value>>
     : is_copy_assignable<typename Container::value_type> {};
 template <typename T1, typename T2>
 struct is_copy_assignable<std::pair<T1, T2>>

From 8d35d800a3de518335e593668f27b391cd0e77d1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Mon, 17 Apr 2023 15:39:07 +0200
Subject: [PATCH 05/16] Optional commit that demonstrates the limitations of
 this PR

---
 tests/test_stl_binders.cpp | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/tests/test_stl_binders.cpp b/tests/test_stl_binders.cpp
index 6d1f76e95c..e38ad3df96 100644
--- a/tests/test_stl_binders.cpp
+++ b/tests/test_stl_binders.cpp
@@ -83,6 +83,32 @@ struct RecursiveMap : std::map<int, RecursiveMap> {
     using Parent::Parent;
 };
 
+/*
+ * Pybind11 does not catch more complicated recursion schemes, such as mutual
+ * recursion.
+ * In that case, an alternative is to add a custom overload.
+ */
+struct MutuallyRecursiveMap;
+struct MutuallyRecursiveVector;
+
+struct MutuallyRecursiveMap : std::map<int, MutuallyRecursiveVector> {};
+struct MutuallyRecursiveVector : std::vector<MutuallyRecursiveMap> {};
+
+namespace pybind11 {
+namespace detail {
+template <>
+struct is_comparable<MutuallyRecursiveVector, void> : std::true_type {};
+template <>
+struct is_copy_assignable<MutuallyRecursiveVector, void> : std::true_type {};
+template <>
+struct is_copy_assignable<MutuallyRecursiveMap, void> : std::true_type {};
+template <>
+struct is_copy_constructible<MutuallyRecursiveVector, void> : std::true_type {};
+template <>
+struct is_copy_constructible<MutuallyRecursiveMap, void> : std::true_type {};
+} // namespace detail
+} // namespace pybind11
+
 TEST_SUBMODULE(stl_binders, m) {
     // test_vector_int
     py::bind_vector<std::vector<unsigned int>>(m, "VectorInt", py::buffer_protocol());
@@ -165,4 +191,6 @@ TEST_SUBMODULE(stl_binders, m) {
 
     py::bind_vector<RecursiveVector>(m, "RecursiveVector");
     py::bind_map<RecursiveMap>(m, "RecursiveMap");
+    py::bind_map<MutuallyRecursiveMap>(m, "MutuallyRecursiveMap");
+    py::bind_vector<MutuallyRecursiveVector>(m, "MutuallyRecursiveVector");
 }

From 79782b5f2a31cb49352ef4e872fe56a2b0c333c0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Wed, 19 Apr 2023 10:26:25 +0200
Subject: [PATCH 06/16] Fix positioning of container bindings

The bindings were previously in a block that was only activated if numpy
was available.
---
 tests/test_stl_binders.cpp | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/tests/test_stl_binders.cpp b/tests/test_stl_binders.cpp
index e38ad3df96..28cee06053 100644
--- a/tests/test_stl_binders.cpp
+++ b/tests/test_stl_binders.cpp
@@ -168,6 +168,12 @@ TEST_SUBMODULE(stl_binders, m) {
             m, "VectorUndeclStruct", py::buffer_protocol());
     });
 
+    // Bind recursive container types
+    py::bind_vector<RecursiveVector>(m, "RecursiveVector");
+    py::bind_map<RecursiveMap>(m, "RecursiveMap");
+    py::bind_map<MutuallyRecursiveMap>(m, "MutuallyRecursiveMap");
+    py::bind_vector<MutuallyRecursiveVector>(m, "MutuallyRecursiveVector");
+
     // The rest depends on numpy:
     try {
         py::module_::import("numpy");
@@ -188,9 +194,4 @@ TEST_SUBMODULE(stl_binders, m) {
     m.def("get_vectorstruct", [] {
         return std::vector<VStruct>{{false, 5, 3.0, true}, {true, 30, -1e4, false}};
     });
-
-    py::bind_vector<RecursiveVector>(m, "RecursiveVector");
-    py::bind_map<RecursiveMap>(m, "RecursiveMap");
-    py::bind_map<MutuallyRecursiveMap>(m, "MutuallyRecursiveMap");
-    py::bind_vector<MutuallyRecursiveVector>(m, "MutuallyRecursiveVector");
 }

From ba0aadf99d890c9cd71bb241fffceb6e7aa67a34 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Fri, 21 Apr 2023 12:03:32 +0200
Subject: [PATCH 07/16] Suggestions from code review: API side

---
 include/pybind11/detail/type_caster_base.h | 39 ++++++++++++++--------
 include/pybind11/stl_bind.h                |  9 ++---
 tests/test_stl_binders.cpp                 | 10 ++----
 3 files changed, 32 insertions(+), 26 deletions(-)

diff --git a/include/pybind11/detail/type_caster_base.h b/include/pybind11/detail/type_caster_base.h
index 979b07a292..675e8622dc 100644
--- a/include/pybind11/detail/type_caster_base.h
+++ b/include/pybind11/detail/type_caster_base.h
@@ -832,15 +832,30 @@ struct is_move_constructible : std::is_move_constructible<T> {};
 
 // True if Container has a dependent type mapped_type that is equivalent
 // to Container itself
+// Actual implementation in the SFINAE specializations below
 template <typename Container, typename MappedType = Container>
-struct map_self_referential {
-    constexpr static bool value = false;
-};
+struct sfinae_is_container_with_self_referential_mapped_type : std::false_type {};
 
+// Tie-breaking between the mapped_type and the value_type specializations is trivial:
+// The specializations are only valid if both conditions are fulfilled:
+// 1) The mapped_type (respectively value_type) exists
+// 2) And it is equivalent to Container
+// So, in each case, only one specialization will activate.
 template <typename Container>
-struct map_self_referential<Container, typename Container::mapped_type> {
-    constexpr static bool value = true;
-};
+struct sfinae_is_container_with_self_referential_mapped_type<Container,
+                                                             typename Container::mapped_type>
+    : std::true_type {};
+
+template <typename Container>
+struct sfinae_is_container_with_self_referential_mapped_type<Container,
+                                                             typename Container::value_type>
+    : std::true_type {};
+
+// Use a helper struct in order to give this a nicer public API without helper template parameter.
+// This makes this struct nicer to specialize by users.
+template <typename Container>
+struct is_container_with_self_referential_mapped_type
+    : sfinae_is_container_with_self_referential_mapped_type<Container> {};
 
 // Specialization for types that appear to be copy constructible but also look like stl containers
 // (we specifically check for: has `value_type` and `reference` with `reference = value_type&`): if
@@ -851,10 +866,8 @@ struct is_copy_constructible<
     enable_if_t<
         all_of<std::is_copy_constructible<Container>,
                std::is_same<typename Container::value_type &, typename Container::reference>,
-               // Avoid infinite recursion (list types)
-               negation<std::is_same<Container, typename Container::value_type>>,
-               // Avoid infinite recursion (map types)
-               negation<map_self_referential<Container>>>::value>>
+               // Avoid infinite recursion
+               negation<is_container_with_self_referential_mapped_type<Container>>>::value>>
     : is_copy_constructible<typename Container::value_type> {};
 
 // Likewise for std::pair
@@ -874,10 +887,8 @@ struct is_copy_assignable<
     enable_if_t<
         all_of<std::is_copy_assignable<Container>,
                std::is_same<typename Container::value_type &, typename Container::reference>,
-               // Avoid infinite recursion (list types)
-               negation<std::is_same<Container, typename Container::value_type>>,
-               // Avoid infinite recursion (map types)
-               negation<map_self_referential<Container>>>::value>>
+               // Avoid infinite recursion
+               negation<is_container_with_self_referential_mapped_type<Container>>>::value>>
     : is_copy_assignable<typename Container::value_type> {};
 template <typename T1, typename T2>
 struct is_copy_assignable<std::pair<T1, T2>>
diff --git a/include/pybind11/stl_bind.h b/include/pybind11/stl_bind.h
index e1d26bf111..069d9dc70e 100644
--- a/include/pybind11/stl_bind.h
+++ b/include/pybind11/stl_bind.h
@@ -61,10 +61,11 @@ struct is_comparable<
 /* For a vector/map data structure, recursively check the value type
    (which is std::pair for maps) */
 template <typename T>
-struct is_comparable<T,
-                     enable_if_t<container_traits<T>::is_vector &&
-                                 // Avoid this instantiation if the type is recursive
-                                 negation<std::is_same<T, typename T::value_type>>::value>> {
+struct is_comparable<
+    T,
+    enable_if_t<container_traits<T>::is_vector &&
+                // Avoid this instantiation if the type is recursive
+                negation<is_container_with_self_referential_mapped_type<T>>::value>> {
     static constexpr const bool value = is_comparable<typename T::value_type>::value;
 };
 
diff --git a/tests/test_stl_binders.cpp b/tests/test_stl_binders.cpp
index 28cee06053..8cf6caf65b 100644
--- a/tests/test_stl_binders.cpp
+++ b/tests/test_stl_binders.cpp
@@ -97,15 +97,9 @@ struct MutuallyRecursiveVector : std::vector<MutuallyRecursiveMap> {};
 namespace pybind11 {
 namespace detail {
 template <>
-struct is_comparable<MutuallyRecursiveVector, void> : std::true_type {};
+struct is_container_with_self_referential_mapped_type<MutuallyRecursiveVector> : std::true_type {};
 template <>
-struct is_copy_assignable<MutuallyRecursiveVector, void> : std::true_type {};
-template <>
-struct is_copy_assignable<MutuallyRecursiveMap, void> : std::true_type {};
-template <>
-struct is_copy_constructible<MutuallyRecursiveVector, void> : std::true_type {};
-template <>
-struct is_copy_constructible<MutuallyRecursiveMap, void> : std::true_type {};
+struct is_container_with_self_referential_mapped_type<MutuallyRecursiveMap> : std::true_type {};
 } // namespace detail
 } // namespace pybind11
 

From 0ecf5f01f8f956a4cb5a81179b25836639fd5f67 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franz=20P=C3=B6schel?= <franz.poeschel@gmail.com>
Date: Fri, 21 Apr 2023 12:09:26 +0200
Subject: [PATCH 08/16] Suggestions from code review: Test side

---
 tests/test_stl_binders.cpp | 22 +++++++++++++---------
 tests/test_stl_binders.py  | 18 +++++++++---------
 2 files changed, 22 insertions(+), 18 deletions(-)

diff --git a/tests/test_stl_binders.cpp b/tests/test_stl_binders.cpp
index 8cf6caf65b..c921033321 100644
--- a/tests/test_stl_binders.cpp
+++ b/tests/test_stl_binders.cpp
@@ -86,20 +86,24 @@ struct RecursiveMap : std::map<int, RecursiveMap> {
 /*
  * Pybind11 does not catch more complicated recursion schemes, such as mutual
  * recursion.
- * In that case, an alternative is to add a custom overload.
+ * In that case, an alternative is to add a custom specialization to
+ * pybind11::detail::is_container_with_self_referential_mapped_type, thus
+ * manually telling pybind11 about the recursion.
  */
-struct MutuallyRecursiveMap;
-struct MutuallyRecursiveVector;
+struct MutuallyRecursiveContainerPairA;
+struct MutuallyRecursiveContainerPairB;
 
-struct MutuallyRecursiveMap : std::map<int, MutuallyRecursiveVector> {};
-struct MutuallyRecursiveVector : std::vector<MutuallyRecursiveMap> {};
+struct MutuallyRecursiveContainerPairA : std::map<int, MutuallyRecursiveContainerPairB> {};
+struct MutuallyRecursiveContainerPairB : std::vector<MutuallyRecursiveContainerPairA> {};
 
 namespace pybind11 {
 namespace detail {
 template <>
-struct is_container_with_self_referential_mapped_type<MutuallyRecursiveVector> : std::true_type {};
+struct is_container_with_self_referential_mapped_type<MutuallyRecursiveContainerPairB>
+    : std::true_type {};
 template <>
-struct is_container_with_self_referential_mapped_type<MutuallyRecursiveMap> : std::true_type {};
+struct is_container_with_self_referential_mapped_type<MutuallyRecursiveContainerPairA>
+    : std::true_type {};
 } // namespace detail
 } // namespace pybind11
 
@@ -165,8 +169,8 @@ TEST_SUBMODULE(stl_binders, m) {
     // Bind recursive container types
     py::bind_vector<RecursiveVector>(m, "RecursiveVector");
     py::bind_map<RecursiveMap>(m, "RecursiveMap");
-    py::bind_map<MutuallyRecursiveMap>(m, "MutuallyRecursiveMap");
-    py::bind_vector<MutuallyRecursiveVector>(m, "MutuallyRecursiveVector");
+    py::bind_map<MutuallyRecursiveContainerPairA>(m, "MutuallyRecursiveContainerPairA");
+    py::bind_vector<MutuallyRecursiveContainerPairB>(m, "MutuallyRecursiveContainerPairB");
 
     // The rest depends on numpy:
     try {
diff --git a/tests/test_stl_binders.py b/tests/test_stl_binders.py
index 47d239a64d..e002f5b678 100644
--- a/tests/test_stl_binders.py
+++ b/tests/test_stl_binders.py
@@ -337,19 +337,19 @@ def test_map_view_types():
     assert type(unordered_map_string_double_const.items()) is items_type
 
 
-def test_recursive_containers():
+def test_recursive_vector():
     recursive_vector = m.RecursiveVector()
     recursive_vector.append(m.RecursiveVector())
     recursive_vector[0].append(m.RecursiveVector())
-    recursive_vector[0][0].append(m.RecursiveVector())
-    recursive_vector[0][0].append(m.RecursiveVector())
+    recursive_vector[0].append(m.RecursiveVector())
     # Can't use len() since test_stl_binders.cpp does not include stl.h,
     # so the necessary conversion is missing
-    assert recursive_vector[0][0].count(m.RecursiveVector()) == 2
+    assert recursive_vector[0].count(m.RecursiveVector()) == 2
+
 
+def test_recursive_map():
     recursive_map = m.RecursiveMap()
-    recursive_map[1] = m.RecursiveMap()
-    recursive_map[1][1] = m.RecursiveMap()
-    recursive_map[1][1][1] = m.RecursiveMap()
-    recursive_map[1][1][2] = m.RecursiveMap()
-    assert list(recursive_map[1][1].keys()) == [1, 2]
+    recursive_map[100] = m.RecursiveMap()
+    recursive_map[100][101] = m.RecursiveMap()
+    recursive_map[100][102] = m.RecursiveMap()
+    assert list(recursive_map[100].keys()) == [101, 102]

From 9ba38bf9bf144424fa58ac5a60c34f06a74435ba Mon Sep 17 00:00:00 2001
From: Franz Poeschel <franz.poeschel@gmail.com>
Date: Mon, 24 Apr 2023 15:22:34 +0200
Subject: [PATCH 09/16] Suggestions from code review

1) Renaming: is_recursive_container and
   MutuallyRecursiveContainerPair(MV|VM)
2) Avoid ambiguous specializations of is_recursive_container
---
 include/pybind11/detail/type_caster_base.h | 42 +++++++++++++---------
 include/pybind11/stl_bind.h                |  9 +++--
 tests/test_stl_binders.cpp                 | 22 ++++++------
 3 files changed, 39 insertions(+), 34 deletions(-)

diff --git a/include/pybind11/detail/type_caster_base.h b/include/pybind11/detail/type_caster_base.h
index 675e8622dc..f1cf689a0f 100644
--- a/include/pybind11/detail/type_caster_base.h
+++ b/include/pybind11/detail/type_caster_base.h
@@ -832,30 +832,38 @@ struct is_move_constructible : std::is_move_constructible<T> {};
 
 // True if Container has a dependent type mapped_type that is equivalent
 // to Container itself
-// Actual implementation in the SFINAE specializations below
+// Actual implementation in the SFINAE specialization below
 template <typename Container, typename MappedType = Container>
-struct sfinae_is_container_with_self_referential_mapped_type : std::false_type {};
+struct is_container_with_recursive_mapped_type : std::false_type {};
 
-// Tie-breaking between the mapped_type and the value_type specializations is trivial:
-// The specializations are only valid if both conditions are fulfilled:
-// 1) The mapped_type (respectively value_type) exists
+// This specialization is only valid if both conditions are fulfilled:
+// 1) The mapped_type exists
 // 2) And it is equivalent to Container
-// So, in each case, only one specialization will activate.
 template <typename Container>
-struct sfinae_is_container_with_self_referential_mapped_type<Container,
-                                                             typename Container::mapped_type>
+struct is_container_with_recursive_mapped_type<Container, typename Container::mapped_type>
     : std::true_type {};
 
+// True if Container has a dependent type value_type that is equivalent
+// to Container itself
+// Actual implementation in the SFINAE specialization below
+template <typename Container, typename MappedType = Container>
+struct is_container_with_recursive_value_type : std::false_type {};
+
+// This specialization is only valid if both conditions are fulfilled:
+// 1) The value_type exists
+// 2) And it is equivalent to Container
 template <typename Container>
-struct sfinae_is_container_with_self_referential_mapped_type<Container,
-                                                             typename Container::value_type>
+struct is_container_with_recursive_value_type<Container, typename Container::value_type>
     : std::true_type {};
 
-// Use a helper struct in order to give this a nicer public API without helper template parameter.
-// This makes this struct nicer to specialize by users.
-template <typename Container>
-struct is_container_with_self_referential_mapped_type
-    : sfinae_is_container_with_self_referential_mapped_type<Container> {};
+// True constant if the type contains itself recursively.
+// By default, this will check the mapped_type and value_type dependent types.
+// In more complex recursion patterns, users can specialize this struct.
+// The second template parameter SFINAE=void is for use of std::enable_if in specializations.
+// An example is found in tests/test_stl_binders.cpp.
+template <typename Container, typename SFINAE = void>
+struct is_recursive_container : any_of<is_container_with_recursive_value_type<Container>,
+                                       is_container_with_recursive_mapped_type<Container>> {};
 
 // Specialization for types that appear to be copy constructible but also look like stl containers
 // (we specifically check for: has `value_type` and `reference` with `reference = value_type&`): if
@@ -867,7 +875,7 @@ struct is_copy_constructible<
         all_of<std::is_copy_constructible<Container>,
                std::is_same<typename Container::value_type &, typename Container::reference>,
                // Avoid infinite recursion
-               negation<is_container_with_self_referential_mapped_type<Container>>>::value>>
+               negation<is_recursive_container<Container>>>::value>>
     : is_copy_constructible<typename Container::value_type> {};
 
 // Likewise for std::pair
@@ -888,7 +896,7 @@ struct is_copy_assignable<
         all_of<std::is_copy_assignable<Container>,
                std::is_same<typename Container::value_type &, typename Container::reference>,
                // Avoid infinite recursion
-               negation<is_container_with_self_referential_mapped_type<Container>>>::value>>
+               negation<is_recursive_container<Container>>>::value>>
     : is_copy_assignable<typename Container::value_type> {};
 template <typename T1, typename T2>
 struct is_copy_assignable<std::pair<T1, T2>>
diff --git a/include/pybind11/stl_bind.h b/include/pybind11/stl_bind.h
index 069d9dc70e..82752ecb88 100644
--- a/include/pybind11/stl_bind.h
+++ b/include/pybind11/stl_bind.h
@@ -61,11 +61,10 @@ struct is_comparable<
 /* For a vector/map data structure, recursively check the value type
    (which is std::pair for maps) */
 template <typename T>
-struct is_comparable<
-    T,
-    enable_if_t<container_traits<T>::is_vector &&
-                // Avoid this instantiation if the type is recursive
-                negation<is_container_with_self_referential_mapped_type<T>>::value>> {
+struct is_comparable<T,
+                     enable_if_t<container_traits<T>::is_vector &&
+                                 // Avoid this instantiation if the type is recursive
+                                 negation<is_recursive_container<T>>::value>> {
     static constexpr const bool value = is_comparable<typename T::value_type>::value;
 };
 
diff --git a/tests/test_stl_binders.cpp b/tests/test_stl_binders.cpp
index c921033321..9eca353f00 100644
--- a/tests/test_stl_binders.cpp
+++ b/tests/test_stl_binders.cpp
@@ -90,20 +90,18 @@ struct RecursiveMap : std::map<int, RecursiveMap> {
  * pybind11::detail::is_container_with_self_referential_mapped_type, thus
  * manually telling pybind11 about the recursion.
  */
-struct MutuallyRecursiveContainerPairA;
-struct MutuallyRecursiveContainerPairB;
+struct MutuallyRecursiveContainerPairMV;
+struct MutuallyRecursiveContainerPairVM;
 
-struct MutuallyRecursiveContainerPairA : std::map<int, MutuallyRecursiveContainerPairB> {};
-struct MutuallyRecursiveContainerPairB : std::vector<MutuallyRecursiveContainerPairA> {};
+struct MutuallyRecursiveContainerPairMV : std::map<int, MutuallyRecursiveContainerPairVM> {};
+struct MutuallyRecursiveContainerPairVM : std::vector<MutuallyRecursiveContainerPairMV> {};
 
 namespace pybind11 {
 namespace detail {
-template <>
-struct is_container_with_self_referential_mapped_type<MutuallyRecursiveContainerPairB>
-    : std::true_type {};
-template <>
-struct is_container_with_self_referential_mapped_type<MutuallyRecursiveContainerPairA>
-    : std::true_type {};
+template <typename SFINAE>
+struct is_recursive_container<MutuallyRecursiveContainerPairMV, SFINAE> : std::true_type {};
+template <typename SFINAE>
+struct is_recursive_container<MutuallyRecursiveContainerPairVM, SFINAE> : std::true_type {};
 } // namespace detail
 } // namespace pybind11
 
@@ -169,8 +167,8 @@ TEST_SUBMODULE(stl_binders, m) {
     // Bind recursive container types
     py::bind_vector<RecursiveVector>(m, "RecursiveVector");
     py::bind_map<RecursiveMap>(m, "RecursiveMap");
-    py::bind_map<MutuallyRecursiveContainerPairA>(m, "MutuallyRecursiveContainerPairA");
-    py::bind_vector<MutuallyRecursiveContainerPairB>(m, "MutuallyRecursiveContainerPairB");
+    py::bind_map<MutuallyRecursiveContainerPairMV>(m, "MutuallyRecursiveContainerPairMV");
+    py::bind_vector<MutuallyRecursiveContainerPairVM>(m, "MutuallyRecursiveContainerPairVM");
 
     // The rest depends on numpy:
     try {

From 531ceb4f66120383fd99ba299d110292b05a68ef Mon Sep 17 00:00:00 2001
From: Franz Poeschel <franz.poeschel@gmail.com>
Date: Tue, 25 Apr 2023 10:43:52 +0200
Subject: [PATCH 10/16] Some little fixes

---
 include/pybind11/stl_bind.h | 5 +++--
 tests/test_stl_binders.cpp  | 5 ++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/include/pybind11/stl_bind.h b/include/pybind11/stl_bind.h
index 82752ecb88..e90a228937 100644
--- a/include/pybind11/stl_bind.h
+++ b/include/pybind11/stl_bind.h
@@ -68,12 +68,13 @@ struct is_comparable<T,
     static constexpr const bool value = is_comparable<typename T::value_type>::value;
 };
 
+/* Skip the recursion if the type itself is recursive */
 template <typename T>
 struct is_comparable<T,
                      enable_if_t<container_traits<T>::is_vector &&
                                  // Special case: The vector type is recursive
-                                 std::is_same<T, typename T::value_type>::value>> {
-    static constexpr const bool value = true;
+                                 is_recursive_container<T>::value>> {
+    static constexpr const bool value = container_traits<T>::is_comparable;
 };
 
 /* For pairs, recursively check the two data types */
diff --git a/tests/test_stl_binders.cpp b/tests/test_stl_binders.cpp
index 9eca353f00..d7c0c4942f 100644
--- a/tests/test_stl_binders.cpp
+++ b/tests/test_stl_binders.cpp
@@ -86,9 +86,8 @@ struct RecursiveMap : std::map<int, RecursiveMap> {
 /*
  * Pybind11 does not catch more complicated recursion schemes, such as mutual
  * recursion.
- * In that case, an alternative is to add a custom specialization to
- * pybind11::detail::is_container_with_self_referential_mapped_type, thus
- * manually telling pybind11 about the recursion.
+ * In that case custom is_recursive_container specializations need to be added,
+ * thus manually telling pybind11 about the recursion.
  */
 struct MutuallyRecursiveContainerPairMV;
 struct MutuallyRecursiveContainerPairVM;

From 1bd1e7e509912b6d6a15c88af4ebea615b18ff86 Mon Sep 17 00:00:00 2001
From: Franz Poeschel <franz.poeschel@gmail.com>
Date: Tue, 25 Apr 2023 10:48:55 +0200
Subject: [PATCH 11/16] Reordering of structs

---
 include/pybind11/detail/type_caster_base.h | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/include/pybind11/detail/type_caster_base.h b/include/pybind11/detail/type_caster_base.h
index f1cf689a0f..3b42f66c93 100644
--- a/include/pybind11/detail/type_caster_base.h
+++ b/include/pybind11/detail/type_caster_base.h
@@ -822,14 +822,6 @@ using movable_cast_op_type
                                   typename std::add_rvalue_reference<intrinsic_t<T>>::type,
                                   typename std::add_lvalue_reference<intrinsic_t<T>>::type>>;
 
-// std::is_copy_constructible isn't quite enough: it lets std::vector<T> (and similar) through when
-// T is non-copyable, but code containing such a copy constructor fails to actually compile.
-template <typename T, typename SFINAE = void>
-struct is_copy_constructible : std::is_copy_constructible<T> {};
-
-template <typename T, typename SFINAE = void>
-struct is_move_constructible : std::is_move_constructible<T> {};
-
 // True if Container has a dependent type mapped_type that is equivalent
 // to Container itself
 // Actual implementation in the SFINAE specialization below
@@ -865,6 +857,14 @@ template <typename Container, typename SFINAE = void>
 struct is_recursive_container : any_of<is_container_with_recursive_value_type<Container>,
                                        is_container_with_recursive_mapped_type<Container>> {};
 
+template <typename T, typename SFINAE = void>
+struct is_move_constructible : std::is_move_constructible<T> {};
+
+// std::is_copy_constructible isn't quite enough: it lets std::vector<T> (and similar) through when
+// T is non-copyable, but code containing such a copy constructor fails to actually compile.
+template <typename T, typename SFINAE = void>
+struct is_copy_constructible : std::is_copy_constructible<T> {};
+
 // Specialization for types that appear to be copy constructible but also look like stl containers
 // (we specifically check for: has `value_type` and `reference` with `reference = value_type&`): if
 // so, copy constructability depends on whether the value_type is copy constructible.

From a839f8f7ad1ca035db6bb37e58f74f802740b7e5 Mon Sep 17 00:00:00 2001
From: Franz Poeschel <franz.poeschel@gmail.com>
Date: Tue, 25 Apr 2023 10:53:05 +0200
Subject: [PATCH 12/16] Add recursive checks for is_move_constructible

---
 include/pybind11/detail/type_caster_base.h | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/include/pybind11/detail/type_caster_base.h b/include/pybind11/detail/type_caster_base.h
index 3b42f66c93..a1edb5522b 100644
--- a/include/pybind11/detail/type_caster_base.h
+++ b/include/pybind11/detail/type_caster_base.h
@@ -860,6 +860,27 @@ struct is_recursive_container : any_of<is_container_with_recursive_value_type<Co
 template <typename T, typename SFINAE = void>
 struct is_move_constructible : std::is_move_constructible<T> {};
 
+// Specialization for types that appear to be move constructible but also look like stl containers
+// (we specifically check for: has `value_type` and `reference` with `reference = value_type&`): if
+// so, move constructability depends on whether the value_type is move constructible.
+template <typename Container>
+struct is_move_constructible<
+    Container,
+    enable_if_t<
+        all_of<std::is_move_constructible<Container>,
+               std::is_same<typename Container::value_type &, typename Container::reference>,
+               // Avoid infinite recursion
+               negation<is_recursive_container<Container>>>::value>>
+    : is_move_constructible<typename Container::value_type> {};
+
+// Likewise for std::pair
+// (after C++17 it is mandatory that the move constructor not exist when the two types aren't
+// themselves move constructible, but this can not be relied upon when T1 or T2 are themselves
+// containers).
+template <typename T1, typename T2>
+struct is_move_constructible<std::pair<T1, T2>>
+    : all_of<is_move_constructible<T1>, is_move_constructible<T2>> {};
+
 // std::is_copy_constructible isn't quite enough: it lets std::vector<T> (and similar) through when
 // T is non-copyable, but code containing such a copy constructor fails to actually compile.
 template <typename T, typename SFINAE = void>

From eba6239ab62390eed8175a768954b4fac5ea515d Mon Sep 17 00:00:00 2001
From: Franz Poeschel <franz.poeschel@gmail.com>
Date: Fri, 28 Apr 2023 11:21:40 +0200
Subject: [PATCH 13/16] Static testing for pybind11 type traits

---
 include/pybind11/detail/type_caster_base.h |   6 +-
 tests/test_copy_move.cpp                   | 238 +++++++++++++++++++++
 2 files changed, 243 insertions(+), 1 deletion(-)

diff --git a/include/pybind11/detail/type_caster_base.h b/include/pybind11/detail/type_caster_base.h
index a1edb5522b..20e9c40e8e 100644
--- a/include/pybind11/detail/type_caster_base.h
+++ b/include/pybind11/detail/type_caster_base.h
@@ -921,7 +921,11 @@ struct is_copy_assignable<
     : is_copy_assignable<typename Container::value_type> {};
 template <typename T1, typename T2>
 struct is_copy_assignable<std::pair<T1, T2>>
-    : all_of<is_copy_assignable<T1>, is_copy_assignable<T2>> {};
+    /*
+     * Need to remove the const qualifier from T1 here since the value_type in
+     * STL map types is std::pair<const Key, T>, and const types are never assignable
+     */
+    : all_of<is_copy_assignable<typename std::remove_const<T1>::type>, is_copy_assignable<T2>> {};
 
 PYBIND11_NAMESPACE_END(detail)
 
diff --git a/tests/test_copy_move.cpp b/tests/test_copy_move.cpp
index 28c2445644..705115f07f 100644
--- a/tests/test_copy_move.cpp
+++ b/tests/test_copy_move.cpp
@@ -13,6 +13,8 @@
 #include "constructor_stats.h"
 #include "pybind11_tests.h"
 
+#include <type_traits>
+
 template <typename derived>
 struct empty {
     static const derived &get_one() { return instance_; }
@@ -293,3 +295,239 @@ TEST_SUBMODULE(copy_move_policies, m) {
     // Make sure that cast from pytype rvalue to other pytype works
     m.def("get_pytype_rvalue_castissue", [](double i) { return py::float_(i).cast<py::int_>(); });
 }
+
+/*
+ * Rest of the file:
+ * static_assert based tests for pybind11 adaptations of of
+ * std::is_move_constructible, std::is_copy_constructible and
+ * std::is_copy_assignable (no adaptation of std::is_move_assignable).
+ * Difference between pybind11 and std traits: pybind11 traits will also check
+ * the contained value_types.
+ */
+
+struct NotMovable {
+    NotMovable() = default;
+    NotMovable(NotMovable const &) = default;
+    NotMovable(NotMovable &&) = delete;
+    NotMovable &operator=(NotMovable const &) = default;
+    NotMovable &operator=(NotMovable &&) = delete;
+};
+static_assert(!std::is_move_constructible<NotMovable>::value,
+              "!std::is_move_constructible<NotMovable>::value");
+static_assert(std::is_copy_constructible<NotMovable>::value,
+              "std::is_copy_constructible<NotMovable>::value");
+static_assert(!pybind11::detail::is_move_constructible<NotMovable>::value,
+              "!pybind11::detail::is_move_constructible<NotMovable>::value");
+static_assert(pybind11::detail::is_copy_constructible<NotMovable>::value,
+              "pybind11::detail::is_copy_constructible<NotMovable>::value");
+static_assert(!std::is_move_assignable<NotMovable>::value,
+              "!std::is_move_assignable<NotMovable>::value");
+static_assert(std::is_copy_assignable<NotMovable>::value,
+              "std::is_copy_assignable<NotMovable>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<NotMovable>::value,
+//               "!pybind11::detail::is_move_assignable<NotMovable>::value");
+static_assert(pybind11::detail::is_copy_assignable<NotMovable>::value,
+              "pybind11::detail::is_copy_assignable<NotMovable>::value");
+
+struct NotCopyable {
+    NotCopyable() = default;
+    NotCopyable(NotCopyable const &) = delete;
+    NotCopyable(NotCopyable &&) = default;
+    NotCopyable &operator=(NotCopyable const &) = delete;
+    NotCopyable &operator=(NotCopyable &&) = default;
+};
+static_assert(std::is_move_constructible<NotCopyable>::value,
+              "std::is_move_constructible<NotCopyable>::value");
+static_assert(!std::is_copy_constructible<NotCopyable>::value,
+              "!std::is_copy_constructible<NotCopyable>::value");
+static_assert(pybind11::detail::is_move_constructible<NotCopyable>::value,
+              "pybind11::detail::is_move_constructible<NotCopyable>::value");
+static_assert(!pybind11::detail::is_copy_constructible<NotCopyable>::value,
+              "!pybind11::detail::is_copy_constructible<NotCopyable>::value");
+static_assert(std::is_move_assignable<NotCopyable>::value,
+              "std::is_move_assignable<NotCopyable>::value");
+static_assert(!std::is_copy_assignable<NotCopyable>::value,
+              "!std::is_copy_assignable<NotCopyable>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<NotCopyable>::value,
+//               "!pybind11::detail::is_move_assignable<NotCopyable>::value");
+static_assert(!pybind11::detail::is_copy_assignable<NotCopyable>::value,
+              "!pybind11::detail::is_copy_assignable<NotCopyable>::value");
+
+struct NotCopyableNotMovable {
+    NotCopyableNotMovable() = default;
+    NotCopyableNotMovable(NotCopyableNotMovable const &) = delete;
+    NotCopyableNotMovable(NotCopyableNotMovable &&) = delete;
+    NotCopyableNotMovable &operator=(NotCopyableNotMovable const &) = delete;
+    NotCopyableNotMovable &operator=(NotCopyableNotMovable &&) = delete;
+};
+static_assert(!std::is_move_constructible<NotCopyableNotMovable>::value,
+              "!std::is_move_constructible<NotCopyableNotMovable>::value");
+static_assert(!std::is_copy_constructible<NotCopyableNotMovable>::value,
+              "!std::is_copy_constructible<NotCopyableNotMovable>::value");
+static_assert(!pybind11::detail::is_move_constructible<NotCopyableNotMovable>::value,
+              "!pybind11::detail::is_move_constructible<NotCopyableNotMovable>::value");
+static_assert(!pybind11::detail::is_copy_constructible<NotCopyableNotMovable>::value,
+              "!pybind11::detail::is_copy_constructible<NotCopyableNotMovable>::value");
+static_assert(!std::is_move_assignable<NotCopyableNotMovable>::value,
+              "!std::is_move_assignable<NotCopyableNotMovable>::value");
+static_assert(!std::is_copy_assignable<NotCopyableNotMovable>::value,
+              "!std::is_copy_assignable<NotCopyableNotMovable>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<NotCopyableNotMovable>::value,
+//               "!pybind11::detail::is_move_assignable<NotCopyableNotMovable>::value");
+static_assert(!pybind11::detail::is_copy_assignable<NotCopyableNotMovable>::value,
+              "!pybind11::detail::is_copy_assignable<NotCopyableNotMovable>::value");
+
+struct NotMovableVector : std::vector<NotMovable> {};
+static_assert(std::is_move_constructible<NotMovableVector>::value,
+              "std::is_move_constructible<NotMovableVector>::value");
+static_assert(std::is_copy_constructible<NotMovableVector>::value,
+              "std::is_copy_constructible<NotMovableVector>::value");
+static_assert(!pybind11::detail::is_move_constructible<NotMovableVector>::value,
+              "!pybind11::detail::is_move_constructible<NotMovableVector>::value");
+static_assert(pybind11::detail::is_copy_constructible<NotMovableVector>::value,
+              "pybind11::detail::is_copy_constructible<NotMovableVector>::value");
+static_assert(std::is_move_assignable<NotMovableVector>::value,
+              "std::is_move_assignable<NotMovableVector>::value");
+static_assert(std::is_copy_assignable<NotMovableVector>::value,
+              "std::is_copy_assignable<NotMovableVector>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<NotMovableVector>::value,
+//               "!pybind11::detail::is_move_assignable<NotMovableVector>::value");
+static_assert(pybind11::detail::is_copy_assignable<NotMovableVector>::value,
+              "pybind11::detail::is_copy_assignable<NotMovableVector>::value");
+
+struct NotCopyableVector : std::vector<NotCopyable> {};
+static_assert(std::is_move_constructible<NotCopyableVector>::value,
+              "std::is_move_constructible<NotCopyableVector>::value");
+static_assert(std::is_copy_constructible<NotCopyableVector>::value,
+              "std::is_copy_constructible<NotCopyableVector>::value");
+static_assert(pybind11::detail::is_move_constructible<NotCopyableVector>::value,
+              "pybind11::detail::is_move_constructible<NotCopyableVector>::value");
+static_assert(!pybind11::detail::is_copy_constructible<NotCopyableVector>::value,
+              "!pybind11::detail::is_copy_constructible<NotCopyableVector>::value");
+static_assert(std::is_move_assignable<NotCopyableVector>::value,
+              "std::is_move_assignable<NotCopyableVector>::value");
+static_assert(std::is_copy_assignable<NotCopyableVector>::value,
+              "std::is_copy_assignable<NotCopyableVector>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<NotCopyableVector>::value,
+//               "!pybind11::detail::is_move_assignable<NotCopyableVector>::value");
+static_assert(!pybind11::detail::is_copy_assignable<NotCopyableVector>::value,
+              "!pybind11::detail::is_copy_assignable<NotCopyableVector>::value");
+
+struct NotCopyableNotMovableVector : std::vector<NotCopyableNotMovable> {};
+static_assert(std::is_move_constructible<NotCopyableNotMovableVector>::value,
+              "std::is_move_constructible<NotCopyableNotMovableVector>::value");
+static_assert(std::is_copy_constructible<NotCopyableNotMovableVector>::value,
+              "std::is_copy_constructible<NotCopyableNotMovableVector>::value");
+static_assert(!pybind11::detail::is_move_constructible<NotCopyableNotMovableVector>::value,
+              "!pybind11::detail::is_move_constructible<NotCopyableNotMovableVector>::value");
+static_assert(!pybind11::detail::is_copy_constructible<NotCopyableNotMovableVector>::value,
+              "!pybind11::detail::is_copy_constructible<NotCopyableNotMovableVector>::value");
+static_assert(std::is_move_assignable<NotCopyableNotMovableVector>::value,
+              "std::is_move_assignable<NotCopyableNotMovableVector>::value");
+static_assert(std::is_copy_assignable<NotCopyableNotMovableVector>::value,
+              "std::is_copy_assignable<NotCopyableNotMovableVector>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<NotCopyableNotMovableVector>::value,
+//               "!pybind11::detail::is_move_assignable<NotCopyableNotMovableVector>::value");
+static_assert(!pybind11::detail::is_copy_assignable<NotCopyableNotMovableVector>::value,
+              "!pybind11::detail::is_copy_assignable<NotCopyableNotMovableVector>::value");
+
+struct NotMovableMap : std::map<int, NotMovable> {};
+static_assert(std::is_move_constructible<NotMovableMap>::value,
+              "std::is_move_constructible<NotMovableMap>::value");
+static_assert(std::is_copy_constructible<NotMovableMap>::value,
+              "std::is_copy_constructible<NotMovableMap>::value");
+static_assert(!pybind11::detail::is_move_constructible<NotMovableMap>::value,
+              "!pybind11::detail::is_move_constructible<NotMovableMap>::value");
+static_assert(pybind11::detail::is_copy_constructible<NotMovableMap>::value,
+              "pybind11::detail::is_copy_constructible<NotMovableMap>::value");
+static_assert(std::is_move_assignable<NotMovableMap>::value,
+              "std::is_move_assignable<NotMovableMap>::value");
+static_assert(std::is_copy_assignable<NotMovableMap>::value,
+              "std::is_copy_assignable<NotMovableMap>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<NotMovableMap>::value,
+//               "!pybind11::detail::is_move_assignable<NotMovableMap>::value");
+static_assert(pybind11::detail::is_copy_assignable<NotMovableMap>::value,
+              "pybind11::detail::is_copy_assignable<NotMovableMap>::value");
+
+struct NotCopyableMap : std::map<int, NotCopyable> {};
+static_assert(std::is_move_constructible<NotCopyableMap>::value,
+              "std::is_move_constructible<NotCopyableMap>::value");
+static_assert(std::is_copy_constructible<NotCopyableMap>::value,
+              "std::is_copy_constructible<NotCopyableMap>::value");
+static_assert(pybind11::detail::is_move_constructible<NotCopyableMap>::value,
+              "pybind11::detail::is_move_constructible<NotCopyableMap>::value");
+static_assert(!pybind11::detail::is_copy_constructible<NotCopyableMap>::value,
+              "!pybind11::detail::is_copy_constructible<NotCopyableMap>::value");
+static_assert(std::is_move_assignable<NotCopyableMap>::value,
+              "std::is_move_assignable<NotCopyableMap>::value");
+static_assert(std::is_copy_assignable<NotCopyableMap>::value,
+              "std::is_copy_assignable<NotCopyableMap>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<NotCopyableMap>::value,
+//               "!pybind11::detail::is_move_assignable<NotCopyableMap>::value");
+static_assert(!pybind11::detail::is_copy_assignable<NotCopyableMap>::value,
+              "!pybind11::detail::is_copy_assignable<NotCopyableMap>::value");
+
+struct NotCopyableNotMovableMap : std::map<int, NotCopyableNotMovable> {};
+static_assert(std::is_move_constructible<NotCopyableNotMovableMap>::value,
+              "std::is_move_constructible<NotCopyableNotMovableMap>::value");
+static_assert(std::is_copy_constructible<NotCopyableNotMovableMap>::value,
+              "std::is_copy_constructible<NotCopyableNotMovableMap>::value");
+static_assert(!pybind11::detail::is_move_constructible<NotCopyableNotMovableMap>::value,
+              "!pybind11::detail::is_move_constructible<NotCopyableNotMovableMap>::value");
+static_assert(!pybind11::detail::is_copy_constructible<NotCopyableNotMovableMap>::value,
+              "!pybind11::detail::is_copy_constructible<NotCopyableNotMovableMap>::value");
+static_assert(std::is_move_assignable<NotCopyableNotMovableMap>::value,
+              "std::is_move_assignable<NotCopyableNotMovableMap>::value");
+static_assert(std::is_copy_assignable<NotCopyableNotMovableMap>::value,
+              "std::is_copy_assignable<NotCopyableNotMovableMap>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<NotCopyableNotMovableMap>::value,
+//               "!pybind11::detail::is_move_assignable<NotCopyableNotMovableMap>::value");
+static_assert(!pybind11::detail::is_copy_assignable<NotCopyableNotMovableMap>::value,
+              "!pybind11::detail::is_copy_assignable<NotCopyableNotMovableMap>::value");
+
+struct RecursiveVector : std::vector<RecursiveVector> {};
+static_assert(std::is_move_constructible<RecursiveVector>::value,
+              "std::is_move_constructible<RecursiveVector>::value");
+static_assert(std::is_copy_constructible<RecursiveVector>::value,
+              "std::is_copy_constructible<RecursiveVector>::value");
+static_assert(pybind11::detail::is_move_constructible<RecursiveVector>::value,
+              "pybind11::detail::is_move_constructible<RecursiveVector>::value");
+static_assert(pybind11::detail::is_copy_constructible<RecursiveVector>::value,
+              "pybind11::detail::is_copy_constructible<RecursiveVector>::value");
+static_assert(std::is_move_assignable<RecursiveVector>::value,
+              "std::is_move_assignable<RecursiveVector>::value");
+static_assert(std::is_copy_assignable<RecursiveVector>::value,
+              "std::is_copy_assignable<RecursiveVector>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<RecursiveVector>::value,
+//               "!pybind11::detail::is_move_assignable<RecursiveVector>::value");
+static_assert(pybind11::detail::is_copy_assignable<RecursiveVector>::value,
+              "pybind11::detail::is_copy_assignable<RecursiveVector>::value");
+
+struct RecursiveMap : std::map<int, RecursiveMap> {};
+static_assert(std::is_move_constructible<RecursiveMap>::value,
+              "std::is_move_constructible<RecursiveMap>::value");
+static_assert(std::is_copy_constructible<RecursiveMap>::value,
+              "std::is_copy_constructible<RecursiveMap>::value");
+static_assert(pybind11::detail::is_move_constructible<RecursiveMap>::value,
+              "pybind11::detail::is_move_constructible<RecursiveMap>::value");
+static_assert(pybind11::detail::is_copy_constructible<RecursiveMap>::value,
+              "pybind11::detail::is_copy_constructible<RecursiveMap>::value");
+static_assert(std::is_move_assignable<RecursiveMap>::value,
+              "std::is_move_assignable<RecursiveMap>::value");
+static_assert(std::is_copy_assignable<RecursiveMap>::value,
+              "std::is_copy_assignable<RecursiveMap>::value");
+// pybind11 does not have this
+// static_assert(!pybind11::detail::is_move_assignable<RecursiveMap>::value,
+//               "!pybind11::detail::is_move_assignable<RecursiveMap>::value");
+static_assert(pybind11::detail::is_copy_assignable<RecursiveMap>::value,
+              "pybind11::detail::is_copy_assignable<RecursiveMap>::value");

From 77e2c56b09319d9d47be6ffc3feabf94d4b6b080 Mon Sep 17 00:00:00 2001
From: Franz Poeschel <franz.poeschel@gmail.com>
Date: Tue, 2 May 2023 15:18:55 +0200
Subject: [PATCH 14/16] More precise checking of recursive types

Instead of a trait `is_recursive_container`, use a trait
`recursive_container_traits` with dependent type
`recursive_container_traits::type_to_check_recursively`.
So, instead of just checking if a type is recursive and then trying to
somehow deal with it, recursively-defined traits such as
is_move_constructible can now directly ask this trait where the
recursion should proceed.
---
 include/pybind11/detail/type_caster_base.h | 251 +++++++++++++++------
 include/pybind11/stl_bind.h                |  18 +-
 tests/test_stl_binders.cpp                 |  11 +-
 3 files changed, 190 insertions(+), 90 deletions(-)

diff --git a/include/pybind11/detail/type_caster_base.h b/include/pybind11/detail/type_caster_base.h
index 20e9c40e8e..6af58ae902 100644
--- a/include/pybind11/detail/type_caster_base.h
+++ b/include/pybind11/detail/type_caster_base.h
@@ -822,56 +822,173 @@ using movable_cast_op_type
                                   typename std::add_rvalue_reference<intrinsic_t<T>>::type,
                                   typename std::add_lvalue_reference<intrinsic_t<T>>::type>>;
 
-// True if Container has a dependent type mapped_type that is equivalent
-// to Container itself
-// Actual implementation in the SFINAE specialization below
-template <typename Container, typename MappedType = Container>
-struct is_container_with_recursive_mapped_type : std::false_type {};
-
-// This specialization is only valid if both conditions are fulfilled:
-// 1) The mapped_type exists
-// 2) And it is equivalent to Container
+template <bool Condition, typename Then, typename Else>
+struct if_then_else {};
+
+template <typename Then, typename Else>
+struct if_then_else<true, Then, Else> {
+    using type = Then;
+};
+
+template <typename Then, typename Else>
+struct if_then_else<false, Then, Else> {
+    using type = Else;
+};
+
+// Does the container have a mapped type and is it recursive?
+// Implemented by specializations below.
+template <typename Container, typename SFINAE = void>
+struct container_mapped_type_traits {
+    static constexpr bool has_mapped_type = false;
+    static constexpr bool has_recursive_mapped_type = false;
+};
+
 template <typename Container>
-struct is_container_with_recursive_mapped_type<Container, typename Container::mapped_type>
-    : std::true_type {};
-
-// True if Container has a dependent type value_type that is equivalent
-// to Container itself
-// Actual implementation in the SFINAE specialization below
-template <typename Container, typename MappedType = Container>
-struct is_container_with_recursive_value_type : std::false_type {};
-
-// This specialization is only valid if both conditions are fulfilled:
-// 1) The value_type exists
-// 2) And it is equivalent to Container
+struct container_mapped_type_traits<
+    Container,
+    typename std::enable_if<
+        std::is_same<typename Container::mapped_type, Container>::value>::type> {
+    static constexpr bool has_mapped_type = true;
+    static constexpr bool has_recursive_mapped_type = true;
+};
+
 template <typename Container>
-struct is_container_with_recursive_value_type<Container, typename Container::value_type>
-    : std::true_type {};
-
-// True constant if the type contains itself recursively.
-// By default, this will check the mapped_type and value_type dependent types.
-// In more complex recursion patterns, users can specialize this struct.
-// The second template parameter SFINAE=void is for use of std::enable_if in specializations.
-// An example is found in tests/test_stl_binders.cpp.
+struct container_mapped_type_traits<
+    Container,
+    typename std::enable_if<
+        negation<std::is_same<typename Container::mapped_type, Container>>::value>::type> {
+    static constexpr bool has_mapped_type = true;
+    static constexpr bool has_recursive_mapped_type = false;
+};
+
+// Does the container have a value type and is it recursive?
+// Implemented by specializations below.
 template <typename Container, typename SFINAE = void>
-struct is_recursive_container : any_of<is_container_with_recursive_value_type<Container>,
-                                       is_container_with_recursive_mapped_type<Container>> {};
+struct container_value_type_traits : std::false_type {
+    static constexpr bool has_value_type = false;
+    static constexpr bool has_recursive_value_type = false;
+};
 
-template <typename T, typename SFINAE = void>
-struct is_move_constructible : std::is_move_constructible<T> {};
+template <typename Container>
+struct container_value_type_traits<
+    Container,
+    typename std::enable_if<
+        std::is_same<typename Container::value_type, Container>::value>::type> {
+    static constexpr bool has_value_type = true;
+    static constexpr bool has_recursive_value_type = true;
+};
 
-// Specialization for types that appear to be move constructible but also look like stl containers
-// (we specifically check for: has `value_type` and `reference` with `reference = value_type&`): if
-// so, move constructability depends on whether the value_type is move constructible.
 template <typename Container>
-struct is_move_constructible<
+struct container_value_type_traits<
     Container,
-    enable_if_t<
-        all_of<std::is_move_constructible<Container>,
-               std::is_same<typename Container::value_type &, typename Container::reference>,
-               // Avoid infinite recursion
-               negation<is_recursive_container<Container>>>::value>>
-    : is_move_constructible<typename Container::value_type> {};
+    typename std::enable_if<
+        negation<std::is_same<typename Container::value_type, Container>>::value>::type> {
+    static constexpr bool has_value_type = true;
+    static constexpr bool has_recursive_value_type = false;
+};
+
+/*
+ * Tag to be used for representing the bottom of recursively defined types.
+ * Define this tag so we don't have to use void.
+ */
+struct recursive_bottom {};
+
+/*
+ * Implementation detail of `recursive_container_traits` below.
+ * `T` is the `value_type` of the container, which might need to be modified to
+ * avoid recursive types and const types.
+ */
+template <typename T, bool is_this_a_map>
+struct impl_type_to_check_recursively {
+    /*
+     * If the container is recursive, then no further recursion should be done.
+     */
+    using if_recursive = recursive_bottom;
+    /*
+     * Otherwise yield `T` unchanged.
+     */
+    using if_not_recursive = T;
+};
+
+/*
+ * For pairs - only as value type of a map -, the first type should remove the `const`.
+ * Also, if the map is recursive, then the recursive checking should consider
+ * the first type only.
+ */
+template <typename A, typename B>
+struct impl_type_to_check_recursively<std::pair<A, B>, /* is_this_a_map = */ true> {
+    using if_recursive = typename std::remove_const<A>::type;
+    using if_not_recursive = std::pair<typename std::remove_const<A>::type, B>;
+};
+
+/*
+ * Implementation of `recursive_container_traits` below.
+ */
+template <typename Container, typename SFINAE = void>
+struct impl_recursive_container_traits {
+    using type_to_check_recursively = recursive_bottom;
+};
+
+template <typename Container>
+struct impl_recursive_container_traits<
+    Container,
+    typename std::enable_if<container_value_type_traits<Container>::has_value_type>::type> {
+    static constexpr bool is_recursive
+        = container_mapped_type_traits<Container>::has_recursive_mapped_type
+          || container_value_type_traits<Container>::has_recursive_value_type;
+    /*
+     * This member dictates which type Pybind11 should check recursively in traits
+     * such as `is_move_constructible`, `is_copy_constructible`, `is_move_assignable`, ...
+     * Direct access to `value_type` should be avoided:
+     * 1. `value_type` might recursively contain the type again
+     * 2. `value_type` of STL map types is `std::pair<A const, B>`, the `const`
+     *    should be removed.
+     *
+     */
+    using type_to_check_recursively = typename if_then_else<
+        is_recursive,
+        typename impl_type_to_check_recursively<
+            typename Container::value_type,
+            container_mapped_type_traits<Container>::has_mapped_type>::if_recursive,
+        typename impl_type_to_check_recursively<
+            typename Container::value_type,
+            container_mapped_type_traits<Container>::has_mapped_type>::if_not_recursive>::type;
+};
+
+/*
+ * This trait defines the `type_to_check_recursively` which is needed to properly
+ * handle recursively defined traits such as `is_move_constructible` without going
+ * into an infinite recursion.
+ * Should be used instead of directly accessing the `value_type`.
+ * It cancels the recursion by returning the `recursive_bottom` tag.
+ *
+ * The default definition of `type_to_check_recursively` is as follows:
+ *
+ * 1. By default, it is `recursive_bottom`, so that the recursion is canceled.
+ * 2. If the type is non-recursive and defines a `value_type`, then the `value_type` is used.
+ *    If the `value_type` is a pair and a `mapped_type` is defined,
+ *    then the `const` is removed from the first type.
+ * 3. If the type is recursive and `value_type` is not a pair, then `recursive_bottom` is returned.
+ * 4. If the type is recursive and `value_type` is a pair and a `mapped_type` is defined,
+ *    then `const` is removed from the first type and the first type is returned.
+ *
+ * This behavior can be extended by the user as seen in test_stl_binders.cpp.
+ *
+ * This struct is exactly the same as impl_recursive_container_traits.
+ * The duplication achieves that user-defined specializations don't compete
+ * with internal specializations, but take precedence.
+ */
+template <typename Container, typename SFINAE = void>
+struct recursive_container_traits : impl_recursive_container_traits<Container> {};
+
+template <typename T>
+struct is_move_constructible
+    : all_of<std::is_move_constructible<T>,
+             is_move_constructible<
+                 typename recursive_container_traits<T>::type_to_check_recursively>> {};
+
+template <>
+struct is_move_constructible<recursive_bottom> : std::true_type {};
 
 // Likewise for std::pair
 // (after C++17 it is mandatory that the move constructor not exist when the two types aren't
@@ -883,21 +1000,14 @@ struct is_move_constructible<std::pair<T1, T2>>
 
 // std::is_copy_constructible isn't quite enough: it lets std::vector<T> (and similar) through when
 // T is non-copyable, but code containing such a copy constructor fails to actually compile.
-template <typename T, typename SFINAE = void>
-struct is_copy_constructible : std::is_copy_constructible<T> {};
+template <typename T>
+struct is_copy_constructible
+    : all_of<std::is_copy_constructible<T>,
+             is_copy_constructible<
+                 typename recursive_container_traits<T>::type_to_check_recursively>> {};
 
-// Specialization for types that appear to be copy constructible but also look like stl containers
-// (we specifically check for: has `value_type` and `reference` with `reference = value_type&`): if
-// so, copy constructability depends on whether the value_type is copy constructible.
-template <typename Container>
-struct is_copy_constructible<
-    Container,
-    enable_if_t<
-        all_of<std::is_copy_constructible<Container>,
-               std::is_same<typename Container::value_type &, typename Container::reference>,
-               // Avoid infinite recursion
-               negation<is_recursive_container<Container>>>::value>>
-    : is_copy_constructible<typename Container::value_type> {};
+template <>
+struct is_copy_constructible<recursive_bottom> : std::true_type {};
 
 // Likewise for std::pair
 // (after C++17 it is mandatory that the copy constructor not exist when the two types aren't
@@ -908,24 +1018,19 @@ struct is_copy_constructible<std::pair<T1, T2>>
     : all_of<is_copy_constructible<T1>, is_copy_constructible<T2>> {};
 
 // The same problems arise with std::is_copy_assignable, so we use the same workaround.
-template <typename T, typename SFINAE = void>
-struct is_copy_assignable : std::is_copy_assignable<T> {};
-template <typename Container>
-struct is_copy_assignable<
-    Container,
-    enable_if_t<
-        all_of<std::is_copy_assignable<Container>,
-               std::is_same<typename Container::value_type &, typename Container::reference>,
-               // Avoid infinite recursion
-               negation<is_recursive_container<Container>>>::value>>
-    : is_copy_assignable<typename Container::value_type> {};
+template <typename T>
+struct is_copy_assignable
+    : all_of<
+          std::is_copy_assignable<T>,
+          is_copy_assignable<typename recursive_container_traits<T>::type_to_check_recursively>> {
+};
+
+template <>
+struct is_copy_assignable<recursive_bottom> : std::true_type {};
+
 template <typename T1, typename T2>
 struct is_copy_assignable<std::pair<T1, T2>>
-    /*
-     * Need to remove the const qualifier from T1 here since the value_type in
-     * STL map types is std::pair<const Key, T>, and const types are never assignable
-     */
-    : all_of<is_copy_assignable<typename std::remove_const<T1>::type>, is_copy_assignable<T2>> {};
+    : all_of<is_copy_assignable<T1>, is_copy_assignable<T2>> {};
 
 PYBIND11_NAMESPACE_END(detail)
 
diff --git a/include/pybind11/stl_bind.h b/include/pybind11/stl_bind.h
index e90a228937..49f1b77821 100644
--- a/include/pybind11/stl_bind.h
+++ b/include/pybind11/stl_bind.h
@@ -61,21 +61,11 @@ struct is_comparable<
 /* For a vector/map data structure, recursively check the value type
    (which is std::pair for maps) */
 template <typename T>
-struct is_comparable<T,
-                     enable_if_t<container_traits<T>::is_vector &&
-                                 // Avoid this instantiation if the type is recursive
-                                 negation<is_recursive_container<T>>::value>> {
-    static constexpr const bool value = is_comparable<typename T::value_type>::value;
-};
+struct is_comparable<T, enable_if_t<container_traits<T>::is_vector>>
+    : is_comparable<typename recursive_container_traits<T>::type_to_check_recursively> {};
 
-/* Skip the recursion if the type itself is recursive */
-template <typename T>
-struct is_comparable<T,
-                     enable_if_t<container_traits<T>::is_vector &&
-                                 // Special case: The vector type is recursive
-                                 is_recursive_container<T>::value>> {
-    static constexpr const bool value = container_traits<T>::is_comparable;
-};
+template <>
+struct is_comparable<recursive_bottom> : std::true_type {};
 
 /* For pairs, recursively check the two data types */
 template <typename T>
diff --git a/tests/test_stl_binders.cpp b/tests/test_stl_binders.cpp
index d7c0c4942f..3c83655506 100644
--- a/tests/test_stl_binders.cpp
+++ b/tests/test_stl_binders.cpp
@@ -10,6 +10,7 @@
 #include <pybind11/numpy.h>
 #include <pybind11/stl_bind.h>
 
+#include "pybind11/detail/type_caster_base.h"
 #include "pybind11_tests.h"
 
 #include <deque>
@@ -86,7 +87,7 @@ struct RecursiveMap : std::map<int, RecursiveMap> {
 /*
  * Pybind11 does not catch more complicated recursion schemes, such as mutual
  * recursion.
- * In that case custom is_recursive_container specializations need to be added,
+ * In that case custom recursive_container_traits specializations need to be added,
  * thus manually telling pybind11 about the recursion.
  */
 struct MutuallyRecursiveContainerPairMV;
@@ -98,9 +99,13 @@ struct MutuallyRecursiveContainerPairVM : std::vector<MutuallyRecursiveContainer
 namespace pybind11 {
 namespace detail {
 template <typename SFINAE>
-struct is_recursive_container<MutuallyRecursiveContainerPairMV, SFINAE> : std::true_type {};
+struct recursive_container_traits<MutuallyRecursiveContainerPairMV, SFINAE> {
+    using type_to_check_recursively = recursive_bottom;
+};
 template <typename SFINAE>
-struct is_recursive_container<MutuallyRecursiveContainerPairVM, SFINAE> : std::true_type {};
+struct recursive_container_traits<MutuallyRecursiveContainerPairVM, SFINAE> {
+    using type_to_check_recursively = recursive_bottom;
+};
 } // namespace detail
 } // namespace pybind11
 

From 3ed36b8e30ddb09ba52670b9030ea31e41da6ed5 Mon Sep 17 00:00:00 2001
From: Franz Poeschel <franz.poeschel@gmail.com>
Date: Thu, 4 May 2023 14:52:09 +0200
Subject: [PATCH 15/16] Review suggestions

1. Use std::conditional
2. Fix typo
---
 include/pybind11/detail/type_caster_base.h | 15 +--------------
 tests/test_copy_move.cpp                   |  2 +-
 2 files changed, 2 insertions(+), 15 deletions(-)

diff --git a/include/pybind11/detail/type_caster_base.h b/include/pybind11/detail/type_caster_base.h
index 6af58ae902..6eca51a746 100644
--- a/include/pybind11/detail/type_caster_base.h
+++ b/include/pybind11/detail/type_caster_base.h
@@ -822,19 +822,6 @@ using movable_cast_op_type
                                   typename std::add_rvalue_reference<intrinsic_t<T>>::type,
                                   typename std::add_lvalue_reference<intrinsic_t<T>>::type>>;
 
-template <bool Condition, typename Then, typename Else>
-struct if_then_else {};
-
-template <typename Then, typename Else>
-struct if_then_else<true, Then, Else> {
-    using type = Then;
-};
-
-template <typename Then, typename Else>
-struct if_then_else<false, Then, Else> {
-    using type = Else;
-};
-
 // Does the container have a mapped type and is it recursive?
 // Implemented by specializations below.
 template <typename Container, typename SFINAE = void>
@@ -945,7 +932,7 @@ struct impl_recursive_container_traits<
      *    should be removed.
      *
      */
-    using type_to_check_recursively = typename if_then_else<
+    using type_to_check_recursively = typename std::conditional<
         is_recursive,
         typename impl_type_to_check_recursively<
             typename Container::value_type,
diff --git a/tests/test_copy_move.cpp b/tests/test_copy_move.cpp
index 705115f07f..f54733550a 100644
--- a/tests/test_copy_move.cpp
+++ b/tests/test_copy_move.cpp
@@ -298,7 +298,7 @@ TEST_SUBMODULE(copy_move_policies, m) {
 
 /*
  * Rest of the file:
- * static_assert based tests for pybind11 adaptations of of
+ * static_assert based tests for pybind11 adaptations of
  * std::is_move_constructible, std::is_copy_constructible and
  * std::is_copy_assignable (no adaptation of std::is_move_assignable).
  * Difference between pybind11 and std traits: pybind11 traits will also check

From 71521c44787becf5f0896aa868e823efecc5f217 Mon Sep 17 00:00:00 2001
From: Franz Poeschel <franz.poeschel@gmail.com>
Date: Thu, 4 May 2023 16:19:38 +0200
Subject: [PATCH 16/16] Remove leftover include from test

---
 tests/test_stl_binders.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/test_stl_binders.cpp b/tests/test_stl_binders.cpp
index 3c83655506..1681760aa8 100644
--- a/tests/test_stl_binders.cpp
+++ b/tests/test_stl_binders.cpp
@@ -10,7 +10,6 @@
 #include <pybind11/numpy.h>
 #include <pybind11/stl_bind.h>
 
-#include "pybind11/detail/type_caster_base.h"
 #include "pybind11_tests.h"
 
 #include <deque>