fix: <ranges> support for py::tuple and py::list

include/pybind11/detail/common.h

@@ -271,6 +271,18 @@ PYBIND11_WARNING_DISABLE_MSVC(4505)
 #    endif
 #endif
 
+#if defined(PYBIND11_CPP20)
+#    if __has_include(<ranges>) // __has_include has been part of C++17, no need to check it
+#        if !defined(PYBIND11_COMPILER_CLANG)
+#            define PYBIND11_HAS_RANGES
+#        else
+#            if __clang_major__ >= 16 // llvm/llvm-project#52696
+#                define PYBIND11_HAS_RANGES
+#            endif
+#        endif
+#    endif
+#endif
+
 #include <Python.h>
 #if PY_VERSION_HEX < 0x03080000
 #    error "PYTHON < 3.8 IS UNSUPPORTED. pybind11 v2.13 was the last to support Python 3.7."

include/pybind11/pytypes.h

@@ -1259,6 +1259,7 @@ class sequence_fast_readonly {
     using pointer = arrow_proxy<const handle>;
 
     sequence_fast_readonly(handle obj, ssize_t n) : ptr(PySequence_Fast_ITEMS(obj.ptr()) + n) {}
+    sequence_fast_readonly() = default;
 
     // NOLINTNEXTLINE(readability-const-return-type) // PR #3263
     reference dereference() const { return *ptr; }
@@ -1281,6 +1282,7 @@ class sequence_slow_readwrite {
     using pointer = arrow_proxy<const sequence_accessor>;
 
     sequence_slow_readwrite(handle obj, ssize_t index) : obj(obj), index(index) {}
+    sequence_slow_readwrite() = default;
 
     reference dereference() const { return {obj, static_cast<size_t>(index)}; }
     void increment() { ++index; }

tests/test_pytypes.cpp

@@ -12,6 +12,9 @@
 #include "pybind11_tests.h"
 
 #include <utility>
+#if defined(PYBIND11_HAS_RANGES)
+#    include <ranges>
+#endif
 
 namespace external {
 namespace detail {
@@ -923,4 +926,41 @@ TEST_SUBMODULE(pytypes, m) {
 #else
     m.attr("defined_PYBIND11_TYPING_H_HAS_STRING_LITERAL") = false;
 #endif
+
+#if defined(PYBIND11_HAS_RANGES) // test_ranges
+    m.attr("defined_PYBIND11_HAS_RANGES") = true;
+    m.def("iterator_default_initialization", []() {
+        using TupleIterator = decltype(py::tuple{}.begin());
+        using ListIterator = decltype(py::list{}.begin());
+        using DictIterator = decltype(py::dict{}.begin());
+        return py::bool_(
+            TupleIterator{} == TupleIterator{} && ListIterator{} == ListIterator{}
+            && DictIterator{}
+                   == DictIterator{}); // value initialization result must compared as true
+    });
+
+    m.def("transform_tuple_plus_one", [](py::tuple &tpl) {
+        static_assert(std::ranges::random_access_range<py::tuple>);
+        for (auto it : tpl | std::views::transform([](auto &o) { return py::cast<int>(o) + 1; })) {
+            py::print(it);
+        }
+    });
+    m.def("transform_list_plus_one", [](py::list &lst) {
+        static_assert(std::ranges::random_access_range<py::list>);
+        for (auto it : lst | std::views::transform([](auto &o) { return py::cast<int>(o) + 1; })) {
+            py::print(it);
+        }
+    });
+    m.def("transform_dict_plus_one", [](py::dict &dct) {
+        static_assert(std::ranges::forward_range<py::dict>);
+        for (auto it : dct | std::views::transform([](auto &o) {
+                           return std::pair{py::cast<int>(o.first) + 1,
+                                            py::cast<int>(o.second) + 1};
+                       })) {
+            py::print("{} : {}"_s.format(it.first, it.second));
+        }
+    });
+#else
+    m.attr("defined_PYBIND11_HAS_RANGES") = false;
+#endif
 }

tests/test_pytypes.py

@@ -1048,3 +1048,46 @@ def test_typevar(doc):
     assert doc(m.annotate_listT_to_T) == "annotate_listT_to_T(arg0: list[T]) -> T"
 
     assert doc(m.annotate_object_to_T) == "annotate_object_to_T(arg0: object) -> T"
+
+
+@pytest.mark.skipif(
+    not m.defined_PYBIND11_HAS_RANGES, reason="C++20 <ranges> not available."
+)
+def test_ranges(capture):
+    assert m.iterator_default_initialization
+
+    with capture:
+        m.transform_tuple_plus_one((1, 2, 3))
+
+    assert (
+        capture.unordered
+        == """
+        2
+        3
+        4
+    """
+    )
+
+    with capture:
+        m.transform_list_plus_one([1, 2, 3])
+
+    assert (
+        capture.unordered
+        == """
+        2
+        3
+        4
+    """
+    )
+
+    with capture:
+        m.transform_dict_plus_one({1: 2, 3: 4, 5: 6})
+
+    assert (
+        capture.unordered
+        == """
+        2 : 3
+        4 : 5
+        6 : 7
+    """
+    )