[predef.iterators] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpv5f6qmdg/{from.md → to.md} +80 -50

tmp/tmpv5f6qmdg/{from.md → to.md} RENAMED Viewed

@@ -18,11 +18,11 @@ namespace std {
     using iterator_type     = Iterator;
     using iterator_concept  = see below;
     using iterator_category = see below;
     using value_type        = iter_value_t<Iterator>;
     using difference_type   = iter_difference_t<Iterator>;
-    using pointer           = typename iterator_traits<Iterator>::pointer;
     using reference         = iter_reference_t<Iterator>;
     constexpr reverse_iterator();
     constexpr explicit reverse_iterator(Iterator x);
     template<class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
@@ -95,14 +95,11 @@ are instantiated [[temp.inst]].
 ``` cpp
 constexpr reverse_iterator();
 ```
-*Effects:* Value-initializes `current`. Iterator operations applied to
-the resulting iterator have defined behavior if and only if the
-corresponding operations are defined on a value-initialized iterator of
-type `Iterator`.
 ``` cpp
 constexpr explicit reverse_iterator(Iterator x);
 ```
@@ -428,10 +425,12 @@ the iterator points to in a container. `back_inserter`,
 `front_inserter`, and `inserter` are three functions making the insert
 iterators out of a container.
 #### Class template `back_insert_iterator` <a id="back.insert.iterator">[[back.insert.iterator]]</a>
 ``` cpp
 namespace std {
   template<class Container>
   class back_insert_iterator {
   protected:
@@ -502,10 +501,12 @@ template<class Container>
 *Returns:* `back_insert_iterator<Container>(x)`.
 #### Class template `front_insert_iterator` <a id="front.insert.iterator">[[front.insert.iterator]]</a>
 ``` cpp
 namespace std {
   template<class Container>
   class front_insert_iterator {
   protected:
@@ -576,10 +577,12 @@ template<class Container>
 *Returns:* `front_insert_iterator<Container>(x)`.
 #### Class template `insert_iterator` <a id="insert.iterator">[[insert.iterator]]</a>
 ``` cpp
 namespace std {
   template<class Container>
   class insert_iterator {
   protected:
@@ -758,10 +761,17 @@ namespace std {
       requires random_access_iterator<Iterator>;
     template<sentinel_for<Iterator> S>
       constexpr bool operator==(const S& s) const;
     constexpr bool operator<(const basic_const_iterator& y) const
       requires random_access_iterator<Iterator>;
     constexpr bool operator>(const basic_const_iterator& y) const
       requires random_access_iterator<Iterator>;
     constexpr bool operator<=(const basic_const_iterator& y) const
@@ -979,10 +989,26 @@ template<sentinel_for<Iterator> S>
   constexpr bool operator==(const S& s) const;
 ```
 *Effects:* Equivalent to: `return `*`current_`*` == s;`
 ``` cpp
 constexpr bool operator<(const basic_const_iterator& y) const
   requires random_access_iterator<Iterator>;
 constexpr bool operator>(const basic_const_iterator& y) const
   requires random_access_iterator<Iterator>;
@@ -1037,11 +1063,11 @@ template<not-a-const-iterator I>
     requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
 ```
 Let *`op`* be the operator.
-*Returns:* Equivalent to: `return x `*`op`*` y.`*`current_`*`;`
 ``` cpp
 friend constexpr basic_const_iterator operator+(const basic_const_iterator& i, difference_type n)
   requires random_access_iterator<Iterator>;
 friend constexpr basic_const_iterator operator+(difference_type n, const basic_const_iterator& i)
@@ -1591,11 +1617,11 @@ namespace std {
     template<sized_sentinel_for<I> I2, sized_sentinel_for<I> S2>
       requires sized_sentinel_for<S, I2>
     friend constexpr iter_difference_t<I2> operator-(
       const common_iterator& x, const common_iterator<I2, S2>& y);
-    friend constexpr iter_rvalue_reference_t<I> iter_move(const common_iterator& i)
       noexcept(noexcept(ranges::iter_move(declval<const I&>())))
         requires input_iterator<I>;
     template<indirectly_swappable<I> I2, class S2>
       friend constexpr void iter_swap(const common_iterator& x, const common_iterator<I2, S2>& y)
         noexcept(noexcept(ranges::iter_swap(declval<const I&>(), declval<const I2&>())));
@@ -1610,30 +1636,34 @@ namespace std {
   };
   template<input_iterator I, class S>
   struct iterator_traits<common_iterator<I, S>> {
     using iterator_concept = see below;
-    using iterator_category = see below;
     using value_type = iter_value_t<I>;
     using difference_type = iter_difference_t<I>;
     using pointer = see below;
     using reference = iter_reference_t<I>;
   };
 }
 ```
 #### Associated types <a id="common.iter.types">[[common.iter.types]]</a>
-The nested *typedef-name*s of the specialization of `iterator_traits`
-for `common_iterator<I, S>` are defined as follows.
 - `iterator_concept` denotes `forward_iterator_tag` if `I` models
   `forward_iterator`; otherwise it denotes `input_iterator_tag`.
-- `iterator_category` denotes `forward_iterator_tag` if the
-  *qualified-id* `iterator_traits<I>::iterator_category` is valid and
-  denotes a type that models `derived_from<forward_iterator_tag>`;
-  otherwise it denotes `input_iterator_tag`.
 - Let `a` denote an lvalue of type `const common_iterator<I, S>`. If the
   expression `a.operator->()` is well-formed, then `pointer` denotes
   `decltype(a.operator->())`. Otherwise, `pointer` denotes `void`.
 #### Constructors and conversions <a id="common.iter.const">[[common.iter.const]]</a>
@@ -1656,11 +1686,11 @@ constexpr common_iterator(S s);
 template<class I2, class S2>
   requires convertible_to<const I2&, I> && convertible_to<const S2&, S>
     constexpr common_iterator(const common_iterator<I2, S2>& x);
 ```
-*Preconditions:* `x.v_.valueless_by_exception()` is `false`.
 *Effects:* Initializes `v_` as if by
 `v_{in_place_index<`i`>, get<`i`>(x.v_)}`, where i is `x.v_.index()`.
 ``` cpp
@@ -1668,30 +1698,30 @@ template<class I2, class S2>
   requires convertible_to<const I2&, I> && convertible_to<const S2&, S> &&
            assignable_from<I&, const I2&> && assignable_from<S&, const S2&>
     constexpr common_iterator& operator=(const common_iterator<I2, S2>& x);
 ```
-*Preconditions:* `x.v_.valueless_by_exception()` is `false`.
 *Effects:* Equivalent to:
 - If `v_.index() == x.v_.index()`, then `get<`i`>(v_) = get<`i`>(x.v_)`.
 - Otherwise, `v_.emplace<`i`>(get<`i`>(x.v_))`.
 where i is `x.v_.index()`.
-*Returns:* `*this`
 #### Accessors <a id="common.iter.access">[[common.iter.access]]</a>
 ``` cpp
 constexpr decltype(auto) operator*();
 constexpr decltype(auto) operator*() const
   requires dereferenceable<const I>;
 ```
-*Preconditions:* `holds_alternative<I>(v_)` is `true`.
 *Effects:* Equivalent to: `return *get<I>(v_);`
 ``` cpp
 constexpr auto operator->() const
@@ -1705,11 +1735,11 @@ indirectly_readable<const I> &&
 (requires(const I& i) { i.operator->(); } ||
  is_reference_v<iter_reference_t<I>> ||
  constructible_from<iter_value_t<I>, iter_reference_t<I>>)
 ```
-*Preconditions:* `holds_alternative<I>(v_)` is `true`.
 *Effects:*
 - If `I` is a pointer type or if the expression
   `get<I>(v_).operator->()` is well-formed, equivalent to:
@@ -1738,21 +1768,21 @@ indirectly_readable<const I> &&
 ``` cpp
 constexpr common_iterator& operator++();
 ```
-*Preconditions:* `holds_alternative<I>(v_)` is `true`.
 *Effects:* Equivalent to `++get<I>(v_)`.
 *Returns:* `*this`.
 ``` cpp
 constexpr decltype(auto) operator++(int);
 ```
-*Preconditions:* `holds_alternative<I>(v_)` is `true`.
 *Effects:* If `I` models `forward_iterator`, equivalent to:
 ``` cpp
 common_iterator tmp = *this;
@@ -1803,12 +1833,12 @@ template<class I2, sentinel_for<I> S2>
   requires sentinel_for<S, I2>
 friend constexpr bool operator==(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 ```
-*Preconditions:* `x.v_.valueless_by_exception()` and
-`y.v_.valueless_by_exception()` are each `false`.
 *Returns:* `true` if i` == `j, and otherwise
 `get<`i`>(x.v_) == get<`j`>(y.v_)`, where i is `x.v_.index()` and j is
 `y.v_.index()`.
@@ -1817,12 +1847,12 @@ template<class I2, sentinel_for<I> S2>
   requires sentinel_for<S, I2> && equality_comparable_with<I, I2>
 friend constexpr bool operator==(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 ```
-*Preconditions:* `x.v_.valueless_by_exception()` and
-`y.v_.valueless_by_exception()` are each `false`.
 *Returns:* `true` if i and j are each `1`, and otherwise
 `get<`i`>(x.v_) == get<`j`>(y.v_)`, where i is `x.v_.index()` and j is
 `y.v_.index()`.
@@ -1831,37 +1861,37 @@ template<sized_sentinel_for<I> I2, sized_sentinel_for<I> S2>
   requires sized_sentinel_for<S, I2>
 friend constexpr iter_difference_t<I2> operator-(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 ```
-*Preconditions:* `x.v_.valueless_by_exception()` and
-`y.v_.valueless_by_exception()` are each `false`.
 *Returns:* `0` if i and j are each `1`, and otherwise
 `get<`i`>(x.v_) - get<`j`>(y.v_)`, where i is `x.v_.index()` and j is
 `y.v_.index()`.
 #### Customizations <a id="common.iter.cust">[[common.iter.cust]]</a>
 ``` cpp
-friend constexpr iter_rvalue_reference_t<I> iter_move(const common_iterator& i)
   noexcept(noexcept(ranges::iter_move(declval<const I&>())))
     requires input_iterator<I>;
 ```
-*Preconditions:* `holds_alternative<I>(i.v_)` is `true`.
 *Effects:* Equivalent to: `return ranges::iter_move(get<I>(i.v_));`
 ``` cpp
 template<indirectly_swappable<I> I2, class S2>
   friend constexpr void iter_swap(const common_iterator& x, const common_iterator<I2, S2>& y)
     noexcept(noexcept(ranges::iter_swap(declval<const I&>(), declval<const I2&>())));
 ```
-*Preconditions:* `holds_alternative<I>(x.v_)` and
-`holds_alternative<I2>(y.v_)` are each `true`.
 *Effects:* Equivalent to
 `ranges::iter_swap(get<I>(x.v_), get<I2>(y.v_))`.
 ### Default sentinel <a id="default.sentinel">[[default.sentinel]]</a>
@@ -1912,13 +1942,13 @@ namespace std {
   public:
     using iterator_type = I;
     using value_type = iter_value_t<I>;                         // present only
                         // if I models indirectly_readable
     using difference_type = iter_difference_t<I>;
-    using iterator_concept = typename I::iterator_concept; // present only
                         // if the qualified-id I::iterator_concept is valid and denotes a type
-    using iterator_category = typename I::iterator_category; // present only
                         // if the qualified-id I::iterator_category is valid and denotes a type
     constexpr counted_iterator() requires default_initializable<I> = default;
     constexpr counted_iterator(I x, iter_difference_t<I> n);
     template<class I2>
       requires convertible_to<const I2&, I>
@@ -1959,30 +1989,30 @@ namespace std {
       requires random_access_iterator<I>;
     template<common_with<I> I2>
       friend constexpr iter_difference_t<I2> operator-(
         const counted_iterator& x, const counted_iterator<I2>& y);
     friend constexpr iter_difference_t<I> operator-(
-      const counted_iterator& x, default_sentinel_t);
     friend constexpr iter_difference_t<I> operator-(
-      default_sentinel_t, const counted_iterator& y);
     constexpr counted_iterator& operator-=(iter_difference_t<I> n)
       requires random_access_iterator<I>;
     constexpr decltype(auto) operator[](iter_difference_t<I> n) const
       requires random_access_iterator<I>;
     template<common_with<I> I2>
       friend constexpr bool operator==(
         const counted_iterator& x, const counted_iterator<I2>& y);
     friend constexpr bool operator==(
-      const counted_iterator& x, default_sentinel_t);
     template<common_with<I> I2>
       friend constexpr strong_ordering operator<=>(
         const counted_iterator& x, const counted_iterator<I2>& y);
-    friend constexpr iter_rvalue_reference_t<I> iter_move(const counted_iterator& i)
       noexcept(noexcept(ranges::iter_move(i.current)))
         requires input_iterator<I>;
     template<indirectly_swappable<I> I2>
       friend constexpr void iter_swap(const counted_iterator& x, const counted_iterator<I2>& y)
         noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
@@ -2005,11 +2035,11 @@ namespace std {
 ``` cpp
 constexpr counted_iterator(I i, iter_difference_t<I> n);
 ```
-*Preconditions:* `n >= 0`.
 *Effects:* Initializes `current` with `std::move(i)` and `length` with
 `n`.
 ``` cpp
@@ -2057,11 +2087,11 @@ constexpr iter_difference_t<I> count() const noexcept;
 constexpr decltype(auto) operator*();
 constexpr decltype(auto) operator*() const
   requires dereferenceable<const I>;
 ```
-*Preconditions:* `length > 0` is `true`.
 *Effects:* Equivalent to: `return *current;`
 ``` cpp
 constexpr auto operator->() const noexcept
@@ -2073,21 +2103,21 @@ constexpr auto operator->() const noexcept
 ``` cpp
 constexpr decltype(auto) operator[](iter_difference_t<I> n) const
   requires random_access_iterator<I>;
 ```
-*Preconditions:* `n < length`.
 *Effects:* Equivalent to: `return current[n];`
 #### Navigation <a id="counted.iter.nav">[[counted.iter.nav]]</a>
 ``` cpp
 constexpr counted_iterator& operator++();
 ```
-*Preconditions:* `length > 0`.
 *Effects:* Equivalent to:
 ``` cpp
 ++current;
@@ -2097,11 +2127,11 @@ return *this;
 ``` cpp
 constexpr decltype(auto) operator++(int);
 ```
-*Preconditions:* `length > 0`.
 *Effects:* Equivalent to:
 ``` cpp
 --length;
@@ -2167,11 +2197,11 @@ friend constexpr counted_iterator operator+(
 ``` cpp
 constexpr counted_iterator& operator+=(iter_difference_t<I> n)
   requires random_access_iterator<I>;
 ```
-*Preconditions:* `n <= length`.
 *Effects:* Equivalent to:
 ``` cpp
 current += n;
@@ -2198,28 +2228,28 @@ sequence [[counted.iterator]].
 *Effects:* Equivalent to: `return y.length - x.length;`
 ``` cpp
 friend constexpr iter_difference_t<I> operator-(
-  const counted_iterator& x, default_sentinel_t);
 ```
 *Effects:* Equivalent to: `return -x.length;`
 ``` cpp
 friend constexpr iter_difference_t<I> operator-(
-  default_sentinel_t, const counted_iterator& y);
 ```
 *Effects:* Equivalent to: `return y.length;`
 ``` cpp
 constexpr counted_iterator& operator-=(iter_difference_t<I> n)
   requires random_access_iterator<I>;
 ```
-*Preconditions:* `-n <= length`.
 *Effects:* Equivalent to:
 ``` cpp
 current -= n;
@@ -2240,11 +2270,11 @@ sequence [[counted.iterator]].
 *Effects:* Equivalent to: `return x.length == y.length;`
 ``` cpp
 friend constexpr bool operator==(
-  const counted_iterator& x, default_sentinel_t);
 ```
 *Effects:* Equivalent to: `return x.length == 0;`
 ``` cpp
@@ -2262,28 +2292,28 @@ sequence [[counted.iterator]].
 because `length` counts down, not up. — *end note*]
 #### Customizations <a id="counted.iter.cust">[[counted.iter.cust]]</a>
 ``` cpp
-friend constexpr iter_rvalue_reference_t<I>
   iter_move(const counted_iterator& i)
     noexcept(noexcept(ranges::iter_move(i.current)))
     requires input_iterator<I>;
 ```
-*Preconditions:* `i.length > 0` is `true`.
 *Effects:* Equivalent to: `return ranges::iter_move(i.current);`
 ``` cpp
 template<indirectly_swappable<I> I2>
   friend constexpr void
     iter_swap(const counted_iterator& x, const counted_iterator<I2>& y)
       noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
 ```
-*Preconditions:* Both `x.length > 0` and `y.length > 0` are `true`.
 *Effects:* Equivalent to `ranges::iter_swap(x.current, y.current)`.
 ### Unreachable sentinel <a id="unreachable.sentinel">[[unreachable.sentinel]]</a>

     using iterator_type     = Iterator;
     using iterator_concept  = see below;
     using iterator_category = see below;
     using value_type        = iter_value_t<Iterator>;
     using difference_type   = iter_difference_t<Iterator>;
+    using pointer           = iterator_traits<Iterator>::pointer;
     using reference         = iter_reference_t<Iterator>;
     constexpr reverse_iterator();
     constexpr explicit reverse_iterator(Iterator x);
     template<class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
 ``` cpp
 constexpr reverse_iterator();
 ```
+*Effects:* Value-initializes `current`.
 ``` cpp
 constexpr explicit reverse_iterator(Iterator x);
 ```
 `front_inserter`, and `inserter` are three functions making the insert
 iterators out of a container.
 #### Class template `back_insert_iterator` <a id="back.insert.iterator">[[back.insert.iterator]]</a>
+##### General <a id="back.insert.iter.general">[[back.insert.iter.general]]</a>
 ``` cpp
 namespace std {
   template<class Container>
   class back_insert_iterator {
   protected:
 *Returns:* `back_insert_iterator<Container>(x)`.
 #### Class template `front_insert_iterator` <a id="front.insert.iterator">[[front.insert.iterator]]</a>
+##### General <a id="front.insert.iter.general">[[front.insert.iter.general]]</a>
 ``` cpp
 namespace std {
   template<class Container>
   class front_insert_iterator {
   protected:
 *Returns:* `front_insert_iterator<Container>(x)`.
 #### Class template `insert_iterator` <a id="insert.iterator">[[insert.iterator]]</a>
+##### General <a id="insert.iter.general">[[insert.iter.general]]</a>
 ``` cpp
 namespace std {
   template<class Container>
   class insert_iterator {
   protected:
       requires random_access_iterator<Iterator>;
     template<sentinel_for<Iterator> S>
       constexpr bool operator==(const S& s) const;
+    template<not-a-const-iterator CI>
+      requires constant-iterator<CI> && convertible_to<Iterator const&, CI>
+    constexpr operator CI() const &;
+    template<not-a-const-iterator CI>
+      requires constant-iterator<CI> && convertible_to<Iterator, CI>
+    constexpr operator CI() &&;
     constexpr bool operator<(const basic_const_iterator& y) const
       requires random_access_iterator<Iterator>;
     constexpr bool operator>(const basic_const_iterator& y) const
       requires random_access_iterator<Iterator>;
     constexpr bool operator<=(const basic_const_iterator& y) const
   constexpr bool operator==(const S& s) const;
 ```
 *Effects:* Equivalent to: `return `*`current_`*` == s;`
+``` cpp
+template<not-a-const-iterator CI>
+  requires constant-iterator<CI> && convertible_to<Iterator const&, CI>
+constexpr operator CI() const &;
+```
+*Returns:* *current\_*.
+``` cpp
+template<not-a-const-iterator CI>
+  requires constant-iterator<CI> && convertible_to<Iterator, CI>
+constexpr operator CI() &&;
+```
+*Returns:* `std::move(`*`current_`*`)`.
 ``` cpp
 constexpr bool operator<(const basic_const_iterator& y) const
   requires random_access_iterator<Iterator>;
 constexpr bool operator>(const basic_const_iterator& y) const
   requires random_access_iterator<Iterator>;
     requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
 ```
 Let *`op`* be the operator.
+*Effects:* Equivalent to: `return x `*`op`*` y.`*`current_`*`;`
 ``` cpp
 friend constexpr basic_const_iterator operator+(const basic_const_iterator& i, difference_type n)
   requires random_access_iterator<Iterator>;
 friend constexpr basic_const_iterator operator+(difference_type n, const basic_const_iterator& i)
     template<sized_sentinel_for<I> I2, sized_sentinel_for<I> S2>
       requires sized_sentinel_for<S, I2>
     friend constexpr iter_difference_t<I2> operator-(
       const common_iterator& x, const common_iterator<I2, S2>& y);
+    friend constexpr decltype(auto) iter_move(const common_iterator& i)
       noexcept(noexcept(ranges::iter_move(declval<const I&>())))
         requires input_iterator<I>;
     template<indirectly_swappable<I> I2, class S2>
       friend constexpr void iter_swap(const common_iterator& x, const common_iterator<I2, S2>& y)
         noexcept(noexcept(ranges::iter_swap(declval<const I&>(), declval<const I2&>())));
   };
   template<input_iterator I, class S>
   struct iterator_traits<common_iterator<I, S>> {
     using iterator_concept = see below;
+    using iterator_category = see below;  // not always present
     using value_type = iter_value_t<I>;
     using difference_type = iter_difference_t<I>;
     using pointer = see below;
     using reference = iter_reference_t<I>;
   };
 }
 ```
 #### Associated types <a id="common.iter.types">[[common.iter.types]]</a>
+The nested *typedef-name* `iterator_category` of the specialization of
+`iterator_traits` for `common_iterator<I, S>` is defined if and only if
+`iter_difference_t<I>` is an integral type. In that case,
+`iterator_category` denotes `forward_iterator_tag` if the *qualified-id*
+`iterator_traits<I>::iterator_category` is valid and denotes a type that
+models `derived_from<forward_iterator_tag>`; otherwise it denotes
+`input_iterator_tag`.
+The remaining nested *typedef-name*s of the specialization of
+`iterator_traits` for `common_iterator<I, S>` are defined as follows:
 - `iterator_concept` denotes `forward_iterator_tag` if `I` models
   `forward_iterator`; otherwise it denotes `input_iterator_tag`.
 - Let `a` denote an lvalue of type `const common_iterator<I, S>`. If the
   expression `a.operator->()` is well-formed, then `pointer` denotes
   `decltype(a.operator->())`. Otherwise, `pointer` denotes `void`.
 #### Constructors and conversions <a id="common.iter.const">[[common.iter.const]]</a>
 template<class I2, class S2>
   requires convertible_to<const I2&, I> && convertible_to<const S2&, S>
     constexpr common_iterator(const common_iterator<I2, S2>& x);
 ```
+`x.v_.valueless_by_exception()` is `false`.
 *Effects:* Initializes `v_` as if by
 `v_{in_place_index<`i`>, get<`i`>(x.v_)}`, where i is `x.v_.index()`.
 ``` cpp
   requires convertible_to<const I2&, I> && convertible_to<const S2&, S> &&
            assignable_from<I&, const I2&> && assignable_from<S&, const S2&>
     constexpr common_iterator& operator=(const common_iterator<I2, S2>& x);
 ```
+`x.v_.valueless_by_exception()` is `false`.
 *Effects:* Equivalent to:
 - If `v_.index() == x.v_.index()`, then `get<`i`>(v_) = get<`i`>(x.v_)`.
 - Otherwise, `v_.emplace<`i`>(get<`i`>(x.v_))`.
 where i is `x.v_.index()`.
+*Returns:* `*this`.
 #### Accessors <a id="common.iter.access">[[common.iter.access]]</a>
 ``` cpp
 constexpr decltype(auto) operator*();
 constexpr decltype(auto) operator*() const
   requires dereferenceable<const I>;
 ```
+`holds_alternative<I>(v_)` is `true`.
 *Effects:* Equivalent to: `return *get<I>(v_);`
 ``` cpp
 constexpr auto operator->() const
 (requires(const I& i) { i.operator->(); } ||
  is_reference_v<iter_reference_t<I>> ||
  constructible_from<iter_value_t<I>, iter_reference_t<I>>)
 ```
+`holds_alternative<I>(v_)` is `true`.
 *Effects:*
 - If `I` is a pointer type or if the expression
   `get<I>(v_).operator->()` is well-formed, equivalent to:
 ``` cpp
 constexpr common_iterator& operator++();
 ```
+`holds_alternative<I>(v_)` is `true`.
 *Effects:* Equivalent to `++get<I>(v_)`.
 *Returns:* `*this`.
 ``` cpp
 constexpr decltype(auto) operator++(int);
 ```
+`holds_alternative<I>(v_)` is `true`.
 *Effects:* If `I` models `forward_iterator`, equivalent to:
 ``` cpp
 common_iterator tmp = *this;
   requires sentinel_for<S, I2>
 friend constexpr bool operator==(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 ```
+`x.v_.valueless_by_exception()` and `y.v_.valueless_by_exception()` are
+each `false`.
 *Returns:* `true` if i` == `j, and otherwise
 `get<`i`>(x.v_) == get<`j`>(y.v_)`, where i is `x.v_.index()` and j is
 `y.v_.index()`.
   requires sentinel_for<S, I2> && equality_comparable_with<I, I2>
 friend constexpr bool operator==(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 ```
+`x.v_.valueless_by_exception()` and `y.v_.valueless_by_exception()` are
+each `false`.
 *Returns:* `true` if i and j are each `1`, and otherwise
 `get<`i`>(x.v_) == get<`j`>(y.v_)`, where i is `x.v_.index()` and j is
 `y.v_.index()`.
   requires sized_sentinel_for<S, I2>
 friend constexpr iter_difference_t<I2> operator-(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 ```
+`x.v_.valueless_by_exception()` and `y.v_.valueless_by_exception()` are
+each `false`.
 *Returns:* `0` if i and j are each `1`, and otherwise
 `get<`i`>(x.v_) - get<`j`>(y.v_)`, where i is `x.v_.index()` and j is
 `y.v_.index()`.
 #### Customizations <a id="common.iter.cust">[[common.iter.cust]]</a>
 ``` cpp
+friend constexpr decltype(auto) iter_move(const common_iterator& i)
   noexcept(noexcept(ranges::iter_move(declval<const I&>())))
     requires input_iterator<I>;
 ```
+`holds_alternative<I>(i.v_)` is `true`.
 *Effects:* Equivalent to: `return ranges::iter_move(get<I>(i.v_));`
 ``` cpp
 template<indirectly_swappable<I> I2, class S2>
   friend constexpr void iter_swap(const common_iterator& x, const common_iterator<I2, S2>& y)
     noexcept(noexcept(ranges::iter_swap(declval<const I&>(), declval<const I2&>())));
 ```
+`holds_alternative<I>(x.v_)` and `holds_alternative<I2>(y.v_)` are each
+`true`.
 *Effects:* Equivalent to
 `ranges::iter_swap(get<I>(x.v_), get<I2>(y.v_))`.
 ### Default sentinel <a id="default.sentinel">[[default.sentinel]]</a>
   public:
     using iterator_type = I;
     using value_type = iter_value_t<I>;                         // present only
                         // if I models indirectly_readable
     using difference_type = iter_difference_t<I>;
+    using iterator_concept = I::iterator_concept; // present only
                         // if the qualified-id I::iterator_concept is valid and denotes a type
+    using iterator_category = I::iterator_category; // present only
                         // if the qualified-id I::iterator_category is valid and denotes a type
     constexpr counted_iterator() requires default_initializable<I> = default;
     constexpr counted_iterator(I x, iter_difference_t<I> n);
     template<class I2>
       requires convertible_to<const I2&, I>
       requires random_access_iterator<I>;
     template<common_with<I> I2>
       friend constexpr iter_difference_t<I2> operator-(
         const counted_iterator& x, const counted_iterator<I2>& y);
     friend constexpr iter_difference_t<I> operator-(
+      const counted_iterator& x, default_sentinel_t) noexcept;
     friend constexpr iter_difference_t<I> operator-(
+      default_sentinel_t, const counted_iterator& y) noexcept;
     constexpr counted_iterator& operator-=(iter_difference_t<I> n)
       requires random_access_iterator<I>;
     constexpr decltype(auto) operator[](iter_difference_t<I> n) const
       requires random_access_iterator<I>;
     template<common_with<I> I2>
       friend constexpr bool operator==(
         const counted_iterator& x, const counted_iterator<I2>& y);
     friend constexpr bool operator==(
+      const counted_iterator& x, default_sentinel_t) noexcept;
     template<common_with<I> I2>
       friend constexpr strong_ordering operator<=>(
         const counted_iterator& x, const counted_iterator<I2>& y);
+    friend constexpr decltype(auto) iter_move(const counted_iterator& i)
       noexcept(noexcept(ranges::iter_move(i.current)))
         requires input_iterator<I>;
     template<indirectly_swappable<I> I2>
       friend constexpr void iter_swap(const counted_iterator& x, const counted_iterator<I2>& y)
         noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
 ``` cpp
 constexpr counted_iterator(I i, iter_difference_t<I> n);
 ```
+`n >= 0` is `true`.
 *Effects:* Initializes `current` with `std::move(i)` and `length` with
 `n`.
 ``` cpp
 constexpr decltype(auto) operator*();
 constexpr decltype(auto) operator*() const
   requires dereferenceable<const I>;
 ```
+`length > 0` is `true`.
 *Effects:* Equivalent to: `return *current;`
 ``` cpp
 constexpr auto operator->() const noexcept
 ``` cpp
 constexpr decltype(auto) operator[](iter_difference_t<I> n) const
   requires random_access_iterator<I>;
 ```
+`n < length` is `true`.
 *Effects:* Equivalent to: `return current[n];`
 #### Navigation <a id="counted.iter.nav">[[counted.iter.nav]]</a>
 ``` cpp
 constexpr counted_iterator& operator++();
 ```
+`length > 0` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 ++current;
 ``` cpp
 constexpr decltype(auto) operator++(int);
 ```
+`length > 0` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 --length;
 ``` cpp
 constexpr counted_iterator& operator+=(iter_difference_t<I> n)
   requires random_access_iterator<I>;
 ```
+`n <= length` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 current += n;
 *Effects:* Equivalent to: `return y.length - x.length;`
 ``` cpp
 friend constexpr iter_difference_t<I> operator-(
+  const counted_iterator& x, default_sentinel_t) noexcept;
 ```
 *Effects:* Equivalent to: `return -x.length;`
 ``` cpp
 friend constexpr iter_difference_t<I> operator-(
+  default_sentinel_t, const counted_iterator& y) noexcept;
 ```
 *Effects:* Equivalent to: `return y.length;`
 ``` cpp
 constexpr counted_iterator& operator-=(iter_difference_t<I> n)
   requires random_access_iterator<I>;
 ```
+`-n <= length` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 current -= n;
 *Effects:* Equivalent to: `return x.length == y.length;`
 ``` cpp
 friend constexpr bool operator==(
+  const counted_iterator& x, default_sentinel_t) noexcept;
 ```
 *Effects:* Equivalent to: `return x.length == 0;`
 ``` cpp
 because `length` counts down, not up. — *end note*]
 #### Customizations <a id="counted.iter.cust">[[counted.iter.cust]]</a>
 ``` cpp
+friend constexpr decltype(auto)
   iter_move(const counted_iterator& i)
     noexcept(noexcept(ranges::iter_move(i.current)))
     requires input_iterator<I>;
 ```
+`i.length > 0` is `true`.
 *Effects:* Equivalent to: `return ranges::iter_move(i.current);`
 ``` cpp
 template<indirectly_swappable<I> I2>
   friend constexpr void
     iter_swap(const counted_iterator& x, const counted_iterator<I2>& y)
       noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
 ```
+Both `x.length > 0` and `y.length > 0` are `true`.
 *Effects:* Equivalent to `ranges::iter_swap(x.current, y.current)`.
 ### Unreachable sentinel <a id="unreachable.sentinel">[[unreachable.sentinel]]</a>

Diff to HTML by rtfpessoa