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

Files changed (1) hide show

tmp/tmp6nu7pp7u/{from.md → to.md} +1228 -369

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

@@ -2,36 +2,35 @@
 ### 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. The fundamental relation between a reverse
-iterator and its corresponding iterator `i` is established by the
-identity: `&*(reverse_iterator(i)) == &*(i - 1)`.
 #### Class template `reverse_iterator` <a id="reverse.iterator">[[reverse.iterator]]</a>
 ``` cpp
 namespace std {
   template<class Iterator>
   class reverse_iterator {
   public:
     using iterator_type     = Iterator;
-    using iterator_category = typename iterator_traits<Iterator>::iterator_category;
-    using value_type        = typename iterator_traits<Iterator>::value_type;
-    using difference_type   = typename iterator_traits<Iterator>::difference_type;
     using pointer           = typename iterator_traits<Iterator>::pointer;
-    using reference         = typename iterator_traits<Iterator>::reference;
     constexpr reverse_iterator();
     constexpr explicit reverse_iterator(Iterator x);
     template<class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
     template<class U> constexpr reverse_iterator& operator=(const reverse_iterator<U>& u);
-    constexpr Iterator base() const;      // explicit
     constexpr reference operator*() const;
-    constexpr pointer   operator->() const;
     constexpr reverse_iterator& operator++();
     constexpr reverse_iterator  operator++(int);
     constexpr reverse_iterator& operator--();
     constexpr reverse_iterator  operator--(int);
@@ -39,72 +38,60 @@ namespace std {
     constexpr reverse_iterator  operator+ (difference_type n) const;
     constexpr reverse_iterator& operator+=(difference_type n);
     constexpr reverse_iterator  operator- (difference_type n) const;
     constexpr reverse_iterator& operator-=(difference_type n);
     constexpr unspecified operator[](difference_type n) const;
   protected:
     Iterator current;
   };
-  template <class Iterator1, class Iterator2>
-    constexpr bool operator==(
-      const reverse_iterator<Iterator1>& x,
-      const reverse_iterator<Iterator2>& y);
-  template <class Iterator1, class Iterator2>
-    constexpr bool operator<(
-      const reverse_iterator<Iterator1>& x,
-      const reverse_iterator<Iterator2>& y);
-  template <class Iterator1, class Iterator2>
-    constexpr bool operator!=(
-      const reverse_iterator<Iterator1>& x,
-      const reverse_iterator<Iterator2>& y);
-  template <class Iterator1, class Iterator2>
-    constexpr bool operator>(
-      const reverse_iterator<Iterator1>& x,
-      const reverse_iterator<Iterator2>& y);
-  template <class Iterator1, class Iterator2>
-    constexpr bool operator>=(
-      const reverse_iterator<Iterator1>& x,
-      const reverse_iterator<Iterator2>& y);
-  template <class Iterator1, class Iterator2>
-    constexpr bool operator<=(
-      const reverse_iterator<Iterator1>& x,
-      const reverse_iterator<Iterator2>& y);
-  template <class Iterator1, class Iterator2>
-    constexpr auto operator-(
-      const reverse_iterator<Iterator1>& x,
-      const reverse_iterator<Iterator2>& y) -> decltype(y.base() - x.base());
-  template <class Iterator>
-    constexpr reverse_iterator<Iterator> operator+(
-      typename reverse_iterator<Iterator>::difference_type n,
-      const reverse_iterator<Iterator>& x);
-  template <class Iterator>
-    constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i);
 }
 ```
-#### `reverse_iterator` requirements <a id="reverse.iter.requirements">[[reverse.iter.requirements]]</a>
-The template parameter `Iterator` shall meet all the requirements of a
-Bidirectional Iterator ([[bidirectional.iterators]]).
-Additionally, `Iterator` shall meet the requirements of a random access
-iterator ([[random.access.iterators]]) if any of the members
-`operator+` ([[reverse.iter.op+]]), `operator-` (
-[[reverse.iter.op-]]), `operator+=` ([[reverse.iter.op+=]]),
-`operator-=` ([[reverse.iter.op-=]]), `operator[]` (
-[[reverse.iter.opindex]]), or the non-member operators `operator<` (
-[[reverse.iter.op<]]), `operator>` ([[reverse.iter.op>]]),
-`operator<=` ([[reverse.iter.op<=]]), `operator>=` (
-[[reverse.iter.op>=]]), `operator-` ([[reverse.iter.opdiff]]) or
-`operator+` ([[reverse.iter.opsum]]) are referenced in a way that
-requires instantiation ([[temp.inst]]).
-#### `reverse_iterator` operations <a id="reverse.iter.ops">[[reverse.iter.ops]]</a>
-##### `reverse_iterator` constructor <a id="reverse.iter.cons">[[reverse.iter.cons]]</a>
 ``` cpp
 constexpr reverse_iterator();
 ```
@@ -123,31 +110,29 @@ constexpr explicit reverse_iterator(Iterator x);
 template<class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
 ```
 *Effects:* Initializes `current` with `u.current`.
-##### `reverse_iterator::operator=` <a id="reverse.iter.op=">[[reverse.iter.op=]]</a>
 ``` 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`.
-##### `operator*` <a id="reverse.iter.op.star">[[reverse.iter.op.star]]</a>
 ``` cpp
 constexpr reference operator*() const;
 ```
@@ -156,195 +141,245 @@ constexpr reference operator*() const;
 ``` cpp
 Iterator tmp = current;
 return *--tmp;
 ```
-##### `operator->` <a id="reverse.iter.opref">[[reverse.iter.opref]]</a>
-``` cpp
-constexpr pointer operator->() const;
-```
-*Returns:* `addressof(operator*())`.
-##### `operator++` <a id="reverse.iter.op++">[[reverse.iter.op++]]</a>
-``` cpp
-constexpr reverse_iterator& operator++();
-```
-*Effects:* As if by: `current;`
-*Returns:* `*this`.
 ``` cpp
-constexpr reverse_iterator operator++(int);
 ```
-*Effects:* As if by:
-``` cpp
-reverse_iterator tmp = *this;
---current;
-return tmp;
-```
-\[reverse.iter.op\]`operator\dcr`
 ``` cpp
