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

Files changed (1) hide show

tmp/tmpg5nowt6v/{from.md → to.md} +581 -98

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

@@ -1,9 +1,11 @@
 ## Iterator adaptors <a id="predef.iterators">[[predef.iterators]]</a>
 ### Reverse iterators <a id="reverse.iterators">[[reverse.iterators]]</a>
 Class template `reverse_iterator` is an iterator adaptor that iterates
 from the end of the sequence defined by its underlying iterator to the
 beginning of that sequence.
 #### Class template `reverse_iterator` <a id="reverse.iterator">[[reverse.iterator]]</a>
@@ -108,26 +110,33 @@ constexpr explicit reverse_iterator(Iterator x);
 ``` cpp
 template<class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
 ```
 *Effects:* Initializes `current` with `u.current`.
 ``` cpp
 template<class U>
   constexpr reverse_iterator&
     operator=(const reverse_iterator<U>& u);
 ```
-*Effects:* Assigns `u.base()` to `current`.
 *Returns:* `*this`.
 #### Conversion <a id="reverse.iter.conv">[[reverse.iter.conv]]</a>
 ``` cpp
-constexpr Iterator base() const;          // explicit
 ```
 *Returns:* `current`.
 #### Element access <a id="reverse.iter.elem">[[reverse.iter.elem]]</a>
@@ -177,11 +186,11 @@ constexpr reverse_iterator operator-(difference_type n) const;
 ``` cpp
 constexpr reverse_iterator& operator++();
 ```
-*Effects:* As if by: `current;`
 *Returns:* `*this`.
 ``` cpp
 constexpr reverse_iterator operator++(int);
@@ -329,11 +338,11 @@ template<class Iterator1, class Iterator2>
 *Returns:* `y.base() - x.base()`.
 ``` cpp
 template<class Iterator>
   constexpr reverse_iterator<Iterator> operator+(
- typename reverse_iterator<Iterator>::difference_type n,
     const reverse_iterator<Iterator>& x);
 ```
 *Returns:* `reverse_iterator<Iterator>(x.base() - n)`.
@@ -347,11 +356,11 @@ friend constexpr iter_rvalue_reference_t<Iterator>
 ``` cpp
 auto tmp = i.base();
 return ranges::iter_move(--tmp);
 ```
-*Remarks:* The expression in `noexcept` is equivalent to:
 ``` cpp
 is_nothrow_copy_constructible_v<Iterator> &&
 noexcept(ranges::iter_move(--declval<Iterator&>()))
 ```
@@ -369,11 +378,11 @@ template<indirectly_swappable<Iterator> Iterator2>
 auto xtmp = x.base();
 auto ytmp = y.base();
 ranges::iter_swap(--xtmp, --ytmp);
 ```
-*Remarks:* The expression in `noexcept` is equivalent to:
 ``` cpp
 is_nothrow_copy_constructible_v<Iterator> &&
 is_nothrow_copy_constructible_v<Iterator2> &&
 noexcept(ranges::iter_swap(--declval<Iterator&>(), --declval<Iterator2&>()))
@@ -386,10 +395,12 @@ template<class Iterator>
 *Returns:* `reverse_iterator<Iterator>(i)`.
 ### Insert iterators <a id="insert.iterators">[[insert.iterators]]</a>
 To make it possible to deal with insertion in the same way as writing
 into an array, a special kind of iterator adaptors, called *insert
 iterators*, are provided in the library. With regular iterator classes,
 ``` cpp
@@ -422,21 +433,20 @@ iterators out of a container.
 ``` cpp
 namespace std {
   template<class Container>
   class back_insert_iterator {
   protected:
-    Container* container = nullptr;
   public:
     using iterator_category = output_iterator_tag;
     using value_type        = void;
     using difference_type   = ptrdiff_t;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
-    constexpr back_insert_iterator() noexcept = default;
     constexpr explicit back_insert_iterator(Container& x);
     constexpr back_insert_iterator& operator=(const typename Container::value_type& value);
     constexpr back_insert_iterator& operator=(typename Container::value_type&& value);
     constexpr back_insert_iterator& operator*();
@@ -497,21 +507,20 @@ template<class Container>
 ``` cpp
 namespace std {
   template<class Container>
   class front_insert_iterator {
   protected:
-    Container* container = nullptr;
   public:
     using iterator_category = output_iterator_tag;
     using value_type        = void;
     using difference_type   = ptrdiff_t;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
-    constexpr front_insert_iterator() noexcept = default;
     constexpr explicit front_insert_iterator(Container& x);
     constexpr front_insert_iterator& operator=(const typename Container::value_type& value);
     constexpr front_insert_iterator& operator=(typename Container::value_type&& value);
     constexpr front_insert_iterator& operator*();
@@ -572,22 +581,21 @@ template<class Container>
 ``` cpp
 namespace std {
   template<class Container>
   class insert_iterator {
   protected:
-    Container* container = nullptr;
-    ranges::iterator_t<Container> iter = ranges::iterator_t<Container>();
   public:
     using iterator_category = output_iterator_tag;
     using value_type        = void;
     using difference_type   = ptrdiff_t;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
-    insert_iterator() = default;
     constexpr insert_iterator(Container& x, ranges::iterator_t<Container> i);
     constexpr insert_iterator& operator=(const typename Container::value_type& value);
     constexpr insert_iterator& operator=(typename Container::value_type&& value);
     constexpr insert_iterator& operator*();
@@ -653,12 +661,425 @@ template<class Container>
     inserter(Container& x, ranges::iterator_t<Container> i);
 ```
 *Returns:* `insert_iterator<Container>(x, i)`.
 ### Move iterators and sentinels <a id="move.iterators">[[move.iterators]]</a>
 Class template `move_iterator` is an iterator adaptor with the same
 behavior as the underlying iterator except that its indirection operator
 implicitly converts the value returned by the underlying iterator’s
 indirection operator to an rvalue. Some generic algorithms can be called
 with move iterators to replace copying with moving.
@@ -681,24 +1102,24 @@ vector<string> v2(make_move_iterator(s.begin()),
 namespace std {
   template<class Iterator>
   class move_iterator {
   public:
     using iterator_type     = Iterator;
-    using iterator_concept  = input_iterator_tag;
-    using iterator_category = see below;
     using value_type        = iter_value_t<Iterator>;
     using difference_type   = iter_difference_t<Iterator>;
     using pointer           = Iterator;
     using reference         = iter_rvalue_reference_t<Iterator>;
     constexpr move_iterator();
     constexpr explicit move_iterator(Iterator i);
     template<class U> constexpr move_iterator(const move_iterator<U>& u);
     template<class U> constexpr move_iterator& operator=(const move_iterator<U>& u);
-    constexpr iterator_type base() const &;
-    constexpr iterator_type base() &&;
     constexpr reference operator*() const;
     constexpr move_iterator& operator++();
     constexpr auto operator++(int);
     constexpr move_iterator& operator--();
@@ -731,11 +1152,23 @@ namespace std {
     Iterator current;   // exposition only
   };
 }
 ```
-The member *typedef-name* `iterator_category` denotes
 - `random_access_iterator_tag` if the type
   `iterator_traits<{}Iterator>::iterator_category` models
   `derived_from<random_access_iterator_tag>`, and
 - `iterator_traits<{}Iterator>::iterator_category` otherwise.
@@ -758,49 +1191,45 @@ parameter shall either meet the *Cpp17RandomAccessIterator* requirements
 ``` cpp
 constexpr move_iterator();
 ```
-*Effects:* Constructs a `move_iterator`, value-initializing `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 move_iterator(Iterator i);
 ```
-*Effects:* Constructs a `move_iterator`, initializing `current` with
-`std::move(i)`.
 ``` cpp
 template<class U> constexpr move_iterator(const move_iterator<U>& u);
 ```
-*Mandates:* `U` is convertible to `Iterator`.
-*Effects:* Constructs a `move_iterator`, initializing `current` with
-`u.base()`.
 ``` cpp
 template<class U> constexpr move_iterator& operator=(const move_iterator<U>& u);
 ```
-*Mandates:* `U` is convertible to `Iterator`.
-*Effects:* Assigns `u.base()` to `current`.
 #### Conversion <a id="move.iter.op.conv">[[move.iter.op.conv]]</a>
 ``` cpp
-constexpr Iterator base() const &;
 ```
-*Constraints:* `Iterator` satisfies `copy_constructible`.
-*Preconditions:* `Iterator` models `copy_constructible`.
 *Returns:* `current`.
 ``` cpp
 constexpr Iterator base() &&;
 ```
@@ -817,11 +1246,11 @@ constexpr reference operator*() const;
 ``` cpp
 constexpr reference operator[](difference_type n) const;
 ```
-*Effects:* Equivalent to: `ranges::iter_move(current + n);`
 #### Navigation <a id="move.iter.nav">[[move.iter.nav]]</a>
 ``` cpp
 constexpr move_iterator& operator++();
@@ -847,11 +1276,11 @@ Otherwise, equivalent to `++current`.
 ``` cpp
 constexpr move_iterator& operator--();
 ```
-*Effects:* As if by `current`.
 *Returns:* `*this`.
 ``` cpp
 constexpr move_iterator operator--(int);
@@ -960,12 +1389,12 @@ template<class Iterator1, three_way_comparable_with<Iterator1> Iterator2>
 #### Non-member functions <a id="move.iter.nonmember">[[move.iter.nonmember]]</a>
 ``` cpp
 template<class Iterator1, class Iterator2>
-  constexpr auto operator-(const move_iterator<Iterator1>& x,
- const move_iterator<Iterator2>& y)
       -> decltype(x.base() - y.base());
 template<sized_sentinel_for<Iterator> S>
   friend constexpr iter_difference_t<Iterator>
     operator-(const move_sentinel<S>& x, const move_iterator& y);
 template<sized_sentinel_for<Iterator> S>
@@ -979,11 +1408,11 @@ template<sized_sentinel_for<Iterator> S>
 template<class Iterator>
   constexpr move_iterator<Iterator>
     operator+(iter_difference_t<Iterator> n, const move_iterator<Iterator>& x);
 ```
-*Constraints:* `x + n` is well-formed and has type `Iterator`.
 *Returns:* `x + n`.
 ``` cpp
 friend constexpr iter_rvalue_reference_t<Iterator>
@@ -1013,11 +1442,11 @@ constexpr move_iterator<Iterator> make_move_iterator(Iterator i);
 Class template `move_sentinel` is a sentinel adaptor useful for denoting
 ranges together with `move_iterator`. When an input iterator type `I`
 and sentinel type `S` model `sentinel_for<S, I>`, `move_sentinel<S>` and
 `move_iterator<I>` model
-`sentinel_for<move_sentinel<S>, move_iterator<I>{>}` as well.
 [*Example 1*:
 A `move_if` algorithm is easily implemented with `copy_if` using
 `move_iterator` and `move_sentinel`:
@@ -1025,11 +1454,12 @@ A `move_if` algorithm is easily implemented with `copy_if` using
 ``` cpp
 template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
          indirect_unary_predicate<I> Pred>
   requires indirectly_movable<I, O>
 void move_if(I first, S last, O out, Pred pred) {
- std::ranges::copy_if(move_iterator<I>{first}, move_sentinel<S>{last}, out, pred);
 }
 ```
 — *end example*]
@@ -1046,10 +1476,11 @@ namespace std {
     template<class S2>
       requires assignable_from<S&, const S2&>
         constexpr move_sentinel& operator=(const move_sentinel<S2>& s);
     constexpr S base() const;
   private:
     S last;     // exposition only
   };
 }
 ```
@@ -1125,50 +1556,50 @@ fun(CI(counted_iterator(s.begin(), 10)), CI(default_sentinel));
 namespace std {
   template<input_or_output_iterator I, sentinel_for<I> S>
     requires (!same_as<I, S> && copyable<I>)
   class common_iterator {
   public:
-    constexpr common_iterator() = default;
     constexpr common_iterator(I i);
     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);
     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&>
-        common_iterator& operator=(const common_iterator<I2, S2>& x);
-    decltype(auto) operator*();
-    decltype(auto) operator*() const
       requires dereferenceable<const I>;
- decltype(auto) operator->() const
       requires see below;
-    common_iterator& operator++();
-    decltype(auto) operator++(int);
     template<class I2, sentinel_for<I> S2>
       requires sentinel_for<S, I2>
-    friend bool operator==(
       const common_iterator& x, const common_iterator<I2, S2>& y);
     template<class I2, sentinel_for<I> S2>
       requires sentinel_for<S, I2> && equality_comparable_with<I, I2>
-    friend bool operator==(
       const common_iterator& x, const common_iterator<I2, S2>& y);
     template<sized_sentinel_for<I> I2, sized_sentinel_for<I> S2>
       requires sized_sentinel_for<S, I2>
-    friend iter_difference_t<I2> operator-(
       const common_iterator& x, const common_iterator<I2, S2>& y);
-    friend 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 void iter_swap(const common_iterator& x, const common_iterator<I2, S2>& y)
         noexcept(noexcept(ranges::iter_swap(declval<const I&>(), declval<const I2&>())));
   private:
     variant<I, S> v_;   // exposition only
   };
@@ -1195,17 +1626,17 @@ namespace std {
 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
-  `iterator_traits<I>::iterator_category` models
-  `derived_from<forward_iterator_tag>`; otherwise it denotes
-  `input_iterator_tag`.
-- If the expression `a.operator->()` is well-formed, where `a` is an
- lvalue of type `const common_iterator<I, S>`, then `pointer` denotes
- the type of that expression. Otherwise, `pointer` denotes `void`.
 #### Constructors and conversions <a id="common.iter.const">[[common.iter.const]]</a>
 ``` cpp
 constexpr common_iterator(I i);
@@ -1234,11 +1665,11 @@ template<class I2, class S2>
 ``` cpp
 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&>
-    common_iterator& operator=(const common_iterator<I2, S2>& x);
 ```
 *Preconditions:* `x.v_.valueless_by_exception()` is `false`.
 *Effects:* Equivalent to:
@@ -1251,34 +1682,34 @@ where i is `x.v_.index()`.
 *Returns:* `*this`
 #### Accessors <a id="common.iter.access">[[common.iter.access]]</a>
 ``` cpp
-decltype(auto) operator*();
-decltype(auto) operator*() const
   requires dereferenceable<const I>;
 ```
-*Preconditions:* `holds_alternative<I>(v_)`.
 *Effects:* Equivalent to: `return *get<I>(v_);`
 ``` cpp
-decltype(auto) operator->() const
   requires see below;
 ```
-The expression in the requires clause is equivalent to:
 ``` cpp
 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_)`.
 *Effects:*
 - If `I` is a pointer type or if the expression
   `get<I>(v_).operator->()` is well-formed, equivalent to:
@@ -1292,53 +1723,87 @@ indirectly_readable<const I> &&
 - Otherwise, equivalent to: `return `*`proxy`*`(*get<I>(v_));` where
   *proxy* is the exposition-only class:
   ``` cpp
   class proxy {
     iter_value_t<I> keep_;
-    proxy(iter_reference_t<I>&& x)
       : keep_(std::move(x)) {}
   public:
-    const iter_value_t<I>* operator->() const {
       return addressof(keep_);
     }
   };
   ```
 #### Navigation <a id="common.iter.nav">[[common.iter.nav]]</a>
 ``` cpp
-common_iterator& operator++();
 ```
-*Preconditions:* `holds_alternative<I>(v_)`.
 *Effects:* Equivalent to `++get<I>(v_)`.
 *Returns:* `*this`.
 ``` cpp
-decltype(auto) operator++(int);
 ```
-*Preconditions:* `holds_alternative<I>(v_)`.
 *Effects:* If `I` models `forward_iterator`, equivalent to:
 ``` cpp
 common_iterator tmp = *this;
 ++*this;
 return tmp;
 ```
-Otherwise, equivalent to: `return get<I>(v_)++;`
 #### Comparisons <a id="common.iter.cmp">[[common.iter.cmp]]</a>
 ``` cpp
 template<class I2, sentinel_for<I> S2>
   requires sentinel_for<S, I2>
-friend 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`.
@@ -1348,11 +1813,11 @@ friend bool operator==(
 `y.v_.index()`.
 ``` cpp
 template<class I2, sentinel_for<I> S2>
   requires sentinel_for<S, I2> && equality_comparable_with<I, I2>
-friend 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`.
@@ -1362,46 +1827,46 @@ friend bool operator==(
 `y.v_.index()`.
 ``` cpp
 template<sized_sentinel_for<I> I2, sized_sentinel_for<I> S2>
   requires sized_sentinel_for<S, I2>
-friend 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()`.
-#### Customization <a id="common.iter.cust">[[common.iter.cust]]</a>
 ``` cpp
-friend 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>(v_)`.
 *Effects:* Equivalent to: `return ranges::iter_move(get<I>(i.v_));`
 ``` cpp
 template<indirectly_swappable<I> I2, class S2>
-  friend 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 sentinels <a id="default.sentinels">[[default.sentinels]]</a>
 ``` cpp
 namespace std {
   struct default_sentinel_t { };
 }
@@ -1434,39 +1899,49 @@ ranges::copy(counted_iterator(s.begin(), 10), default_sentinel, back_inserter(v)
 — *end example*]
 Two values `i1` and `i2` of types `counted_iterator<I1>` and
 `counted_iterator<I2>` refer to elements of the same sequence if and
-only if `next(i1.base(), i1.count())` and `next(i2.base(), i2.count())`
 refer to the same (possibly past-the-end) element.
 ``` cpp
 namespace std {
   template<input_or_output_iterator I>
   class counted_iterator {
   public:
     using iterator_type = I;
-    constexpr counted_iterator() = default;
     constexpr counted_iterator(I x, iter_difference_t<I> n);
     template<class I2>
       requires convertible_to<const I2&, I>
         constexpr counted_iterator(const counted_iterator<I2>& x);
     template<class I2>
       requires assignable_from<I&, const I2&>
         constexpr counted_iterator& operator=(const counted_iterator<I2>& x);
-    constexpr I base() const & requires copy_constructible<I>;
     constexpr I base() &&;
     constexpr iter_difference_t<I> count() const noexcept;
     constexpr decltype(auto) operator*();
     constexpr decltype(auto) operator*() const
       requires dereferenceable<const I>;
     constexpr counted_iterator& operator++();
-    decltype(auto) operator++(int);
     constexpr counted_iterator operator++(int)
       requires forward_iterator<I>;
     constexpr counted_iterator& operator--()
       requires bidirectional_iterator<I>;
     constexpr counted_iterator operator--(int)
@@ -1515,18 +1990,15 @@ namespace std {
   private:
     I current = I();                    // exposition only
     iter_difference_t<I> length = 0;    // exposition only
   };
-  template<class I>
-  struct incrementable_traits<counted_iterator<I>> {
-    using difference_type = iter_difference_t<I>;
-  };
   template<input_iterator I>
   struct iterator_traits<counted_iterator<I>> : iterator_traits<I> {
-    using pointer = void;
   };
 }
 ```
 #### Constructors and conversions <a id="counted.iter.const">[[counted.iter.const]]</a>
@@ -1560,11 +2032,11 @@ template<class I2>
 *Returns:* `*this`.
 #### Accessors <a id="counted.iter.access">[[counted.iter.access]]</a>
 ``` cpp
-constexpr I base() const & requires copy_constructible<I>;
 ```
 *Effects:* Equivalent to: `return current;`
 ``` cpp
@@ -1585,12 +2057,21 @@ constexpr iter_difference_t<I> count() const noexcept;
 constexpr decltype(auto) operator*();
 constexpr decltype(auto) operator*() const
   requires dereferenceable<const I>;
 ```
 *Effects:* Equivalent to: `return *current;`
 ``` cpp
 constexpr decltype(auto) operator[](iter_difference_t<I> n) const
   requires random_access_iterator<I>;
 ```
@@ -1613,11 +2094,11 @@ constexpr counted_iterator& operator++();
 --length;
 return *this;
 ```
 ``` cpp
-decltype(auto) operator++(int);
 ```
 *Preconditions:* `length > 0`.
 *Effects:* Equivalent to:
@@ -1787,24 +2268,26 @@ friend constexpr iter_rvalue_reference_t<I>
   iter_move(const counted_iterator& i)
     noexcept(noexcept(ranges::iter_move(i.current)))
     requires input_iterator<I>;
 ```
 *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)));
 ```
 *Effects:* Equivalent to `ranges::iter_swap(x.current, y.current)`.
-### Unreachable sentinel <a id="unreachable.sentinels">[[unreachable.sentinels]]</a>
-#### Class `unreachable_sentinel_t` <a id="unreachable.sentinel">[[unreachable.sentinel]]</a>
 Class `unreachable_sentinel_t` can be used with any
 `weakly_incrementable` type to denote the “upper bound” of an unbounded
 interval.

 ## Iterator adaptors <a id="predef.iterators">[[predef.iterators]]</a>
 ### Reverse iterators <a id="reverse.iterators">[[reverse.iterators]]</a>
+#### General <a id="reverse.iterators.general">[[reverse.iterators.general]]</a>
 Class template `reverse_iterator` is an iterator adaptor that iterates
 from the end of the sequence defined by its underlying iterator to the
 beginning of that sequence.
 #### Class template `reverse_iterator` <a id="reverse.iterator">[[reverse.iterator]]</a>
 ``` cpp
 template<class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
 ```
+*Constraints:* `is_same_v<U, Iterator>` is `false` and `const U&` models
+`convertible_to<Iterator>`.
 *Effects:* Initializes `current` with `u.current`.
 ``` cpp
 template<class U>
   constexpr reverse_iterator&
     operator=(const reverse_iterator<U>& u);
 ```
+*Constraints:* `is_same_v<U, Iterator>` is `false`, `const U&` models
+`convertible_to<Iterator>`, and `assignable_from<Iterator&, const U&>`
+is modeled.
+*Effects:* Assigns `u.current` to `current`.
 *Returns:* `*this`.
 #### Conversion <a id="reverse.iter.conv">[[reverse.iter.conv]]</a>
 ``` cpp
+constexpr Iterator base() const;
 ```
 *Returns:* `current`.
 #### Element access <a id="reverse.iter.elem">[[reverse.iter.elem]]</a>
 ``` cpp
 constexpr reverse_iterator& operator++();
 ```
+*Effects:* As if by: `–current;`
 *Returns:* `*this`.
 ``` cpp
 constexpr reverse_iterator operator++(int);
 *Returns:* `y.base() - x.base()`.
 ``` cpp
 template<class Iterator>
   constexpr reverse_iterator<Iterator> operator+(
+ iter_difference_t<Iterator> n,
     const reverse_iterator<Iterator>& x);
 ```
 *Returns:* `reverse_iterator<Iterator>(x.base() - n)`.
 ``` cpp
 auto tmp = i.base();
 return ranges::iter_move(--tmp);
 ```
+*Remarks:* The exception specification is equivalent to:
 ``` cpp
 is_nothrow_copy_constructible_v<Iterator> &&
 noexcept(ranges::iter_move(--declval<Iterator&>()))
 ```
 auto xtmp = x.base();
 auto ytmp = y.base();
 ranges::iter_swap(--xtmp, --ytmp);
 ```
+*Remarks:* The exception specification is equivalent to:
 ``` cpp
 is_nothrow_copy_constructible_v<Iterator> &&
 is_nothrow_copy_constructible_v<Iterator2> &&
 noexcept(ranges::iter_swap(--declval<Iterator&>(), --declval<Iterator2&>()))
 *Returns:* `reverse_iterator<Iterator>(i)`.
 ### Insert iterators <a id="insert.iterators">[[insert.iterators]]</a>
+#### General <a id="insert.iterators.general">[[insert.iterators.general]]</a>
 To make it possible to deal with insertion in the same way as writing
 into an array, a special kind of iterator adaptors, called *insert
 iterators*, are provided in the library. With regular iterator classes,
 ``` cpp
 ``` cpp
 namespace std {
   template<class Container>
   class back_insert_iterator {
   protected:
+    Container* container;
   public:
     using iterator_category = output_iterator_tag;
     using value_type        = void;
     using difference_type   = ptrdiff_t;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
     constexpr explicit back_insert_iterator(Container& x);
     constexpr back_insert_iterator& operator=(const typename Container::value_type& value);
     constexpr back_insert_iterator& operator=(typename Container::value_type&& value);
     constexpr back_insert_iterator& operator*();
 ``` cpp
 namespace std {
   template<class Container>
   class front_insert_iterator {
   protected:
+    Container* container;
   public:
     using iterator_category = output_iterator_tag;
     using value_type        = void;
     using difference_type   = ptrdiff_t;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
     constexpr explicit front_insert_iterator(Container& x);
     constexpr front_insert_iterator& operator=(const typename Container::value_type& value);
     constexpr front_insert_iterator& operator=(typename Container::value_type&& value);
     constexpr front_insert_iterator& operator*();
 ``` cpp
 namespace std {
   template<class Container>
   class insert_iterator {
   protected:
+    Container* container;
+    ranges::iterator_t<Container> iter;
   public:
     using iterator_category = output_iterator_tag;
     using value_type        = void;
     using difference_type   = ptrdiff_t;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
     constexpr insert_iterator(Container& x, ranges::iterator_t<Container> i);
     constexpr insert_iterator& operator=(const typename Container::value_type& value);
     constexpr insert_iterator& operator=(typename Container::value_type&& value);
     constexpr insert_iterator& operator*();
     inserter(Container& x, ranges::iterator_t<Container> i);
 ```
 *Returns:* `insert_iterator<Container>(x, i)`.
+### Constant iterators and sentinels <a id="const.iterators">[[const.iterators]]</a>
+#### General <a id="const.iterators.general">[[const.iterators.general]]</a>
+Class template `basic_const_iterator` is an iterator adaptor with the
+same behavior as the underlying iterator except that its indirection
+operator implicitly converts the value returned by the underlying
+iterator’s indirection operator to a type such that the adapted iterator
+is a constant iterator [[iterator.requirements]]. Some generic
+algorithms can be called with constant iterators to avoid mutation.
+Specializations of `basic_const_iterator` are constant iterators.
+#### Alias templates <a id="const.iterators.alias">[[const.iterators.alias]]</a>
+``` cpp
+template<indirectly_readable It>
+  using iter_const_reference_t =
+    common_reference_t<const iter_value_t<It>&&, iter_reference_t<It>>;
+template<class It>
+  concept constant-iterator =                                                   // exposition only
+    input_iterator<It> && same_as<iter_const_reference_t<It>, iter_reference_t<It>>;
+template<input_iterator I>
+  using const_iterator = see below;
+```
+*Result:* If `I` models `constant-iterator`, `I`. Otherwise,
+`basic_const_iterator<I>`.
+``` cpp
+template<semiregular S>
+  using const_sentinel = see below;
+```
+*Result:* If `S` models `input_iterator`, `const_iterator<S>`.
+Otherwise, `S`.
+#### Class template `basic_const_iterator` <a id="const.iterators.iterator">[[const.iterators.iterator]]</a>
+``` cpp
+namespace std {
+  template<class I>
+    concept not-a-const-iterator = see below;                   // exposition only
+  template<indirectly_readable I>
+    using iter-const-rvalue-reference-t =                       // exposition only
+      common_reference_t<const iter_value_t<I>&&, iter_rvalue_reference_t<I>>;
+  template<input_iterator Iterator>
+  class basic_const_iterator {
+    Iterator current_ = Iterator();                             // exposition only
+    using reference = iter_const_reference_t<Iterator>;         // exposition only
+    using rvalue-reference =                                    // exposition only
+      iter-const-rvalue-reference-t<Iterator>;
+  public:
+    using iterator_concept = see below;
+    using iterator_category = see below;  // not always present
+    using value_type = iter_value_t<Iterator>;
+    using difference_type = iter_difference_t<Iterator>;
+    basic_const_iterator() requires default_initializable<Iterator> = default;
+    constexpr basic_const_iterator(Iterator current);
+    template<convertible_to<Iterator> U>
+      constexpr basic_const_iterator(basic_const_iterator<U> current);
+    template<different-from<basic_const_iterator> T>
+        requires convertible_to<T, Iterator>
+      constexpr basic_const_iterator(T&& current);
+    constexpr const Iterator& base() const & noexcept;
+    constexpr Iterator base() &&;
+    constexpr reference operator*() const;
+    constexpr const auto* operator->() const
+       requires is_lvalue_reference_v<iter_reference_t<Iterator>> &&
+                same_as<remove_cvref_t<iter_reference_t<Iterator>>, value_type>;
+    constexpr basic_const_iterator& operator++();
+    constexpr void operator++(int);
+    constexpr basic_const_iterator operator++(int) requires forward_iterator<Iterator>;
+    constexpr basic_const_iterator& operator--() requires bidirectional_iterator<Iterator>;
+    constexpr basic_const_iterator operator--(int) requires bidirectional_iterator<Iterator>;
+    constexpr basic_const_iterator& operator+=(difference_type n)
+      requires random_access_iterator<Iterator>;
+    constexpr basic_const_iterator& operator-=(difference_type n)
+      requires random_access_iterator<Iterator>;
+    constexpr reference operator[](difference_type n) const
+      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
+      requires random_access_iterator<Iterator>;
+    constexpr bool operator>=(const basic_const_iterator& y) const
+      requires random_access_iterator<Iterator>;
+    constexpr auto operator<=>(const basic_const_iterator& y) const
+      requires random_access_iterator<Iterator> && three_way_comparable<Iterator>;
+    template<different-from<basic_const_iterator> I>
+      constexpr bool operator<(const I& y) const
+        requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+    template<different-from<basic_const_iterator> I>
+      constexpr bool operator>(const I& y) const
+        requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+    template<different-from<basic_const_iterator> I>
+      constexpr bool operator<=(const I& y) const
+        requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+    template<different-from<basic_const_iterator> I>
+      constexpr bool operator>=(const I& y) const
+        requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+    template<different-from<basic_const_iterator> I>
+      constexpr auto operator<=>(const I& y) const
+        requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I> &&
+                 three_way_comparable_with<Iterator, I>;
+    template<not-a-const-iterator I>
+      friend constexpr bool operator<(const I& x, const basic_const_iterator& y)
+        requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+    template<not-a-const-iterator I>
+      friend constexpr bool operator>(const I& x, const basic_const_iterator& y)
+        requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+    template<not-a-const-iterator I>
+      friend constexpr bool operator<=(const I& x, const basic_const_iterator& y)
+        requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+    template<not-a-const-iterator I>
+      friend constexpr bool operator>=(const I& x, const basic_const_iterator& y)
+        requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+    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)
+      requires random_access_iterator<Iterator>;
+    friend constexpr basic_const_iterator operator-(const basic_const_iterator& i,
+                                                    difference_type n)
+      requires random_access_iterator<Iterator>;
+    template<sized_sentinel_for<Iterator> S>
+      constexpr difference_type operator-(const S& y) const;
+    template<not-a-const-iterator S>
+      requires sized_sentinel_for<S, Iterator>
+      friend constexpr difference_type operator-(const S& x, const basic_const_iterator& y);
+    friend constexpr rvalue-reference iter_move(const basic_const_iterator& i)
+      noexcept(noexcept(static_cast<rvalue-reference>(ranges::iter_move(i.current_))))
+      {
+        return static_cast<rvalue-reference>(ranges::iter_move(i.current_));
+      }
+  };
+}
+```
+Given some type `I`, the concept *not-a-const-iterator* is defined as
+`false` if `I` is a specialization of `basic_const_iterator` and `true`
+otherwise.
+#### Member types <a id="const.iterators.types">[[const.iterators.types]]</a>
+`basic_const_iterator<Iterator>::iterator_concept` is defined as
+follows:
+- If `Iterator` models `contiguous_iterator`, then `iterator_concept`
+  denotes `contiguous_iterator_tag`.
+- Otherwise, if `Iterator` models `random_access_iterator`, then
+  `iterator_concept` denotes `random_access_iterator_tag`.
+- Otherwise, if `Iterator` models `bidirectional_iterator`, then
+  `iterator_concept` denotes `bidirectional_iterator_tag`.
+- Otherwise, if `Iterator` models `forward_iterator`, then
+  `iterator_concept` denotes `forward_iterator_tag`.
+- Otherwise, `iterator_concept` denotes `input_iterator_tag`.
+The member *typedef-name* `iterator_category` is defined if and only if
+`Iterator` models `forward_iterator`. In that case,
+`basic_const_iterator<Iterator>::iterator_category` denotes the type
+`iterator_traits<{}Iterator>::iterator_category`.
+#### Operations <a id="const.iterators.ops">[[const.iterators.ops]]</a>
+``` cpp
+constexpr basic_const_iterator(Iterator current);
+```
+*Effects:* Initializes *current\_* with `std::move(current)`.
+``` cpp
+template<convertible_to<Iterator> U>
+  constexpr basic_const_iterator(basic_const_iterator<U> current);
+```
+*Effects:* Initializes *current\_* with
+`std::move(current.`*`current_`*`)`.
+``` cpp
+template<different-from<basic_const_iterator> T>
+  requires convertible_to<T, Iterator>
+  constexpr basic_const_iterator(T&& current);
+```
+*Effects:* Initializes *current\_* with `std::forward<T>(current)`.
+``` cpp
+constexpr const Iterator& base() const & noexcept;
+```
+*Effects:* Equivalent to: `return `*`current_`*`;`
+``` cpp
+constexpr Iterator base() &&;
+```
+*Effects:* Equivalent to: `return std::move(`*`current_`*`);`
+``` cpp
+constexpr reference operator*() const;
+```
+*Effects:* Equivalent to:
+`return static_cast<`*`reference`*`>(*`*`current_`*`);`
+``` cpp
+constexpr const auto* operator->() const
+  requires is_lvalue_reference_v<iter_reference_t<Iterator>> &&
+           same_as<remove_cvref_t<iter_reference_t<Iterator>>, value_type>;
+```
+*Returns:* If `Iterator` models `contiguous_iterator`,
+`to_address(`*`current_`*`)`; otherwise, `addressof(*`*`current_`*`)`.
+``` cpp
+constexpr basic_const_iterator& operator++();
+```
+*Effects:* Equivalent to:
+``` cpp
+++current_;
+return *this;
+```
+``` cpp
+constexpr void operator++(int);
+```
+*Effects:* Equivalent to: `++`*`current_`*`;`
+``` cpp
+constexpr basic_const_iterator operator++(int) requires forward_iterator<Iterator>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+++*this;
+return tmp;
+```
+``` cpp
+constexpr basic_const_iterator& operator--() requires bidirectional_iterator<Iterator>;
+```
+*Effects:* Equivalent to:
+``` cpp
+--current_;
+return *this;
+```
+``` cpp
+constexpr basic_const_iterator operator--(int) requires bidirectional_iterator<Iterator>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+--*this;
+return tmp;
+```
+``` cpp
+constexpr basic_const_iterator& operator+=(difference_type n)
+  requires random_access_iterator<Iterator>;
+constexpr basic_const_iterator& operator-=(difference_type n)
+  requires random_access_iterator<Iterator>;
+```
+Let *`op`* be the operator.
+*Effects:* Equivalent to:
+``` cpp
+current_ op n;
+return *this;
+```
+``` cpp
+constexpr reference operator[](difference_type n) const requires random_access_iterator<Iterator>
+```
+*Effects:* Equivalent to:
+`return static_cast<`*`reference`*`>(`*`current_`*`[n]);`
+``` cpp
+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>;
+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 auto operator<=>(const basic_const_iterator& y) const
+  requires random_access_iterator<Iterator> && three_way_comparable<Iterator>;
+```
+Let *`op`* be the operator.
+*Effects:* Equivalent to:
+`return `*`current_`*` `*`op`*` `*`y.current_`*`;`
+``` cpp
+template<different-from<basic_const_iterator> I>
+  constexpr bool operator<(const I& y) const
+    requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+template<different-from<basic_const_iterator> I>
+  constexpr bool operator>(const I& y) const
+    requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+template<different-from<basic_const_iterator> I>
+  constexpr bool operator<=(const I& y) const
+    requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+template<different-from<basic_const_iterator> I>
+  constexpr bool operator>=(const I& y) const
+    requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+template<different-from<basic_const_iterator> I>
+  constexpr auto operator<=>(const I& y) const
+    requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I> &&
+             three_way_comparable_with<Iterator, I>;
+```
+Let *`op`* be the operator.
+*Effects:* Equivalent to: `return `*`current_`*` `*`op`*` y;`
+``` cpp
+template<not-a-const-iterator I>
+  friend constexpr bool operator<(const I& x, const basic_const_iterator& y)
+    requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+template<not-a-const-iterator I>
+  friend constexpr bool operator>(const I& x, const basic_const_iterator& y)
+    requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+template<not-a-const-iterator I>
+  friend constexpr bool operator<=(const I& x, const basic_const_iterator& y)
+    requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+template<not-a-const-iterator I>
+  friend constexpr bool operator>=(const I& x, const basic_const_iterator& y)
+    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)
+  requires random_access_iterator<Iterator>;
+```
+*Effects:* Equivalent to:
+`return basic_const_iterator(i.`*`current_`*` + n);`
+``` cpp
+friend constexpr basic_const_iterator operator-(const basic_const_iterator& i, difference_type n)
+  requires random_access_iterator<Iterator>;
+```
+*Effects:* Equivalent to:
+`return basic_const_iterator(i.`*`current_`*` - n);`
+``` cpp
+template<sized_sentinel_for<Iterator> S>
+  constexpr difference_type operator-(const S& y) const;
+```
+*Effects:* Equivalent to: `return `*`current_`*` - y;`
+``` cpp
+template<not-a-const-iterator S>
+  requires sized_sentinel_for<S, Iterator>
+  friend constexpr difference_type operator-(const S& x, const basic_const_iterator& y);
+```
+*Effects:* Equivalent to: `return x - y.`*`current_`*`;`
 ### Move iterators and sentinels <a id="move.iterators">[[move.iterators]]</a>
+#### General <a id="move.iterators.general">[[move.iterators.general]]</a>
 Class template `move_iterator` is an iterator adaptor with the same
 behavior as the underlying iterator except that its indirection operator
 implicitly converts the value returned by the underlying iterator’s
 indirection operator to an rvalue. Some generic algorithms can be called
 with move iterators to replace copying with moving.
 namespace std {
   template<class Iterator>
   class move_iterator {
   public:
     using iterator_type     = Iterator;
+    using iterator_concept  = see below;
+    using iterator_category = see below;                      // not always present
     using value_type        = iter_value_t<Iterator>;
     using difference_type   = iter_difference_t<Iterator>;
     using pointer           = Iterator;
     using reference         = iter_rvalue_reference_t<Iterator>;
     constexpr move_iterator();
     constexpr explicit move_iterator(Iterator i);
     template<class U> constexpr move_iterator(const move_iterator<U>& u);
     template<class U> constexpr move_iterator& operator=(const move_iterator<U>& u);
+    constexpr const Iterator& base() const & noexcept;
+    constexpr Iterator base() &&;
     constexpr reference operator*() const;
     constexpr move_iterator& operator++();
     constexpr auto operator++(int);
     constexpr move_iterator& operator--();
     Iterator current;   // exposition only
   };
 }
 ```
+The member *typedef-name* `iterator_concept` is defined as follows:
+- If `Iterator` models `random_access_iterator`, then `iterator_concept`
+  denotes `random_access_iterator_tag`.
+- Otherwise, if `Iterator` models `bidirectional_iterator`, then
+  `iterator_concept` denotes `bidirectional_iterator_tag`.
+- Otherwise, if `Iterator` models `forward_iterator`, then
+  `iterator_concept` denotes `forward_iterator_tag`.
+- Otherwise, `iterator_concept` denotes `input_iterator_tag`.
+The member *typedef-name* `iterator_category` is defined if and only if
+the *qualified-id* `iterator_traits<Iterator>::iterator_category` is
+valid and denotes a type. In that case, `iterator_category` denotes
 - `random_access_iterator_tag` if the type
   `iterator_traits<{}Iterator>::iterator_category` models
   `derived_from<random_access_iterator_tag>`, and
 - `iterator_traits<{}Iterator>::iterator_category` otherwise.
 ``` cpp
 constexpr move_iterator();
 ```
+*Effects:* Value-initializes `current`.
 ``` cpp
 constexpr explicit move_iterator(Iterator i);
 ```
+*Effects:* Initializes `current` with `std::move(i)`.
 ``` cpp
 template<class U> constexpr move_iterator(const move_iterator<U>& u);
 ```
+*Constraints:* `is_same_v<U, Iterator>` is `false` and `const U&` models
+`convertible_to<Iterator>`.
+*Effects:* Initializes `current` with `u.current`.
 ``` cpp
 template<class U> constexpr move_iterator& operator=(const move_iterator<U>& u);
 ```
+*Constraints:* `is_same_v<U, Iterator>` is `false`, `const U&` models
+`convertible_to<Iterator>`, and `assignable_from<Iterator&, const U&>`
+is modeled.
+*Effects:* Assigns `u.current` to `current`.
+*Returns:* `*this`.
 #### Conversion <a id="move.iter.op.conv">[[move.iter.op.conv]]</a>
 ``` cpp
+constexpr const Iterator& base() const & noexcept;
 ```
 *Returns:* `current`.
 ``` cpp
 constexpr Iterator base() &&;
 ```
 ``` cpp
 constexpr reference operator[](difference_type n) const;
 ```
+*Effects:* Equivalent to: `return ranges::iter_move(current + n);`
 #### Navigation <a id="move.iter.nav">[[move.iter.nav]]</a>
 ``` cpp
 constexpr move_iterator& operator++();
 ``` cpp
 constexpr move_iterator& operator--();
 ```
+*Effects:* As if by `–current`.
 *Returns:* `*this`.
 ``` cpp
 constexpr move_iterator operator--(int);
 #### Non-member functions <a id="move.iter.nonmember">[[move.iter.nonmember]]</a>
 ``` cpp
 template<class Iterator1, class Iterator2>
+  constexpr auto operator-(
+ const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y)
       -> decltype(x.base() - y.base());
 template<sized_sentinel_for<Iterator> S>
   friend constexpr iter_difference_t<Iterator>
     operator-(const move_sentinel<S>& x, const move_iterator& y);
 template<sized_sentinel_for<Iterator> S>
 template<class Iterator>
   constexpr move_iterator<Iterator>
     operator+(iter_difference_t<Iterator> n, const move_iterator<Iterator>& x);
 ```
+*Constraints:* `x.base() + n` is well-formed and has type `Iterator`.
 *Returns:* `x + n`.
 ``` cpp
 friend constexpr iter_rvalue_reference_t<Iterator>
 Class template `move_sentinel` is a sentinel adaptor useful for denoting
 ranges together with `move_iterator`. When an input iterator type `I`
 and sentinel type `S` model `sentinel_for<S, I>`, `move_sentinel<S>` and
 `move_iterator<I>` model
+`sentinel_for<move_sentinel<S>, move_iterator<I>>` as well.
 [*Example 1*:
 A `move_if` algorithm is easily implemented with `copy_if` using
 `move_iterator` and `move_sentinel`:
 ``` cpp
 template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
          indirect_unary_predicate<I> Pred>
   requires indirectly_movable<I, O>
 void move_if(I first, S last, O out, Pred pred) {
+  ranges::copy_if(move_iterator<I>{std::move(first)}, move_sentinel<S>{last},
+                  std::move(out), pred);
 }
 ```
 — *end example*]
     template<class S2>
       requires assignable_from<S&, const S2&>
         constexpr move_sentinel& operator=(const move_sentinel<S2>& s);
     constexpr S base() const;
   private:
     S last;     // exposition only
   };
 }
 ```
 namespace std {
   template<input_or_output_iterator I, sentinel_for<I> S>
     requires (!same_as<I, S> && copyable<I>)
   class common_iterator {
   public:
+    constexpr common_iterator() requires default_initializable<I> = default;
     constexpr common_iterator(I i);
     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);
     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);
+ constexpr decltype(auto) operator*();
+ constexpr decltype(auto) operator*() const
       requires dereferenceable<const I>;
+ constexpr auto operator->() const
       requires see below;
+ constexpr common_iterator& operator++();
+ constexpr decltype(auto) operator++(int);
     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);
     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);
     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&>())));
   private:
     variant<I, S> v_;   // exposition only
   };
 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>
 ``` cpp
 constexpr common_iterator(I i);
 ``` cpp
 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:
 *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
   requires see below;
 ```
+The expression in the *requires-clause* is equivalent to:
 ``` cpp
 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:
 - Otherwise, equivalent to: `return `*`proxy`*`(*get<I>(v_));` where
   *proxy* is the exposition-only class:
   ``` cpp
   class proxy {
     iter_value_t<I> keep_;
+ constexpr proxy(iter_reference_t<I>&& x)
       : keep_(std::move(x)) {}
   public:
+ constexpr const iter_value_t<I>* operator->() const noexcept {
       return addressof(keep_);
     }
   };
   ```
 #### Navigation <a id="common.iter.nav">[[common.iter.nav]]</a>
 ``` 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;
 ++*this;
 return tmp;
 ```
