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

Files changed (1) hide show

tmp/tmpuwugfig3/{from.md → to.md} +212 -207

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

@@ -11,94 +11,91 @@ 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
-        iterator<typename iterator_traits<Iterator>::iterator_category,
-        typename iterator_traits<Iterator>::value_type,
-        typename iterator_traits<Iterator>::difference_type,
-        typename iterator_traits<Iterator>::pointer,
-        typename iterator_traits<Iterator>::reference> {
   public:
- typedef Iterator                                            iterator_type;
- typedef typename iterator_traits<Iterator>::difference_type difference_type;
- typedef typename iterator_traits<Iterator>::reference       reference;
- typedef typename iterator_traits<Iterator>::pointer         pointer;
-    reverse_iterator();
-    explicit reverse_iterator(Iterator x);
-    template <class U> reverse_iterator(const reverse_iterator<U>& u);
-    template <class U> reverse_iterator& operator=(const reverse_iterator<U>& u);
-    Iterator base() const;      // explicit
-    reference operator*() const;
-    pointer   operator->() const;
-    reverse_iterator& operator++();
-    reverse_iterator  operator++(int);
-    reverse_iterator& operator--();
-    reverse_iterator  operator--(int);
-    reverse_iterator  operator+ (difference_type n) const;
-    reverse_iterator& operator+=(difference_type n);
-    reverse_iterator  operator- (difference_type n) const;
-    reverse_iterator& operator-=(difference_type n);
-    unspecified operator[](difference_type n) const;
   protected:
     Iterator current;
   };
   template <class Iterator1, class Iterator2>