-constexpr reverse_iterator& operator--();
 ```
-*Effects:* As if by `++current`.
-*Returns:* `*this`.
-``` cpp
-constexpr reverse_iterator operator--(int);
-```
-*Effects:* As if by:
-``` cpp
-reverse_iterator tmp = *this;
-++current;
-return tmp;
-```
-##### `operator+` <a id="reverse.iter.op+">[[reverse.iter.op+]]</a>
 ``` cpp
 constexpr reverse_iterator operator+(difference_type n) const;
 ```
 *Returns:* `reverse_iterator(current-n)`.
-##### `operator+=` <a id="reverse.iter.op+=">[[reverse.iter.op+=]]</a>
-``` cpp
-constexpr reverse_iterator& operator+=(difference_type n);
-```
-*Effects:* As if by: `current -= n;`
-*Returns:* `*this`.
-##### `operator-` <a id="reverse.iter.op-">[[reverse.iter.op-]]</a>
 ``` cpp
 constexpr reverse_iterator operator-(difference_type n) const;
 ```
 *Returns:* `reverse_iterator(current+n)`.
-##### `operator-=` <a id="reverse.iter.op-=">[[reverse.iter.op-=]]</a>
 ``` cpp
 constexpr reverse_iterator& operator-=(difference_type n);
 ```
 *Effects:* As if by: `current += n;`
 *Returns:* `*this`.
-##### `operator[]` <a id="reverse.iter.opindex">[[reverse.iter.opindex]]</a>
-``` cpp
-constexpr unspecified operator[](difference_type n) const;
-```
-*Returns:* `current[-n-1]`.
-##### `operator==` <a id="reverse.iter.op==">[[reverse.iter.op==]]</a>
 ``` cpp
 template<class Iterator1, class Iterator2>
   constexpr bool operator==(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
-*Returns:* `x.current == y.current`.
-##### `operator<` <a id="reverse.iter.op<">[[reverse.iter.op<]]</a>
-``` cpp
-template <class Iterator1, class Iterator2>
-  constexpr bool operator<(
-    const reverse_iterator<Iterator1>& x,
-    const reverse_iterator<Iterator2>& y);
-```
-*Returns:* `x.current > y.current`.
-##### `operator!=` <a id="reverse.iter.op!=">[[reverse.iter.op!=]]</a>
 ``` cpp
 template<class Iterator1, class Iterator2>
   constexpr bool operator!=(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
-*Returns:* `x.current != y.current`.
-##### `operator>` <a id="reverse.iter.op>">[[reverse.iter.op>]]</a>
 ``` cpp
 template<class Iterator1, class Iterator2>
   constexpr bool operator>(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
-*Returns:* `x.current < y.current`.
-##### `operator>=` <a id="reverse.iter.op>=">[[reverse.iter.op>=]]</a>
-``` cpp
-template <class Iterator1, class Iterator2>
-  constexpr bool operator>=(
-    const reverse_iterator<Iterator1>& x,
-    const reverse_iterator<Iterator2>& y);
-```
-*Returns:* `x.current <= y.current`.
-##### `operator<=` <a id="reverse.iter.op<=">[[reverse.iter.op<=]]</a>
 ``` cpp
 template<class Iterator1, class Iterator2>
   constexpr bool operator<=(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
-*Returns:* `x.current >= y.current`.
-##### `operator-` <a id="reverse.iter.opdiff">[[reverse.iter.opdiff]]</a>
 ``` cpp
 template<class Iterator1, class Iterator2>
   constexpr auto operator-(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y) -> decltype(y.base() - x.base());
 ```
-*Returns:* `y.current - x.current`.
-##### `operator+` <a id="reverse.iter.opsum">[[reverse.iter.opsum]]</a>
 ``` 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.current - n)`.
-##### Non-member function `make_reverse_iterator()` <a id="reverse.iter.make">[[reverse.iter.make]]</a>
 ``` cpp
 template<class Iterator>
   constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i);
 ```
@@ -367,16 +402,16 @@ insert corresponding elements into the container. This device allows all
 of the copying algorithms in the library to work in the *insert mode*
 instead of the *regular overwrite* mode.
 An insert iterator is constructed from a container and possibly one of
 its iterators pointing to where insertion takes place if it is neither
-at the beginning nor at the end of the container. Insert iterators
-satisfy the requirements of output iterators. `operator*` returns the
-insert iterator itself. The assignment `operator=(const T& x)` is
-defined on insert iterators to allow writing into them, it inserts `x`
-right before where the insert iterator is pointing. In other words, an
-insert iterator is like a cursor pointing into the container where the
 insertion takes place. `back_insert_iterator` inserts elements at the
 end of a container, `front_insert_iterator` inserts elements at the
 beginning of a container, and `insert_iterator` inserts elements where
 the iterator points to in a container. `back_inserter`,
 `front_inserter`, and `inserter` are three functions making the insert
@@ -387,84 +422,74 @@ iterators out of a container.
 ``` 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   = void;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
- explicit back_insert_iterator(Container& x);
- back_insert_iterator& operator=(const typename Container::value_type& value);
-    back_insert_iterator& operator=(typename Container::value_type&& value);
-    back_insert_iterator& operator*();
-    back_insert_iterator& operator++();
-    back_insert_iterator  operator++(int);
   };
-  template <class Container>
-    back_insert_iterator<Container> back_inserter(Container& x);
 }
 ```
-#### `back_insert_iterator` operations <a id="back.insert.iter.ops">[[back.insert.iter.ops]]</a>
-##### `back_insert_iterator` constructor <a id="back.insert.iter.cons">[[back.insert.iter.cons]]</a>
 ``` cpp
-explicit back_insert_iterator(Container& x);
 ```
 *Effects:* Initializes `container` with `addressof(x)`.
-##### `back_insert_iterator::operator=` <a id="back.insert.iter.op=">[[back.insert.iter.op=]]</a>
 ``` cpp
-back_insert_iterator& operator=(const typename Container::value_type& value);
 ```
 *Effects:* As if by: `container->push_back(value);`
 *Returns:* `*this`.
 ``` cpp
-back_insert_iterator& operator=(typename Container::value_type&& value);
 ```
 *Effects:* As if by: `container->push_back(std::move(value));`
 *Returns:* `*this`.
-##### `back_insert_iterator::operator*` <a id="back.insert.iter.op*">[[back.insert.iter.op*]]</a>
 ``` cpp
-back_insert_iterator& operator*();
 ```
 *Returns:* `*this`.
-##### `back_insert_iterator::operator++` <a id="back.insert.iter.op++">[[back.insert.iter.op++]]</a>
 ``` cpp
-back_insert_iterator& operator++();
-back_insert_iterator  operator++(int);
 ```
 *Returns:* `*this`.
 #####  `back_inserter` <a id="back.inserter">[[back.inserter]]</a>
 ``` cpp
 template<class Container>
-  back_insert_iterator<Container> back_inserter(Container& x);
 ```
 *Returns:* `back_insert_iterator<Container>(x)`.
 #### Class template `front_insert_iterator` <a id="front.insert.iterator">[[front.insert.iterator]]</a>
@@ -472,84 +497,74 @@ template <class Container>
 ``` 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   = void;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
- explicit front_insert_iterator(Container& x);
- front_insert_iterator& operator=(const typename Container::value_type& value);
-    front_insert_iterator& operator=(typename Container::value_type&& value);
-    front_insert_iterator& operator*();
-    front_insert_iterator& operator++();
-    front_insert_iterator  operator++(int);
   };