+Otherwise, if `requires(I& i) { { *i++ } -> `*`can-reference`*`; }` is
+`true` or
+``` cpp
+indirectly_readable<I> && constructible_from<iter_value_t<I>, iter_reference_t<I>> &&
+move_constructible<iter_value_t<I>>
+```
+is `false`, equivalent to:
+``` cpp
+return get<I>(v_)++;
+```
+Otherwise, equivalent to:
+``` cpp
+postfix-proxy p(**this);
+++*this;
+return p;
+```
+where *postfix-proxy* is the exposition-only class:
+``` cpp
+class postfix-proxy {
+  iter_value_t<I> keep_;
+  constexpr postfix-proxy(iter_reference_t<I>&& x)
+    : keep_(std::forward<iter_reference_t<I>>(x)) {}
+public:
+  constexpr const iter_value_t<I>& operator*() const noexcept {
+    return keep_;
+  }
+};
+```
 #### Comparisons <a id="common.iter.cmp">[[common.iter.cmp]]</a>
 ``` cpp
 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`.
 `y.v_.index()`.
 ``` cpp
 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`.
 `y.v_.index()`.
 ``` cpp
 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>
 ``` cpp
 namespace std {
   struct default_sentinel_t { };
 }
 — *end example*]
 Two values `i1` and `i2` of types `counted_iterator<I1>` and
 `counted_iterator<I2>` refer to elements of the same sequence if and
