iota | product types with a clean syntax | Functional Programming library

There are differences between the C++17 (C++98) iterator model and the C++20 Ranges iterator model that are not backwards compatible. The two big ones are:

1. The C++98 model requires that forward iterators have a reference that is either value_type& or value_type const&.
2. The C++98 model does not allow for contiguous iterators. The strongest category was random_access.

The consequence of (1) is pretty significant - it means that if you have an iterator that returns a prvalue (whether proxy reference or not), it can never be stronger than an input iterator. So, views::iota(1, 10), despite easily being able to support random access, is only, at best, a C++98 input range.

However, you can't just... remove this requirement. Existing code that assumes C++98 iterators and uses iterator_category to make judgements is perfectly within its rights to assume that if iterator_category is, say, bidirectional_iterator_tag, that its reference is some kind of lvalue reference to value_type.

What iterator_concept does is add a new C++20 layer that allows an iterator to both advertise its C++98/17 category and, distinctly, advertise its C++20 category. So going back to the iota_view example, that view's iterator has iterator_category set to input_iterator_tag (because the reference is a prvalue and so it does not satisfy the old requirements for even forward) but its iterator_concept is set to random_access_iterator_tag (because once we drop that restriction, we can easily support all the random access restrictions).

In [iterator.concepts.general], we have this magic function ITER_CONCEPT(I) which helps us figure out what tag to use in C++20.

The issue with (2) is that it was hard to just add a new contiguous_iterator_tag before due to the way that various C++98/17 code would check for that tag (lots of code might check for exactly random_access_iterator_tag). The iterator_concept approach avoids this problem by also introducing concepts that directly check the right thing for you (i.e. the random_access_iterator concept checks that ITER_CONCEPT(I) derives from random_access_iterator_tag, not that it simply is that).

Guidelines:

• If you're using an iterator in C++17, use std::iterator_traits::iterator_category.
• If you're using an iterator in C++20, use the std::meow_iterator concepts
• If you're writing an iterator in C++17, add the iterator_category alias and make sure you follow the forward iterator/reference restriction (or... don't, but it's on you)
• If you're writing an iterator in C++20, follow the guidance in P2259 which has a good description of the problem and how and when to provide the iterator_category and iterator_concept type aliases.

The concept of a sentinel is closely linked to a iterator as it is known from other languages, which support to advance and test whether you reached the end. A good example would be a zero-terminated string where you stop when you reached \0 but do not know the size in advance.

My assumption is that modeling it as a std::forward_iterator is enough for the use cases where you would need to convert a C++20 iterator with a sentinel to call an older algorithm.

I also think it should be possible to provide a generic implementation that could detect cases where the iterator provides more functionality. It would complicate the implementation in the standard library, maybe that was the argument against it. In generic code, you could still detect the special cases yourself to avoid wrapping a random access iterator.

But to my understanding, if you deal with a performance critical code section, you should be careful with wrapping everything as a std::common_iterator unless it is needed. I would not be surprised if the underlying variant introduces some overhead.

Because fold expressions are... expressions. A for loop is a statement. ... unpacking applies (with one or two exceptions) to expressions, not to statements.

Not quite the syntax you are after but you can also use filter using a lambda:

Do you have an idea if this is the correct expected behavior (and why)?

Yes: this is the expected behavior. It is an inherent property of the iteration model where we have operator* and operator++ as separate operations.

filter's operator++ has to look for the next underlying iterator that satisfies the predicate. That involves doing *it on transform's iterator which involves invoking the function. But once we find that next iterator, when we read it again, that will again invoke the transform. In a code snippet:

This is not standard C++ as of 2021.

This is a proposed syntax (named an ‘expansion statement’) meant for what can be described as a more-or-less loop analogue of if constexpr: a compile-time loop construct, unrolled syntactically. Its advantage over ordinary loops is that it allows iterating over heterogeneously-typed structures.

This syntax would allow writing loops like the following:

Modifying it in place is a no-go.

Consider that you have to insert something at every position. You would need to copy every single item into a temp place then copy them back.

You might argue that you could do it from the end, backwards. But if we have some deletions we would also need to store some of the elements there, potentially getting back to copying every element into some temp storage and back.

I think the fastest way would be to allocate a new array, and build it up, using the original as temp storage. This way you are guaranteed that each element is copied exactly once.

Now, depending on the types used (like ints, or pointers) this could be a lot faster than anything else you might cook up. If copies are expensive consider using moves, or pointers.

If you are worried about performance, you should benchmark you code and tune it. It's hard to argue precisely about performance without data.

If you're sure of the type, you just need to make it explicit by typecasting via the as keyword (https://dart.dev/guides/language/language-tour#type-test-operators).

For example: