This page is a snapshot from the LWG issues list, see the Library Active Issues List for more information and the meaning of New status.

### 3609. `std::ranges::iota_view<int, long>` has non-subtractable `iterator` and `sentinel` types

Section: 24.6.4.4 [range.iota.sentinel] Status: New Submitter: Jiang An Opened: 2021-09-25 Last modified: 2021-10-14

Priority: 3

View all issues with New status.

Discussion:

Currently `std::ranges::iota_view<int, long>` uses its special `sentinel` type, as its `W` and `Bound` are different types and `Bound` is not `std::unreachable_sentinel_t`. However, as `W` (`int`) is not an iterator type, the iterator and sentinel types don't satisfy `std::sized_sentinel_for`, and thus not subtractable.

IMO we should handle `operator-` overloads for `iota_view::iterator` and `iota_view::sentinel` like `iota_view::size` and `operator-` for `iota_view::iterator`.

[2021-10-14; Reflector poll]

Set priority to 3 after reflector poll.

[Tim Song commented:]

We might be able to simplify the `(y_value > x.value_)` conditional since we know that we are working with an iterator and its sentinel.

Proposed resolution:

This wording is relative to N4892.

1. Modify 24.6.4.4 [range.iota.sentinel] as indicated:

   > >     namespace std::ranges {
   > >       template<weakly_incrementable W, semiregular Bound>
   > >         requires weakly-equality-comparable-with<W, Bound> && copyable<W>
   > >       struct iota_view<W, Bound>::sentinel {
   > >       private:
   > >         Bound bound_ = Bound(); // exposition only
   > >       public:
   > >         sentinel() = default;
   > >         constexpr explicit sentinel(Bound bound);

   > >         friend constexpr bool operator==(const iterator& x, const sentinel& y);

   > >         friend constexpr iter_difference_t<W>IOTA-DIFF-T(W) operator-(const iterator& x, const sentinel& y)
   > >           requires (is-integer-like<W> && is-integer-like<Bound>) || sized_sentinel_for<Bound, W>;

   > >         friend constexpr iter_difference_t<W>IOTA-DIFF-T(W) operator-(const sentinel& x, const iterator& y)
   > >           requires (is-integer-like<W> && is-integer-like<Bound>) || sized_sentinel_for<Bound, W>;
   > >       };
   > >     }

   > […]

   >     friend constexpr iter_difference_t<W>IOTA-DIFF-T(W) operator-(const iterator& x, const sentinel& y)
   >       requires (is-integer-like<W> && is-integer-like<Bound>) || sized_sentinel_for<Bound, W>;

   > > -3- Effects: Equivalent to: `return x.value_ - y.bound_;`

   > > >     using D = IOTA-DIFF-T(W);
   > > >     if constexpr (is-integer-like<W>) {
   > > >       auto y_value = W(y.bound_);
   > > >       if constexpr (is-signed-integer-like<W>) {
   > > >         return D(D(x.value_) - D(y_value));
   > > >       } else {
   > > >         return (y_value > x.value_)
   > > >           ? D(-D(y_value - x.value_))
   > > >           : D(x.value_ - y_value);
   > > >       }
   > > >     } else {
   > > >       return x.value_ - y.bound_;
   > > >     }

   >     friend constexpr iter_difference_t<W>IOTA-DIFF-T(W) operator-(const sentinel& x, const iterator& y)
   >       requires (is-integer-like<W> && is-integer-like<Bound>) || sized_sentinel_for<Bound, W>;

   > > -4- Effects: Equivalent to: `return -(y - x);`