pybind11 and ownership issues

I'm writing a pybind11 wrapper for a tuple-like class, and I'd like it have __iter__ method.

To do this, I convert the "tuple" fields to a vector of variants and define "__iter__" like this:

cls.def(
  "__iter__", 
  [](const MyTuple& t){
      // some metaprogramming to get the underlying types of MyTuple
      using my_variant = std::variant<...>;
      std::vector<my_variant> fields; // local!
      fill(fields); // fill with t's fields converted to my_variant
      return py::make_iterator(begin(fields), end(fields));
  },
  py::keep_alive<0, 1>()
); 

Of course, this is a bad idea, because fields will die as soon as it goes out of scope.

Other than defining a custom holder for MyTuple (which would encapsulate this vector), is there a simple trick that could pass the ownership of this auxiliary vector to pybind11?

If I do define a custom holder, is it possible to access it from py::class_?

If your tuple class can be used with std::apply (or if you can do something similar), you can simply create a Python tuple and return its iterator:

.def("__iter__", 
    [](const MyTuple& t){
        return py::iter(std::apply(
            [](auto&&... args) {
                return py::make_tuple(args...);
            },
            t));
    }) // no need for keep_alive here

You could also create a custom iterator, e.g.

template <class Tuple>
struct tuple_iterator;

template <template <typename...> typename Tuple, typename... Args>
struct tuple_iterator<Tuple<Args...>> {
    using TupleType   = Tuple<Args...>;
    using VariantType = std::variant<std::add_pointer_t<std::add_const_t<Args>>...>;

    tuple_iterator() : index_{sizeof...(Args)}, values_{} {}

    tuple_iterator(TupleType const& tuple) : index_{0} {
        std::apply(
            [this](auto const&... args) {
                values_ = {VariantType{&args}...};
            },
            tuple.v);
    }

    VariantType operator*() const { return values_[index_]; }

    tuple_iterator& operator++() {
        ++index_;
        return *this;
    }

    friend bool operator==(tuple_iterator const& lhs, tuple_iterator const& rhs) {
        return lhs.index_ == rhs.index_;
    }

private:
    std::size_t index_;
    std::vector<VariantType> values_;
};

Then you can simply:

.def("__iter__",
    [](MyTuple const& tuple) {
        return py::make_iterator(
            tuple_iterator<MyTuple>{tuple},
            tuple_iterator<MyTuple>{},
            py::return_value_policy::reference_internal);
    },
    py::keep_alive<0, 1>()
)

The second version has the advantage of not making copy of the objects.