2) Calculates the difference type for both iterator types and integer-like types.

• If I is not an integral type, or if it is an integral type and sizeof(std::iter_difference_t<I>) is greater than sizeof(I), then /*iota-diff-t*/<I> is std::iter_difference_t<I>.
• Otherwise, /*iota-diff-t*/<I> is a signed integer type of width greater than the width of I if such a type exists.
• Otherwise, I is one of the widest integral types, and /*iota-diff-t*/<I> is an unspecified signed-integer-like type of width not less than the width of I. It is unspecified whether /*iota-diff-t*/<I> models weakly_incrementable in this case.

3) Type I models decrementable only if I satisfies decrementable and all concepts it subsumes are modeled, and given equal objects a and b of type I:

• If a and b are in the domain of both pre- and post- operator-- (i.e. they are decrementable), then the following are all true:
  • std::addressof(--a) == std::addressof(a),
  • bool(a-- == b),
  • bool(((void)a--, a) == --b),
  • bool(++(--a) == b).
• If a and b are in the domain of both pre- and post- operator++ (i.e. they are incrementable), then bool(--(++a) == b) is true.

4) Let D denote /*iota-diff-t*/<I>. Type I models advanceable only if I satisfies advanceable and all concepts it subsumes are modeled, and given

• objects a and b of type I and
• value n of type D,

such that b is reachable from a after n applications of ++a, all following conditions are satisfied:

• (a += n) is equal to b.
• std::addressof(a += n) is equal to std::addressof(a).
• I(a + n) is equal to (a += n).
• For any two positive values x and y of type D, if I(a + D(x + y)) is well-defined, then I(a + D(x + y)) is equal to I(I(a + x) + y).
• I(a + D(0)) is equal to a.
• If I(a + D(n - 1)) is well-defined, then I(a + n) is equal to [](I c) { return ++c; }(I(a + D(n - 1))).
• (b += -n) is equal to a.
• (b -= n) is equal to a.
• std::addressof(b -= n) is equal to std::addressof(b).
• I(b - n) is equal to (b -= n).
• D(b - a) is equal to n.
• D(a - b) is equal to D(-n).
• bool(a <= b) is true.

std::ranges::iota_view::iterator::iterator

1) Value initializes value_.

2) Initializes value_ with value.

std::ranges::iota_view::iterator::operator*

Returns value_.

Example

#include <cassert>
#include <ranges>

int main()
{
    auto it{std::views::iota(6, 9).begin()};
    const int& r = *it; // binds with temporary
    assert(*it == 6 and r == 6);
    ++it;
    assert(*it == 7 and r == 6);
}

std::ranges::iota_view::iterator::operator++

1) Equivalent to ++value_ ; return *this;.

2) Equivalent to ++value_ ;.

3) Equivalent to auto tmp = *this; ++value_ ; return tmp;.

Example

#include <cassert>
#include <ranges>

int main()
{
    auto it{std::views::iota(8).begin()};
    assert(*it == 8);
    assert(*++it == 9);
    assert(*it++ == 9);
    assert(*it == 10);
}

std::ranges::iota_view::iterator::operator--

1) Equivalent to --value_ ; return *this;.

2) Equivalent to auto tmp = *this; --value_ ; return tmp;.

Example

#include <cassert>
#include <ranges>

int main()
{
    auto it{std::views::iota(8).begin()};
    assert(*it == 8);
    assert(*--it == 7);
    assert(*it-- == 7);
    assert(*it == 6);
}

std::ranges::iota_view::iterator::operator+=

Updates value_ and returns *this:

• If W is an unsigned-integer-like type:
  • If n is non-negative, performs value_ += static_cast<W>(n).
  • Otherwise, performs value_ -= static_cast<W>(-n).
• Otherwise, performs value_ += n.

Example

#include <cassert>
#include <ranges>

int main()
{
    auto it{std::views::iota(5).begin()};
    assert(*it == 5);
    assert(*(it += 3) == 8);
}

std::ranges::iota_view::iterator::operator-=

Updates value_ and returns *this:

• If W is an unsigned-integer-like type:
  • If n is non-negative, performs value_ -= static_cast<W>(n).
  • Otherwise, performs value_ += static_cast<W>(-n).
• Otherwise, performs value_ -= n.

Example

#include <cassert>
#include <ranges>

int main()
{
    auto it{std::views::iota(6).begin()};
    assert(*it == 6);
    assert(*(it -= -3) == 9);
}

std::ranges::iota_view::iterator::operator[]

Returns W(value_ + n).

Example

#include <cassert>
#include <ranges>

int main()
{
    auto it{std::views::iota(6).begin()};
    assert(*it == 6);
    assert(*(it + 3) == 9);
}

operator==, <, >, <=, >=, <=>(std::ranges::iota_view::iterator)

1) Returns x.value_ == y.value_.

2) Returns x.value_ < y.value_.

3) Returns y < x.

4) Returns !(y < x).

5) Returns !(x < y).

6) Returns x.value_ <=> y.value_.

The != operator is synthesized from operator==.

These functions are not visible to ordinary unqualified or qualified lookup, and can only be found by argument-dependent lookup when iterator is an associated class of the arguments.

operator+(std::ranges::iota_view::iterator)

Equivalent to i += n; return i;.

These functions are not visible to ordinary unqualified or qualified lookup, and can only be found by argument-dependent lookup when iterator is an associated class of the arguments.

operator-(std::ranges::iota_view::iterator)

1) Equivalent to i -= n; return i;.

These functions are not visible to ordinary unqualified or qualified lookup, and can only be found by argument-dependent lookup when iterator is an associated class of the arguments.