-  template <class Container>
-    front_insert_iterator<Container> front_inserter(Container& x);
 }
 ```
-#### `front_insert_iterator` operations <a id="front.insert.iter.ops">[[front.insert.iter.ops]]</a>
-##### `front_insert_iterator` constructor <a id="front.insert.iter.cons">[[front.insert.iter.cons]]</a>
 ``` cpp
-explicit front_insert_iterator(Container& x);
 ```
 *Effects:* Initializes `container` with `addressof(x)`.
-##### `front_insert_iterator::operator=` <a id="front.insert.iter.op=">[[front.insert.iter.op=]]</a>
 ``` cpp
-front_insert_iterator& operator=(const typename Container::value_type& value);
 ```
 *Effects:* As if by: `container->push_front(value);`
 *Returns:* `*this`.
 ``` cpp
-front_insert_iterator& operator=(typename Container::value_type&& value);
 ```
 *Effects:* As if by: `container->push_front(std::move(value));`
 *Returns:* `*this`.
-##### `front_insert_iterator::operator*` <a id="front.insert.iter.op*">[[front.insert.iter.op*]]</a>
 ``` cpp
-front_insert_iterator& operator*();
 ```
 *Returns:* `*this`.
-##### `front_insert_iterator::operator++` <a id="front.insert.iter.op++">[[front.insert.iter.op++]]</a>
 ``` cpp
-front_insert_iterator& operator++();
-front_insert_iterator  operator++(int);
 ```
 *Returns:* `*this`.
 ##### `front_inserter` <a id="front.inserter">[[front.inserter]]</a>
 ``` cpp
 template<class Container>
-  front_insert_iterator<Container> front_inserter(Container& x);
 ```
 *Returns:* `front_insert_iterator<Container>(x)`.
 #### Class template `insert_iterator` <a id="insert.iterator">[[insert.iterator]]</a>
@@ -557,50 +572,44 @@ template <class Container>
 ``` cpp
 namespace std {
   template<class Container>
   class insert_iterator {
   protected:
-    Container* container;
- typename Container::iterator iter;
   public:
     using iterator_category = output_iterator_tag;
     using value_type        = void;
-    using difference_type   = void;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
-    insert_iterator(Container& x, typename Container::iterator i);
-    insert_iterator& operator=(const typename Container::value_type& value);
-    insert_iterator& operator=(typename Container::value_type&& value);
-    insert_iterator& operator*();
-    insert_iterator& operator++();
-    insert_iterator& operator++(int);
   };
-  template <class Container>
-    insert_iterator<Container> inserter(Container& x, typename Container::iterator i);
 }
 ```
-#### `insert_iterator` operations <a id="insert.iter.ops">[[insert.iter.ops]]</a>
-##### `insert_iterator` constructor <a id="insert.iter.cons">[[insert.iter.cons]]</a>
 ``` cpp
-insert_iterator(Container& x, typename Container::iterator i);
 ```
 *Effects:* Initializes `container` with `addressof(x)` and `iter` with
 `i`.
-##### `insert_iterator::operator=` <a id="insert.iter.op=">[[insert.iter.op=]]</a>
 ``` cpp
-insert_iterator& operator=(const typename Container::value_type& value);
 ```
 *Effects:* As if by:
 ``` cpp
@@ -609,11 +618,11 @@ iter = container->insert(iter, value);
 ```
 *Returns:* `*this`.
 ``` cpp
-insert_iterator& operator=(typename Container::value_type&& value);
 ```
 *Effects:* As if by:
 ``` cpp
@@ -621,37 +630,34 @@ iter = container->insert(iter, std::move(value));
 ++iter;
 ```
 *Returns:* `*this`.
-##### `insert_iterator::operator*` <a id="insert.iter.op*">[[insert.iter.op*]]</a>
 ``` cpp
-insert_iterator& operator*();
 ```
 *Returns:* `*this`.
-##### `insert_iterator::operator++` <a id="insert.iter.op++">[[insert.iter.op++]]</a>
 ``` cpp
-insert_iterator& operator++();
-insert_iterator& operator++(int);
 ```
 *Returns:* `*this`.
 ##### `inserter` <a id="inserter">[[inserter]]</a>
 ``` cpp
 template<class Container>
-  insert_iterator<Container> inserter(Container& x, typename Container::iterator i);
 ```
 *Returns:* `insert_iterator<Container>(x, i)`.
-### Move iterators <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
@@ -675,89 +681,82 @@ vector<string> v2(make_move_iterator(s.begin()),
 namespace std {
   template<class Iterator>
   class move_iterator {
   public:
     using iterator_type     = Iterator;
-    using iterator_category = typename iterator_traits<Iterator>::iterator_category;
-    using value_type        = typename iterator_traits<Iterator>::value_type;
-    using difference_type   = typename iterator_traits<Iterator>::difference_type;
     using pointer           = Iterator;
-    using reference         = see below;
     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 reference operator*() const;
-    constexpr pointer operator->() const;
     constexpr move_iterator& operator++();
-    constexpr move_iterator operator++(int);
     constexpr move_iterator& operator--();
     constexpr move_iterator operator--(int);
     constexpr move_iterator operator+(difference_type n) const;
     constexpr move_iterator& operator+=(difference_type n);
     constexpr move_iterator operator-(difference_type n) const;
     constexpr move_iterator& operator-=(difference_type n);
-    constexpr unspecified operator[](difference_type n) const;
   private:
     Iterator current;   // exposition only
   };
-  template <class Iterator1, class Iterator2>
-    constexpr bool operator==(
-      const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
-  template <class Iterator1, class Iterator2>
-    constexpr bool operator!=(
-      const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
-  template <class Iterator1, class Iterator2>
-    constexpr bool operator<(
-      const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
-  template <class Iterator1, class Iterator2>
-    constexpr bool operator<=(
-      const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
-  template <class Iterator1, class Iterator2>
-    constexpr bool operator>(
-      const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
-  template <class Iterator1, class Iterator2>
-    constexpr bool operator>=(
-      const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
-  template <class Iterator1, class Iterator2>
-    constexpr auto operator-(
-      const move_iterator<Iterator1>& x,
-      const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base());
-  template <class Iterator>
-    constexpr move_iterator<Iterator> operator+(
-      typename move_iterator<Iterator>::difference_type n, const move_iterator<Iterator>& x);
-  template <class Iterator>
-    constexpr move_iterator<Iterator> make_move_iterator(Iterator i);
 }
 ```
