try to take advantage of existing infra

Author: EricCousineau-TRI

include/pybind11/cast.h

@@ -759,6 +759,10 @@ template <typename T> struct handle_type_name { static constexpr auto name = _<T
 template <> struct handle_type_name<bytes> { static constexpr auto name = _(PYBIND11_BYTES_NAME); };
 template <> struct handle_type_name<int_> { static constexpr auto name = _("int"); };
 template <> struct handle_type_name<iterable> { static constexpr auto name = _("Iterable"); };
+template <typename T>
+struct handle_type_name<iterable_t<T>> {
+    static constexpr auto name = _("Iterable[") + type_caster<T>::name + _("]");
+}
 template <> struct handle_type_name<iterator> { static constexpr auto name = _("Iterator"); };
 template <> struct handle_type_name<none> { static constexpr auto name = _("None"); };
 template <> struct handle_type_name<args> { static constexpr auto name = _("*args"); };
@@ -795,36 +799,6 @@ struct pyobject_caster {
     PYBIND11_TYPE_CASTER(type, handle_type_name<type>::name);
 };
 
-// Specialize for iterator_t<T>.
-template <typename T>
-struct iterable_t_type_caster : type_caster<py::iterable> {
-    using Base = type_caster<py::iterable>;
-    using MyType = iterable_t<T>;
-
-    // Python to C++.
-    bool load(handle src, bool convert) {
-        if (!isinstance<py::iterable>(src)) {
-            return false;
-        }
-        for (handle src_i : src) {
-            // TODO: Would be nice if we could use something like
-            // `check(h, convert)` where nothing is necessarily converted.
-            if (!isinstance<T>(src_i)) {
-                return false;
-            }
-        }
-        return Base::load(src, convert);
-    }
-
-    static constexpr auto name = _("Iterable[") + type_caster<T>::name + _("]");
-    operator MyType() {
-        py::iterable h = static_cast<py::iterable>(*static_cast<Base*>(this));
-        return MyType(h);
-    }
-    template <typename U>
-    using cast_op_type = MyType;
-};
-
 template <typename T>
 class type_caster<T, enable_if_t<is_pyobject<T>::value>> : public pyobject_caster<T> { };
 

include/pybind11/pytypes.h

@@ -763,6 +763,39 @@ inline bool PyIterable_Check(PyObject *obj) {
     }
 }
 
+template <typename T>
+bool PyIterableT_Check(PyObject *obj) {
+    static_assert(
+        is_generic_type<T>::value || is_pyobject<T>::value,
+        "iterable_t can only be used with pyobjects and generic types "
+        "(py::class_<T>");
+    PyObject *iter = PyObject_GetIter(obj);
+    if (iter) {
+        if (iter == obj) {
+            // If they are the same, then that's bad! For now, just throw a
+            // cast error.
+            Py_DECREF(iter);
+            throw cast_error(
+                "iterable_t<T> cannot be used with exhausitble iterables "
+                "(e.g., iterators, generators).");
+        }
+        bool good = true;
+        // Now that we know that the iterable `obj` will not be exhausted,
+        // let's check the contained types.
+        for (handle h : handle(iter)) {
+            if (!isinstance<T>(h)) {
+                good = false;
+                break;
+            }
+        }
+        Py_DECREF(iter);
+        return good;
+    } else {
+        PyErr_Clear();
+        return false;
+    }
+}
+
 inline bool PyNone_Check(PyObject *o) { return o == Py_None; }
 inline bool PyEllipsis_Check(PyObject *o) { return o == Py_Ellipsis; }
 
@@ -953,17 +986,16 @@ class iterable : public object {
 
 /// Provides similar interface to `iterable`, but constraining the intended
 /// type.
-/// @warning Due to usage of `isinstance<T>()` in the related type-caster, this
-/// does *not* work for iterables of type-converted values (e.g. `int`).
+/// @warning Due to technical reasons, this is constrained in two ways:
+/// - Due to how `isinstance<T>()` works, this does *not* work for iterables of
+///   type-converted values (e.g. `int`).
+/// - Because we must check the contained types within the iterable (for
+///   overloads), we must iterate through the iterable. For this reason, the
+///   iterable should *not* be exhaustible (e.g., iterator, generator).
 template <typename T>
-class iterable_t : public py::iterable {
+class iterable_t : public iterable {
 public:
-    // See type_caster specialization.
-    static_assert(
-        is_generic_type<T>::value || is_pyobject<T>::value,
-        "iterable_t can only be used with pyobjects and generic types "
-        "(py::class_<T>");
-    using py::iterable::iterable;
+    PYBIND11_OBJECT_DEFAULT(iterable_t, iterable, detail::PyIterableT_Check<T>)
 };
 
 class bytes;