WIP pytypes: Add iterable_t<>

Author: EricCousineau-TRI

include/pybind11/cast.h

@@ -50,6 +50,18 @@ PYBIND11_NAMESPACE_BEGIN(detail)
 template <typename type, typename SFINAE = void> class type_caster : public type_caster_base<type> { };
 template <typename type> using make_caster = type_caster<intrinsic_t<type>>;
 
+template <
+    typename T,
+    enable_if_t<std::is_base<type_caster_generic, make_caster<T>
+    >
+struct is_generic_type : public std::true_type {};
+
+template <
+    typename T,
+    enable_if_t<!std::is_base<type_caster_generic, make_caster<T>
+    >
+struct is_generic_type : public std::false_type {};
+
 // Shortcut for calling a caster's `cast_op_type` cast operator for casting a type_caster to a T
 template <typename T> typename make_caster<T>::template cast_op_type<T> cast_op(make_caster<T> &caster) {
     return caster.operator typename make_caster<T>::template cast_op_type<T>();
@@ -752,6 +764,7 @@ template <> struct handle_type_name<none> { static constexpr auto name = _("None
 template <> struct handle_type_name<args> { static constexpr auto name = _("*args"); };
 template <> struct handle_type_name<kwargs> { static constexpr auto name = _("**kwargs"); };
 
+
 template <typename type>
 struct pyobject_caster {
     template <typename T = type, enable_if_t<std::is_same<T, handle>::value, int> = 0>
@@ -782,6 +795,36 @@ 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

@@ -26,6 +26,11 @@ PYBIND11_NAMESPACE_BEGIN(detail)
 class args_proxy;
 inline bool isinstance_generic(handle obj, const std::type_info &tp);
 
+// Indicates that type is generic and and does not have a specialized
+// `type_caster<>` specialization. Defined in `cast.h`.
+template <typename T, typename SFINAE>
+struct is_generic_type;
+
 // Accessor forward declarations
 template <typename Policy> class accessor;
 namespace accessor_policies {
@@ -380,13 +385,18 @@ class error_already_set : public std::runtime_error {
 /** \ingroup python_builtins
     \rst
     Return true if ``obj`` is an instance of ``T``. Type ``T`` must be a subclass of
-    `object` or a class which was exposed to Python as ``py::class_<T>``.
+    `object` or a class which was exposed to Python as ``py::class_<T>`` (generic).
 \endrst */
 template <typename T, detail::enable_if_t<std::is_base_of<object, T>::value, int> = 0>
 bool isinstance(handle obj) { return T::check_(obj); }
 
 template <typename T, detail::enable_if_t<!std::is_base_of<object, T>::value, int> = 0>
-bool isinstance(handle obj) { return detail::isinstance_generic(obj, typeid(T)); }
+bool isinstance(handle obj) {
+    static_assert(
+        is_generic_type<T>::value,
+        "isisntance<T>() requires specialization for this type");
+    return detail::isinstance_generic(obj, typeid(T));
+}
 
 template <> inline bool isinstance<handle>(handle) = delete;
 template <> inline bool isinstance<object>(handle obj) { return obj.ptr() != nullptr; }
@@ -941,6 +951,21 @@ class iterable : public object {
     PYBIND11_OBJECT_DEFAULT(iterable, object, detail::PyIterable_Check)
 };
 
+/// 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`).
+template <typename T>
+class iterable_t : public py::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;
+};
+
 class bytes;
 
 class str : public object {