Binding STL containers containing custom types

[nicholasjng]

Thank you for making this library! I am taking my first steps in it right now (without having much pybind11 experience), and I am still trying to understand some of the basic concepts.

Right now, I am trying to port a pybind11 extension to nanobind. It's almost a drop-in replacement of py -> nb, but there is one blocker remaining: In the extension, a map with a custom type Foo as value type is being exported to Python via py::bind_map (with a MAKE_OPAQUE declaration):

typedef std::map<std::string, Foo> FooMap;

Now bind_map is not ported over yet, so I attempted some workarounds. In short, I arrived at the conclusion of adding a bare nb::class_<FooMap>(m, "FooMap") declaration like suggested in #11, but this ends up erroring out my tests because the resulting Python FooMap does not support item assignment.

I guess I could get this to work by adding the __setitem__ and __getitem__ methods on the nb::class_<FooMap>, as py::bind_map would have done (along with the other methods).

But say I do not care about a custom FooMap type, and would like it to end up as a dict[str, Foo] in Python. If that's possible, what do I need to do to achieve this?

PS: I am in fact registering my Foo type as a nanobind class as well, if that helps. After reading up on the casting implementation, it felt naturally to me to just look for a way to implement casting for it and then leverage the casters in nanobind/stl/{map|vector}.h for an immediate solution. Is it as "simple" as implementing a value caster for my Foo type?

[wjakob]

You can simply include nanobind/stl/map.h and either bind your Foo type using nb::class_<> or implement a custom caster for it. This should be enough to get an automatic bidirectional conversion between the STL type and dict[str, Foo].

The main disadvantage of such an approach is performance when dealing with large maps. Every time you call a method that takes such a map as an input, all elements will be converted. Perhaps that's what you will need to do anyway, and then it does not matter. But if the function only accesses, say, 1 element in a map with millions of entries, then the py::bind_map approach from pybind11 will be superior.

There really isn't anything magic in py::bind_map that couldn't be realized on top of nanobind. It's just that nobody has bothered to port it over yet. I would be happy to accept PRs in this direction, as long as they are sufficiently self-contained and don't add complexity to nanobind itself (which should not be necessary as this feature can be implemented using standard constructions).

[nicholasjng]

Thanks, that worked! I am now running into what is described in https://pybind11.readthedocs.io/en/stable/advanced/cast/stl.html#making-opaque-types , where I do not pick up map values being inserted in Python back on the C++ side. I guess I need to use an opaque type instead.
I will give implementing nb::bind_map a shot, then. Thank you for the quick answer!