-Let `R` denote `iterator_traits<Iterator>::reference`. If
-`is_reference_v<R>` is `true`, the template specialization
-`move_iterator<Iterator>` shall define the nested type named `reference`
-as a synonym for `remove_reference_t<R>&&`, otherwise as a synonym for
-`R`.
-#### `move_iterator` requirements <a id="move.iter.requirements">[[move.iter.requirements]]</a>
-The template parameter `Iterator` shall meet the requirements of an
-input iterator ([[input.iterators]]). Additionally, if any of the
-bidirectional or random access traversal functions are instantiated, the
-template parameter shall meet the requirements for a Bidirectional
-Iterator ([[bidirectional.iterators]]) or a Random Access Iterator (
-[[random.access.iterators]]), respectively.
-#### `move_iterator` operations <a id="move.iter.ops">[[move.iter.ops]]</a>
-##### `move_iterator` constructors <a id="move.iter.op.const">[[move.iter.op.const]]</a>
 ``` cpp
 constexpr move_iterator();
 ```
@@ -769,78 +768,84 @@ value-initialized iterator of type `Iterator`.
 ``` cpp
 constexpr explicit move_iterator(Iterator i);
 ```
 *Effects:* Constructs a `move_iterator`, initializing `current` with
-`i`.
 ``` cpp
 template<class U> constexpr move_iterator(const move_iterator<U>& u);
 ```
 *Effects:* Constructs a `move_iterator`, initializing `current` with
 `u.base()`.
-*Requires:* `U` shall be convertible to `Iterator`.
-##### `move_iterator::operator=` <a id="move.iter.op=">[[move.iter.op=]]</a>
 ``` cpp
 template<class U> constexpr move_iterator& operator=(const move_iterator<U>& u);
 ```
 *Effects:* Assigns `u.base()` to `current`.
-*Requires:* `U` shall be convertible to `Iterator`.
-##### `move_iterator` conversion <a id="move.iter.op.conv">[[move.iter.op.conv]]</a>
 ``` cpp
-constexpr Iterator base() const;
 ```
 *Returns:* `current`.
-##### `move_iterator::operator*` <a id="move.iter.op.star">[[move.iter.op.star]]</a>
 ``` cpp
 constexpr reference operator*() const;
 ```
-*Returns:* `static_cast<reference>(*current)`.
-##### `move_iterator::operator->` <a id="move.iter.op.ref">[[move.iter.op.ref]]</a>
 ``` cpp
-constexpr pointer operator->() const;
 ```
-*Returns:* `current`.
-##### `move_iterator::operator++` <a id="move.iter.op.incr">[[move.iter.op.incr]]</a>
 ``` cpp
 constexpr move_iterator& operator++();
 ```
 *Effects:* As if by `++current`.
 *Returns:* `*this`.
 ``` cpp
-constexpr move_iterator operator++(int);
 ```
-*Effects:* As if by:
 ``` cpp
 move_iterator tmp = *this;
 ++current;
 return tmp;
 ```
-##### `move_iterator::operator-{-}` <a id="move.iter.op.decr">[[move.iter.op.decr]]</a>
 ``` cpp
 constexpr move_iterator& operator--();
 ```
@@ -858,119 +863,973 @@ constexpr move_iterator operator--(int);
 move_iterator tmp = *this;
 --current;
 return tmp;
 ```
-##### `move_iterator::operator+` <a id="move.iter.op.+">[[move.iter.op.+]]</a>
 ``` cpp
 constexpr move_iterator operator+(difference_type n) const;
 ```
 *Returns:* `move_iterator(current + n)`.
-##### `move_iterator::operator+=` <a id="move.iter.op.+=">[[move.iter.op.+=]]</a>
 ``` cpp
 constexpr move_iterator& operator+=(difference_type n);
 ```
 *Effects:* As if by: `current += n;`
 *Returns:* `*this`.
-##### `move_iterator::operator-` <a id="move.iter.op.-">[[move.iter.op.-]]</a>
 ``` cpp
 constexpr move_iterator operator-(difference_type n) const;
 ```
 *Returns:* `move_iterator(current - n)`.
-##### `move_iterator::operator-=` <a id="move.iter.op.-=">[[move.iter.op.-=]]</a>
 ``` cpp
 constexpr move_iterator& operator-=(difference_type n);
 ```
 *Effects:* As if by: `current -= n;`
 *Returns:* `*this`.
-##### `move_iterator::operator[]` <a id="move.iter.op.index">[[move.iter.op.index]]</a>
-``` cpp
-constexpr unspecified operator[](difference_type n) const;
-```
-*Returns:* `std::move(current[n])`.
-##### `move_iterator` comparisons <a id="move.iter.op.comp">[[move.iter.op.comp]]</a>
 ``` cpp
 template<class Iterator1, class Iterator2>
