Exchanging Variant with non-copyable Members

[WillAyd]

When working with a variant, the type caster seems to work perfectly as long as the variant members are copyable, i.e. with a setup like:

#include <nanobind/nanobind.h>
#include <nanobind/stl/variant.h>

#include <iostream>
#include <variant>

namespace nb = nanobind;

class A {};

class B {};

using MyVariant = std::variant<A, B>;

template <class... Ts> struct overloaded : Ts... {
  using Ts::operator()...;
};
template<class... Ts>
overloaded(Ts...) -> overloaded<Ts...>;

auto Visit (const MyVariant &mv) {
  std::visit(overloaded{
      [](A arg) { std::cout << "Class A found" << std::endl; },
      [](B arg) { std::cout << "Class B found" << std::endl; }
    }, mv);
};

NB_MODULE(my_ext, m) {
  nb::class_<A>(m, "A").def(nb::init<>()).def("visit", &Visit);
  nb::class_<B>(m, "B").def(nb::init<>())
    .def("visit", &Visit);  
}

Types are properly exchanged and recognized between Python and C++:

>>> import my_ext
>>> my_ext.A().visit()
Class A found
>>> my_ext.B().visit()
Class B found

However, if A or B were not copyable, the program would fail to compile:

../subprojects/nanobind/include/nanobind/nb_func.h: In instantiation of ‘PyObject* nanobind::detail::func_create(Func&&, Return (*)(Args ...), std::index_sequence<Is2 ...>, const Extra& ...) [with bool ReturnRef = false; bool CheckGuard = true; Func = void (*&)(const std::variant<A, B>&); Return = void; Args = {const std::variant<A, B>&}; long unsigned int ...Is = {0}; Extra = {nanobind::scope, nanobind::name, nanobind::is_method}; PyObject = _object; std::index_sequence<Is2 ...> = std::integer_sequence<long unsigned int, 0>]’:
../subprojects/nanobind/include/nanobind/nb_func.h:187:37:   required from ‘void nanobind::cpp_function_def(Return (*)(Args ...), const Extra& ...) [with Return = void; Args = {const std::variant<A, B>&}; Extra = {nanobind::scope, nanobind::name, nanobind::is_method}]’
../subprojects/nanobind/include/nanobind/nb_class.h:453:25:   required from ‘nanobind::class_<T, Ts>& nanobind::class_<T, Ts>::def(const char*, Func&&, const Extra& ...) [with Func = void (*)(const std::variant<A, B>&); Extra = {}; T = A; Ts = {}]’
../my_ext.cpp:39:46:   required from here
../subprojects/nanobind/include/nanobind/nb_func.h:134:37: error: use of deleted function ‘nanobind::detail::tuple<T, Ts ...>::tuple() [with T = nanobind::detail::type_caster<std::variant<A, B>, int>; Ts = {}]’
  134 |         tuple<make_caster<Args>...> in;
      |                                     ^~
In file included from ../subprojects/nanobind/include/nanobind/nanobind.h:42,
                 from ../my_ext.cpp:1:
../subprojects/nanobind/include/nanobind/nb_tuple.h:33:5: note: ‘nanobind::detail::tuple<T, Ts ...>::tuple() [with T = nanobind::detail::type_caster<std::variant<A, B>, int>; Ts = {}]’ is implicitly deleted because the default definition would be ill-formed:
   33 |     tuple() = default;
      |     ^~~~~
../subprojects/nanobind/include/nanobind/nb_tuple.h:33:5: error: use of deleted function ‘nanobind::detail::type_caster<std::variant<A, B>, int>::type_caster()’
In file included from ../my_ext.cpp:2:
../subprojects/nanobind/include/nanobind/stl/variant.h:40:34: note: ‘nanobind::detail::type_caster<std::variant<A, B>, int>::type_caster()’ is implicitly deleted because the default definition would be ill-formed:
   40 | template <typename... Ts> struct type_caster<std::variant<Ts...>> {
      |                                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
../subprojects/nanobind/include/nanobind/stl/variant.h:40:34: error: use of deleted function ‘std::variant<_Types>::variant() [with _Types = {A, B}]’
In file included from ../subprojects/nanobind/include/nanobind/stl/variant.h:13,
                 from ../my_ext.cpp:2:
/usr/include/c++/11/variant:1395:7: note: ‘std::variant<_Types>::variant() [with _Types = {A, B}]’ is implicitly deleted because the default definition would be ill-formed:
 1395 |       variant() = default;
      |       ^~~~~~~
/usr/include/c++/11/variant:1395:7: error: use of deleted function ‘constexpr std::_Enable_default_constructor<false, _Tag>::_Enable_default_constructor() [with _Tag = std::variant<A, B>]’
In file included from /usr/include/c++/11/variant:38,
                 from ../subprojects/nanobind/include/nanobind/stl/variant.h:13,
                 from ../my_ext.cpp:2:
/usr/include/c++/11/bits/enable_special_members.h:113:15: note: declared here
  113 |     constexpr _Enable_default_constructor() noexcept = delete;

This makes sense given the type casters always copy. I assume bind_variant if it existed would be the better option here, although I'm still not entirely sure that is the right approach, given there is nothing that the Variant itself needs to expose to Python.

Are there any ideas or guidance on the best way to make this work?

[wjakob]

This kind of thing is beyond the scope of what nanobind can provide out of the box given its philosophy on being simple and requiring the C++ codebase to adapt. It might be possible with pybind11, though I am not 100% sure.

[yosh-matsuda]

How about using variant of pointers?

using MyVariant = std::variant<A*, B*>;