CXXIter VS range-v3

I mostly agree. Though more often than not, it's not as easy as just switching to another language. If you've got a large codebase in C++, switching to Rust is unpracticable. But I think there are some nice lessons to be learned from Rust, that can be translated over to C++. I liked the idea of having the data stored within the locking structure, so it's impossible to access it incorrectly e.g.. And for iterators, I basically cloned Rust's interface in a C++20 library: https://github.com/seijikun/CXXIter

I'm especially intrigued by the way you implemented your usable interface that contains all of the chainable methods. I used a large struct where I manually added methods for every supported operator. And the operators themselves are then implemented each with their own struct in the back. Arguably, that makes it impossible to extend the public interface from the outside as a user. If I understood it correctly, that's where you used your member_overload mechanism, right? I'm still digging and trying to understand how it works though.

I thought it might be a nice opportunity to get to know C++20 in the process, so I first read up about the new features, and then started applying them to a little iterator library I call CXXIter... that then somehow ended up getting a little bigger and more ergonomic than I had expected. I took inspiration for functions and appearance from LINQ, as well as from Rust's iterators. CXXIter allows passing elements as references, as well as using moves to pass them through the iterator. I know that there already are a couple of these libraries - but what would programming be without a little NIH here and there? :)

std::ranges is in c++20, but you can pull in the library it was based on if you use 17 (https://github.com/ericniebler/range-v3)

What you are describing seems to be std::ranges. If you’re interested in understanding how to implement it, I recommend checking out the original reference implementation, rangev3. Trying to implement your own ranges framework is really good practice for learning how to do efficient, advanced generic programming in C++. I highly recommend it as a hobby learning project. But it’s also really, really hard to do correctly, so please just use the stdlib and/or rangev3 in any real project.

In C++23, there will be std::views::cartesian_product. It is already available in the range-v3 library, the one that the standard is based on.

/** * @brief Forwards value equivalent to the std::forward. * * Using cast instead of std::forward to avoid template instantiation. Used by * Eric Niebler in range library. * * @see https://github.com/ericniebler/range-v3 */

It uses a custom zip_iterator (which isn't very good, and you should really use the one from boost or from range-v3).

It contains very little functionality compared to the Eric Niebler’s reference implementation for my liking. Especially views. This will undoubtedly change in the future. But the point is moot, because they are not really supported the is no other option for now other than https://github.com/ericniebler/range-v3.

range-v3 is a great library allowing you to bridge the gap: https://github.com/ericniebler/range-v3

[range-v3](https://github.com/ericniebler/range-v3) which std::ranges was based on has the `to>()` which as far as I know is expected to get into c++23 :)