-constexpr bool operator==(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 ```
 *Returns:* `x.base() == y.base()`.
-``` cpp
-template <class Iterator1, class Iterator2>
-constexpr bool operator!=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
-```
-*Returns:* `!(x == y)`.
 ``` cpp
 template<class Iterator1, class Iterator2>
 constexpr bool operator<(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 ```
 *Returns:* `x.base() < y.base()`.
-``` cpp
-template <class Iterator1, class Iterator2>
-constexpr bool operator<=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
-```
-*Returns:* `!(y < x)`.
 ``` cpp
 template<class Iterator1, class Iterator2>
 constexpr bool operator>(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 ```
 *Returns:* `y < x`.
 ``` cpp
 template<class Iterator1, class Iterator2>
 constexpr bool operator>=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 ```
 *Returns:* `!(x < y)`.
-##### `move_iterator` 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());
 ```
 *Returns:* `x.base() - y.base()`.
 ``` cpp
 template<class Iterator>
-  constexpr move_iterator<Iterator> operator+(
- typename move_iterator<Iterator>::difference_type n, const move_iterator<Iterator>& x);
 ```
 *Returns:* `x + n`.
 ``` cpp
 template<class Iterator>
 constexpr move_iterator<Iterator> make_move_iterator(Iterator i);
 ```
-*Returns:* `move_iterator<Iterator>(i)`.

 ### 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>
 ``` cpp
 namespace std {
   template<class Iterator>
   class reverse_iterator {
   public:
     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);
     template<class U> constexpr reverse_iterator& operator=(const reverse_iterator<U>& u);
+    constexpr Iterator base() const;
     constexpr reference operator*() const;
+    constexpr pointer   operator->() const requires see below;
     constexpr reverse_iterator& operator++();
     constexpr reverse_iterator  operator++(int);
     constexpr reverse_iterator& operator--();
     constexpr reverse_iterator  operator--(int);
     constexpr reverse_iterator  operator+ (difference_type n) const;
     constexpr reverse_iterator& operator+=(difference_type n);
     constexpr reverse_iterator  operator- (difference_type n) const;
     constexpr reverse_iterator& operator-=(difference_type n);
     constexpr unspecified operator[](difference_type n) const;
+    friend constexpr iter_rvalue_reference_t<Iterator>
+      iter_move(const reverse_iterator& i) noexcept(see below);
+    template<indirectly_swappable<Iterator> Iterator2>
+      friend constexpr void
+        iter_swap(const reverse_iterator& x,
+                  const reverse_iterator<Iterator2>& y) noexcept(see below);
   protected:
     Iterator current;
   };
 }
 ```
+The member *typedef-name* `iterator_concept` denotes
+- `random_access_iterator_tag` if `Iterator` models
+  `random_access_iterator`, and
+- `bidirectional_iterator_tag` otherwise.
+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.
+#### Requirements <a id="reverse.iter.requirements">[[reverse.iter.requirements]]</a>
+The template parameter `Iterator` shall either meet the requirements of
+a *Cpp17BidirectionalIterator* [[bidirectional.iterators]] or model
+`bidirectional_iterator` [[iterator.concept.bidir]].
+Additionally, `Iterator` shall either meet the requirements of a
+*Cpp17RandomAccessIterator* [[random.access.iterators]] or model
+`random_access_iterator` [[iterator.concept.random.access]] if the
+definitions of any of the members
+- `operator+`, `operator-`, `operator+=`, `operator-=`
+  [[reverse.iter.nav]], or
+- `operator[]` [[reverse.iter.elem]],
+or the non-member operators [[reverse.iter.cmp]]
+- `operator<`, `operator>`, `operator<=`, `operator>=`, `operator-`, or
+  `operator+` [[reverse.iter.nonmember]]
+are instantiated [[temp.inst]].
+#### Construction and assignment <a id="reverse.iter.cons">[[reverse.iter.cons]]</a>
 ``` cpp
 constexpr reverse_iterator();
 ```
 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>
 ``` cpp
 constexpr reference operator*() const;
 ```
 ``` cpp
 Iterator tmp = current;
 return *--tmp;
 ```
 ``` cpp
+constexpr pointer operator->() const
+  requires (is_pointer_v<Iterator> ||
+            requires (const Iterator i) { i.operator->(); });
 ```
+*Effects:*
+- If `Iterator` is a pointer type, equivalent to:
+  `return prev(current);`
+- Otherwise, equivalent to: `return prev(current).operator->();`
 ``` cpp
+constexpr unspecified operator[](difference_type n) const;
 ```
+*Returns:* `current[-n-1]`.
+#### Navigation <a id="reverse.iter.nav">[[reverse.iter.nav]]</a>
 ``` cpp
 constexpr reverse_iterator operator+(difference_type n) const;
 ```
 *Returns:* `reverse_iterator(current-n)`.
 ``` cpp
 constexpr reverse_iterator operator-(difference_type n) const;
 ```
 *Returns:* `reverse_iterator(current+n)`.
+``` cpp
+constexpr reverse_iterator& operator++();
+```
+*Effects:* As if by: `current;`
+*Returns:* `*this`.
+``` cpp
+constexpr reverse_iterator operator++(int);
+```
+*Effects:* As if by:
+``` cpp
+reverse_iterator tmp = *this;
+--current;
+return tmp;
+```
+``` cpp
+constexpr reverse_iterator& operator--();
+```
+*Effects:* As if by `++current`.
+*Returns:* `*this`.
+``` cpp
+constexpr reverse_iterator operator--(int);
+```
+*Effects:* As if by:
+``` cpp
+reverse_iterator tmp = *this;
+++current;
+return tmp;
+```
+``` cpp
+constexpr reverse_iterator& operator+=(difference_type n);
+```
+*Effects:* As if by: `current -= n;`
+*Returns:* `*this`.
 ``` cpp
 constexpr reverse_iterator& operator-=(difference_type n);
 ```
 *Effects:* As if by: `current += n;`
 *Returns:* `*this`.
+#### Comparisons <a id="reverse.iter.cmp">[[reverse.iter.cmp]]</a>
 ``` cpp
 template<class Iterator1, class Iterator2>
   constexpr bool operator==(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
+*Constraints:* `x.base() == y.base()` is well-formed and convertible to
+`bool`.
+*Returns:* `x.base() == y.base()`.
 ``` cpp
 template<class Iterator1, class Iterator2>
   constexpr bool operator!=(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
+*Constraints:* `x.base() != y.base()` is well-formed and convertible to
+`bool`.
+*Returns:* `x.base() != y.base()`.
+``` cpp
+template<class Iterator1, class Iterator2>
+  constexpr bool operator<(
+    const reverse_iterator<Iterator1>& x,
+    const reverse_iterator<Iterator2>& y);
+```
+*Constraints:* `x.base() > y.base()` is well-formed and convertible to
+`bool`.
+*Returns:* `x.base() > y.base()`.
 ``` cpp
 template<class Iterator1, class Iterator2>
   constexpr bool operator>(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
+*Constraints:* `x.base() < y.base()` is well-formed and convertible to
+`bool`.
+*Returns:* `x.base() < y.base()`.
 ``` cpp
 template<class Iterator1, class Iterator2>
   constexpr bool operator<=(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y);
 ```
+*Constraints:* `x.base() >= y.base()` is well-formed and convertible to
+`bool`.
+*Returns:* `x.base() >= y.base()`.
+``` cpp
+template<class Iterator1, class Iterator2>
+  constexpr bool operator>=(
+    const reverse_iterator<Iterator1>& x,
+    const reverse_iterator<Iterator2>& y);
+```
+*Constraints:* `x.base() <= y.base()` is well-formed and convertible to
+`bool`.
+*Returns:* `x.base() <= y.base()`.
+``` cpp
+template<class Iterator1, three_way_comparable_with<Iterator1> Iterator2>
+  constexpr compare_three_way_result_t<Iterator1, Iterator2>
+    operator<=>(const reverse_iterator<Iterator1>& x,
+                const reverse_iterator<Iterator2>& y);
+```
+*Returns:* `y.base() <=> x.base()`.
+[*Note 1*: The argument order in the *Returns:* element is reversed
+because this is a reverse iterator. — *end note*]
+#### Non-member functions <a id="reverse.iter.nonmember">[[reverse.iter.nonmember]]</a>
 ``` cpp
 template<class Iterator1, class Iterator2>
   constexpr auto operator-(
     const reverse_iterator<Iterator1>& x,
     const reverse_iterator<Iterator2>& y) -> decltype(y.base() - x.base());
 ```
+*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)`.
+``` cpp
+friend constexpr iter_rvalue_reference_t<Iterator>
+  iter_move(const reverse_iterator& i) noexcept(see below);
+```
+*Effects:* Equivalent to:
+``` 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&>()))
+```
+``` cpp
+template<indirectly_swappable<Iterator> Iterator2>
+  friend constexpr void
+    iter_swap(const reverse_iterator& x,
+              const reverse_iterator<Iterator2>& y) noexcept(see below);
+```
+*Effects:* Equivalent to:
+``` cpp
+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&>()))
+```
 ``` cpp
 template<class Iterator>
   constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i);
 ```
 of the copying algorithms in the library to work in the *insert mode*
 instead of the *regular overwrite* mode.
 An insert iterator is constructed from a container and possibly one of
 its iterators pointing to where insertion takes place if it is neither
+at the beginning nor at the end of the container. Insert iterators meet
+the requirements of output iterators. `operator*` returns the insert
+iterator itself. The assignment `operator=(const T& x)` is defined on
+insert iterators to allow writing into them, it inserts `x` right before
+where the insert iterator is pointing. In other words, an insert
+iterator is like a cursor pointing into the container where the
 insertion takes place. `back_insert_iterator` inserts elements at the
 end of a container, `front_insert_iterator` inserts elements at the
 beginning of a container, and `insert_iterator` inserts elements where
 the iterator points to in a container. `back_inserter`,
 `front_inserter`, and `inserter` are three functions making the insert
 ``` 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*();
+ constexpr back_insert_iterator& operator++();
+ constexpr back_insert_iterator  operator++(int);
   };
 }
 ```
+##### Operations <a id="back.insert.iter.ops">[[back.insert.iter.ops]]</a>
 ``` cpp
+constexpr explicit back_insert_iterator(Container& x);
 ```
 *Effects:* Initializes `container` with `addressof(x)`.
 ``` cpp
+constexpr back_insert_iterator& operator=(const typename Container::value_type& value);
 ```
 *Effects:* As if by: `container->push_back(value);`
 *Returns:* `*this`.
 ``` cpp
+constexpr back_insert_iterator& operator=(typename Container::value_type&& value);
 ```
 *Effects:* As if by: `container->push_back(std::move(value));`
 *Returns:* `*this`.
 ``` cpp
+constexpr back_insert_iterator& operator*();
 ```
 *Returns:* `*this`.
 ``` cpp
+constexpr back_insert_iterator& operator++();
+constexpr back_insert_iterator  operator++(int);
 ```
 *Returns:* `*this`.
 #####  `back_inserter` <a id="back.inserter">[[back.inserter]]</a>
 ``` cpp
 template<class Container>
+ constexpr back_insert_iterator<Container> back_inserter(Container& x);
 ```
 *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:
+    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*();
+ constexpr front_insert_iterator& operator++();
+ constexpr front_insert_iterator  operator++(int);
   };
 }
 ```
+##### Operations <a id="front.insert.iter.ops">[[front.insert.iter.ops]]</a>
 ``` cpp
+constexpr explicit front_insert_iterator(Container& x);
 ```
 *Effects:* Initializes `container` with `addressof(x)`.
 ``` cpp
+constexpr front_insert_iterator& operator=(const typename Container::value_type& value);
 ```
 *Effects:* As if by: `container->push_front(value);`
 *Returns:* `*this`.
 ``` cpp
+constexpr front_insert_iterator& operator=(typename Container::value_type&& value);
 ```
 *Effects:* As if by: `container->push_front(std::move(value));`
 *Returns:* `*this`.
 ``` cpp
+constexpr front_insert_iterator& operator*();
 ```
 *Returns:* `*this`.
 ``` cpp
+constexpr front_insert_iterator& operator++();
+constexpr front_insert_iterator  operator++(int);
 ```
 *Returns:* `*this`.
 ##### `front_inserter` <a id="front.inserter">[[front.inserter]]</a>
 ``` cpp
 template<class Container>
+ constexpr front_insert_iterator<Container> front_inserter(Container& x);
 ```
 *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:
+    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*();
+ constexpr insert_iterator& operator++();
+ constexpr insert_iterator& operator++(int);
   };
 }
 ```
+##### Operations <a id="insert.iter.ops">[[insert.iter.ops]]</a>
 ``` cpp
+constexpr insert_iterator(Container& x, ranges::iterator_t<Container> i);
 ```
 *Effects:* Initializes `container` with `addressof(x)` and `iter` with
 `i`.
 ``` cpp
+constexpr insert_iterator& operator=(const typename Container::value_type& value);
 ```
 *Effects:* As if by:
 ``` cpp
 ```
 *Returns:* `*this`.
 ``` cpp
+constexpr insert_iterator& operator=(typename Container::value_type&& value);
 ```
 *Effects:* As if by:
 ``` cpp
 ++iter;
 ```
 *Returns:* `*this`.
 ``` cpp
+constexpr insert_iterator& operator*();
 ```
 *Returns:* `*this`.
 ``` cpp
+constexpr insert_iterator& operator++();
+constexpr insert_iterator& operator++(int);
 ```
 *Returns:* `*this`.
 ##### `inserter` <a id="inserter">[[inserter]]</a>
 ``` cpp
 template<class Container>
+ constexpr insert_iterator<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
 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--();
     constexpr move_iterator operator--(int);
     constexpr move_iterator operator+(difference_type n) const;
     constexpr move_iterator& operator+=(difference_type n);
     constexpr move_iterator operator-(difference_type n) const;
     constexpr move_iterator& operator-=(difference_type n);
+    constexpr reference operator[](difference_type n) const;
+    template<sentinel_for<Iterator> S>
+      friend constexpr bool
+        operator==(const move_iterator& x, const move_sentinel<S>& y);
+    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>
+      friend constexpr iter_difference_t<Iterator>
+        operator-(const move_iterator& x, const move_sentinel<S>& y);
+    friend constexpr iter_rvalue_reference_t<Iterator>
+      iter_move(const move_iterator& i)
+        noexcept(noexcept(ranges::iter_move(i.current)));
+    template<indirectly_swappable<Iterator> Iterator2>
+      friend constexpr void
+        iter_swap(const move_iterator& x, const move_iterator<Iterator2>& y)
+          noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
   private:
     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.
+#### Requirements <a id="move.iter.requirements">[[move.iter.requirements]]</a>
+The template parameter `Iterator` shall either meet the
+*Cpp17InputIterator* requirements [[input.iterators]] or model
+`input_iterator` [[iterator.concept.input]]. Additionally, if any of the
+bidirectional traversal functions are instantiated, the template
+parameter shall either meet the *Cpp17BidirectionalIterator*
+requirements [[bidirectional.iterators]] or model
+`bidirectional_iterator` [[iterator.concept.bidir]]. If any of the
+random access traversal functions are instantiated, the template
+parameter shall either meet the *Cpp17RandomAccessIterator* requirements
+[[random.access.iterators]] or model `random_access_iterator`
+[[iterator.concept.random.access]].
+#### Construction and assignment <a id="move.iter.cons">[[move.iter.cons]]</a>
 ``` cpp
 constexpr move_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() &&;
+```
+*Returns:* `std::move(current)`.
+#### Element access <a id="move.iter.elem">[[move.iter.elem]]</a>
 ``` cpp
 constexpr reference operator*() const;
 ```
+*Effects:* Equivalent to: `return ranges::iter_move(current);`
 ``` 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++();
 ```
 *Effects:* As if by `++current`.
 *Returns:* `*this`.
 ``` cpp
+constexpr auto operator++(int);
 ```
+*Effects:* If `Iterator` models `forward_iterator`, equivalent to:
 ``` cpp
 move_iterator tmp = *this;
 ++current;
 return tmp;
 ```
+Otherwise, equivalent to `++current`.
 ``` cpp
 constexpr move_iterator& operator--();
 ```
 move_iterator tmp = *this;
 --current;
 return tmp;
 ```
 ``` cpp
 constexpr move_iterator operator+(difference_type n) const;
 ```
 *Returns:* `move_iterator(current + n)`.
 ``` cpp
 constexpr move_iterator& operator+=(difference_type n);
 ```
 *Effects:* As if by: `current += n;`
 *Returns:* `*this`.
 ``` cpp
 constexpr move_iterator operator-(difference_type n) const;
 ```
 *Returns:* `move_iterator(current - n)`.
 ``` cpp
 constexpr move_iterator& operator-=(difference_type n);
 ```
 *Effects:* As if by: `current -= n;`
 *Returns:* `*this`.
+#### Comparisons <a id="move.iter.op.comp">[[move.iter.op.comp]]</a>
 ``` cpp
 template<class Iterator1, class Iterator2>
+ constexpr bool operator==(const move_iterator<Iterator1>& x,
+                            const move_iterator<Iterator2>& y);
+template<sentinel_for<Iterator> S>
+  friend constexpr bool operator==(const move_iterator& x,
+                                   const move_sentinel<S>& y);
 ```
+*Constraints:* `x.base() == y.base()` is well-formed and convertible to
+`bool`.
 *Returns:* `x.base() == y.base()`.
 ``` cpp
 template<class Iterator1, class Iterator2>
 constexpr bool operator<(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 ```
+*Constraints:* `x.base() < y.base()` is well-formed and convertible to
+`bool`.
 *Returns:* `x.base() < y.base()`.
 ``` cpp
 template<class Iterator1, class Iterator2>
 constexpr bool operator>(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 ```
+*Constraints:* `y.base() < x.base()` is well-formed and convertible to
+`bool`.
 *Returns:* `y < x`.
+``` cpp
+template<class Iterator1, class Iterator2>
+constexpr bool operator<=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
+```
+*Constraints:* `y.base() < x.base()` is well-formed and convertible to
+`bool`.
+*Returns:* `!(y < x)`.
 ``` cpp
 template<class Iterator1, class Iterator2>
 constexpr bool operator>=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 ```
+*Constraints:* `x.base() < y.base()` is well-formed and convertible to
+`bool`.
 *Returns:* `!(x < y)`.
+``` cpp
+template<class Iterator1, three_way_comparable_with<Iterator1> Iterator2>
+  constexpr compare_three_way_result_t<Iterator1, Iterator2>
+    operator<=>(const move_iterator<Iterator1>& x,
+                const move_iterator<Iterator2>& y);
+```
+*Returns:* `x.base() <=> y.base()`.
+#### 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>
+  friend constexpr iter_difference_t<Iterator>
+    operator-(const move_iterator& x, const move_sentinel<S>& y);
 ```
 *Returns:* `x.base() - y.base()`.
 ``` cpp
 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>
+  iter_move(const move_iterator& i)
+    noexcept(noexcept(ranges::iter_move(i.current)));
+```
+*Effects:* Equivalent to: `return ranges::iter_move(i.current);`
+``` cpp
+template<indirectly_swappable<Iterator> Iterator2>
+  friend constexpr void
+    iter_swap(const move_iterator& x, const move_iterator<Iterator2>& y)
+      noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
+```
+*Effects:* Equivalent to: `ranges::iter_swap(x.current, y.current)`.
 ``` cpp
 template<class Iterator>
 constexpr move_iterator<Iterator> make_move_iterator(Iterator i);
 ```
+*Returns:* `move_iterator<Iterator>(std::move(i))`.
+#### Class template `move_sentinel` <a id="move.sentinel">[[move.sentinel]]</a>
+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) {
+  std::ranges::copy_if(move_iterator<I>{first}, move_sentinel<S>{last}, out, pred);
+}
+```
+— *end example*]
+``` cpp
+namespace std {
+  template<semiregular S>
+  class move_sentinel {
+  public:
+    constexpr move_sentinel();
+    constexpr explicit move_sentinel(S s);
+    template<class S2>
+      requires convertible_to<const S2&, S>
+        constexpr move_sentinel(const move_sentinel<S2>& s);
+    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
+  };
+}
+```
+#### Operations <a id="move.sent.ops">[[move.sent.ops]]</a>
+``` cpp
+constexpr move_sentinel();
+```
+*Effects:* Value-initializes `last`. If
+`is_trivially_default_constructible_v<S>` is `true`, then this
+constructor is a `constexpr` constructor.
+``` cpp
+constexpr explicit move_sentinel(S s);
+```
+*Effects:* Initializes `last` with `std::move(s)`.
+``` cpp
+template<class S2>
+  requires convertible_to<const S2&, S>
+    constexpr move_sentinel(const move_sentinel<S2>& s);
+```
+*Effects:* Initializes `last` with `s.last`.
+``` cpp
+template<class S2>
+  requires assignable_from<S&, const S2&>
+    constexpr move_sentinel& operator=(const move_sentinel<S2>& s);
+```
+*Effects:* Equivalent to: `last = s.last; return *this;`
+``` cpp
+constexpr S base() const;
+```
+*Returns:* `last`.
+### Common iterators <a id="iterators.common">[[iterators.common]]</a>
+#### Class template `common_iterator` <a id="common.iterator">[[common.iterator]]</a>
+Class template `common_iterator` is an iterator/sentinel adaptor that is
+capable of representing a non-common range of elements (where the types
+of the iterator and sentinel differ) as a common range (where they are
+the same). It does this by holding either an iterator or a sentinel, and
+implementing the equality comparison operators appropriately.
+[*Note 1*: The `common_iterator` type is useful for interfacing with
+legacy code that expects the begin and end of a range to have the same
+type. — *end note*]
+[*Example 1*:
+``` cpp
+template<class ForwardIterator>
+void fun(ForwardIterator begin, ForwardIterator end);
+list<int> s;
+// populate the list s
+using CI = common_iterator<counted_iterator<list<int>::iterator>, default_sentinel_t>;
+// call fun on a range of 10 ints
+fun(CI(counted_iterator(s.begin(), 10)), CI(default_sentinel));
+```
+— *end example*]
+``` cpp
+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
+  };
+  template<class I, class S>
+  struct incrementable_traits<common_iterator<I, S>> {
+    using difference_type = iter_difference_t<I>;
+  };
+  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
+  `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);
+```
+*Effects:* Initializes `v_` as if by
+`v_{in_place_type<I>, std::move(i)}`.
+``` cpp
+constexpr common_iterator(S s);
+```
+*Effects:* Initializes `v_` as if by
+`v_{in_place_type<S>, std::move(s)}`.
+``` cpp
+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
+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:
+- 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
+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:
+  `return get<I>(v_);`
+- Otherwise, if `iter_reference_t<I>` is a reference type, equivalent
+  to:
+  ``` cpp
+  auto&& tmp = *get<I>(v_);
+  return addressof(tmp);
+  ```
+- 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`.
+*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()`.
+``` 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`.
+*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()`.
+``` 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 { };
+}
+```
+Class `default_sentinel_t` is an empty type used to denote the end of a
+range. It can be used together with iterator types that know the bound
+of their range (e.g., `counted_iterator` [[counted.iterator]]).
+### Counted iterators <a id="iterators.counted">[[iterators.counted]]</a>
+#### Class template `counted_iterator` <a id="counted.iterator">[[counted.iterator]]</a>
+Class template `counted_iterator` is an iterator adaptor with the same
+behavior as the underlying iterator except that it keeps track of the
+distance to the end of its range. It can be used together with
+`default_sentinel` in calls to generic algorithms to operate on a range
+of N elements starting at a given position without needing to know the
+end position a priori.
+[*Example 1*:
+``` cpp
+list<string> s;
+// populate the list s with at least 10 strings
+vector<string> v;
+// copies 10 strings into v:
+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)
+      requires bidirectional_iterator<I>;
+    constexpr counted_iterator operator+(iter_difference_t<I> n) const
+      requires random_access_iterator<I>;
+    friend constexpr counted_iterator operator+(
+      iter_difference_t<I> n, const counted_iterator& x)
+        requires random_access_iterator<I>;
+    constexpr counted_iterator& operator+=(iter_difference_t<I> n)
+      requires random_access_iterator<I>;
+    constexpr counted_iterator operator-(iter_difference_t<I> n) const
+      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)));
+  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>
+``` 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
+template<class I2>
+  requires convertible_to<const I2&, I>
+    constexpr counted_iterator(const counted_iterator<I2>& x);
+```
+*Effects:* Initializes `current` with `x.current` and `length` with
+`x.length`.
+``` cpp
+template<class I2>
+  requires assignable_from<I&, const I2&>
+    constexpr counted_iterator& operator=(const counted_iterator<I2>& x);
+```
+*Effects:* Assigns `x.current` to `current` and `x.length` to `length`.
+*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
+constexpr I base() &&;
+```
+*Returns:* `std::move(current)`.
+``` cpp
+constexpr iter_difference_t<I> count() const noexcept;
+```
+*Effects:* Equivalent to: `return length;`
+#### Element access <a id="counted.iter.elem">[[counted.iter.elem]]</a>
+``` cpp
+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>;
+```
+*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;
+--length;
+return *this;
+```
+``` cpp
+decltype(auto) operator++(int);
+```
+*Preconditions:* `length > 0`.
+*Effects:* Equivalent to:
+``` cpp
+--length;
+try { return current++; }
+catch(...) { ++length; throw; }
+```
+``` cpp
+constexpr counted_iterator operator++(int)
+  requires forward_iterator<I>;
+```
+*Effects:* Equivalent to:
+``` cpp
+counted_iterator tmp = *this;
+++*this;
+return tmp;
+```
+``` cpp
+constexpr counted_iterator& operator--()
+    requires bidirectional_iterator<I>;
+```
+*Effects:* Equivalent to:
+``` cpp
+--current;
+++length;
+return *this;
+```
+``` cpp
+constexpr counted_iterator operator--(int)
+    requires bidirectional_iterator<I>;
+```
+*Effects:* Equivalent to:
+``` cpp
+counted_iterator tmp = *this;
+--*this;
+return tmp;
+```
+``` cpp
+constexpr counted_iterator operator+(iter_difference_t<I> n) const
+    requires random_access_iterator<I>;
+```
+*Effects:* Equivalent to:
+`return counted_iterator(current + n, length - n);`
+``` cpp
+friend constexpr counted_iterator operator+(
+  iter_difference_t<I> n, const counted_iterator& x)
+    requires random_access_iterator<I>;
+```
+*Effects:* Equivalent to: `return x + n;`
+``` cpp
+constexpr counted_iterator& operator+=(iter_difference_t<I> n)
+    requires random_access_iterator<I>;
+```
+*Preconditions:* `n <= length`.
+*Effects:* Equivalent to:
+``` cpp
+current += n;
+length -= n;
+return *this;
+```
+``` cpp
+constexpr counted_iterator operator-(iter_difference_t<I> n) const
+    requires random_access_iterator<I>;
+```
+*Effects:* Equivalent to:
+`return counted_iterator(current - n, length + n);`
+``` cpp
+template<common_with<I> I2>
+  friend constexpr iter_difference_t<I2> operator-(
+    const counted_iterator& x, const counted_iterator<I2>& y);
+```
+*Preconditions:* `x` and `y` refer to elements of the same
+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;
+length += n;
+return *this;
+```
+#### Comparisons <a id="counted.iter.cmp">[[counted.iter.cmp]]</a>
+``` cpp
+template<common_with<I> I2>
+  friend constexpr bool operator==(
+    const counted_iterator& x, const counted_iterator<I2>& y);
+```
+*Preconditions:* `x` and `y` refer to elements of the same
+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
+template<common_with<I> I2>
+  friend constexpr strong_ordering operator<=>(
+    const counted_iterator& x, const counted_iterator<I2>& y);
+```
+*Preconditions:* `x` and `y` refer to elements of the same
+sequence [[counted.iterator]].
+*Effects:* Equivalent to: `return y.length <=> x.length;`
+[*Note 1*: The argument order in the *Effects:* element is reversed
+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>;
+```
+*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.
+[*Example 1*:
+``` cpp
+char* p;
+// set p to point to a character buffer containing newlines
+char* nl = find(p, unreachable_sentinel, '\n');
+```
+Provided a newline character really exists in the buffer, the use of
+`unreachable_sentinel` above potentially makes the call to `find` more
+efficient since the loop test against the sentinel does not require a
+conditional branch.
+— *end example*]
+``` cpp
+namespace std {
+  struct unreachable_sentinel_t {
+    template<weakly_incrementable I>
+      friend constexpr bool operator==(unreachable_sentinel_t, const I&) noexcept
+      { return false; }
+  };
+}
+```

Diff to HTML by rtfpessoa