-    bool operator==(
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
-    bool operator<(
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
-    bool operator!=(
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
-    bool operator>(
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
-    bool operator>=(
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
-    bool operator<=(
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
-    auto operator-(
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y) -> decltype(y.base() - x.base());
   template <class Iterator>
-    reverse_iterator<Iterator> operator+(
       typename reverse_iterator<Iterator>::difference_type n,
       const reverse_iterator<Iterator>& x);
   template <class Iterator>
-    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 global 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]]).
@@ -106,257 +103,252 @@ 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
-reverse_iterator();
 ```
-*Effects:* Value initializes `current`. Iterator operations applied to
 the resulting iterator have defined behavior if and only if the
 corresponding operations are defined on a value-initialized iterator of
 type `Iterator`.
 ``` cpp
-explicit reverse_iterator(Iterator x);
 ```
 *Effects:* Initializes `current` with `x`.
 ``` cpp
-template <class U> 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>
-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
-Iterator base() const;          // explicit
 ```
 *Returns:* `current`.
 ##### `operator*` <a id="reverse.iter.op.star">[[reverse.iter.op.star]]</a>
 ``` cpp
-reference operator*() const;
 ```
-*Effects:*
 ``` cpp
 Iterator tmp = current;
 return *--tmp;
 ```
 ##### `operator->` <a id="reverse.iter.opref">[[reverse.iter.opref]]</a>
 ``` cpp
-pointer operator->() const;
 ```
-*Returns:* `std::addressof(operator*())`.
 ##### `operator++` <a id="reverse.iter.op++">[[reverse.iter.op++]]</a>
 ``` cpp
-reverse_iterator& operator++();
 ```
-*Effects:* `current;`
 *Returns:* `*this`.
 ``` cpp
-reverse_iterator operator++(int);
 ```
-*Effects:*
 ``` cpp
 reverse_iterator tmp = *this;
 --current;
 return tmp;
 ```
 \[reverse.iter.op\]`operator\dcr`
 ``` cpp
-reverse_iterator& operator--();
 ```
-*Effects:* `++current`
 *Returns:* `*this`.
 ``` cpp
-reverse_iterator operator--(int);
 ```
-*Effects:*
 ``` cpp
 reverse_iterator tmp = *this;
 ++current;
 return tmp;
 ```
 ##### `operator+` <a id="reverse.iter.op+">[[reverse.iter.op+]]</a>
 ``` cpp
-reverse_iterator
-operator+(typename reverse_iterator<Iterator>::difference_type n) const;
 ```
 *Returns:* `reverse_iterator(current-n)`.
 ##### `operator+=` <a id="reverse.iter.op+=">[[reverse.iter.op+=]]</a>
 ``` cpp
-reverse_iterator&
-operator+=(typename reverse_iterator<Iterator>::difference_type n);
 ```
-*Effects:* `current -= n;`
 *Returns:* `*this`.
 ##### `operator-` <a id="reverse.iter.op-">[[reverse.iter.op-]]</a>
 ``` cpp
-reverse_iterator
-operator-(typename reverse_iterator<Iterator>::difference_type n) const;
 ```
 *Returns:* `reverse_iterator(current+n)`.
 ##### `operator-=` <a id="reverse.iter.op-=">[[reverse.iter.op-=]]</a>
 ``` cpp
-reverse_iterator&
-operator-=(typename reverse_iterator<Iterator>::difference_type n);
 ```
-*Effects:* `current += n;`
 *Returns:* `*this`.
 ##### `operator[]` <a id="reverse.iter.opindex">[[reverse.iter.opindex]]</a>
 ``` cpp
-unspecified operator[](
-    typename reverse_iterator<Iterator>::difference_type n) const;
 ```
 *Returns:* `current[-n-1]`.
 ##### `operator==` <a id="reverse.iter.op==">[[reverse.iter.op==]]</a>
 ``` cpp
 template <class Iterator1, class Iterator2>
-  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>
-  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>
-  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>
-  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>
-  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>
-  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>
-    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>
-  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>
-  reverse_iterator<Iterator> make_reverse_iterator(Iterator i);
 ```
 *Returns:* `reverse_iterator<Iterator>(i)`.
 ### Insert iterators <a id="insert.iterators">[[insert.iterators]]</a>
@@ -393,26 +385,29 @@ iterators out of a container.
 #### Class template `back_insert_iterator` <a id="back.insert.iterator">[[back.insert.iterator]]</a>
 ``` cpp
 namespace std {
   template <class Container>
-  class back_insert_iterator :
-    public iterator<output_iterator_tag,void,void,void,void> {
   protected:
     Container* container;
   public:
- typedef Container container_type;
     explicit back_insert_iterator(Container& x);
-    back_insert_iterator<Container>&
- operator=(const typename Container::value_type& value);
-    back_insert_iterator<Container>&
-      operator=(typename Container::value_type&& value);
-    back_insert_iterator<Container>& operator*();
-    back_insert_iterator<Container>& operator++();
-    back_insert_iterator<Container>  operator++(int);
   };
   template <class Container>
     back_insert_iterator<Container> back_inserter(Container& x);
 }
@@ -424,45 +419,43 @@ namespace std {
 ``` cpp
 explicit back_insert_iterator(Container& x);
 ```
-*Effects:* Initializes `container` with `std::addressof(x)`.
 ##### `back_insert_iterator::operator=` <a id="back.insert.iter.op=">[[back.insert.iter.op=]]</a>
 ``` cpp
-back_insert_iterator<Container>&
-  operator=(const typename Container::value_type& value);
 ```
-*Effects:* `container->push_back(value);`
 *Returns:* `*this`.
 ``` cpp
-back_insert_iterator<Container>&
-  operator=(typename Container::value_type&& value);
 ```
-*Effects:* `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<Container>& operator*();
 ```
 *Returns:* `*this`.
 ##### `back_insert_iterator::operator++` <a id="back.insert.iter.op++">[[back.insert.iter.op++]]</a>
 ``` cpp
-back_insert_iterator<Container>& operator++();
-back_insert_iterator<Container>  operator++(int);
 ```
 *Returns:* `*this`.
 #####  `back_inserter` <a id="back.inserter">[[back.inserter]]</a>
@@ -477,26 +470,29 @@ template <class Container>
 #### Class template `front_insert_iterator` <a id="front.insert.iterator">[[front.insert.iterator]]</a>
 ``` cpp
 namespace std {
   template <class Container>
-  class front_insert_iterator :
-    public iterator<output_iterator_tag,void,void,void,void> {
   protected:
     Container* container;
   public:
- typedef Container container_type;
     explicit front_insert_iterator(Container& x);
-    front_insert_iterator<Container>&
- operator=(const typename Container::value_type& value);
-    front_insert_iterator<Container>&
-      operator=(typename Container::value_type&& value);
-    front_insert_iterator<Container>& operator*();
-    front_insert_iterator<Container>& operator++();
-    front_insert_iterator<Container>  operator++(int);
   };
   template <class Container>
     front_insert_iterator<Container> front_inserter(Container& x);
 }
@@ -508,45 +504,43 @@ namespace std {
 ``` cpp
 explicit front_insert_iterator(Container& x);
 ```
-*Effects:* Initializes `container` with `std::addressof(x)`.
 ##### `front_insert_iterator::operator=` <a id="front.insert.iter.op=">[[front.insert.iter.op=]]</a>
 ``` cpp
-front_insert_iterator<Container>&
-  operator=(const typename Container::value_type& value);
 ```
-*Effects:* `container->push_front(value);`
 *Returns:* `*this`.
 ``` cpp
-front_insert_iterator<Container>&
-  operator=(typename Container::value_type&& value);
 ```
-*Effects:* `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<Container>& operator*();
 ```
 *Returns:* `*this`.
 ##### `front_insert_iterator::operator++` <a id="front.insert.iter.op++">[[front.insert.iter.op++]]</a>
 ``` cpp
-front_insert_iterator<Container>& operator++();
-front_insert_iterator<Container>  operator++(int);
 ```
 *Returns:* `*this`.
 ##### `front_inserter` <a id="front.inserter">[[front.inserter]]</a>
@@ -561,27 +555,30 @@ template <class Container>
 #### Class template `insert_iterator` <a id="insert.iterator">[[insert.iterator]]</a>
 ``` cpp
 namespace std {
   template <class Container>
-  class insert_iterator :
-    public iterator<output_iterator_tag,void,void,void,void> {
   protected:
     Container* container;
     typename Container::iterator iter;
   public:
- typedef Container container_type;
     insert_iterator(Container& x, typename Container::iterator i);
-    insert_iterator<Container>&
- operator=(const typename Container::value_type& value);
-    insert_iterator<Container>&
-      operator=(typename Container::value_type&& value);
-    insert_iterator<Container>& operator*();
-    insert_iterator<Container>& operator++();
-    insert_iterator<Container>& operator++(int);
   };
   template <class Container>
     insert_iterator<Container> inserter(Container& x, typename Container::iterator i);
 }
@@ -593,35 +590,33 @@ namespace std {
 ``` cpp
 insert_iterator(Container& x, typename Container::iterator i);
 ```
-*Effects:* Initializes `container` with `std::addressof(x)` and `iter`
-with `i`.
 ##### `insert_iterator::operator=` <a id="insert.iter.op=">[[insert.iter.op=]]</a>
 ``` cpp
-insert_iterator<Container>&
-  operator=(const typename Container::value_type& value);
 ```
-*Effects:*
 ``` cpp
 iter = container->insert(iter, value);
 ++iter;
 ```
 *Returns:* `*this`.
 ``` cpp
-insert_iterator<Container>&
-  operator=(typename Container::value_type&& value);
 ```
-*Effects:*
 ``` cpp
 iter = container->insert(iter, std::move(value));
 ++iter;
 ```
@@ -629,20 +624,20 @@ iter = container->insert(iter, std::move(value));
 *Returns:* `*this`.
 ##### `insert_iterator::operator*` <a id="insert.iter.op*">[[insert.iter.op*]]</a>
 ``` cpp
-insert_iterator<Container>& operator*();
 ```
 *Returns:* `*this`.
 ##### `insert_iterator::operator++` <a id="insert.iter.op++">[[insert.iter.op++]]</a>
 ``` cpp
-insert_iterator<Container>& operator++();
-insert_iterator<Container>& operator++(int);
 ```
 *Returns:* `*this`.
 ##### `inserter` <a id="inserter">[[inserter]]</a>
@@ -657,315 +652,325 @@ template <class Container>
 ### 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 reference. Some generic algorithms can
-be called with move iterators to replace copying with moving.
 ``` cpp
 list<string> s;
 // populate the list s
 vector<string> v1(s.begin(), s.end());          // copies strings into v1
 vector<string> v2(make_move_iterator(s.begin()),
                   make_move_iterator(s.end())); // moves strings into v2
 ```
 #### Class template `move_iterator` <a id="move.iterator">[[move.iterator]]</a>
 ``` cpp
 namespace std {
   template <class Iterator>
   class move_iterator {
   public:
- typedef Iterator                                              iterator_type;
- typedef typename iterator_traits<Iterator>::difference_type   difference_type;
- typedef Iterator                                              pointer;
- typedef typename iterator_traits<Iterator>::value_type        value_type;
- typedef typename iterator_traits<Iterator>::iterator_category iterator_category;
- typedef value_type&&                                          reference;
-    move_iterator();
-    explicit move_iterator(Iterator i);
-    template <class U> move_iterator(const move_iterator<U>& u);
-    template <class U> move_iterator& operator=(const move_iterator<U>& u);
-    iterator_type base() const;
-    reference operator*() const;
-    pointer operator->() const;
-    move_iterator& operator++();
-    move_iterator operator++(int);
-    move_iterator& operator--();
-    move_iterator operator--(int);
-    move_iterator operator+(difference_type n) const;
-    move_iterator& operator+=(difference_type n);
-    move_iterator operator-(difference_type n) const;
-    move_iterator& operator-=(difference_type n);
-    unspecified operator[](difference_type n) const;
   private:
     Iterator current;   // exposition only
   };
   template <class Iterator1, class Iterator2>
-    bool operator==(
       const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
-    bool operator!=(
       const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
-    bool operator<(
       const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
-    bool operator<=(
       const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
-    bool operator>(
       const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
-    bool operator>=(
       const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
   template <class Iterator1, class Iterator2>
-    auto operator-(
       const move_iterator<Iterator1>& x,
       const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base());
   template <class Iterator>
-    move_iterator<Iterator> operator+(
       typename move_iterator<Iterator>::difference_type n, const move_iterator<Iterator>& x);
   template <class Iterator>
-    move_iterator<Iterator> make_move_iterator(Iterator i);
 }
 ```
 #### `move_iterator` requirements <a id="move.iter.requirements">[[move.iter.requirements]]</a>
-The template parameter `Iterator` shall meet the requirements for 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
-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
-explicit move_iterator(Iterator i);
 ```
 *Effects:* Constructs a `move_iterator`, initializing `current` with
 `i`.
 ``` cpp
-template <class U> 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> 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
-Iterator base() const;
 ```
 *Returns:* `current`.
 ##### `move_iterator::operator*` <a id="move.iter.op.star">[[move.iter.op.star]]</a>
 ``` cpp
-reference operator*() const;
 ```
-*Returns:* `std::move(`\*current).
 ##### `move_iterator::operator->` <a id="move.iter.op.ref">[[move.iter.op.ref]]</a>
 ``` cpp
-pointer operator->() const;
 ```
 *Returns:* `current`.
 ##### `move_iterator::operator++` <a id="move.iter.op.incr">[[move.iter.op.incr]]</a>
 ``` cpp
-move_iterator& operator++();
 ```
-*Effects:* `++current`.
 *Returns:* `*this`.
 ``` cpp
-move_iterator operator++(int);
 ```
-*Effects:*
 ``` cpp
 move_iterator tmp = *this;
 ++current;
 return tmp;
 ```
 ##### `move_iterator::operator-{-}` <a id="move.iter.op.decr">[[move.iter.op.decr]]</a>
 ``` cpp
-move_iterator& operator--();
 ```
-*Effects:* \dcr`current`.
 *Returns:* `*this`.
 ``` cpp
-move_iterator operator--(int);
 ```
-*Effects:*
 ``` cpp
 move_iterator tmp = *this;
 --current;
 return tmp;
 ```
 ##### `move_iterator::operator+` <a id="move.iter.op.+">[[move.iter.op.+]]</a>
 ``` cpp
-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
-move_iterator& operator+=(difference_type n);
 ```
-*Effects:* `current += n`.
 *Returns:* `*this`.
 ##### `move_iterator::operator-` <a id="move.iter.op.-">[[move.iter.op.-]]</a>
 ``` cpp
-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
-move_iterator& operator-=(difference_type n);
 ```
-*Effects:* `current -= n`.
 *Returns:* `*this`.
 ##### `move_iterator::operator[]` <a id="move.iter.op.index">[[move.iter.op.index]]</a>
 ``` cpp
-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>
-bool operator==(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 ```
 *Returns:* `x.base() == y.base()`.
 ``` cpp
 template <class Iterator1, class Iterator2>
-bool operator!=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 ```
 *Returns:* `!(x == y)`.
 ``` cpp
 template <class Iterator1, class Iterator2>
-bool operator<(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 ```
 *Returns:* `x.base() < y.base()`.
 ``` cpp
 template <class Iterator1, class Iterator2>
-bool operator<=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 ```
 *Returns:* `!(y < x)`.
 ``` cpp
 template <class Iterator1, class Iterator2>
-bool operator>(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 ```
 *Returns:* `y < x`.
 ``` cpp
 template <class Iterator1, class Iterator2>
-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>
-    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>
-  move_iterator<Iterator> operator+(
     typename move_iterator<Iterator>::difference_type n, const move_iterator<Iterator>& x);
 ```
 *Returns:* `x + n`.
 ``` cpp
 template <class Iterator>
-move_iterator<Iterator> make_move_iterator(Iterator i);
 ```
 *Returns:* `move_iterator<Iterator>(i)`.

 #### 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);
+ 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();
 ```
+*Effects:* Value-initializes `current`. Iterator operations applied to
 the resulting iterator have defined behavior if and only if the
 corresponding operations are defined on a value-initialized iterator of
 type `Iterator`.
 ``` cpp
+constexpr explicit reverse_iterator(Iterator x);
 ```
 *Effects:* Initializes `current` with `x`.
 ``` cpp
+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;
 ```
+*Effects:* As if by:
 ``` 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);
 ```
 *Returns:* `reverse_iterator<Iterator>(i)`.
 ### Insert iterators <a id="insert.iterators">[[insert.iterators]]</a>
 #### Class template `back_insert_iterator` <a id="back.insert.iterator">[[back.insert.iterator]]</a>
 ``` cpp
 namespace std {
   template <class Container>
+  class back_insert_iterator {
   protected:
     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);
 }
 ``` 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>
 #### 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;
   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);
 }
 ``` 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>
 #### Class template `insert_iterator` <a id="insert.iterator">[[insert.iterator]]</a>
 ``` 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);
 }
 ``` 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
 iter = container->insert(iter, value);
 ++iter;
 ```
 *Returns:* `*this`.
 ``` cpp
+insert_iterator& operator=(typename Container::value_type&& value);
 ```
+*Effects:* As if by:
 ``` cpp
 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>
 ### 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
+with move iterators to replace copying with moving.
+[*Example 1*:
 ``` cpp
 list<string> s;
 // populate the list s
 vector<string> v1(s.begin(), s.end());          // copies strings into v1
 vector<string> v2(make_move_iterator(s.begin()),
                   make_move_iterator(s.end())); // moves strings into v2
 ```
+— *end example*]
 #### Class template `move_iterator` <a id="move.iterator">[[move.iterator]]</a>
 ``` cpp
 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();
 ```
+*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
 `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--();
 ```
+*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.+">[[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)`.

Diff to HTML by rtfpessoa