Auto-wrapping `std::vector<T>` etc. as view

It would be really useful to have a way to convert std::vector<T> to T[::1] in Cython. This would allow zero-copy usage of std::vector<T>'s data in Python or other Cython contexts.

Here’s some dummy code illustrating a bit more how one might like to use this.

cdef vector[uint8_t] v = memoryview(b"abc")
cdef uint8_t[::1] d = v

[scoder]

Do you have thoughts on how we handle this templating in this new object?

Hmm, right, mapping the item type is an issue. A case like vector[int] is simple (items would be Python int objects), but a vector[vector[int]] would then return copied int-lists as items again, and it’s not obvious how to let users map those.

Although, why not listview(container, mapping_function)? Where the optional mapping_function could also be cython.listview, amongst other things, and the default would just be the normal C->Python type mapping.

I don’t see this as a plain object implementation. It can well be a language feature with deep integration into the type system. It can be implemented with Cython code generation, like fused types or the C++ type mappings. Maybe with a base class that can then be shared across different Cython modules. (Not sure if the latter is helpful, maybe for type checks?)

And if the item type is one that is supported by the buffer protocol (including structs etc.), then the generated type could include support for the buffer protocol. (vector can apparently provide access to its buffer).

[da-woods]

Practically it would have to be generated code like the code for struct conversion since it isn’t possible to template cdef classes.