+only if there exists some integer n such that
+`next(i1.base(), i1.count() + n)` and `next(i2.base(), i2.count() + n)`
 refer to the same (possibly past-the-end) element.
 ``` cpp
 namespace std {
   template<input_or_output_iterator I>
   class counted_iterator {
   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>
         constexpr counted_iterator(const counted_iterator<I2>& x);
     template<class I2>
       requires assignable_from<I&, const I2&>
         constexpr counted_iterator& operator=(const counted_iterator<I2>& x);
+    constexpr const I& base() const & noexcept;
     constexpr I base() &&;
     constexpr iter_difference_t<I> count() const noexcept;
     constexpr decltype(auto) operator*();
     constexpr decltype(auto) operator*() const
       requires dereferenceable<const I>;
+    constexpr auto operator->() const noexcept
+      requires contiguous_iterator<I>;
     constexpr counted_iterator& operator++();
+ constexpr decltype(auto) operator++(int);
     constexpr counted_iterator operator++(int)
       requires forward_iterator<I>;
     constexpr counted_iterator& operator--()
       requires bidirectional_iterator<I>;
     constexpr counted_iterator operator--(int)
   private:
     I current = I();                    // exposition only
     iter_difference_t<I> length = 0;    // exposition only
   };
   template<input_iterator I>
+    requires same_as<ITER_TRAITS(I), iterator_traits<I>>   // see [iterator.concepts.general]
   struct iterator_traits<counted_iterator<I>> : iterator_traits<I> {
+    using pointer = conditional_t<contiguous_iterator<I>,
+                                  add_pointer_t<iter_reference_t<I>>, void>;
   };
 }
 ```
 #### Constructors and conversions <a id="counted.iter.const">[[counted.iter.const]]</a>
 *Returns:* `*this`.
 #### Accessors <a id="counted.iter.access">[[counted.iter.access]]</a>
 ``` cpp
+constexpr const I& base() const & noexcept;
 ```
 *Effects:* Equivalent to: `return current;`
 ``` cpp
 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
+  requires contiguous_iterator<I>;
+```
+*Effects:* Equivalent to: `return to_address(current);`
 ``` cpp
 constexpr decltype(auto) operator[](iter_difference_t<I> n) const
   requires random_access_iterator<I>;
 ```
 --length;
 return *this;
 ```
 ``` cpp
+constexpr decltype(auto) operator++(int);
 ```
 *Preconditions:* `length > 0`.
 *Effects:* Equivalent to:
   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>
 Class `unreachable_sentinel_t` can be used with any
 `weakly_incrementable` type to denote the “upper bound” of an unbounded
 interval.

Diff to HTML by rtfpessoa