Why does views::reverse not work with iota_view

Question

I have the following C++ program, and for some reason I can not use int64_t as template argument.

#include <iostream>
#include <ranges>

template<typename T> 
void fn() {
    for (auto val : std::ranges::iota_view{T{1701}, T{8473}} 
                  | std::views::reverse
                  | std::views::take(5))
    {
        std::cout << val << std::endl;
    }

}

int main()
{
    fn<int16_t>();
    fn<int32_t>();
    // does not compile:
    // fn<int64_t>();
}

Is this expected(I am doing something wrong), or is it just some unfortunate bug in compiler/std lib?

Note: when I remove std::views::reverse code compiles for int64_t also.

You can reduce the problem to https://godbolt.org/z/vzxWjzYqr and you get a soup of template errors. Curious! — bradgonesurfing, May 17 '21 at 16:16
You haven't included the definition of `int16_t`, `int32_t` and `int64_t`. — eerorika, May 17 '21 at 16:19
Does this answer your question? [C++20 ranges too many | operators?](https://stackoverflow.com/questions/66130679/c20-ranges-too-many-operators) — Gaurav Sehgal, May 17 '21 at 16:22
@GauravSehgal I would guess not, since although I do not understand that answer, I do not feel it explains the int16 && int32 vs int64 difference — NoSenseEtAl, May 17 '21 at 16:24
Seems iota_view is flaky across compilers. This https://godbolt.org/z/1PoGTMEsY works with gcc but not with clang and it is the int32_t example. — bradgonesurfing, May 17 '21 at 16:25
Clang even fails to compile the example given on cppreference for how to use iota_view https://godbolt.org/z/1PjP6enqc https://en.cppreference.com/w/cpp/ranges/iota_view — bradgonesurfing, May 17 '21 at 16:36

score 9 · Accepted Answer · edited May 17 '21 at 18:11

This is a libstdc++ bug, submitted 100639.

iota is a surprisingly complex range. In particular, we need to pick a difference_type that is sufficiently wide for the type that we're incrementing to avoid overflow (see also P1522). As a result, we have in [range.iota]:

Let IOTA-DIFF-T(W) be defined as follows:

[...]

Otherwise, IOTA-DIFF-T(W) is a signed integer type of width greater than the width of W if such a type exists.

Otherwise, IOTA-DIFF-T(W) is an unspecified signed-integer-like type ([iterator.concept.winc]) of width not less than the width of W.

[Note 1: It is unspecified whether this type satisfies weakly_incrementable. — end note]

For iota_view<int64_t, int64_t>, our difference type is __int128 (a wide-enough signed integral type). On gcc, signed_integral<__int128> is false when compiling in conforming mode (-std=c++20) and true with extensions (-std=gnu++20).

Now, in libstdc++, reverse_view is implemented as:

template<typename _Iterator>
class reverse_iterator
  : public iterator<typename iterator_traits<_Iterator>::iterator_category,
                    typename iterator_traits<_Iterator>::value_type,
                    typename iterator_traits<_Iterator>::difference_type,
                    typename iterator_traits<_Iterator>::pointer,
                    typename iterator_traits<_Iterator>::reference>
{
  // ...
  typedef typename __traits_type::reference reference;
  // ...
  _GLIBCXX17_CONSTEXPR reference operator*() const;
  // ...
};

This isn't how reverse_iterator is specified. [reverse.iterator] defines the reference type as:

using reference = iter_reference_t<Iterator>;

The difference is that the latter just means the type of *it, while the former actually goes through iterator_traits and tries to determine what reference means if It::reference doesn't exist as a type. That determination is specified in [iterator.traits]:

Otherwise, if I satisfies the exposition-only concept cpp17-input-iterator, iterator_traits has the following publicly accessible members: [...]

where reference is I::reference if it exists or iter_reference_t if it doesn't. That looks like it's the same thing, but we have to first satisfy cpp17-input-iterator. And cpp17-input-iterator requires, among other things:

template<class I>
concept cpp17-input-iterator =
  cpp17-iterator<I> && equality_comparable<I> && requires(I i) {
    // ...
    requires signed_integral<typename incrementable_traits<I>::difference_type>;
  };

So basically, iterator_t<iota_view<int64_t, int64_t>> satsifies cpp17-input-iterator if and only if signed_integral<__int128> holds, which is only true if we're compiling in -std=gnu++20.

But we shouldn't need to meet this requirement, since reverse_iterator should just directly use iter_reference_t and not go through iterator_traits, which side-steps having to check signed_integral<__int128>.

Why does views::reverse not work with iota_view

1 Answers1