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

Files changed (1) hide show

tmp/tmpazswxqeu/{from.md → to.md} +1070 -426

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

@@ -36,359 +36,405 @@ namespace std {
       { *t } -> can-reference;  // not required to be equality-preserving
     };
   // [iterator.assoc.types], associated types
   // [incrementable.traits], incrementable traits
-  template<class> struct incrementable_traits;
   template<class T>
-    using iter_difference_t = see below;
   // [readable.traits], indirectly readable traits
-  template<class> struct indirectly_readable_traits;
   template<class T>
-    using iter_value_t = see below;
   // [iterator.traits], iterator traits
-  template<class I> struct iterator_traits;
-  template<class T> requires is_object_v<T> struct iterator_traits<T*>;
   template<dereferenceable T>
-    using iter_reference_t = decltype(*declval<T&>());
   namespace ranges {
-    // [iterator.cust], customization points
     inline namespace unspecified {
       // [iterator.cust.move], ranges::iter_move
-      inline constexpr unspecified iter_move = unspecified;
       // [iterator.cust.swap], ranges::iter_swap
-      inline constexpr unspecified iter_swap = unspecified;
     }
   }
   template<dereferenceable T>
     requires requires(T& t) {
       { ranges::iter_move(t) } -> can-reference;
     }
-  using iter_rvalue_reference_t
     = decltype(ranges::iter_move(declval<T&>()));
   // [iterator.concepts], iterator concepts
   // [iterator.concept.readable], concept indirectly_readable
   template<class In>
-    concept indirectly_readable = see below;
   template<indirectly_readable T>
-    using iter_common_reference_t =
-      common_reference_t<iter_reference_t<T>, iter_value_t<T>&>;
   // [iterator.concept.writable], concept indirectly_writable
   template<class Out, class T>
-    concept indirectly_writable = see below;
   // [iterator.concept.winc], concept weakly_incrementable
   template<class I>
-    concept weakly_incrementable = see below;
   // [iterator.concept.inc], concept incrementable
   template<class I>
-    concept incrementable = see below;
   // [iterator.concept.iterator], concept input_or_output_iterator
   template<class I>
-    concept input_or_output_iterator = see below;
   // [iterator.concept.sentinel], concept sentinel_for
   template<class S, class I>
-    concept sentinel_for = see below;
   // [iterator.concept.sizedsentinel], concept sized_sentinel_for
   template<class S, class I>
- inline constexpr bool disable_sized_sentinel_for = false;
   template<class S, class I>
-    concept sized_sentinel_for = see below;
   // [iterator.concept.input], concept input_iterator
   template<class I>
-    concept input_iterator = see below;
   // [iterator.concept.output], concept output_iterator
   template<class I, class T>
-    concept output_iterator = see below;
   // [iterator.concept.forward], concept forward_iterator
   template<class I>
-    concept forward_iterator = see below;
   // [iterator.concept.bidir], concept bidirectional_iterator
   template<class I>
-    concept bidirectional_iterator = see below;
   // [iterator.concept.random.access], concept random_access_iterator
   template<class I>
-    concept random_access_iterator = see below;
   // [iterator.concept.contiguous], concept contiguous_iterator
   template<class I>
-    concept contiguous_iterator = see below;
   // [indirectcallable], indirect callable requirements
   // [indirectcallable.indirectinvocable], indirect callables
   template<class F, class I>
-    concept indirectly_unary_invocable = see below;
   template<class F, class I>
-    concept indirectly_regular_unary_invocable = see below;
   template<class F, class I>
-    concept indirect_unary_predicate = see below;
   template<class F, class I1, class I2>
-    concept indirect_binary_predicate = see below;
   template<class F, class I1, class I2 = I1>
-    concept indirect_equivalence_relation = see below;
   template<class F, class I1, class I2 = I1>
-    concept indirect_strict_weak_order = see below;
   template<class F, class... Is>
     requires (indirectly_readable<Is> && ...) && invocable<F, iter_reference_t<Is>...>
-      using indirect_result_t = invoke_result_t<F, iter_reference_t<Is>...>;
   // [projected], projected
   template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>
-    struct projected;
   template<weakly_incrementable I, class Proj>
-    struct incrementable_traits<projected<I, Proj>>;
   // [alg.req], common algorithm requirements
   // [alg.req.ind.move], concept indirectly_movable
   template<class In, class Out>
-    concept indirectly_movable = see below;
   template<class In, class Out>
-    concept indirectly_movable_storable = see below;
   // [alg.req.ind.copy], concept indirectly_copyable
   template<class In, class Out>
-    concept indirectly_copyable = see below;
   template<class In, class Out>
-    concept indirectly_copyable_storable = see below;
   // [alg.req.ind.swap], concept indirectly_swappable
   template<class I1, class I2 = I1>
-    concept indirectly_swappable = see below;
   // [alg.req.ind.cmp], concept indirectly_comparable
   template<class I1, class I2, class R, class P1 = identity, class P2 = identity>
-    concept indirectly_comparable = see below;
   // [alg.req.permutable], concept permutable
   template<class I>
-    concept permutable = see below;
   // [alg.req.mergeable], concept mergeable
   template<class I1, class I2, class Out,
       class R = ranges::less, class P1 = identity, class P2 = identity>
-    concept mergeable = see below;
   // [alg.req.sortable], concept sortable
   template<class I, class R = ranges::less, class P = identity>
-    concept sortable = see below;
   // [iterator.primitives], primitives
   // [std.iterator.tags], iterator tags
-  struct input_iterator_tag { };
-  struct output_iterator_tag { };
-  struct forward_iterator_tag: public input_iterator_tag { };
-  struct bidirectional_iterator_tag: public forward_iterator_tag { };
-  struct random_access_iterator_tag: public bidirectional_iterator_tag { };
-  struct contiguous_iterator_tag: public random_access_iterator_tag { };
   // [iterator.operations], iterator operations
   template<class InputIterator, class Distance>
     constexpr void
-      advance(InputIterator& i, Distance n);
   template<class InputIterator>
     constexpr typename iterator_traits<InputIterator>::difference_type
-      distance(InputIterator first, InputIterator last);
   template<class InputIterator>
     constexpr InputIterator
-      next(InputIterator x,
            typename iterator_traits<InputIterator>::difference_type n = 1);
   template<class BidirectionalIterator>
     constexpr BidirectionalIterator
-      prev(BidirectionalIterator x,
            typename iterator_traits<BidirectionalIterator>::difference_type n = 1);
   // [range.iter.ops], range iterator operations
   namespace ranges {
     // [range.iter.op.advance], ranges::advance
     template<input_or_output_iterator I>
-      constexpr void advance(I& i, iter_difference_t<I> n);
     template<input_or_output_iterator I, sentinel_for<I> S>
-      constexpr void advance(I& i, S bound);
     template<input_or_output_iterator I, sentinel_for<I> S>
-      constexpr iter_difference_t<I> advance(I& i, iter_difference_t<I> n, S bound);
     // [range.iter.op.distance], ranges::distance
-    template<input_or_output_iterator I, sentinel_for<I> S>
- constexpr iter_difference_t<I> distance(I first, S last);
     template<range R>
-      constexpr range_difference_t<R> distance(R&& r);
     // [range.iter.op.next], ranges::next
     template<input_or_output_iterator I>
-      constexpr I next(I x);
     template<input_or_output_iterator I>
-      constexpr I next(I x, iter_difference_t<I> n);
     template<input_or_output_iterator I, sentinel_for<I> S>
-      constexpr I next(I x, S bound);
     template<input_or_output_iterator I, sentinel_for<I> S>
-      constexpr I next(I x, iter_difference_t<I> n, S bound);
     // [range.iter.op.prev], ranges::prev
     template<bidirectional_iterator I>
-      constexpr I prev(I x);
     template<bidirectional_iterator I>
-      constexpr I prev(I x, iter_difference_t<I> n);
     template<bidirectional_iterator I>
-      constexpr I prev(I x, iter_difference_t<I> n, I bound);
   }
   // [predef.iterators], predefined iterators and sentinels
   // [reverse.iterators], reverse iterators
-  template<class Iterator> class reverse_iterator;
   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, 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);
   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);
   template<class Iterator1, class Iterator2>
       requires (!sized_sentinel_for<Iterator1, Iterator2>)
- inline constexpr bool disable_sized_sentinel_for<reverse_iterator<Iterator1>,
                                                      reverse_iterator<Iterator2>> = true;
   // [insert.iterators], insert iterators
-  template<class Container> class back_insert_iterator;
   template<class Container>
-    constexpr back_insert_iterator<Container> back_inserter(Container& x);
-  template<class Container> class front_insert_iterator;
   template<class Container>
-    constexpr front_insert_iterator<Container> front_inserter(Container& x);
-  template<class Container> class insert_iterator;
   template<class Container>
     constexpr insert_iterator<Container>
-      inserter(Container& x, ranges::iterator_t<Container> i);
   // [move.iterators], move iterators and sentinels
-  template<class Iterator> class move_iterator;
   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, 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);
   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);
-  template<semiregular S> class move_sentinel;
   // [iterators.common], common iterators
   template<input_or_output_iterator I, sentinel_for<I> S>
     requires (!same_as<I, S> && copyable<I>)
-      class common_iterator;
   template<class I, class S>
-    struct incrementable_traits<common_iterator<I, S>>;
   template<input_iterator I, class S>
-    struct iterator_traits<common_iterator<I, S>>;
-  // [default.sentinels], default sentinels
-  struct default_sentinel_t;
-  inline constexpr default_sentinel_t default_sentinel{};
   // [iterators.counted], counted iterators
-  template<input_or_output_iterator I> class counted_iterator;
-  template<class I>
-    struct incrementable_traits<counted_iterator<I>>;
   template<input_iterator I>
- struct iterator_traits<counted_iterator<I>>;
-  // [unreachable.sentinels], unreachable sentinels
-  struct unreachable_sentinel_t;
-  inline constexpr unreachable_sentinel_t unreachable_sentinel{};
   // [stream.iterators], stream iterators
   template<class T, class charT = char, class traits = char_traits<charT>,
            class Distance = ptrdiff_t>
   class istream_iterator;
@@ -407,43 +453,57 @@ namespace std {
   template<class charT, class traits = char_traits<charT>>
     class ostreambuf_iterator;
   // [iterator.range], range access
-  template<class C> constexpr auto begin(C& c) -> decltype(c.begin());
-  template<class C> constexpr auto begin(const C& c) -> decltype(c.begin());
-  template<class C> constexpr auto end(C& c) -> decltype(c.end());
-  template<class C> constexpr auto end(const C& c) -> decltype(c.end());
-  template<class T, size_t N> constexpr T* begin(T (&array)[N]) noexcept;
-  template<class T, size_t N> constexpr T* end(T (&array)[N]) noexcept;
-  template<class C> constexpr auto cbegin(const C& c) noexcept(noexcept(std::begin(c)))
-    -> decltype(std::begin(c));
-  template<class C> constexpr auto cend(const C& c) noexcept(noexcept(std::end(c)))
-    -> decltype(std::end(c));
-  template<class C> constexpr auto rbegin(C& c) -> decltype(c.rbegin());
-  template<class C> constexpr auto rbegin(const C& c) -> decltype(c.rbegin());
-  template<class C> constexpr auto rend(C& c) -> decltype(c.rend());
-  template<class C> constexpr auto rend(const C& c) -> decltype(c.rend());
-  template<class T, size_t N> constexpr reverse_iterator<T*> rbegin(T (&array)[N]);
-  template<class T, size_t N> constexpr reverse_iterator<T*> rend(T (&array)[N]);
-  template<class E> constexpr reverse_iterator<const E*> rbegin(initializer_list<E> il);
-  template<class E> constexpr reverse_iterator<const E*> rend(initializer_list<E> il);
-  template<class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c));
-  template<class C> constexpr auto crend(const C& c) -> decltype(std::rend(c));
-  template<class C> constexpr auto size(const C& c) -> decltype(c.size());
-  template<class T, size_t N> constexpr size_t size(const T (&array)[N]) noexcept;
-  template<class C> constexpr auto ssize(const C& c)
- -> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>;
-  template<class T, ptrdiff_t N> constexpr ptrdiff_t ssize(const T (&array)[N]) noexcept;
-  template<class C> [[nodiscard]] constexpr auto empty(const C& c) -> decltype(c.empty());
-  template<class T, size_t N> [[nodiscard]] constexpr bool empty(const T (&array)[N]) noexcept;
-  template<class E> [[nodiscard]] constexpr bool empty(initializer_list<E> il) noexcept;
-  template<class C> constexpr auto data(C& c) -> decltype(c.data());
-  template<class C> constexpr auto data(const C& c) -> decltype(c.data());
-  template<class T, size_t N> constexpr T* data(T (&array)[N]) noexcept;
-  template<class E> constexpr const E* data(initializer_list<E> il) noexcept;
 }
 ```
 ## Iterator requirements <a id="iterator.requirements">[[iterator.requirements]]</a>
@@ -483,11 +543,11 @@ access iterators*, and *contiguous iterators*, as shown in
 The six categories of iterators correspond to the iterator concepts
 - `input_iterator` [[iterator.concept.input]],
 - `output_iterator` [[iterator.concept.output]],
 - `forward_iterator` [[iterator.concept.forward]],
-- `bidirectional_iterator` [[iterator.concept.bidir]]
 - `random_access_iterator` [[iterator.concept.random.access]], and
 - `contiguous_iterator` [[iterator.concept.contiguous]],
 respectively. The generic term *iterator* refers to any type that models
 the `input_or_output_iterator` concept [[iterator.concept.iterator]].
@@ -518,22 +578,16 @@ value pointing past the last element of the array, so for any iterator
 type there is an iterator value that points past the last element of a
 corresponding sequence. Such a value is called a *past-the-end value*.
 Values of an iterator `i` for which the expression `*i` is defined are
 called *dereferenceable*. The library never assumes that past-the-end
 values are dereferenceable. Iterators can also have singular values that
-are not associated with any sequence.
-[*Example 1*: After the declaration of an uninitialized pointer `x` (as
-with `int* x;`), `x` must always be assumed to have a singular value of
-a pointer. — *end example*]
-Results of most expressions are undefined for singular values; the only
-exceptions are destroying an iterator that holds a singular value, the
-assignment of a non-singular value to an iterator that holds a singular
-value, and, for iterators that meet the *Cpp17DefaultConstructible*
-requirements, using a value-initialized iterator as the source of a copy
-or move operation.
 [*Note 2*: This guarantee is not offered for default-initialization,
 although the distinction only matters for types with trivial default
 constructors such as pointers or aggregates holding
 pointers. — *end note*]
@@ -554,18 +608,18 @@ elements in the data structure starting with the element pointed to by
 first iterator `j` such that `j == s`.
 A sentinel `s` is called *reachable from* an iterator `i` if and only if
 there is a finite sequence of applications of the expression `++i` that
 makes `i == s`. If `s` is reachable from `i`, \[`i`, `s`) denotes a
-valid range.
 A *counted range* `i`+\[0, `n`) is empty if `n == 0`; otherwise,
 `i`+\[0, `n`) refers to the `n` elements in the data structure starting
 with the element pointed to by `i` and up to but not including the
 element, if any, pointed to by the result of `n` applications of `++i`.
-A counted range `i`+\[0, `n`) is valid if and only if `n == 0`; or `n`
-is positive, `i` is dereferenceable, and `++i`+\[0, `-``-``n`) is valid.
 The result of the application of library functions to invalid ranges is
 undefined.
 All the categories of iterators require only those functions that are
@@ -661,10 +715,16 @@ template<class T>
   requires is_object_v<T>
 struct cond-value-type<T> {
   using value_type = remove_cv_t<T>;
 };
 template<class> struct indirectly_readable_traits { };
 template<class T>
 struct indirectly_readable_traits<T*>
   : cond-value-type<T> { };
@@ -677,20 +737,28 @@ struct indirectly_readable_traits<I> {
 template<class I>
 struct indirectly_readable_traits<const I>
   : indirectly_readable_traits<I> { };
-template<class T>
-  requires requires { typename T::value_type; }
 struct indirectly_readable_traits<T>
   : cond-value-type<typename T::value_type> { };
-template<class T>
-  requires requires { typename T::element_type; }
 struct indirectly_readable_traits<T>
   : cond-value-type<typename T::element_type> { };
 template<class T> using iter_value_t = see below;
 ```
 Let R_`I` be `remove_cvref_t<I>`. The type `iter_value_t<I>` denotes
@@ -748,15 +816,15 @@ The definitions in this subclause make use of the following
 exposition-only concepts:
 ``` cpp
 template<class I>
 concept cpp17-iterator =
- copyable<I> && requires(I i) {
     {   *i } -> can-reference;
     {  ++i } -> same_as<I&>;
     { *i++ } -> can-reference;
-  };
 template<class I>
 concept cpp17-input-iterator =
   cpp17-iterator<I> && equality_comparable<I> && requires(I i) {
     typename incrementable_traits<I>::difference_type;
@@ -769,11 +837,11 @@ concept cpp17-input-iterator =
   };
 template<class I>
 concept cpp17-forward-iterator =
   cpp17-input-iterator<I> && constructible_from<I> &&
- is_lvalue_reference_v<iter_reference_t<I>> &&
   same_as<remove_cvref_t<iter_reference_t<I>>,
           typename indirectly_readable_traits<I>::value_type> &&
   requires(I i) {
     {  i++ } -> convertible_to<const I&>;
     { *i++ } -> same_as<iter_reference_t<I>>;
@@ -865,10 +933,16 @@ The members of a specialization `iterator_traits<I>` generated from the
 Explicit or partial specializations of `iterator_traits` may have a
 member type `iterator_concept` that is used to indicate conformance to
 the iterator concepts [[iterator.concepts]].
 `iterator_traits` is specialized for pointers as
 ``` cpp
 namespace std {
   template<class T>
@@ -882,11 +956,11 @@ namespace std {
     using reference         = T&;
   };
 }
 ```
-[*Example 1*:
 To implement a generic `reverse` function, a C++ program can do the
 following:
 ``` cpp
@@ -905,26 +979,23 @@ void reverse(BI first, BI last) {
 }
 ```
 — *end example*]
-### Customization points <a id="iterator.cust">[[iterator.cust]]</a>
 #### `ranges::iter_move` <a id="iterator.cust.move">[[iterator.cust.move]]</a>
 The name `ranges::iter_move` denotes a customization point object
 [[customization.point.object]]. The expression `ranges::iter_move(E)`
 for a subexpression `E` is expression-equivalent to:
 - `iter_move(E)`, if `E` has class or enumeration type and
   `iter_move(E)` is a well-formed expression when treated as an
-  unevaluated operand, with overload resolution performed in a context
- that does not include a declaration of `ranges::iter_move` but does
- include the declaration
-  ``` cpp
-  void iter_move();
-  ```
 - Otherwise, if the expression `*E` is well-formed:
   - if `*E` is an lvalue, `std::move(*E)`;
   - otherwise, `*E`.
 - Otherwise, `ranges::iter_move(E)` is ill-formed. \[*Note 1*: This case
   can result in substitution failure when `ranges::iter_move(E)` appears
@@ -970,20 +1041,23 @@ The expression `ranges::iter_swap(E1, E2)` for subexpressions `E1` and
   and does not include a declaration of `ranges::iter_swap`. If the
   function selected by overload resolution does not exchange the values
   denoted by `E1` and `E2`, the program is ill-formed, no diagnostic
   required.
 - Otherwise, if the types of `E1` and `E2` each model
   `indirectly_readable`, and if the reference types of `E1` and `E2`
   model `swappable_with` [[concept.swappable]], then
   `ranges::swap(*E1, *E2)`.
 - Otherwise, if the types `T1` and `T2` of `E1` and `E2` model
   `indirectly_movable_storable<T1, T2>` and
   `indirectly_movable_storable<T2, T1>`, then
   `(void)(*E1 = iter-exchange-move(E2, E1))`, except that `E1` is
   evaluated only once.
-- Otherwise, `ranges::iter_swap(E1, E2)` is ill-formed. \[*Note 1*: This
   case can result in substitution failure when
   `ranges::iter_swap(E1, E2)` appears in the immediate context of a
   template instantiation. — *end note*]
 ### Iterator concepts <a id="iterator.concepts">[[iterator.concepts]]</a>
@@ -1018,11 +1092,10 @@ struct I {
   I operator++(int);
   I& operator--();
   I operator--(int);
   bool operator==(I) const;
-  bool operator!=(I) const;
 };
 ```
 `iterator_traits<I>::iterator_category` denotes `input_iterator_tag`,
 and `ITER_CONCEPT(I)` denotes `random_access_iterator_tag`.
@@ -1057,14 +1130,10 @@ template<class In>
 ```
 Given a value `i` of type `I`, `I` models `indirectly_readable` only if
 the expression `*i` is equality-preserving.
-[*Note 1*: The expression `*i` is indirectly required to be valid via
-the exposition-only `dereferenceable` concept
-[[iterator.synopsis]]. — *end note*]
 #### Concept  <a id="iterator.concept.writable">[[iterator.concept.writable]]</a>
 The `indirectly_writable` concept specifies the requirements for writing
 a value into an iterator’s referenced object.
@@ -1084,11 +1153,11 @@ template<class Out, class T>
 Let `E` be an expression such that `decltype((E))` is `T`, and let `o`
 be a dereferenceable object of type `Out`. `Out` and `T` model
 `indirectly_writable<Out, T>` only if
 - If `Out` and `T` model
-  `indirectly_readable<Out> && same_as<iter_value_t<Out>, decay_t<T>{>}`,
   then `*o` after any above assignment is equal to the value of `E`
   before the assignment.
 After evaluating any above assignment expression, `o` is not required to
 be dereferenceable.
@@ -1114,99 +1183,126 @@ that can be incremented with the pre- and post-increment operators. The
 increment operations are not required to be equality-preserving, nor is
 the type required to be `equality_comparable`.
 ``` cpp
 template<class T>
- inline constexpr bool is-integer-like = see below; // exposition only
 template<class T>
- inline constexpr bool is-signed-integer-like = see below; // exposition only
 template<class I>
   concept weakly_incrementable =
- default_initializable<I> && movable<I> &&
     requires(I i) {
       typename iter_difference_t<I>;
       requires is-signed-integer-like<iter_difference_t<I>>;
       { ++i } -> same_as<I&>;   // not required to be equality-preserving
       i++;                      // not required to be equality-preserving
     };
 ```
 A type `I` is an *integer-class type* if it is in a set of
-implementation-defined class types that behave as integer types do, as
-defined in below.
 The range of representable values of an integer-class type is the
-continuous set of values over which it is defined. The values 0 and 1
-are part of the range of every integer-class type. If any negative
-numbers are part of the range, the type is a
-*signed-integer-class type*; otherwise, it is an
-*unsigned-integer-class type*.
-For every integer-class type `I`, let `B(I)` be a hypothetical extended
-integer type of the same signedness with the smallest width
-[[basic.fundamental]] capable of representing the same range of values.
-The width of `I` is equal to the width of `B(I)`.
-Let `a` and `b` be objects of integer-class type `I`, let `x` and `y` be
-objects of type `B(I)` as described above that represent the same values
-as `a` and `b` respectively, and let `c` be an lvalue of any integral
-type.
-- For every unary operator `@` for which the expression `@x` is
-  well-formed, `@a` shall also be well-formed and have the same value,
-  effects, and value category as `@x` provided that value is
-  representable by `I`. If `@x` has type `bool`, so too does `@a`; if
-  `@x` has type `B(I)`, then `@a` has type `I`.
 - For every assignment operator `@=` for which `c @= x` is well-formed,
   `c @= a` shall also be well-formed and shall have the same value and
   effects as `c @= x`. The expression `c @= a` shall be an lvalue
   referring to `c`.
-- For every binary operator `@` for which `x @ y` is well-formed,
-  `a @ b` shall also be well-formed and shall have the same value,
- effects, and value category as `x @ y` provided that value is
- representable by `I`. If `x @ y` has type `bool`, so too does `a @ b`;
- if `x @ y` has type `B(I)`, then `a @ b` has type `I`.
-Expressions of integer-class type are explicitly convertible to any
-integral type. Expressions of integral type are both implicitly and
-explicitly convertible to any integer-class type. Conversions between
-integral and integer-class types do not exit via an exception.
 An expression `E` of integer-class type `I` is contextually convertible
 to `bool` as if by `bool(E != I(0))`.
 All integer-class types model `regular` [[concepts.object]] and
-`totally_ordered` [[concept.totallyordered]].
 A value-initialized object of integer-class type has value 0.
 For every (possibly cv-qualified) integer-class type `I`,
-`numeric_limits<I>` is specialized such that:
-- `numeric_limits<I>::is_specialized` is `true`,
-- `numeric_limits<I>::is_signed` is `true` if and only if `I` is a
-  signed-integer-class type,
-- `numeric_limits<I>::is_integer` is `true`,
-- `numeric_limits<I>::is_exact` is `true`,
-- `numeric_limits<I>::digits` is equal to the width of the integer-class
-  type,
-- `numeric_limits<I>::digits10` is equal to
-  `static_cast<int>(digits * log10(2))`, and
-- `numeric_limits<I>::min()` and `numeric_limits<I>::max()` return the
-  lowest and highest representable values of `I`, respectively, and
-  `numeric_limits<I>::lowest()` returns `numeric_limits<I>::{}min()`.
-A type `I` is *integer-like* if it models `integral<I>` or if it is an
-integer-class type. A type `I` is *signed-integer-like* if it models
-`signed_integral<I>` or if it is a signed-integer-class type. A type `I`
-is *unsigned-integer-like* if it models `unsigned_integral<I>` or if it
-is an unsigned-integer-class type.
 `is-integer-like<I>` is `true` if and only if `I` is an integer-like
-type. `is-signed-integer-like<I>` is `true` if and only if I is a
 signed-integer-like type.
 Let `i` be an object of type `I`. When `i` is in the domain of both pre-
 and post-increment, `i` is said to be *incrementable*. `I` models
 `weakly_incrementable<I>` only if
@@ -1215,17 +1311,20 @@ and post-increment, `i` is said to be *incrementable*. `I` models
 - If `i` is incrementable, then both `++i` and `i++` advance `i` to the
   next element.
 - If `i` is incrementable, then `addressof(++i)` is equal to
   `addressof(i)`.
-[*Note 1*: For `weakly_incrementable` types, `a` equals `b` does not
 imply that `++a` equals `++b`. (Equality does not guarantee the
-substitution property or referential transparency.) Algorithms on weakly
-incrementable types should never attempt to pass through the same
-incrementable value twice. They should be single-pass algorithms. These
-algorithms can be used with istreams as the source of the input data
-through the `istream_iterator` class template. — *end note*]
 #### Concept  <a id="iterator.concept.inc">[[iterator.concept.inc]]</a>
 The `incrementable` concept specifies requirements on types that can be
 incremented with the pre- and post-increment operators. The increment
@@ -1262,13 +1361,12 @@ The `input_or_output_iterator` concept forms the basis of the iterator
 concept taxonomy; every iterator models `input_or_output_iterator`. This
 concept specifies operations for dereferencing and incrementing an
 iterator. Most algorithms will require additional operations to compare
 iterators with sentinels [[iterator.concept.sentinel]], to read
 [[iterator.concept.input]] or write [[iterator.concept.output]] values,
-or to provide a richer set of iterator movements (
-[[iterator.concept.forward]], [[iterator.concept.bidir]],
-[[iterator.concept.random.access]]).
 ``` cpp
 template<class I>
   concept input_or_output_iterator =
     requires(I i) {
@@ -1290,19 +1388,20 @@ denote a range.
 ``` cpp
 template<class S, class I>
   concept sentinel_for =
     semiregular<S> &&
     input_or_output_iterator<I> &&
-    weakly-equality-comparable-with<S, I>; // See [concept.equalitycomparable]
 ```
 Let `s` and `i` be values of type `S` and `I` such that \[`i`, `s`)
 denotes a range. Types `S` and `I` model `sentinel_for<S, I>` only if
 - `i == s` is well-defined.
 - If `bool(i != s)` then `i` is dereferenceable and \[`++i`, `s`)
   denotes a range.
 The domain of `==` is not static. Given an iterator `i` and sentinel `s`
 such that \[`i`, `s`) denotes a range and `i != s`, `i` and `s` are not
 required to continue to denote a range after incrementing any other
 iterator equal to `i`. Consequently, `i == s` is no longer required to
@@ -1336,11 +1435,11 @@ and `I` model `sized_sentinel_for<S, I>` only if
 - If -N is representable by `iter_difference_t<I>`, then `i - s` is
   well-defined and equals -N.
 ``` cpp
 template<class S, class I>
- inline constexpr bool disable_sized_sentinel_for = false;
 ```
 *Remarks:* Pursuant to [[namespace.std]], users may specialize
 `disable_sized_sentinel_for` for cv-unqualified non-array object types
 `S` and `I` if `S` and/or `I` is a program-defined type. Such
@@ -1404,13 +1503,13 @@ be a dereferenceable object of type `I`. `I` and `T` model
 ``` cpp
 *i = E;
 ++i;
 ```
-[*Note 2*: Algorithms on output iterators should never attempt to pass
-through the same iterator twice. They should be single-pass
-algorithms. — *end note*]
 #### Concept  <a id="iterator.concept.forward">[[iterator.concept.forward]]</a>
 The `forward_iterator` concept adds copyability, equality comparison,
 and the multi-pass guarantee, specified below.
@@ -1438,11 +1537,11 @@ range.
 Two dereferenceable iterators `a` and `b` of type `X` offer the
 *multi-pass guarantee* if:
 - `a == b` implies `++a == ++b` and
-- The expression `((void)[](X x){++x;}(a), *a)` is equivalent to the
   expression `*a`.
 [*Note 2*: The requirement that `a == b` implies `++a == ++b` and the
 removal of the restrictions on the number of assignments through a
 mutable iterator (which applies to output iterators) allow the use of
@@ -1548,15 +1647,21 @@ non-dereferenceable iterator of type `I` such that `b` is reachable from
 `a` and `c` is reachable from `b`, and let `D` be
 `iter_difference_t<I>`. The type `I` models `contiguous_iterator` only
 if
 - `to_address(a) == addressof(*a)`,
-- `to_address(b) == to_address(a) + D(b - a)`, and
-- `to_address(c) == to_address(a) + D(c - a)`.
 ### C++17 iterator requirements <a id="iterator.cpp17">[[iterator.cpp17]]</a>
 In the following sections, `a` and `b` denote values of type `X` or
 `const X`, `difference_type` and `reference` refer to the types
 `iterator_traits<X>::difference_type` and
 `iterator_traits<X>::reference`, respectively, `n` denotes a value of
 `difference_type`, `u`, `tmp`, and `m` denote identifiers, `r` denotes a
@@ -1571,19 +1676,18 @@ value of some type that is writable to the output iterator.
 The *Cpp17Iterator* requirements form the basis of the iterator
 taxonomy; every iterator meets the *Cpp17Iterator* requirements. This
 set of requirements specifies operations for dereferencing and
 incrementing an iterator. Most algorithms will require additional
 operations to read [[input.iterators]] or write [[output.iterators]]
-values, or to provide a richer set of iterator movements (
-[[forward.iterators]], [[bidirectional.iterators]],
-[[random.access.iterators]]).
-A type `X` meets the *Cpp17Iterator* requirements if:
-- `X` meets the *Cpp17CopyConstructible*, *Cpp17CopyAssignable*, and
-  *Cpp17Destructible* requirements [[utility.arg.requirements]] and
- lvalues of type `X` are swappable [[swappable.requirements]], and
 - `iterator_traits<X>::difference_type` is a signed integer type or
   `void`, and
 - the expressions in [[iterator]] are valid and have the indicated
   semantics.
@@ -1605,31 +1709,35 @@ uses that algorithm makes of `==` and `!=`.
 [*Example 1*: The call `find(a,b,x)` is defined only if the value of
 `a` has the property *p* defined as follows: `b` has property *p* and a
 value `i` has property *p* if (`*i==x`) or if (`*i!=x` and `++i` has
 property *p*). — *end example*]
 [*Note 1*: For input iterators, `a == b` does not imply `++a == ++b`.
 (Equality does not guarantee the substitution property or referential
-transparency.) Algorithms on input iterators should never attempt to
-pass through the same iterator twice. They should be *single pass*
-algorithms. Value type `T` is not required to be a *Cpp17CopyAssignable*
-type ([[cpp17.copyassignable]]). These algorithms can be used with
-istreams as the source of the input data through the `istream_iterator`
-class template. — *end note*]
 #### Output iterators <a id="output.iterators">[[output.iterators]]</a>
 A class or pointer type `X` meets the requirements of an output iterator
 if `X` meets the *Cpp17Iterator* requirements [[iterator.iterators]] and
 the expressions in [[outputiterator]] are valid and have the indicated
 semantics.
 [*Note 1*: The only valid use of an `operator*` is on the left side of
 the assignment statement. Assignment through the same value of the
-iterator happens only once. Algorithms on output iterators should never
-attempt to pass through the same iterator twice. They should be
-single-pass algorithms. Equality and inequality might not be
 defined. — *end note*]
 #### Forward iterators <a id="forward.iterators">[[forward.iterators]]</a>
 A class or pointer type `X` meets the requirements of a forward iterator
@@ -1691,85 +1799,95 @@ requirements, the following expressions are valid as shown in
 ### Indirect callable requirements <a id="indirectcallable">[[indirectcallable]]</a>
 #### General <a id="indirectcallable.general">[[indirectcallable.general]]</a>
 There are several concepts that group requirements of algorithms that
-take callable objects ([[func.def]]) as arguments.
 #### Indirect callables <a id="indirectcallable.indirectinvocable">[[indirectcallable.indirectinvocable]]</a>
 The indirect callable concepts are used to constrain those algorithms
-that accept callable objects ([[func.def]]) as arguments.
 ``` cpp
 namespace std {
   template<class F, class I>
     concept indirectly_unary_invocable =
       indirectly_readable<I> &&
       copy_constructible<F> &&
-      invocable<F&, iter_value_t<I>&> &&
       invocable<F&, iter_reference_t<I>> &&
       invocable<F&, iter_common_reference_t<I>> &&
       common_reference_with<
-        invoke_result_t<F&, iter_value_t<I>&>,
         invoke_result_t<F&, iter_reference_t<I>>>;
   template<class F, class I>
     concept indirectly_regular_unary_invocable =
       indirectly_readable<I> &&
       copy_constructible<F> &&
-      regular_invocable<F&, iter_value_t<I>&> &&
       regular_invocable<F&, iter_reference_t<I>> &&
       regular_invocable<F&, iter_common_reference_t<I>> &&
       common_reference_with<
-        invoke_result_t<F&, iter_value_t<I>&>,
         invoke_result_t<F&, iter_reference_t<I>>>;
   template<class F, class I>
     concept indirect_unary_predicate =
       indirectly_readable<I> &&
       copy_constructible<F> &&
-      predicate<F&, iter_value_t<I>&> &&
       predicate<F&, iter_reference_t<I>> &&
       predicate<F&, iter_common_reference_t<I>>;
   template<class F, class I1, class I2>
     concept indirect_binary_predicate =
       indirectly_readable<I1> && indirectly_readable<I2> &&
       copy_constructible<F> &&
-      predicate<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
-      predicate<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
-      predicate<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
       predicate<F&, iter_reference_t<I1>, iter_reference_t<I2>> &&
       predicate<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
   template<class F, class I1, class I2 = I1>
     concept indirect_equivalence_relation =
       indirectly_readable<I1> && indirectly_readable<I2> &&
       copy_constructible<F> &&
-      equivalence_relation<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
-      equivalence_relation<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
-      equivalence_relation<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
       equivalence_relation<F&, iter_reference_t<I1>, iter_reference_t<I2>> &&
       equivalence_relation<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
   template<class F, class I1, class I2 = I1>
     concept indirect_strict_weak_order =
       indirectly_readable<I1> && indirectly_readable<I2> &&
       copy_constructible<F> &&
-      strict_weak_order<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
-      strict_weak_order<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
-      strict_weak_order<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
       strict_weak_order<F&, iter_reference_t<I1>, iter_reference_t<I2>> &&
       strict_weak_order<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
 }
 ```
 #### Class template `projected` <a id="projected">[[projected]]</a>
 Class template `projected` is used to constrain algorithms that accept
-callable objects and projections [[defns.projection]]. It combines a
 `indirectly_readable` type `I` and a callable object type `Proj` into a
 new `indirectly_readable` type whose `reference` type is the result of
 applying `Proj` to the `iter_reference_t` of `I`.
 ``` cpp
@@ -1805,12 +1923,12 @@ different sequences: `indirectly_comparable`.
 below imposes constraints on the concepts’ arguments in addition to
 those that appear in the concepts’ bodies [[range.cmp]]. — *end note*]
 #### Concept  <a id="alg.req.ind.move">[[alg.req.ind.move]]</a>
-The `indirectly_movable` concept specifies the relationship between a
-`indirectly_readable` type and a `indirectly_writable` type between
 which values may be moved.
 ``` cpp
 template<class In, class Out>
   concept indirectly_movable =
@@ -1846,12 +1964,12 @@ iter_value_t<In> obj(ranges::iter_move(i));
 state of the value denoted by `*i` is valid but unspecified
 [[lib.types.movedfrom]].
 #### Concept  <a id="alg.req.ind.copy">[[alg.req.ind.copy]]</a>
-The `indirectly_copyable` concept specifies the relationship between a
-`indirectly_readable` type and a `indirectly_writable` type between
 which values may be copied.
 ``` cpp
 template<class In, class Out>
   concept indirectly_copyable =
@@ -1962,10 +2080,12 @@ template<class I, class R = ranges::less, class P = identity>
     indirect_strict_weak_order<R, projected<I, P>>;
 ```
 ## Iterator primitives <a id="iterator.primitives">[[iterator.primitives]]</a>
 To simplify the use of iterators, the library provides several classes
 and functions.
 ### Standard iterator tags <a id="std.iterator.tags">[[std.iterator.tags]]</a>
@@ -1993,13 +2113,13 @@ namespace std {
 }
 ```
 [*Example 1*:
-For a program-defined iterator `BinaryTreeIterator`, it could be
-included into the bidirectional iterator category by specializing the
-`iterator_traits` template:
 ``` cpp
 template<class T> struct iterator_traits<BinaryTreeIterator<T>> {
   using iterator_category = bidirectional_iterator_tag;
   using difference_type   = ptrdiff_t;
@@ -2067,12 +2187,12 @@ template<class InputIterator>
 *Preconditions:* `last` is reachable from `first`, or `InputIterator`
 meets the *Cpp17RandomAccessIterator* requirements and `first` is
 reachable from `last`.
 *Effects:* If `InputIterator` meets the *Cpp17RandomAccessIterator*
-requirements, returns `(last - first)`; otherwise, returns the number of
-increments needed to get from `first` to `last`.
 ``` cpp
 template<class InputIterator>
   constexpr InputIterator next(InputIterator x,
     typename iterator_traits<InputIterator>::difference_type n = 1);
@@ -2088,10 +2208,12 @@ template<class BidirectionalIterator>
 *Effects:* Equivalent to: `advance(x, -n); return x;`
 ### Range iterator operations <a id="range.iter.ops">[[range.iter.ops]]</a>
 The library includes the function templates `ranges::advance`,
 `ranges::distance`, `ranges::next`, and `ranges::prev` to manipulate
 iterators. These operations adapt to the set of operators provided by
 each iterator category to provide the most efficient implementation
 possible for a concrete iterator type.
@@ -2100,11 +2222,11 @@ possible for a concrete iterator type.
 `random_access_iterator` forward `n` steps in constant time. For an
 iterator type that does not model `random_access_iterator`,
 `ranges::advance` instead performs `n` individual increments with the
 `++` operator. — *end example*]
-The function templates defined in this subclause are not found by
 argument-dependent name lookup [[basic.lookup.argdep]]. When found by
 unqualified [[basic.lookup.unqual]] name lookup for the
 *postfix-expression* in a function call [[expr.call]], they inhibit
 argument-dependent name lookup.
@@ -2119,18 +2241,18 @@ void foo() {
 ```
 The function call expression at `#1` invokes `std::ranges::distance`,
 not `std::distance`, despite that (a) the iterator type returned from
 `begin(vec)` and `end(vec)` may be associated with namespace `std` and
-(b) `std::distance` is more specialized ([[temp.func.order]]) than
 `std::ranges::distance` since the former requires its first two
 parameters to have the same type.
 — *end example*]
 The number and order of deducible template parameters for the function
-templates defined in this subclause is unspecified, except where
 explicitly stated otherwise.
 #### `ranges::advance` <a id="range.iter.op.advance">[[range.iter.op.advance]]</a>
 ``` cpp
@@ -2150,11 +2272,13 @@ not negative.
 ``` cpp
 template<input_or_output_iterator I, sentinel_for<I> S>
   constexpr void ranges::advance(I& i, S bound);
 ```
-*Preconditions:* \[`i`, `bound`) denotes a range.
 *Effects:*
 - If `I` and `S` model `assignable_from<I&, S>`, equivalent to
   `i = std::move(bound)`.
@@ -2187,21 +2311,27 @@ template<input_or_output_iterator I, sentinel_for<I> S>
 starting positions of `i`.
 #### `ranges::distance` <a id="range.iter.op.distance">[[range.iter.op.distance]]</a>
 ``` cpp
-template<input_or_output_iterator I, sentinel_for<I> S>
   constexpr iter_difference_t<I> ranges::distance(I first, S last);
 ```
-*Preconditions:* \[`first`, `last`) denotes a range, or \[`last`,
-`first`) denotes a range and `S` and `I` model
-`same_as<S, I> && sized_sentinel_for<S, I>`.
-*Effects:* If `S` and `I` model `sized_sentinel_for<S, I>`, returns
-`(last - first)`; otherwise, returns the number of increments needed to
-get from `first` to `last`.
 ``` cpp
 template<range R>
   constexpr range_difference_t<R> ranges::distance(R&& r);
 ```
@@ -2253,11 +2383,11 @@ template<input_or_output_iterator I, sentinel_for<I> S>
 ``` cpp
 template<bidirectional_iterator I>
   constexpr I ranges::prev(I x);
 ```
-*Effects:* Equivalent to: `-``-``x; return x;`
 ``` cpp
 template<bidirectional_iterator I>
   constexpr I ranges::prev(I x, iter_difference_t<I> n);
 ```
@@ -2273,10 +2403,12 @@ template<bidirectional_iterator I>
 ## Iterator adaptors <a id="predef.iterators">[[predef.iterators]]</a>
 ### Reverse iterators <a id="reverse.iterators">[[reverse.iterators]]</a>
 Class template `reverse_iterator` is an iterator adaptor that iterates
 from the end of the sequence defined by its underlying iterator to the
 beginning of that sequence.
 #### Class template `reverse_iterator` <a id="reverse.iterator">[[reverse.iterator]]</a>
@@ -2381,26 +2513,33 @@ constexpr explicit reverse_iterator(Iterator x);
 ``` cpp
 template<class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
 ```
 *Effects:* Initializes `current` with `u.current`.
 ``` cpp
 template<class U>
   constexpr reverse_iterator&
     operator=(const reverse_iterator<U>& u);
 ```
-*Effects:* Assigns `u.base()` to `current`.
 *Returns:* `*this`.
 #### Conversion <a id="reverse.iter.conv">[[reverse.iter.conv]]</a>
 ``` cpp
-constexpr Iterator base() const;          // explicit
 ```
 *Returns:* `current`.
 #### Element access <a id="reverse.iter.elem">[[reverse.iter.elem]]</a>
@@ -2450,11 +2589,11 @@ constexpr reverse_iterator operator-(difference_type n) const;
 ``` cpp
 constexpr reverse_iterator& operator++();
 ```
-*Effects:* As if by: `current;`
 *Returns:* `*this`.
 ``` cpp
 constexpr reverse_iterator operator++(int);
@@ -2602,11 +2741,11 @@ template<class Iterator1, class Iterator2>
 *Returns:* `y.base() - x.base()`.
 ``` cpp
 template<class Iterator>
   constexpr reverse_iterator<Iterator> operator+(
- typename reverse_iterator<Iterator>::difference_type n,
     const reverse_iterator<Iterator>& x);
 ```
 *Returns:* `reverse_iterator<Iterator>(x.base() - n)`.
@@ -2620,11 +2759,11 @@ friend constexpr iter_rvalue_reference_t<Iterator>
 ``` cpp
 auto tmp = i.base();
 return ranges::iter_move(--tmp);
 ```
-*Remarks:* The expression in `noexcept` is equivalent to:
 ``` cpp
 is_nothrow_copy_constructible_v<Iterator> &&
 noexcept(ranges::iter_move(--declval<Iterator&>()))
 ```
@@ -2642,11 +2781,11 @@ template<indirectly_swappable<Iterator> Iterator2>
 auto xtmp = x.base();
 auto ytmp = y.base();
 ranges::iter_swap(--xtmp, --ytmp);
 ```
-*Remarks:* The expression in `noexcept` is equivalent to:
 ``` cpp
 is_nothrow_copy_constructible_v<Iterator> &&
 is_nothrow_copy_constructible_v<Iterator2> &&
 noexcept(ranges::iter_swap(--declval<Iterator&>(), --declval<Iterator2&>()))
@@ -2659,10 +2798,12 @@ template<class Iterator>
 *Returns:* `reverse_iterator<Iterator>(i)`.
 ### Insert iterators <a id="insert.iterators">[[insert.iterators]]</a>
 To make it possible to deal with insertion in the same way as writing
 into an array, a special kind of iterator adaptors, called *insert
 iterators*, are provided in the library. With regular iterator classes,
 ``` cpp
@@ -2695,21 +2836,20 @@ iterators out of a container.
 ``` cpp
 namespace std {
   template<class Container>
   class back_insert_iterator {
   protected:
-    Container* container = nullptr;
   public:
     using iterator_category = output_iterator_tag;
     using value_type        = void;
     using difference_type   = ptrdiff_t;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
-    constexpr back_insert_iterator() noexcept = default;
     constexpr explicit back_insert_iterator(Container& x);
     constexpr back_insert_iterator& operator=(const typename Container::value_type& value);
     constexpr back_insert_iterator& operator=(typename Container::value_type&& value);
     constexpr back_insert_iterator& operator*();
@@ -2770,21 +2910,20 @@ template<class Container>
 ``` cpp
 namespace std {
   template<class Container>
   class front_insert_iterator {
   protected:
-    Container* container = nullptr;
   public:
     using iterator_category = output_iterator_tag;
     using value_type        = void;
     using difference_type   = ptrdiff_t;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
-    constexpr front_insert_iterator() noexcept = default;
     constexpr explicit front_insert_iterator(Container& x);
     constexpr front_insert_iterator& operator=(const typename Container::value_type& value);
     constexpr front_insert_iterator& operator=(typename Container::value_type&& value);
     constexpr front_insert_iterator& operator*();
@@ -2845,22 +2984,21 @@ template<class Container>
 ``` cpp
 namespace std {
   template<class Container>
   class insert_iterator {
   protected:
-    Container* container = nullptr;
-    ranges::iterator_t<Container> iter = ranges::iterator_t<Container>();
   public:
     using iterator_category = output_iterator_tag;
     using value_type        = void;
     using difference_type   = ptrdiff_t;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
-    insert_iterator() = default;
     constexpr insert_iterator(Container& x, ranges::iterator_t<Container> i);
     constexpr insert_iterator& operator=(const typename Container::value_type& value);
     constexpr insert_iterator& operator=(typename Container::value_type&& value);
     constexpr insert_iterator& operator*();
@@ -2926,12 +3064,425 @@ template<class Container>
     inserter(Container& x, ranges::iterator_t<Container> i);
 ```
 *Returns:* `insert_iterator<Container>(x, i)`.
 ### Move iterators and sentinels <a id="move.iterators">[[move.iterators]]</a>
 Class template `move_iterator` is an iterator adaptor with the same
 behavior as the underlying iterator except that its indirection operator
 implicitly converts the value returned by the underlying iterator’s
 indirection operator to an rvalue. Some generic algorithms can be called
 with move iterators to replace copying with moving.
@@ -2954,24 +3505,24 @@ vector<string> v2(make_move_iterator(s.begin()),
 namespace std {
   template<class Iterator>
   class move_iterator {
   public:
     using iterator_type     = Iterator;
-    using iterator_concept  = input_iterator_tag;
-    using iterator_category = see below;
     using value_type        = iter_value_t<Iterator>;
     using difference_type   = iter_difference_t<Iterator>;
     using pointer           = Iterator;
     using reference         = iter_rvalue_reference_t<Iterator>;
     constexpr move_iterator();
     constexpr explicit move_iterator(Iterator i);
     template<class U> constexpr move_iterator(const move_iterator<U>& u);
     template<class U> constexpr move_iterator& operator=(const move_iterator<U>& u);
-    constexpr iterator_type base() const &;
-    constexpr iterator_type base() &&;
     constexpr reference operator*() const;
     constexpr move_iterator& operator++();
     constexpr auto operator++(int);
     constexpr move_iterator& operator--();
@@ -3004,11 +3555,23 @@ namespace std {
     Iterator current;   // exposition only
   };
 }
 ```
-The member *typedef-name* `iterator_category` denotes
 - `random_access_iterator_tag` if the type
   `iterator_traits<{}Iterator>::iterator_category` models
   `derived_from<random_access_iterator_tag>`, and
 - `iterator_traits<{}Iterator>::iterator_category` otherwise.
@@ -3031,49 +3594,45 @@ parameter shall either meet the *Cpp17RandomAccessIterator* requirements
 ``` cpp
 constexpr move_iterator();
 ```
-*Effects:* Constructs a `move_iterator`, value-initializing `current`.
-Iterator operations applied to the resulting iterator have defined
-behavior if and only if the corresponding operations are defined on a
-value-initialized iterator of type `Iterator`.
 ``` cpp
 constexpr explicit move_iterator(Iterator i);
 ```
-*Effects:* Constructs a `move_iterator`, initializing `current` with
-`std::move(i)`.
 ``` cpp
 template<class U> constexpr move_iterator(const move_iterator<U>& u);
 ```
-*Mandates:* `U` is convertible to `Iterator`.
-*Effects:* Constructs a `move_iterator`, initializing `current` with
-`u.base()`.
 ``` cpp
 template<class U> constexpr move_iterator& operator=(const move_iterator<U>& u);
 ```
-*Mandates:* `U` is convertible to `Iterator`.
-*Effects:* Assigns `u.base()` to `current`.
 #### Conversion <a id="move.iter.op.conv">[[move.iter.op.conv]]</a>
 ``` cpp
-constexpr Iterator base() const &;
 ```
-*Constraints:* `Iterator` satisfies `copy_constructible`.
-*Preconditions:* `Iterator` models `copy_constructible`.
 *Returns:* `current`.
 ``` cpp
 constexpr Iterator base() &&;
 ```
@@ -3090,11 +3649,11 @@ constexpr reference operator*() const;
 ``` cpp
 constexpr reference operator[](difference_type n) const;
 ```
-*Effects:* Equivalent to: `ranges::iter_move(current + n);`
 #### Navigation <a id="move.iter.nav">[[move.iter.nav]]</a>
 ``` cpp
 constexpr move_iterator& operator++();
@@ -3120,11 +3679,11 @@ Otherwise, equivalent to `++current`.
 ``` cpp
 constexpr move_iterator& operator--();
 ```
-*Effects:* As if by `current`.
 *Returns:* `*this`.
 ``` cpp
 constexpr move_iterator operator--(int);
@@ -3233,12 +3792,12 @@ template<class Iterator1, three_way_comparable_with<Iterator1> Iterator2>
 #### Non-member functions <a id="move.iter.nonmember">[[move.iter.nonmember]]</a>
 ``` cpp
 template<class Iterator1, class Iterator2>
-  constexpr auto operator-(const move_iterator<Iterator1>& x,
- const move_iterator<Iterator2>& y)
       -> decltype(x.base() - y.base());
 template<sized_sentinel_for<Iterator> S>
   friend constexpr iter_difference_t<Iterator>
     operator-(const move_sentinel<S>& x, const move_iterator& y);
 template<sized_sentinel_for<Iterator> S>
@@ -3252,11 +3811,11 @@ template<sized_sentinel_for<Iterator> S>
 template<class Iterator>
   constexpr move_iterator<Iterator>
     operator+(iter_difference_t<Iterator> n, const move_iterator<Iterator>& x);
 ```
-*Constraints:* `x + n` is well-formed and has type `Iterator`.
 *Returns:* `x + n`.
 ``` cpp
 friend constexpr iter_rvalue_reference_t<Iterator>
@@ -3286,11 +3845,11 @@ constexpr move_iterator<Iterator> make_move_iterator(Iterator i);
 Class template `move_sentinel` is a sentinel adaptor useful for denoting
 ranges together with `move_iterator`. When an input iterator type `I`
 and sentinel type `S` model `sentinel_for<S, I>`, `move_sentinel<S>` and
 `move_iterator<I>` model
-`sentinel_for<move_sentinel<S>, move_iterator<I>{>}` as well.
 [*Example 1*:
 A `move_if` algorithm is easily implemented with `copy_if` using
 `move_iterator` and `move_sentinel`:
@@ -3298,11 +3857,12 @@ A `move_if` algorithm is easily implemented with `copy_if` using
 ``` cpp
 template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
          indirect_unary_predicate<I> Pred>
   requires indirectly_movable<I, O>
 void move_if(I first, S last, O out, Pred pred) {
- std::ranges::copy_if(move_iterator<I>{first}, move_sentinel<S>{last}, out, pred);
 }
 ```
 — *end example*]
@@ -3319,10 +3879,11 @@ namespace std {
     template<class S2>
       requires assignable_from<S&, const S2&>
         constexpr move_sentinel& operator=(const move_sentinel<S2>& s);
     constexpr S base() const;
   private:
     S last;     // exposition only
   };
 }
 ```
@@ -3398,50 +3959,50 @@ fun(CI(counted_iterator(s.begin(), 10)), CI(default_sentinel));
 namespace std {
   template<input_or_output_iterator I, sentinel_for<I> S>
     requires (!same_as<I, S> && copyable<I>)
   class common_iterator {
   public:
-    constexpr common_iterator() = default;
     constexpr common_iterator(I i);
     constexpr common_iterator(S s);
     template<class I2, class S2>
       requires convertible_to<const I2&, I> && convertible_to<const S2&, S>
         constexpr common_iterator(const common_iterator<I2, S2>& x);
     template<class I2, class S2>
       requires convertible_to<const I2&, I> && convertible_to<const S2&, S> &&
                assignable_from<I&, const I2&> && assignable_from<S&, const S2&>
-        common_iterator& operator=(const common_iterator<I2, S2>& x);
-    decltype(auto) operator*();
-    decltype(auto) operator*() const
       requires dereferenceable<const I>;
- decltype(auto) operator->() const
       requires see below;
-    common_iterator& operator++();
-    decltype(auto) operator++(int);
     template<class I2, sentinel_for<I> S2>
       requires sentinel_for<S, I2>
-    friend bool operator==(
       const common_iterator& x, const common_iterator<I2, S2>& y);
     template<class I2, sentinel_for<I> S2>
       requires sentinel_for<S, I2> && equality_comparable_with<I, I2>
-    friend bool operator==(
       const common_iterator& x, const common_iterator<I2, S2>& y);
     template<sized_sentinel_for<I> I2, sized_sentinel_for<I> S2>
       requires sized_sentinel_for<S, I2>
-    friend iter_difference_t<I2> operator-(
       const common_iterator& x, const common_iterator<I2, S2>& y);
-    friend iter_rvalue_reference_t<I> iter_move(const common_iterator& i)
       noexcept(noexcept(ranges::iter_move(declval<const I&>())))
         requires input_iterator<I>;
     template<indirectly_swappable<I> I2, class S2>
-      friend void iter_swap(const common_iterator& x, const common_iterator<I2, S2>& y)
         noexcept(noexcept(ranges::iter_swap(declval<const I&>(), declval<const I2&>())));
   private:
     variant<I, S> v_;   // exposition only
   };
@@ -3468,17 +4029,17 @@ namespace std {
 The nested *typedef-name*s of the specialization of `iterator_traits`
 for `common_iterator<I, S>` are defined as follows.
 - `iterator_concept` denotes `forward_iterator_tag` if `I` models
   `forward_iterator`; otherwise it denotes `input_iterator_tag`.
-- `iterator_category` denotes `forward_iterator_tag` if
-  `iterator_traits<I>::iterator_category` models
-  `derived_from<forward_iterator_tag>`; otherwise it denotes
-  `input_iterator_tag`.
-- If the expression `a.operator->()` is well-formed, where `a` is an
- lvalue of type `const common_iterator<I, S>`, then `pointer` denotes
- the type of that expression. Otherwise, `pointer` denotes `void`.
 #### Constructors and conversions <a id="common.iter.const">[[common.iter.const]]</a>
 ``` cpp
 constexpr common_iterator(I i);
@@ -3507,11 +4068,11 @@ template<class I2, class S2>
 ``` cpp
 template<class I2, class S2>
   requires convertible_to<const I2&, I> && convertible_to<const S2&, S> &&
            assignable_from<I&, const I2&> && assignable_from<S&, const S2&>
-    common_iterator& operator=(const common_iterator<I2, S2>& x);
 ```
 *Preconditions:* `x.v_.valueless_by_exception()` is `false`.
 *Effects:* Equivalent to:
@@ -3524,34 +4085,34 @@ where i is `x.v_.index()`.
 *Returns:* `*this`
 #### Accessors <a id="common.iter.access">[[common.iter.access]]</a>
 ``` cpp
-decltype(auto) operator*();
-decltype(auto) operator*() const
   requires dereferenceable<const I>;
 ```
-*Preconditions:* `holds_alternative<I>(v_)`.
 *Effects:* Equivalent to: `return *get<I>(v_);`
 ``` cpp
-decltype(auto) operator->() const
   requires see below;
 ```
-The expression in the requires clause is equivalent to:
 ``` cpp
 indirectly_readable<const I> &&
 (requires(const I& i) { i.operator->(); } ||
  is_reference_v<iter_reference_t<I>> ||
  constructible_from<iter_value_t<I>, iter_reference_t<I>>)
 ```
-*Preconditions:* `holds_alternative<I>(v_)`.
 *Effects:*
 - If `I` is a pointer type or if the expression
   `get<I>(v_).operator->()` is well-formed, equivalent to:
@@ -3565,53 +4126,87 @@ indirectly_readable<const I> &&
 - Otherwise, equivalent to: `return `*`proxy`*`(*get<I>(v_));` where
   *proxy* is the exposition-only class:
   ``` cpp
   class proxy {
     iter_value_t<I> keep_;
-    proxy(iter_reference_t<I>&& x)
       : keep_(std::move(x)) {}
   public:
-    const iter_value_t<I>* operator->() const {
       return addressof(keep_);
     }
   };
   ```
 #### Navigation <a id="common.iter.nav">[[common.iter.nav]]</a>
 ``` cpp
-common_iterator& operator++();
 ```
-*Preconditions:* `holds_alternative<I>(v_)`.
 *Effects:* Equivalent to `++get<I>(v_)`.
 *Returns:* `*this`.
 ``` cpp
-decltype(auto) operator++(int);
 ```
-*Preconditions:* `holds_alternative<I>(v_)`.
 *Effects:* If `I` models `forward_iterator`, equivalent to:
 ``` cpp
 common_iterator tmp = *this;
 ++*this;
 return tmp;
 ```
-Otherwise, equivalent to: `return get<I>(v_)++;`
 #### Comparisons <a id="common.iter.cmp">[[common.iter.cmp]]</a>
 ``` cpp
 template<class I2, sentinel_for<I> S2>
   requires sentinel_for<S, I2>
-friend bool operator==(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 ```
 *Preconditions:* `x.v_.valueless_by_exception()` and
 `y.v_.valueless_by_exception()` are each `false`.
@@ -3621,11 +4216,11 @@ friend bool operator==(
 `y.v_.index()`.
 ``` cpp
 template<class I2, sentinel_for<I> S2>
   requires sentinel_for<S, I2> && equality_comparable_with<I, I2>
-friend bool operator==(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 ```
 *Preconditions:* `x.v_.valueless_by_exception()` and
 `y.v_.valueless_by_exception()` are each `false`.
@@ -3635,46 +4230,46 @@ friend bool operator==(
 `y.v_.index()`.
 ``` cpp
 template<sized_sentinel_for<I> I2, sized_sentinel_for<I> S2>
   requires sized_sentinel_for<S, I2>
-friend iter_difference_t<I2> operator-(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 ```
 *Preconditions:* `x.v_.valueless_by_exception()` and
 `y.v_.valueless_by_exception()` are each `false`.
 *Returns:* `0` if i and j are each `1`, and otherwise
 `get<`i`>(x.v_) - get<`j`>(y.v_)`, where i is `x.v_.index()` and j is
 `y.v_.index()`.
-#### Customization <a id="common.iter.cust">[[common.iter.cust]]</a>
 ``` cpp
-friend iter_rvalue_reference_t<I> iter_move(const common_iterator& i)
   noexcept(noexcept(ranges::iter_move(declval<const I&>())))
     requires input_iterator<I>;
 ```
-*Preconditions:* `holds_alternative<I>(v_)`.
 *Effects:* Equivalent to: `return ranges::iter_move(get<I>(i.v_));`
 ``` cpp
 template<indirectly_swappable<I> I2, class S2>
-  friend void iter_swap(const common_iterator& x, const common_iterator<I2, S2>& y)
     noexcept(noexcept(ranges::iter_swap(declval<const I&>(), declval<const I2&>())));
 ```
 *Preconditions:* `holds_alternative<I>(x.v_)` and
 `holds_alternative<I2>(y.v_)` are each `true`.
 *Effects:* Equivalent to
 `ranges::iter_swap(get<I>(x.v_), get<I2>(y.v_))`.
-### Default sentinels <a id="default.sentinels">[[default.sentinels]]</a>
 ``` cpp
 namespace std {
   struct default_sentinel_t { };
 }
@@ -3707,39 +4302,49 @@ ranges::copy(counted_iterator(s.begin(), 10), default_sentinel, back_inserter(v)
 — *end example*]
 Two values `i1` and `i2` of types `counted_iterator<I1>` and
 `counted_iterator<I2>` refer to elements of the same sequence if and
-only if `next(i1.base(), i1.count())` and `next(i2.base(), i2.count())`
 refer to the same (possibly past-the-end) element.
 ``` cpp
 namespace std {
   template<input_or_output_iterator I>
   class counted_iterator {
   public:
     using iterator_type = I;
-    constexpr counted_iterator() = default;
     constexpr counted_iterator(I x, iter_difference_t<I> n);
     template<class I2>
       requires convertible_to<const I2&, I>
         constexpr counted_iterator(const counted_iterator<I2>& x);
     template<class I2>
       requires assignable_from<I&, const I2&>
         constexpr counted_iterator& operator=(const counted_iterator<I2>& x);
-    constexpr I base() const & requires copy_constructible<I>;
     constexpr I base() &&;
     constexpr iter_difference_t<I> count() const noexcept;
     constexpr decltype(auto) operator*();
     constexpr decltype(auto) operator*() const
       requires dereferenceable<const I>;
     constexpr counted_iterator& operator++();
-    decltype(auto) operator++(int);
     constexpr counted_iterator operator++(int)
       requires forward_iterator<I>;
     constexpr counted_iterator& operator--()
       requires bidirectional_iterator<I>;
     constexpr counted_iterator operator--(int)
@@ -3788,18 +4393,15 @@ namespace std {
   private:
     I current = I();                    // exposition only
     iter_difference_t<I> length = 0;    // exposition only
   };
-  template<class I>
-  struct incrementable_traits<counted_iterator<I>> {
-    using difference_type = iter_difference_t<I>;
-  };
   template<input_iterator I>
   struct iterator_traits<counted_iterator<I>> : iterator_traits<I> {
-    using pointer = void;
   };
 }
 ```
 #### Constructors and conversions <a id="counted.iter.const">[[counted.iter.const]]</a>
@@ -3833,11 +4435,11 @@ template<class I2>
 *Returns:* `*this`.
 #### Accessors <a id="counted.iter.access">[[counted.iter.access]]</a>
 ``` cpp
-constexpr I base() const & requires copy_constructible<I>;
 ```
 *Effects:* Equivalent to: `return current;`
 ``` cpp
@@ -3858,12 +4460,21 @@ constexpr iter_difference_t<I> count() const noexcept;
 constexpr decltype(auto) operator*();
 constexpr decltype(auto) operator*() const
   requires dereferenceable<const I>;
 ```
 *Effects:* Equivalent to: `return *current;`
 ``` cpp
 constexpr decltype(auto) operator[](iter_difference_t<I> n) const
   requires random_access_iterator<I>;
 ```
@@ -3886,11 +4497,11 @@ constexpr counted_iterator& operator++();
 --length;
 return *this;
 ```
 ``` cpp
-decltype(auto) operator++(int);
 ```
 *Preconditions:* `length > 0`.
 *Effects:* Equivalent to:
@@ -4060,24 +4671,26 @@ friend constexpr iter_rvalue_reference_t<I>
   iter_move(const counted_iterator& i)
     noexcept(noexcept(ranges::iter_move(i.current)))
     requires input_iterator<I>;
 ```
 *Effects:* Equivalent to: `return ranges::iter_move(i.current);`
 ``` cpp
 template<indirectly_swappable<I> I2>
   friend constexpr void
     iter_swap(const counted_iterator& x, const counted_iterator<I2>& y)
       noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
 ```
 *Effects:* Equivalent to `ranges::iter_swap(x.current, y.current)`.
-### Unreachable sentinel <a id="unreachable.sentinels">[[unreachable.sentinels]]</a>
-#### Class `unreachable_sentinel_t` <a id="unreachable.sentinel">[[unreachable.sentinel]]</a>
 Class `unreachable_sentinel_t` can be used with any
 `weakly_incrementable` type to denote the “upper bound” of an unbounded
 interval.
@@ -4106,10 +4719,12 @@ namespace std {
 }
 ```
 ## Stream iterators <a id="stream.iterators">[[stream.iterators]]</a>
 To make it possible for algorithmic templates to work directly with
 input/output streams, appropriate iterator-like class templates are
 provided.
 [*Example 1*:
@@ -4125,10 +4740,12 @@ the partial sums onto `cout`.
 — *end example*]
 ### Class template `istream_iterator` <a id="istream.iterator">[[istream.iterator]]</a>
 The class template `istream_iterator` is an input iterator
 [[input.iterators]] that reads successive elements from the input stream
 for which it was constructed.
 ``` cpp
@@ -4147,11 +4764,11 @@ namespace std {
     using istream_type      = basic_istream<charT,traits>;
     constexpr istream_iterator();
     constexpr istream_iterator(default_sentinel_t);
     istream_iterator(istream_type& s);
-    istream_iterator(const istream_iterator& x) = default;
     ~istream_iterator() = default;
     istream_iterator& operator=(const istream_iterator&) = default;
     const T& operator*() const;
     const T* operator->() const;
@@ -4192,17 +4809,21 @@ istream_iterator(istream_type& s);
 *Effects:* Initializes `in_stream` with `addressof(s)`,
 value-initializes `value`, and then calls `operator++()`.
 ``` cpp
-istream_iterator(const istream_iterator& x) = default;
 ```
-*Ensures:* `in_stream == x.in_stream` is `true`.
-*Remarks:* If `is_trivially_copy_constructible_v<T>` is `true`, then
-this constructor is trivial.
 ``` cpp
 ~istream_iterator() = default;
 ```
@@ -4270,10 +4891,12 @@ friend bool operator==(const istream_iterator& i, default_sentinel_t);
 *Returns:* `!i.in_stream`.
 ### Class template `ostream_iterator` <a id="ostream.iterator">[[ostream.iterator]]</a>
 `ostream_iterator` writes (using `operator<<`) successive elements onto
 the output stream from which it was constructed. If it was constructed
 with `charT*` as a constructor argument, this string, called a
 *delimiter string*, is written to the stream after every `T` is written.
@@ -4289,11 +4912,10 @@ namespace std {
     using reference         = void;
     using char_type         = charT;
     using traits_type       = traits;
     using ostream_type      = basic_ostream<charT,traits>;
-    constexpr ostream_iterator() noexcept = default;
     ostream_iterator(ostream_type& s);
     ostream_iterator(ostream_type& s, const charT* delimiter);
     ostream_iterator(const ostream_iterator& x);
     ~ostream_iterator();
     ostream_iterator& operator=(const ostream_iterator&) = default;
@@ -4302,12 +4924,12 @@ namespace std {
     ostream_iterator& operator*();
     ostream_iterator& operator++();
     ostream_iterator& operator++(int);
   private:
-    basic_ostream<charT,traits>* out_stream = nullptr; // exposition only
-    const charT* delim = nullptr; // exposition only
   };
 }
 ```
 #### Constructors and destructor <a id="ostream.iterator.cons.des">[[ostream.iterator.cons.des]]</a>
@@ -4354,10 +4976,12 @@ ostream_iterator& operator++(int);
 *Returns:* `*this`.
 ### Class template `istreambuf_iterator` <a id="istreambuf.iterator">[[istreambuf.iterator]]</a>
 The class template `istreambuf_iterator` defines an input iterator
 [[input.iterators]] that reads successive *characters* from the
 streambuf for which it was constructed. `operator*` provides access to
 the current input character, if any. Each time `operator++` is
 evaluated, the iterator advances to the next input character. If the end
@@ -4388,10 +5012,11 @@ namespace std {
     using traits_type       = traits;
     using int_type          = typename traits::int_type;
     using streambuf_type    = basic_streambuf<charT,traits>;
     using istream_type      = basic_istream<charT,traits>;
     class proxy;                          // exposition only
     constexpr istreambuf_iterator() noexcept;
     constexpr istreambuf_iterator(default_sentinel_t) noexcept;
     istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
@@ -4513,10 +5138,12 @@ friend bool operator==(const istreambuf_iterator& i, default_sentinel_t s);
 *Returns:* `i.equal(s)`.
 ### Class template `ostreambuf_iterator` <a id="ostreambuf.iterator">[[ostreambuf.iterator]]</a>
 The class template `ostreambuf_iterator` writes successive *characters*
 onto the output stream from which it was constructed.
 ``` cpp
 namespace std {
@@ -4531,22 +5158,21 @@ namespace std {
     using char_type         = charT;
     using traits_type       = traits;
     using streambuf_type    = basic_streambuf<charT,traits>;
     using ostream_type      = basic_ostream<charT,traits>;
-    constexpr ostreambuf_iterator() noexcept = default;
     ostreambuf_iterator(ostream_type& s) noexcept;
     ostreambuf_iterator(streambuf_type* s) noexcept;
     ostreambuf_iterator& operator=(charT c);
     ostreambuf_iterator& operator*();
     ostreambuf_iterator& operator++();
     ostreambuf_iterator& operator++(int);
     bool failed() const noexcept;
   private:
-    streambuf_type* sbuf_ = nullptr; // exposition only
   };
 }
 ```
 #### Constructors <a id="ostreambuf.iter.cons">[[ostreambuf.iter.cons]]</a>
@@ -4603,12 +5229,11 @@ bool failed() const noexcept;
 In addition to being available via inclusion of the `<iterator>` header,
 the function templates in [[iterator.range]] are available when any of
 the following headers are included: `<array>`, `<deque>`,
 `<forward_list>`, `<list>`, `<map>`, `<regex>`, `<set>`, `<span>`,
 `<string>`, `<string_view>`, `<unordered_map>`, `<unordered_set>`, and
-`<vector>`. Each of these templates is a designated customization point
-[[namespace.std]].
 ``` cpp
 template<class C> constexpr auto begin(C& c) -> decltype(c.begin());
 template<class C> constexpr auto begin(const C& c) -> decltype(c.begin());
 ```
@@ -4781,20 +5406,26 @@ template<class E> constexpr const E* data(initializer_list<E> il) noexcept;
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.lval]: expr.md#basic.lval
 [bidirectional.iterators]: #bidirectional.iterators
 [bidirectionaliterator]: #bidirectionaliterator
 [common.iter.access]: #common.iter.access
 [common.iter.cmp]: #common.iter.cmp
 [common.iter.const]: #common.iter.const
 [common.iter.cust]: #common.iter.cust
 [common.iter.nav]: #common.iter.nav
 [common.iter.types]: #common.iter.types
 [common.iterator]: #common.iterator
 [concept.swappable]: concepts.md#concept.swappable
-[concept.totallyordered]: concepts.md#concept.totallyordered
 [concepts.object]: concepts.md#concepts.object
 [containers]: containers.md#containers
 [counted.iter.access]: #counted.iter.access
 [counted.iter.cmp]: #counted.iter.cmp
 [counted.iter.const]: #counted.iter.const
 [counted.iter.cust]: #counted.iter.cust
@@ -4802,12 +5433,13 @@ template<class E> constexpr const E* data(initializer_list<E> il) noexcept;
 [counted.iter.nav]: #counted.iter.nav
 [counted.iterator]: #counted.iterator
 [cpp17.copyassignable]: #cpp17.copyassignable
 [cpp17.equalitycomparable]: #cpp17.equalitycomparable
 [customization.point.object]: library.md#customization.point.object
-[default.sentinels]: #default.sentinels
-[defns.projection]: library.md#defns.projection
 [expr.call]: expr.md#expr.call
 [expr.const]: expr.md#expr.const
 [forward.iterators]: #forward.iterators
 [forwarditerator]: #forwarditerator
 [front.insert.iter.ops]: #front.insert.iter.ops
@@ -4816,22 +5448,26 @@ template<class E> constexpr const E* data(initializer_list<E> il) noexcept;
 [func.def]: utilities.md#func.def
 [incrementable.traits]: #incrementable.traits
 [indirectcallable]: #indirectcallable
 [indirectcallable.general]: #indirectcallable.general
 [indirectcallable.indirectinvocable]: #indirectcallable.indirectinvocable
 [input.iterators]: #input.iterators
 [inputiterator]: #inputiterator
 [insert.iter.ops]: #insert.iter.ops
 [insert.iterator]: #insert.iterator
 [insert.iterators]: #insert.iterators
 [inserter]: #inserter
 [iostream.format]: input.md#iostream.format
 [istream.iterator]: #istream.iterator
 [istream.iterator.cons]: #istream.iterator.cons
 [istream.iterator.ops]: #istream.iterator.ops
 [istreambuf.iterator]: #istreambuf.iterator
 [istreambuf.iterator.cons]: #istreambuf.iterator.cons
 [istreambuf.iterator.ops]: #istreambuf.iterator.ops
 [istreambuf.iterator.proxy]: #istreambuf.iterator.proxy
 [iterator]: #iterator
 [iterator.assoc.types]: #iterator.assoc.types
 [iterator.concept.bidir]: #iterator.concept.bidir
@@ -4848,16 +5484,18 @@ template<class E> constexpr const E* data(initializer_list<E> il) noexcept;
 [iterator.concept.winc]: #iterator.concept.winc
 [iterator.concept.writable]: #iterator.concept.writable
 [iterator.concepts]: #iterator.concepts
 [iterator.concepts.general]: #iterator.concepts.general
 [iterator.cpp17]: #iterator.cpp17
 [iterator.cust]: #iterator.cust
 [iterator.cust.move]: #iterator.cust.move
 [iterator.cust.swap]: #iterator.cust.swap
 [iterator.iterators]: #iterator.iterators
 [iterator.operations]: #iterator.operations
 [iterator.primitives]: #iterator.primitives
 [iterator.range]: #iterator.range
 [iterator.requirements]: #iterator.requirements
 [iterator.requirements.general]: #iterator.requirements.general
 [iterator.synopsis]: #iterator.synopsis
 [iterator.traits]: #iterator.traits
@@ -4875,19 +5513,23 @@ template<class E> constexpr const E* data(initializer_list<E> il) noexcept;
 [move.iter.op.comp]: #move.iter.op.comp
 [move.iter.op.conv]: #move.iter.op.conv
 [move.iter.requirements]: #move.iter.requirements
 [move.iterator]: #move.iterator
 [move.iterators]: #move.iterators
 [move.sent.ops]: #move.sent.ops
 [move.sentinel]: #move.sentinel
 [namespace.std]: library.md#namespace.std
 [ostream.iterator]: #ostream.iterator
 [ostream.iterator.cons.des]: #ostream.iterator.cons.des
 [ostream.iterator.ops]: #ostream.iterator.ops
 [ostreambuf.iter.cons]: #ostreambuf.iter.cons
 [ostreambuf.iter.ops]: #ostreambuf.iter.ops
 [ostreambuf.iterator]: #ostreambuf.iterator
 [output.iterators]: #output.iterators
 [outputiterator]: #outputiterator
 [predef.iterators]: #predef.iterators
 [projected]: #projected
 [random.access.iterators]: #random.access.iterators
@@ -4896,10 +5538,11 @@ template<class E> constexpr const E* data(initializer_list<E> il) noexcept;
 [range.iter.op.advance]: #range.iter.op.advance
 [range.iter.op.distance]: #range.iter.op.distance
 [range.iter.op.next]: #range.iter.op.next
 [range.iter.op.prev]: #range.iter.op.prev
 [range.iter.ops]: #range.iter.ops
 [ranges]: ranges.md#ranges
 [readable.traits]: #readable.traits
 [reverse.iter.cmp]: #reverse.iter.cmp
 [reverse.iter.cons]: #reverse.iter.cons
 [reverse.iter.conv]: #reverse.iter.conv
@@ -4907,22 +5550,23 @@ template<class E> constexpr const E* data(initializer_list<E> il) noexcept;
 [reverse.iter.nav]: #reverse.iter.nav
 [reverse.iter.nonmember]: #reverse.iter.nonmember
 [reverse.iter.requirements]: #reverse.iter.requirements
 [reverse.iterator]: #reverse.iterator
 [reverse.iterators]: #reverse.iterators
 [std.iterator.tags]: #std.iterator.tags
 [stream.buffers]: input.md#stream.buffers
 [stream.iterators]: #stream.iterators
 [swappable.requirements]: library.md#swappable.requirements
 [temp.deduct]: temp.md#temp.deduct
 [temp.func.order]: temp.md#temp.func.order
 [temp.inst]: temp.md#temp.inst
 [unreachable.sentinel]: #unreachable.sentinel
-[unreachable.sentinels]: #unreachable.sentinels
 [utility.arg.requirements]: library.md#utility.arg.requirements
-[^1]: The sentinel denoting the end of a range may have the same type as
     the iterator denoting the beginning of the range, or a different
     type.
 [^2]: This definition applies to pointers, since pointers are iterators.
     The effect of dereferencing an iterator that has been invalidated is

       { *t } -> can-reference;  // not required to be equality-preserving
     };
   // [iterator.assoc.types], associated types
   // [incrementable.traits], incrementable traits
+  template<class> struct incrementable_traits;                                      // freestanding
   template<class T>
+    using iter_difference_t = see below;                                            // freestanding
   // [readable.traits], indirectly readable traits
+  template<class> struct indirectly_readable_traits;                                // freestanding
   template<class T>
+    using iter_value_t = see below;                                                 // freestanding
   // [iterator.traits], iterator traits
+  template<class I> struct iterator_traits;                                         // freestanding
+  template<class T> requires is_object_v<T> struct iterator_traits<T*>;             // freestanding
   template<dereferenceable T>
+    using iter_reference_t = decltype(*declval<T&>());                              // freestanding
   namespace ranges {
+    // [iterator.cust], customization point objects
     inline namespace unspecified {
       // [iterator.cust.move], ranges::iter_move
+      inline constexpr unspecified iter_move = unspecified;                         // freestanding
       // [iterator.cust.swap], ranges::iter_swap
+      inline constexpr unspecified iter_swap = unspecified;                         // freestanding
     }
   }
   template<dereferenceable T>
     requires requires(T& t) {
       { ranges::iter_move(t) } -> can-reference;
     }
+  using iter_rvalue_reference_t                                                     // freestanding
     = decltype(ranges::iter_move(declval<T&>()));
   // [iterator.concepts], iterator concepts
   // [iterator.concept.readable], concept indirectly_readable
   template<class In>
+    concept indirectly_readable = see below;                                        // freestanding
   template<indirectly_readable T>
+    using indirect-value-t = see below;         // exposition only
+  template<indirectly_readable T>
+    using iter_common_reference_t =                                                 // freestanding
+      common_reference_t<iter_reference_t<T>, indirect-value-t<T>>;
   // [iterator.concept.writable], concept indirectly_writable
   template<class Out, class T>
+    concept indirectly_writable = see below;                                        // freestanding
   // [iterator.concept.winc], concept weakly_incrementable
   template<class I>
+    concept weakly_incrementable = see below;                                       // freestanding
   // [iterator.concept.inc], concept incrementable
   template<class I>
+    concept incrementable = see below;                                              // freestanding
   // [iterator.concept.iterator], concept input_or_output_iterator
   template<class I>
+    concept input_or_output_iterator = see below;                                   // freestanding
   // [iterator.concept.sentinel], concept sentinel_for
   template<class S, class I>
+    concept sentinel_for = see below;                                               // freestanding
   // [iterator.concept.sizedsentinel], concept sized_sentinel_for
   template<class S, class I>
+    constexpr bool disable_sized_sentinel_for = false;                              // freestanding
   template<class S, class I>
+    concept sized_sentinel_for = see below;                                         // freestanding
   // [iterator.concept.input], concept input_iterator
   template<class I>
+    concept input_iterator = see below;                                             // freestanding
   // [iterator.concept.output], concept output_iterator
   template<class I, class T>
+    concept output_iterator = see below;                                            // freestanding
   // [iterator.concept.forward], concept forward_iterator
   template<class I>
+    concept forward_iterator = see below;                                           // freestanding
   // [iterator.concept.bidir], concept bidirectional_iterator
   template<class I>
+    concept bidirectional_iterator = see below;                                     // freestanding
   // [iterator.concept.random.access], concept random_access_iterator
   template<class I>
+    concept random_access_iterator = see below;                                     // freestanding
   // [iterator.concept.contiguous], concept contiguous_iterator
   template<class I>
+    concept contiguous_iterator = see below;                                        // freestanding
   // [indirectcallable], indirect callable requirements
   // [indirectcallable.indirectinvocable], indirect callables
   template<class F, class I>
+    concept indirectly_unary_invocable = see below;                                 // freestanding
   template<class F, class I>
+    concept indirectly_regular_unary_invocable = see below;                         // freestanding
   template<class F, class I>
+    concept indirect_unary_predicate = see below;                                   // freestanding
   template<class F, class I1, class I2>
+    concept indirect_binary_predicate = see below;                                  // freestanding
   template<class F, class I1, class I2 = I1>
+    concept indirect_equivalence_relation = see below;                              // freestanding
   template<class F, class I1, class I2 = I1>
+    concept indirect_strict_weak_order = see below;                                 // freestanding
   template<class F, class... Is>
     requires (indirectly_readable<Is> && ...) && invocable<F, iter_reference_t<Is>...>
+      using indirect_result_t = invoke_result_t<F, iter_reference_t<Is>...>;        // freestanding
   // [projected], projected
   template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>
+    struct projected;                                                               // freestanding
   template<weakly_incrementable I, class Proj>
+    struct incrementable_traits<projected<I, Proj>>;                                // freestanding
   // [alg.req], common algorithm requirements
   // [alg.req.ind.move], concept indirectly_movable
   template<class In, class Out>
+    concept indirectly_movable = see below;                                         // freestanding
   template<class In, class Out>
+    concept indirectly_movable_storable = see below;                                // freestanding
   // [alg.req.ind.copy], concept indirectly_copyable
   template<class In, class Out>
+    concept indirectly_copyable = see below;                                        // freestanding
   template<class In, class Out>
+    concept indirectly_copyable_storable = see below;                               // freestanding
   // [alg.req.ind.swap], concept indirectly_swappable
   template<class I1, class I2 = I1>
+    concept indirectly_swappable = see below;                                       // freestanding
   // [alg.req.ind.cmp], concept indirectly_comparable
   template<class I1, class I2, class R, class P1 = identity, class P2 = identity>
+    concept indirectly_comparable = see below;                                      // freestanding
   // [alg.req.permutable], concept permutable
   template<class I>
+    concept permutable = see below;                                                 // freestanding
   // [alg.req.mergeable], concept mergeable
   template<class I1, class I2, class Out,
       class R = ranges::less, class P1 = identity, class P2 = identity>
+    concept mergeable = see below;                                                  // freestanding
   // [alg.req.sortable], concept sortable
   template<class I, class R = ranges::less, class P = identity>
+    concept sortable = see below;                                                   // freestanding
   // [iterator.primitives], primitives
   // [std.iterator.tags], iterator tags
+  struct input_iterator_tag { };                                                    // freestanding
+  struct output_iterator_tag { };                                                   // freestanding
+  struct forward_iterator_tag: public input_iterator_tag { };                       // freestanding
+  struct bidirectional_iterator_tag: public forward_iterator_tag { };               // freestanding
+  struct random_access_iterator_tag: public bidirectional_iterator_tag { };         // freestanding
+  struct contiguous_iterator_tag: public random_access_iterator_tag { };            // freestanding
   // [iterator.operations], iterator operations
   template<class InputIterator, class Distance>
     constexpr void
+      advance(InputIterator& i, Distance n);                                        // freestanding
   template<class InputIterator>
     constexpr typename iterator_traits<InputIterator>::difference_type
+      distance(InputIterator first, InputIterator last);                            // freestanding
   template<class InputIterator>
     constexpr InputIterator
+      next(InputIterator x,                                                         // freestanding
            typename iterator_traits<InputIterator>::difference_type n = 1);
   template<class BidirectionalIterator>
     constexpr BidirectionalIterator
+      prev(BidirectionalIterator x,                                                 // freestanding
            typename iterator_traits<BidirectionalIterator>::difference_type n = 1);
   // [range.iter.ops], range iterator operations
   namespace ranges {
     // [range.iter.op.advance], ranges::advance
     template<input_or_output_iterator I>
+      constexpr void advance(I& i, iter_difference_t<I> n);                         // freestanding
     template<input_or_output_iterator I, sentinel_for<I> S>
+      constexpr void advance(I& i, S bound);                                        // freestanding
     template<input_or_output_iterator I, sentinel_for<I> S>
+      constexpr iter_difference_t<I> advance(I& i, iter_difference_t<I> n,          // freestanding
+                                             S bound);
     // [range.iter.op.distance], ranges::distance
+    template<class I, sentinel_for<I> S>
+ requires (!sized_sentinel_for<S, I>)
+      constexpr iter_difference_t<I> distance(I first, S last);                     // freestanding
+    template<class I, sized_sentinel_for<decay_t<I>> S>
+      constexpr iter_difference_t<decay_t<I>> distance(I&& first, S last);          // freestanding
     template<range R>
+      constexpr range_difference_t<R> distance(R&& r);                              // freestanding
     // [range.iter.op.next], ranges::next
     template<input_or_output_iterator I>
+      constexpr I next(I x);                                                        // freestanding
     template<input_or_output_iterator I>
+      constexpr I next(I x, iter_difference_t<I> n);                                // freestanding
     template<input_or_output_iterator I, sentinel_for<I> S>
+      constexpr I next(I x, S bound);                                               // freestanding
     template<input_or_output_iterator I, sentinel_for<I> S>
+      constexpr I next(I x, iter_difference_t<I> n, S bound);                       // freestanding
     // [range.iter.op.prev], ranges::prev
     template<bidirectional_iterator I>
+      constexpr I prev(I x);                                                        // freestanding
     template<bidirectional_iterator I>
+      constexpr I prev(I x, iter_difference_t<I> n);                                // freestanding
     template<bidirectional_iterator I>
+      constexpr I prev(I x, iter_difference_t<I> n, I bound);                       // freestanding
   }
   // [predef.iterators], predefined iterators and sentinels
   // [reverse.iterators], reverse iterators
+  template<class Iterator> class reverse_iterator;                                  // freestanding
   template<class Iterator1, class Iterator2>
+    constexpr bool operator==(                                                      // freestanding
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template<class Iterator1, class Iterator2>
+    constexpr bool operator!=(                                                      // freestanding
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template<class Iterator1, class Iterator2>
+    constexpr bool operator<(                                                       // freestanding
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template<class Iterator1, class Iterator2>
+    constexpr bool operator>(                                                       // freestanding
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template<class Iterator1, class Iterator2>
+    constexpr bool operator<=(                                                      // freestanding
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template<class Iterator1, class Iterator2>
+    constexpr bool operator>=(                                                      // freestanding
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y);
   template<class Iterator1, three_way_comparable_with<Iterator1> Iterator2>
     constexpr compare_three_way_result_t<Iterator1, Iterator2>
+      operator<=>(const reverse_iterator<Iterator1>& x,                             // freestanding
                   const reverse_iterator<Iterator2>& y);
   template<class Iterator1, class Iterator2>
+    constexpr auto operator-(                                                       // freestanding
       const reverse_iterator<Iterator1>& x,
       const reverse_iterator<Iterator2>& y) -> decltype(y.base() - x.base());
   template<class Iterator>
+    constexpr reverse_iterator<Iterator> operator+(                                 // freestanding
+ iter_difference_t<Iterator> n,
       const reverse_iterator<Iterator>& x);
   template<class Iterator>
+    constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i);         // freestanding
   template<class Iterator1, class Iterator2>
       requires (!sized_sentinel_for<Iterator1, Iterator2>)
+    constexpr bool disable_sized_sentinel_for<reverse_iterator<Iterator1>,          // freestanding
                                                      reverse_iterator<Iterator2>> = true;
   // [insert.iterators], insert iterators
+  template<class Container> class back_insert_iterator;                             // freestanding
   template<class Container>
+    constexpr back_insert_iterator<Container> back_inserter(Container& x);          // freestanding
+  template<class Container> class front_insert_iterator;                            // freestanding
   template<class Container>
+    constexpr front_insert_iterator<Container> front_inserter(Container& x);        // freestanding
+  template<class Container> class insert_iterator;                                  // freestanding
   template<class Container>
     constexpr insert_iterator<Container>
+      inserter(Container& x, ranges::iterator_t<Container> i);                      // freestanding
+  // [const.iterators], constant iterators and sentinels
+  // [const.iterators.alias], alias templates
+  template<indirectly_readable I>
+    using iter_const_reference_t = see below;                                       // freestanding
+  template<class Iterator>
+    concept constant-iterator = see below; // exposition only
+  template<input_iterator I>
+    using const_iterator = see below;                                               // freestanding
+  template<semiregular S>
+    using const_sentinel = see below;                                               // freestanding
+  // [const.iterators.iterator], class template basic_const_iterator
+  template<input_iterator Iterator>
+    class basic_const_iterator;                                                     // freestanding
+  template<class T, common_with<T> U>
+    requires input_iterator<common_type_t<T, U>>
+  struct common_type<basic_const_iterator<T>, U> {                                  // freestanding
+    using type = basic_const_iterator<common_type_t<T, U>>;
+  };
+  template<class T, common_with<T> U>
+    requires input_iterator<common_type_t<T, U>>
+  struct common_type<U, basic_const_iterator<T>> {                                  // freestanding
+    using type = basic_const_iterator<common_type_t<T, U>>;
+  };
+  template<class T, common_with<T> U>
+    requires input_iterator<common_type_t<T, U>>
+  struct common_type<basic_const_iterator<T>, basic_const_iterator<U>> {            // freestanding
+    using type = basic_const_iterator<common_type_t<T, U>>;
+  };
+  template<input_iterator I>
+    constexpr const_iterator<I> make_const_iterator(I it) { return it; }            // freestanding
+  template<semiregular S>
+    constexpr const_sentinel<S> make_const_sentinel(S s) { return s; }              // freestanding
   // [move.iterators], move iterators and sentinels
+  template<class Iterator> class move_iterator;                                     // freestanding
   template<class Iterator1, class Iterator2>
+    constexpr bool operator==(                                                      // freestanding
       const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
   template<class Iterator1, class Iterator2>
+    constexpr bool operator<(                                                       // freestanding
       const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
   template<class Iterator1, class Iterator2>
+    constexpr bool operator>(                                                       // freestanding
       const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
   template<class Iterator1, class Iterator2>
+    constexpr bool operator<=(                                                      // freestanding
       const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
   template<class Iterator1, class Iterator2>
+    constexpr bool operator>=(                                                      // freestanding
       const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
   template<class Iterator1, three_way_comparable_with<Iterator1> Iterator2>
     constexpr compare_three_way_result_t<Iterator1, Iterator2>
+      operator<=>(const move_iterator<Iterator1>& x,                                // freestanding
                   const move_iterator<Iterator2>& y);
   template<class Iterator1, class Iterator2>
+    constexpr auto operator-(                                                       // freestanding
+ const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y)
+ -> decltype(x.base() - y.base());
   template<class Iterator>
+    constexpr move_iterator<Iterator>
+ operator+(iter_difference_t<Iterator> n, const move_iterator<Iterator>& x);   // freestanding
   template<class Iterator>
+    constexpr move_iterator<Iterator> make_move_iterator(Iterator i);               // freestanding
+  template<class Iterator1, class Iterator2>
+      requires (!sized_sentinel_for<Iterator1, Iterator2>)
+    constexpr bool disable_sized_sentinel_for<move_iterator<Iterator1>,             // freestanding
+                                              move_iterator<Iterator2>> = true;
+  template<semiregular S> class move_sentinel;                                      // freestanding
   // [iterators.common], common iterators
   template<input_or_output_iterator I, sentinel_for<I> S>
     requires (!same_as<I, S> && copyable<I>)
+      class common_iterator;                                                        // freestanding
   template<class I, class S>
+    struct incrementable_traits<common_iterator<I, S>>;                             // freestanding
   template<input_iterator I, class S>
+    struct iterator_traits<common_iterator<I, S>>;                                  // freestanding
+  // [default.sentinel], default sentinel
+  struct default_sentinel_t;                                                        // freestanding
+  inline constexpr default_sentinel_t default_sentinel{};                           // freestanding
   // [iterators.counted], counted iterators
+  template<input_or_output_iterator I> class counted_iterator;                      // freestanding
   template<input_iterator I>
+ requires see below
+    struct iterator_traits<counted_iterator<I>>;                                    // freestanding
+  // [unreachable.sentinel], unreachable sentinel
+  struct unreachable_sentinel_t;                                                    // freestanding
+  inline constexpr unreachable_sentinel_t unreachable_sentinel{};                   // freestanding
   // [stream.iterators], stream iterators
   template<class T, class charT = char, class traits = char_traits<charT>,
            class Distance = ptrdiff_t>
   class istream_iterator;
   template<class charT, class traits = char_traits<charT>>
     class ostreambuf_iterator;
   // [iterator.range], range access
+  template<class C> constexpr auto begin(C& c) -> decltype(c.begin());              // freestanding
+  template<class C> constexpr auto begin(const C& c) -> decltype(c.begin());        // freestanding
+  template<class C> constexpr auto end(C& c) -> decltype(c.end());                  // freestanding
+  template<class C> constexpr auto end(const C& c) -> decltype(c.end());            // freestanding
+  template<class T, size_t N> constexpr T* begin(T (&array)[N]) noexcept;           // freestanding
+  template<class T, size_t N> constexpr T* end(T (&array)[N]) noexcept;             // freestanding
+  template<class C> constexpr auto cbegin(const C& c)                               // freestanding
+ noexcept(noexcept(std::begin(c))) -> decltype(std::begin(c));
+  template<class C> constexpr auto cend(const C& c)                                 // freestanding
+ noexcept(noexcept(std::end(c))) -> decltype(std::end(c));
+  template<class C> constexpr auto rbegin(C& c) -> decltype(c.rbegin());            // freestanding
+  template<class C> constexpr auto rbegin(const C& c) -> decltype(c.rbegin());      // freestanding
+  template<class C> constexpr auto rend(C& c) -> decltype(c.rend());                // freestanding
+  template<class C> constexpr auto rend(const C& c) -> decltype(c.rend());          // freestanding
+  template<class T, size_t N> constexpr reverse_iterator<T*> rbegin(T (&array)[N])  // freestanding
+  template<class T, size_t N> constexpr reverse_iterator<T*> rend(T (&array)[N]);   // freestanding
+  template<class E> constexpr reverse_iterator<const E*>
+    rbegin(initializer_list<E> il);                                                 // freestanding
+  template<class E> constexpr reverse_iterator<const E*>
+    rend(initializer_list<E> il);                                                   // freestanding
+  template<class C> constexpr auto
+    crbegin(const C& c) -> decltype(std::rbegin(c));                                // freestanding
+  template<class C> constexpr auto
+    crend(const C& c) -> decltype(std::rend(c));                                    // freestanding
+  template<class C> constexpr auto
+    size(const C& c) -> decltype(c.size());                                         // freestanding
+  template<class T, size_t N> constexpr size_t
+ size(const T (&array)[N]) noexcept;                                             // freestanding
+  template<class C> constexpr auto
+    ssize(const C& c)
+      -> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>;               // freestanding
+  template<class T, ptrdiff_t N> constexpr ptrdiff_t
+    ssize(const T (&array)[N]) noexcept;                                            // freestanding
+  template<class C> [[nodiscard]] constexpr auto
+    empty(const C& c) -> decltype(c.empty());                                       // freestanding
+  template<class T, size_t N> [[nodiscard]] constexpr bool
+    empty(const T (&array)[N]) noexcept;                                            // freestanding
+  template<class E> [[nodiscard]] constexpr bool
+    empty(initializer_list<E> il) noexcept;                                         // freestanding
+  template<class C> constexpr auto data(C& c) -> decltype(c.data());                // freestanding
+  template<class C> constexpr auto data(const C& c) -> decltype(c.data());          // freestanding
+  template<class T, size_t N> constexpr T* data(T (&array)[N]) noexcept;            // freestanding
+  template<class E> constexpr const E* data(initializer_list<E> il) noexcept;       // freestanding
 }
 ```
 ## Iterator requirements <a id="iterator.requirements">[[iterator.requirements]]</a>
 The six categories of iterators correspond to the iterator concepts
 - `input_iterator` [[iterator.concept.input]],
 - `output_iterator` [[iterator.concept.output]],
 - `forward_iterator` [[iterator.concept.forward]],
+- `bidirectional_iterator` [[iterator.concept.bidir]],
 - `random_access_iterator` [[iterator.concept.random.access]], and
 - `contiguous_iterator` [[iterator.concept.contiguous]],
 respectively. The generic term *iterator* refers to any type that models
 the `input_or_output_iterator` concept [[iterator.concept.iterator]].
 type there is an iterator value that points past the last element of a
 corresponding sequence. Such a value is called a *past-the-end value*.
 Values of an iterator `i` for which the expression `*i` is defined are
 called *dereferenceable*. The library never assumes that past-the-end
 values are dereferenceable. Iterators can also have singular values that
+are not associated with any sequence. Results of most expressions are
+undefined for singular values; the only exceptions are destroying an
+iterator that holds a singular value, the assignment of a non-singular
+value to an iterator that holds a singular value, and, for iterators
+that meet the *Cpp17DefaultConstructible* requirements, using a
+value-initialized iterator as the source of a copy or move operation.
 [*Note 2*: This guarantee is not offered for default-initialization,
 although the distinction only matters for types with trivial default
 constructors such as pointers or aggregates holding
 pointers. — *end note*]
 first iterator `j` such that `j == s`.
 A sentinel `s` is called *reachable from* an iterator `i` if and only if
 there is a finite sequence of applications of the expression `++i` that
 makes `i == s`. If `s` is reachable from `i`, \[`i`, `s`) denotes a
+*valid range*.
 A *counted range* `i`+\[0, `n`) is empty if `n == 0`; otherwise,
 `i`+\[0, `n`) refers to the `n` elements in the data structure starting
 with the element pointed to by `i` and up to but not including the
 element, if any, pointed to by the result of `n` applications of `++i`.
+A counted range `i`+\[0, `n`) is *valid* if and only if `n == 0`; or `n`
+is positive, `i` is dereferenceable, and `++i`+\[0, `–n`) is valid.
 The result of the application of library functions to invalid ranges is
 undefined.
 All the categories of iterators require only those functions that are
   requires is_object_v<T>
 struct cond-value-type<T> {
   using value_type = remove_cv_t<T>;
 };
+template<class T>
+  concept has-member-value-type = requires { typename T::value_type; };         // exposition only
+template<class T>
+  concept has-member-element-type = requires { typename T::element_type; };     // exposition only
 template<class> struct indirectly_readable_traits { };
 template<class T>
 struct indirectly_readable_traits<T*>
   : cond-value-type<T> { };
 template<class I>
 struct indirectly_readable_traits<const I>
   : indirectly_readable_traits<I> { };
+template<has-member-value-type T>
 struct indirectly_readable_traits<T>
   : cond-value-type<typename T::value_type> { };
+template<has-member-element-type T>
 struct indirectly_readable_traits<T>
   : cond-value-type<typename T::element_type> { };
+template<has-member-value-type T>
+  requires has-member-element-type<T>
+struct indirectly_readable_traits<T> { };
+template<has-member-value-type T>
+  requires has-member-element-type<T> &&
+           same_as<remove_cv_t<typename T::element_type>, remove_cv_t<typename T::value_type>>
+struct indirectly_readable_traits<T>
+  : cond-value-type<typename T::value_type> { };
 template<class T> using iter_value_t = see below;
 ```
 Let R_`I` be `remove_cvref_t<I>`. The type `iter_value_t<I>` denotes
 exposition-only concepts:
 ``` cpp
 template<class I>
 concept cpp17-iterator =
+  requires(I i) {
     {   *i } -> can-reference;
     {  ++i } -> same_as<I&>;
     { *i++ } -> can-reference;
+  } && copyable<I>;
 template<class I>
 concept cpp17-input-iterator =
   cpp17-iterator<I> && equality_comparable<I> && requires(I i) {
     typename incrementable_traits<I>::difference_type;
   };
 template<class I>
 concept cpp17-forward-iterator =
   cpp17-input-iterator<I> && constructible_from<I> &&
+ is_reference_v<iter_reference_t<I>> &&
   same_as<remove_cvref_t<iter_reference_t<I>>,
           typename indirectly_readable_traits<I>::value_type> &&
   requires(I i) {
     {  i++ } -> convertible_to<const I&>;
     { *i++ } -> same_as<iter_reference_t<I>>;
 Explicit or partial specializations of `iterator_traits` may have a
 member type `iterator_concept` that is used to indicate conformance to
 the iterator concepts [[iterator.concepts]].
+[*Example 1*: To indicate conformance to the `input_iterator` concept
+but a lack of conformance to the *Cpp17InputIterator* requirements
+[[input.iterators]], an `iterator_traits` specialization might have
+`iterator_concept` denote `input_iterator_tag` but not define
+`iterator_category`. — *end example*]
 `iterator_traits` is specialized for pointers as
 ``` cpp
 namespace std {
   template<class T>
     using reference         = T&;
   };
 }
 ```
+[*Example 2*:
 To implement a generic `reverse` function, a C++ program can do the
 following:
 ``` cpp
 }
 ```
 — *end example*]
+### Customization point objects <a id="iterator.cust">[[iterator.cust]]</a>
 #### `ranges::iter_move` <a id="iterator.cust.move">[[iterator.cust.move]]</a>
 The name `ranges::iter_move` denotes a customization point object
 [[customization.point.object]]. The expression `ranges::iter_move(E)`
 for a subexpression `E` is expression-equivalent to:
 - `iter_move(E)`, if `E` has class or enumeration type and
   `iter_move(E)` is a well-formed expression when treated as an
+  unevaluated operand, where the meaning of `iter_move` is established
+ as-if by performing argument-dependent lookup only
+ [[basic.lookup.argdep]].
 - Otherwise, if the expression `*E` is well-formed:
   - if `*E` is an lvalue, `std::move(*E)`;
   - otherwise, `*E`.
 - Otherwise, `ranges::iter_move(E)` is ill-formed. \[*Note 1*: This case
   can result in substitution failure when `ranges::iter_move(E)` appears
   and does not include a declaration of `ranges::iter_swap`. If the
   function selected by overload resolution does not exchange the values
   denoted by `E1` and `E2`, the program is ill-formed, no diagnostic
   required.
+  \[*Note 1*: This precludes calling unconstrained `std::iter_swap`.
+  When the deleted overload is viable, program-defined overloads need to
+  be more specialized [[temp.func.order]] to be selected. — *end note*]
 - Otherwise, if the types of `E1` and `E2` each model
   `indirectly_readable`, and if the reference types of `E1` and `E2`
   model `swappable_with` [[concept.swappable]], then
   `ranges::swap(*E1, *E2)`.
 - Otherwise, if the types `T1` and `T2` of `E1` and `E2` model
   `indirectly_movable_storable<T1, T2>` and
   `indirectly_movable_storable<T2, T1>`, then
   `(void)(*E1 = iter-exchange-move(E2, E1))`, except that `E1` is
   evaluated only once.
+- Otherwise, `ranges::iter_swap(E1, E2)` is ill-formed. \[*Note 2*: This
   case can result in substitution failure when
   `ranges::iter_swap(E1, E2)` appears in the immediate context of a
   template instantiation. — *end note*]
 ### Iterator concepts <a id="iterator.concepts">[[iterator.concepts]]</a>
   I operator++(int);
   I& operator--();
   I operator--(int);
   bool operator==(I) const;
 };
 ```
 `iterator_traits<I>::iterator_category` denotes `input_iterator_tag`,
 and `ITER_CONCEPT(I)` denotes `random_access_iterator_tag`.
 ```
 Given a value `i` of type `I`, `I` models `indirectly_readable` only if
 the expression `*i` is equality-preserving.
 #### Concept  <a id="iterator.concept.writable">[[iterator.concept.writable]]</a>
 The `indirectly_writable` concept specifies the requirements for writing
 a value into an iterator’s referenced object.
 Let `E` be an expression such that `decltype((E))` is `T`, and let `o`
 be a dereferenceable object of type `Out`. `Out` and `T` model
 `indirectly_writable<Out, T>` only if
 - If `Out` and `T` model
+  `indirectly_readable<Out> && same_as<iter_value_t<Out>, decay_t<T>>`,
   then `*o` after any above assignment is equal to the value of `E`
   before the assignment.
 After evaluating any above assignment expression, `o` is not required to
 be dereferenceable.
 increment operations are not required to be equality-preserving, nor is
 the type required to be `equality_comparable`.
 ``` cpp
 template<class T>
+  constexpr bool is-integer-like = see below; // exposition only
 template<class T>
+  constexpr bool is-signed-integer-like = see below; // exposition only
 template<class I>
   concept weakly_incrementable =
+    movable<I> &&
     requires(I i) {
       typename iter_difference_t<I>;
       requires is-signed-integer-like<iter_difference_t<I>>;
       { ++i } -> same_as<I&>;   // not required to be equality-preserving
       i++;                      // not required to be equality-preserving
     };
 ```
 A type `I` is an *integer-class type* if it is in a set of
+*implementation-defined* types that behave as integer types do, as
+defined below.
+[*Note 1*: An integer-class type is not necessarily a class
+type. — *end note*]
 The range of representable values of an integer-class type is the
+continuous set of values over which it is defined. For any integer-class
+type, its range of representable values is either -2ᴺ⁻¹ to 2ᴺ⁻¹-1
+(inclusive) for some integer N, in which case it is a
+*signed-integer-class type*, or 0 to 2ᴺ-1 (inclusive) for some integer
+N, in which case it is an *unsigned-integer-class type*. In both cases,
+N is called the *width* of the integer-class type. The width of an
+integer-class type is greater than that of every integral type of the
+same signedness.
+A type `I` other than cv `bool` is *integer-like* if it models
+`integral<I>` or if it is an integer-class type. An integer-like type
+`I` is *signed-integer-like* if it models `signed_integral<I>` or if it
+is a signed-integer-class type. An integer-like type `I` is
+*unsigned-integer-like* if it models `unsigned_integral<I>` or if it is
+an unsigned-integer-class type.
+For every integer-class type `I`, let `B(I)` be a unique hypothetical
+extended integer type of the same signedness with the same width
+[[basic.fundamental]] as `I`.
+[*Note 2*: The corresponding hypothetical specialization
+`numeric_limits<B(I)>` meets the requirements on `numeric_limits`
+specializations for integral types [[numeric.limits]]. — *end note*]
+For every integral type `J`, let `B(J)` be the same type as `J`.
+Expressions of integer-class type are explicitly convertible to any
+integer-like type, and implicitly convertible to any integer-class type
+of equal or greater width and the same signedness. Expressions of
+integral type are both implicitly and explicitly convertible to any
+integer-class type. Conversions between integral and integer-class types
+and between two integer-class types do not exit via an exception. The
+result of such a conversion is the unique value of the destination type
+that is congruent to the source modulo 2ᴺ, where N is the width of the
+destination type.
+Let `a` be an object of integer-class type `I`, let `b` be an object of
+integer-like type `I2` such that the expression `b` is implicitly
+convertible to `I`, let `x` and `y` be, respectively, objects of type
+`B(I)` and `B(I2)` as described above that represent the same values as
+`a` and `b`, and let `c` be an lvalue of any integral type.
+- The expressions `a++` and `a--` shall be prvalues of type `I` whose
+  values are equal to that of `a` prior to the evaluation of the
+  expressions. The expression `a++` shall modify the value of `a` by
+  adding `1` to it. The expression `a--` shall modify the value of `a`
+  by subtracting `1` from it.
+- The expressions `++a`, `--a`, and `&a` shall be expression-equivalent
+  to `a += 1`, `a -= 1`, and `addressof(a)`, respectively.
+- For every *unary-operator* `@` other than `&` for which the expression
+  `@x` is well-formed, `@a` shall also be well-formed and have the same
+  value, effects, and value category as `@x`. If `@x` has type `bool`,
+  so too does `@a`; if `@x` has type `B(I)`, then `@a` has type `I`.
 - For every assignment operator `@=` for which `c @= x` is well-formed,
   `c @= a` shall also be well-formed and shall have the same value and
   effects as `c @= x`. The expression `c @= a` shall be an lvalue
   referring to `c`.
+- For every assignment operator `@=` for which `x @= y` is well-formed,
+  `a @= b` shall also be well-formed and shall have the same effects as
+  `x @= y`, except that the value that would be stored into `x` is
+ stored into `a`. The expression `a @= b` shall be an lvalue referring
+ to `a`.
+- For every non-assignment binary operator `@` for which `x @ y` and
+  `y @ x` are well-formed, `a @ b` and `b @ a` shall also be well-formed
+  and shall have the same value, effects, and value category as `x @ y`
+  and `y @ x`, respectively. If `x @ y` or `y @ x` has type `B(I)`, then
+  `a @ b` or `b @ a`, respectively, has type `I`; if `x @ y` or `y @ x`
+  has type `B(I2)`, then `a @ b` or `b @ a`, respectively, has type
+  `I2`; if `x @ y` or `y @ x` has any other type, then `a @ b` or
+  `b @ a`, respectively, has that type.
 An expression `E` of integer-class type `I` is contextually convertible
 to `bool` as if by `bool(E != I(0))`.
 All integer-class types model `regular` [[concepts.object]] and
+`three_way_comparable<strong_ordering>` [[cmp.concept]].
 A value-initialized object of integer-class type has value 0.
 For every (possibly cv-qualified) integer-class type `I`,
+`numeric_limits<I>` is specialized such that each static data member `m`
+has the same value as `numeric_limits<B(I)>::m`, and each static member
+function `f` returns `I(numeric_limits<B(I)>::f())`.
+For any two integer-like types `I1` and `I2`, at least one of which is
+an integer-class type, `common_type_t<I1, I2>` denotes an integer-class
+type whose width is not less than that of `I1` or `I2`. If both `I1` and
+`I2` are signed-integer-like types, then `common_type_t<I1, I2>` is also
+a signed-integer-like type.
 `is-integer-like<I>` is `true` if and only if `I` is an integer-like
+type. `is-signed-integer-like<I>` is `true` if and only if `I` is a
 signed-integer-like type.
 Let `i` be an object of type `I`. When `i` is in the domain of both pre-
 and post-increment, `i` is said to be *incrementable*. `I` models
 `weakly_incrementable<I>` only if
 - If `i` is incrementable, then both `++i` and `i++` advance `i` to the
   next element.
 - If `i` is incrementable, then `addressof(++i)` is equal to
   `addressof(i)`.
+*Recommended practice:* The implementaton of an algorithm on a weakly
+incrementable type should never attempt to pass through the same
+incrementable value twice; such an algorithm should be a single-pass
+algorithm.
+[*Note 3*: For `weakly_incrementable` types, `a` equals `b` does not
 imply that `++a` equals `++b`. (Equality does not guarantee the
+substitution property or referential transparency.) Such algorithms can
+be used with istreams as the source of the input data through the
+`istream_iterator` class template. — *end note*]
 #### Concept  <a id="iterator.concept.inc">[[iterator.concept.inc]]</a>
 The `incrementable` concept specifies requirements on types that can be
 incremented with the pre- and post-increment operators. The increment
 concept taxonomy; every iterator models `input_or_output_iterator`. This
 concept specifies operations for dereferencing and incrementing an
 iterator. Most algorithms will require additional operations to compare
 iterators with sentinels [[iterator.concept.sentinel]], to read
 [[iterator.concept.input]] or write [[iterator.concept.output]] values,
+or to provide a richer set of iterator movements
+[[iterator.concept.forward]], [[iterator.concept.bidir]], [[iterator.concept.random.access]].
 ``` cpp
 template<class I>
   concept input_or_output_iterator =
     requires(I i) {
 ``` cpp
 template<class S, class I>
   concept sentinel_for =
     semiregular<S> &&
     input_or_output_iterator<I> &&
+    weakly-equality-comparable-with<S, I>; // see [concept.equalitycomparable]
 ```
 Let `s` and `i` be values of type `S` and `I` such that \[`i`, `s`)
 denotes a range. Types `S` and `I` model `sentinel_for<S, I>` only if
 - `i == s` is well-defined.
 - If `bool(i != s)` then `i` is dereferenceable and \[`++i`, `s`)
   denotes a range.
+- `assignable_from<I&, S>` is either modeled or not satisfied.
 The domain of `==` is not static. Given an iterator `i` and sentinel `s`
 such that \[`i`, `s`) denotes a range and `i != s`, `i` and `s` are not
 required to continue to denote a range after incrementing any other
 iterator equal to `i`. Consequently, `i == s` is no longer required to
 - If -N is representable by `iter_difference_t<I>`, then `i - s` is
   well-defined and equals -N.
 ``` cpp
 template<class S, class I>
+  constexpr bool disable_sized_sentinel_for = false;
 ```
 *Remarks:* Pursuant to [[namespace.std]], users may specialize
 `disable_sized_sentinel_for` for cv-unqualified non-array object types
 `S` and `I` if `S` and/or `I` is a program-defined type. Such
 ``` cpp
 *i = E;
 ++i;
 ```
+*Recommended practice:* The implementation of an algorithm on output
+iterators should never attempt to pass through the same iterator twice;
+such an algorithm should be a single-pass algorithm.
 #### Concept  <a id="iterator.concept.forward">[[iterator.concept.forward]]</a>
 The `forward_iterator` concept adds copyability, equality comparison,
 and the multi-pass guarantee, specified below.
 Two dereferenceable iterators `a` and `b` of type `X` offer the
 *multi-pass guarantee* if:
 - `a == b` implies `++a == ++b` and
+- the expression `((void)[](X x){++x;}(a), *a)` is equivalent to the
   expression `*a`.
 [*Note 2*: The requirement that `a == b` implies `++a == ++b` and the
 removal of the restrictions on the number of assignments through a
 mutable iterator (which applies to output iterators) allow the use of
 `a` and `c` is reachable from `b`, and let `D` be
 `iter_difference_t<I>`. The type `I` models `contiguous_iterator` only
 if
 - `to_address(a) == addressof(*a)`,
+- `to_address(b) == to_address(a) + D(b - a)`,
+- `to_address(c) == to_address(a) + D(c - a)`,
+- `ranges::iter_move(a)` has the same type, value category, and effects
+  as `std::move(*a)`, and
+- if `ranges::iter_swap(a, b)` is well-formed, it has effects equivalent
+  to `ranges::swap(*a, *b)`.
 ### C++17 iterator requirements <a id="iterator.cpp17">[[iterator.cpp17]]</a>
+#### General <a id="iterator.cpp17.general">[[iterator.cpp17.general]]</a>
 In the following sections, `a` and `b` denote values of type `X` or
 `const X`, `difference_type` and `reference` refer to the types
 `iterator_traits<X>::difference_type` and
 `iterator_traits<X>::reference`, respectively, `n` denotes a value of
 `difference_type`, `u`, `tmp`, and `m` denote identifiers, `r` denotes a
 The *Cpp17Iterator* requirements form the basis of the iterator
 taxonomy; every iterator meets the *Cpp17Iterator* requirements. This
 set of requirements specifies operations for dereferencing and
 incrementing an iterator. Most algorithms will require additional
 operations to read [[input.iterators]] or write [[output.iterators]]
+values, or to provide a richer set of iterator movements
+[[forward.iterators]], [[bidirectional.iterators]], [[random.access.iterators]].
+A type `X` meets the requirements if:
+- `X` meets the *Cpp17CopyConstructible*, *Cpp17CopyAssignable*,
+  *Cpp17Swappable*, and *Cpp17Destructible* requirements
+ [[utility.arg.requirements]], [[swappable.requirements]], and
 - `iterator_traits<X>::difference_type` is a signed integer type or
   `void`, and
 - the expressions in [[iterator]] are valid and have the indicated
   semantics.
 [*Example 1*: The call `find(a,b,x)` is defined only if the value of
 `a` has the property *p* defined as follows: `b` has property *p* and a
 value `i` has property *p* if (`*i==x`) or if (`*i!=x` and `++i` has
 property *p*). — *end example*]
+*Recommended practice:* The implementation of an algorithm on input
+iterators should never attempt to pass through the same iterator twice;
+such an algorithm should be a single pass algorithm.
 [*Note 1*: For input iterators, `a == b` does not imply `++a == ++b`.
 (Equality does not guarantee the substitution property or referential
+transparency.) Value type `T` is not required to be a
+*Cpp17CopyAssignable* type ([[cpp17.copyassignable]]). Such an
+algorithm can be used with istreams as the source of the input data
+through the `istream_iterator` class template. — *end note*]
 #### Output iterators <a id="output.iterators">[[output.iterators]]</a>
 A class or pointer type `X` meets the requirements of an output iterator
 if `X` meets the *Cpp17Iterator* requirements [[iterator.iterators]] and
 the expressions in [[outputiterator]] are valid and have the indicated
 semantics.
+*Recommended practice:* The implementation of an algorithm on output
+iterators should never attempt to pass through the same iterator twice;
+such an algorithm should be a single-pass algorithm.
 [*Note 1*: The only valid use of an `operator*` is on the left side of
 the assignment statement. Assignment through the same value of the
+iterator happens only once. Equality and inequality are not necessarily
 defined. — *end note*]
 #### Forward iterators <a id="forward.iterators">[[forward.iterators]]</a>
 A class or pointer type `X` meets the requirements of a forward iterator
 ### Indirect callable requirements <a id="indirectcallable">[[indirectcallable]]</a>
 #### General <a id="indirectcallable.general">[[indirectcallable.general]]</a>
 There are several concepts that group requirements of algorithms that
+take callable objects [[func.def]] as arguments.
+#### Indirect callable traits <a id="indirectcallable.traits">[[indirectcallable.traits]]</a>
+To implement algorithms taking projections, it is necessary to determine
+the projected type of an iterator’s value type. For the exposition-only
+alias template *`indirect-value-t`*, `indirect-value-t<T>` denotes
+- `invoke_result_t<Proj&, indirect-value-t<I>>` if `T` names
+  `projected<I, Proj>`, and
+- `iter_value_t<T>&` otherwise.
 #### Indirect callables <a id="indirectcallable.indirectinvocable">[[indirectcallable.indirectinvocable]]</a>
 The indirect callable concepts are used to constrain those algorithms
+that accept callable objects [[func.def]] as arguments.
 ``` cpp
 namespace std {
   template<class F, class I>
     concept indirectly_unary_invocable =
       indirectly_readable<I> &&
       copy_constructible<F> &&
+      invocable<F&, indirect-value-t<I>> &&
       invocable<F&, iter_reference_t<I>> &&
       invocable<F&, iter_common_reference_t<I>> &&
       common_reference_with<
+        invoke_result_t<F&, indirect-value-t<I>>,
         invoke_result_t<F&, iter_reference_t<I>>>;
   template<class F, class I>
     concept indirectly_regular_unary_invocable =
       indirectly_readable<I> &&
       copy_constructible<F> &&
+      regular_invocable<F&, indirect-value-t<I>> &&
       regular_invocable<F&, iter_reference_t<I>> &&
       regular_invocable<F&, iter_common_reference_t<I>> &&
       common_reference_with<
+        invoke_result_t<F&, indirect-value-t<I>>,
         invoke_result_t<F&, iter_reference_t<I>>>;
   template<class F, class I>
     concept indirect_unary_predicate =
       indirectly_readable<I> &&
       copy_constructible<F> &&
+      predicate<F&, indirect-value-t<I>> &&
       predicate<F&, iter_reference_t<I>> &&
       predicate<F&, iter_common_reference_t<I>>;
   template<class F, class I1, class I2>
     concept indirect_binary_predicate =
       indirectly_readable<I1> && indirectly_readable<I2> &&
       copy_constructible<F> &&
+      predicate<F&, indirect-value-t<I1>, indirect-value-t<I2>> &&
+      predicate<F&, indirect-value-t<I1>, iter_reference_t<I2>> &&
+      predicate<F&, iter_reference_t<I1>, indirect-value-t<I2>> &&
       predicate<F&, iter_reference_t<I1>, iter_reference_t<I2>> &&
       predicate<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
   template<class F, class I1, class I2 = I1>
     concept indirect_equivalence_relation =
       indirectly_readable<I1> && indirectly_readable<I2> &&
       copy_constructible<F> &&
+      equivalence_relation<F&, indirect-value-t<I1>, indirect-value-t<I2>> &&
+      equivalence_relation<F&, indirect-value-t<I1>, iter_reference_t<I2>> &&
+      equivalence_relation<F&, iter_reference_t<I1>, indirect-value-t<I2>> &&
       equivalence_relation<F&, iter_reference_t<I1>, iter_reference_t<I2>> &&
       equivalence_relation<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
   template<class F, class I1, class I2 = I1>
     concept indirect_strict_weak_order =
       indirectly_readable<I1> && indirectly_readable<I2> &&
       copy_constructible<F> &&
+      strict_weak_order<F&, indirect-value-t<I1>, indirect-value-t<I2>> &&
+      strict_weak_order<F&, indirect-value-t<I1>, iter_reference_t<I2>> &&
+      strict_weak_order<F&, iter_reference_t<I1>, indirect-value-t<I2>> &&
       strict_weak_order<F&, iter_reference_t<I1>, iter_reference_t<I2>> &&
       strict_weak_order<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
 }
 ```
 #### Class template `projected` <a id="projected">[[projected]]</a>
 Class template `projected` is used to constrain algorithms that accept
+callable objects and projections [[defns.projection]]. It combines an
 `indirectly_readable` type `I` and a callable object type `Proj` into a
 new `indirectly_readable` type whose `reference` type is the result of
 applying `Proj` to the `iter_reference_t` of `I`.
 ``` cpp
 below imposes constraints on the concepts’ arguments in addition to
 those that appear in the concepts’ bodies [[range.cmp]]. — *end note*]
 #### Concept  <a id="alg.req.ind.move">[[alg.req.ind.move]]</a>
+The `indirectly_movable` concept specifies the relationship between an
+`indirectly_readable` type and an `indirectly_writable` type between
 which values may be moved.
 ``` cpp
 template<class In, class Out>
   concept indirectly_movable =
 state of the value denoted by `*i` is valid but unspecified
 [[lib.types.movedfrom]].
 #### Concept  <a id="alg.req.ind.copy">[[alg.req.ind.copy]]</a>
+The `indirectly_copyable` concept specifies the relationship between an
+`indirectly_readable` type and an `indirectly_writable` type between
 which values may be copied.
 ``` cpp
 template<class In, class Out>
   concept indirectly_copyable =
     indirect_strict_weak_order<R, projected<I, P>>;
 ```
 ## Iterator primitives <a id="iterator.primitives">[[iterator.primitives]]</a>
+### General <a id="iterator.primitives.general">[[iterator.primitives.general]]</a>
 To simplify the use of iterators, the library provides several classes
 and functions.
 ### Standard iterator tags <a id="std.iterator.tags">[[std.iterator.tags]]</a>
 }
 ```
 [*Example 1*:
+A program-defined iterator `BinaryTreeIterator` can be included into the
+bidirectional iterator category by specializing the `iterator_traits`
+template:
 ``` cpp
 template<class T> struct iterator_traits<BinaryTreeIterator<T>> {
   using iterator_category = bidirectional_iterator_tag;
   using difference_type   = ptrdiff_t;
 *Preconditions:* `last` is reachable from `first`, or `InputIterator`
 meets the *Cpp17RandomAccessIterator* requirements and `first` is
 reachable from `last`.
 *Effects:* If `InputIterator` meets the *Cpp17RandomAccessIterator*
+requirements, returns `(last - first)`; otherwise, increments `first`
+until `last` is reached and returns the number of increments.
 ``` cpp
 template<class InputIterator>
   constexpr InputIterator next(InputIterator x,
     typename iterator_traits<InputIterator>::difference_type n = 1);
 *Effects:* Equivalent to: `advance(x, -n); return x;`
 ### Range iterator operations <a id="range.iter.ops">[[range.iter.ops]]</a>
+#### General <a id="range.iter.ops.general">[[range.iter.ops.general]]</a>
 The library includes the function templates `ranges::advance`,
 `ranges::distance`, `ranges::next`, and `ranges::prev` to manipulate
 iterators. These operations adapt to the set of operators provided by
 each iterator category to provide the most efficient implementation
 possible for a concrete iterator type.
 `random_access_iterator` forward `n` steps in constant time. For an
 iterator type that does not model `random_access_iterator`,
 `ranges::advance` instead performs `n` individual increments with the
 `++` operator. — *end example*]
+The function templates defined in [[range.iter.ops]] are not found by
 argument-dependent name lookup [[basic.lookup.argdep]]. When found by
 unqualified [[basic.lookup.unqual]] name lookup for the
 *postfix-expression* in a function call [[expr.call]], they inhibit
 argument-dependent name lookup.
 ```
 The function call expression at `#1` invokes `std::ranges::distance`,
 not `std::distance`, despite that (a) the iterator type returned from
 `begin(vec)` and `end(vec)` may be associated with namespace `std` and
+(b) `std::distance` is more specialized [[temp.func.order]] than
 `std::ranges::distance` since the former requires its first two
 parameters to have the same type.
 — *end example*]
 The number and order of deducible template parameters for the function
+templates defined in [[range.iter.ops]] is unspecified, except where
 explicitly stated otherwise.
 #### `ranges::advance` <a id="range.iter.op.advance">[[range.iter.op.advance]]</a>
 ``` cpp
 ``` cpp
 template<input_or_output_iterator I, sentinel_for<I> S>
   constexpr void ranges::advance(I& i, S bound);
 ```
+*Preconditions:* Either
+`assignable_from<I&, S> || sized_sentinel_for<S, I>` is modeled, or
+\[`i`, `bound`) denotes a range.
 *Effects:*
 - If `I` and `S` model `assignable_from<I&, S>`, equivalent to
   `i = std::move(bound)`.
 starting positions of `i`.
 #### `ranges::distance` <a id="range.iter.op.distance">[[range.iter.op.distance]]</a>
 ``` cpp
+template<class I, sentinel_for<I> S>
+  requires (!sized_sentinel_for<S, I>)
   constexpr iter_difference_t<I> ranges::distance(I first, S last);
 ```
+*Preconditions:* \[`first`, `last`) denotes a range.
+*Effects:* Increments `first` until `last` is reached and returns the
+number of increments.
+``` cpp
+template<class I, sized_sentinel_for<decay_t<I>> S>
+  constexpr iter_difference_t<decay_t<I>> ranges::distance(I&& first, S last);
+```
+*Effects:* Equivalent to:
+`return last - static_cast<const decay_t<I>&>(first);`
 ``` cpp
 template<range R>
   constexpr range_difference_t<R> ranges::distance(R&& r);
 ```
 ``` cpp
 template<bidirectional_iterator I>
   constexpr I ranges::prev(I x);
 ```
+*Effects:* Equivalent to: `–x; return x;`
 ``` cpp
 template<bidirectional_iterator I>
   constexpr I ranges::prev(I x, iter_difference_t<I> n);
 ```
 ## Iterator adaptors <a id="predef.iterators">[[predef.iterators]]</a>
 ### Reverse iterators <a id="reverse.iterators">[[reverse.iterators]]</a>
+#### General <a id="reverse.iterators.general">[[reverse.iterators.general]]</a>
 Class template `reverse_iterator` is an iterator adaptor that iterates
 from the end of the sequence defined by its underlying iterator to the
 beginning of that sequence.
 #### Class template `reverse_iterator` <a id="reverse.iterator">[[reverse.iterator]]</a>
 ``` cpp
 template<class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
 ```
+*Constraints:* `is_same_v<U, Iterator>` is `false` and `const U&` models
+`convertible_to<Iterator>`.
 *Effects:* Initializes `current` with `u.current`.
 ``` cpp
 template<class U>
   constexpr reverse_iterator&
     operator=(const reverse_iterator<U>& u);
 ```
+*Constraints:* `is_same_v<U, Iterator>` is `false`, `const U&` models
+`convertible_to<Iterator>`, and `assignable_from<Iterator&, const U&>`
+is modeled.
+*Effects:* Assigns `u.current` to `current`.
 *Returns:* `*this`.
 #### Conversion <a id="reverse.iter.conv">[[reverse.iter.conv]]</a>
 ``` cpp
+constexpr Iterator base() const;
 ```
 *Returns:* `current`.
 #### Element access <a id="reverse.iter.elem">[[reverse.iter.elem]]</a>
 ``` cpp
 constexpr reverse_iterator& operator++();
 ```
+*Effects:* As if by: `–current;`
 *Returns:* `*this`.
 ``` cpp
 constexpr reverse_iterator operator++(int);
 *Returns:* `y.base() - x.base()`.
 ``` cpp
 template<class Iterator>
   constexpr reverse_iterator<Iterator> operator+(
+ iter_difference_t<Iterator> n,
     const reverse_iterator<Iterator>& x);
 ```
 *Returns:* `reverse_iterator<Iterator>(x.base() - n)`.
 ``` cpp
 auto tmp = i.base();
 return ranges::iter_move(--tmp);
 ```
+*Remarks:* The exception specification is equivalent to:
 ``` cpp
 is_nothrow_copy_constructible_v<Iterator> &&
 noexcept(ranges::iter_move(--declval<Iterator&>()))
 ```
 auto xtmp = x.base();
 auto ytmp = y.base();
 ranges::iter_swap(--xtmp, --ytmp);
 ```
+*Remarks:* The exception specification is equivalent to:
 ``` cpp
 is_nothrow_copy_constructible_v<Iterator> &&
 is_nothrow_copy_constructible_v<Iterator2> &&
 noexcept(ranges::iter_swap(--declval<Iterator&>(), --declval<Iterator2&>()))
 *Returns:* `reverse_iterator<Iterator>(i)`.
 ### Insert iterators <a id="insert.iterators">[[insert.iterators]]</a>
+#### General <a id="insert.iterators.general">[[insert.iterators.general]]</a>
 To make it possible to deal with insertion in the same way as writing
 into an array, a special kind of iterator adaptors, called *insert
 iterators*, are provided in the library. With regular iterator classes,
 ``` cpp
 ``` cpp
 namespace std {
   template<class Container>
   class back_insert_iterator {
   protected:
+    Container* container;
   public:
     using iterator_category = output_iterator_tag;
     using value_type        = void;
     using difference_type   = ptrdiff_t;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
     constexpr explicit back_insert_iterator(Container& x);
     constexpr back_insert_iterator& operator=(const typename Container::value_type& value);
     constexpr back_insert_iterator& operator=(typename Container::value_type&& value);
     constexpr back_insert_iterator& operator*();
 ``` cpp
 namespace std {
   template<class Container>
   class front_insert_iterator {
   protected:
+    Container* container;
   public:
     using iterator_category = output_iterator_tag;
     using value_type        = void;
     using difference_type   = ptrdiff_t;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
     constexpr explicit front_insert_iterator(Container& x);
     constexpr front_insert_iterator& operator=(const typename Container::value_type& value);
     constexpr front_insert_iterator& operator=(typename Container::value_type&& value);
     constexpr front_insert_iterator& operator*();
 ``` cpp
 namespace std {
   template<class Container>
   class insert_iterator {
   protected:
+    Container* container;
+    ranges::iterator_t<Container> iter;
   public:
     using iterator_category = output_iterator_tag;
     using value_type        = void;
     using difference_type   = ptrdiff_t;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
     constexpr insert_iterator(Container& x, ranges::iterator_t<Container> i);
     constexpr insert_iterator& operator=(const typename Container::value_type& value);
     constexpr insert_iterator& operator=(typename Container::value_type&& value);
     constexpr insert_iterator& operator*();
     inserter(Container& x, ranges::iterator_t<Container> i);
 ```
 *Returns:* `insert_iterator<Container>(x, i)`.
+### Constant iterators and sentinels <a id="const.iterators">[[const.iterators]]</a>
+#### General <a id="const.iterators.general">[[const.iterators.general]]</a>
+Class template `basic_const_iterator` is an iterator adaptor with the
+same behavior as the underlying iterator except that its indirection
+operator implicitly converts the value returned by the underlying
+iterator’s indirection operator to a type such that the adapted iterator
+is a constant iterator [[iterator.requirements]]. Some generic
+algorithms can be called with constant iterators to avoid mutation.
+Specializations of `basic_const_iterator` are constant iterators.
+#### Alias templates <a id="const.iterators.alias">[[const.iterators.alias]]</a>
+``` cpp
+template<indirectly_readable It>
+  using iter_const_reference_t =
+    common_reference_t<const iter_value_t<It>&&, iter_reference_t<It>>;
+template<class It>
+  concept constant-iterator =                                                   // exposition only
+    input_iterator<It> && same_as<iter_const_reference_t<It>, iter_reference_t<It>>;
+template<input_iterator I>
+  using const_iterator = see below;
+```
+*Result:* If `I` models `constant-iterator`, `I`. Otherwise,
+`basic_const_iterator<I>`.
+``` cpp
+template<semiregular S>
+  using const_sentinel = see below;
+```
+*Result:* If `S` models `input_iterator`, `const_iterator<S>`.
+Otherwise, `S`.
+#### Class template `basic_const_iterator` <a id="const.iterators.iterator">[[const.iterators.iterator]]</a>
+``` cpp
+namespace std {
+  template<class I>
+    concept not-a-const-iterator = see below;                   // exposition only
+  template<indirectly_readable I>
+    using iter-const-rvalue-reference-t =                       // exposition only
+      common_reference_t<const iter_value_t<I>&&, iter_rvalue_reference_t<I>>;
+  template<input_iterator Iterator>
+  class basic_const_iterator {
+    Iterator current_ = Iterator();                             // exposition only
+    using reference = iter_const_reference_t<Iterator>;         // exposition only
+    using rvalue-reference =                                    // exposition only
+      iter-const-rvalue-reference-t<Iterator>;
+  public:
+    using iterator_concept = see below;
+    using iterator_category = see below;  // not always present
+    using value_type = iter_value_t<Iterator>;
+    using difference_type = iter_difference_t<Iterator>;
+    basic_const_iterator() requires default_initializable<Iterator> = default;
+    constexpr basic_const_iterator(Iterator current);
+    template<convertible_to<Iterator> U>
+      constexpr basic_const_iterator(basic_const_iterator<U> current);
+    template<different-from<basic_const_iterator> T>
+        requires convertible_to<T, Iterator>
+      constexpr basic_const_iterator(T&& current);
+    constexpr const Iterator& base() const & noexcept;
+    constexpr Iterator base() &&;
+    constexpr reference operator*() const;
+    constexpr const auto* operator->() const
+       requires is_lvalue_reference_v<iter_reference_t<Iterator>> &&
+                same_as<remove_cvref_t<iter_reference_t<Iterator>>, value_type>;
+    constexpr basic_const_iterator& operator++();
+    constexpr void operator++(int);
+    constexpr basic_const_iterator operator++(int) requires forward_iterator<Iterator>;
+    constexpr basic_const_iterator& operator--() requires bidirectional_iterator<Iterator>;
+    constexpr basic_const_iterator operator--(int) requires bidirectional_iterator<Iterator>;
+    constexpr basic_const_iterator& operator+=(difference_type n)
+      requires random_access_iterator<Iterator>;
+    constexpr basic_const_iterator& operator-=(difference_type n)
+      requires random_access_iterator<Iterator>;
+    constexpr reference operator[](difference_type n) const
+      requires random_access_iterator<Iterator>;
+    template<sentinel_for<Iterator> S>
+      constexpr bool operator==(const S& s) const;
+    constexpr bool operator<(const basic_const_iterator& y) const
+      requires random_access_iterator<Iterator>;
+    constexpr bool operator>(const basic_const_iterator& y) const
+      requires random_access_iterator<Iterator>;
+    constexpr bool operator<=(const basic_const_iterator& y) const
+      requires random_access_iterator<Iterator>;
+    constexpr bool operator>=(const basic_const_iterator& y) const
+      requires random_access_iterator<Iterator>;
+    constexpr auto operator<=>(const basic_const_iterator& y) const
+      requires random_access_iterator<Iterator> && three_way_comparable<Iterator>;
+    template<different-from<basic_const_iterator> I>
+      constexpr bool operator<(const I& y) const
+        requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+    template<different-from<basic_const_iterator> I>
+      constexpr bool operator>(const I& y) const
+        requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+    template<different-from<basic_const_iterator> I>
+      constexpr bool operator<=(const I& y) const
+        requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+    template<different-from<basic_const_iterator> I>
+      constexpr bool operator>=(const I& y) const
+        requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+    template<different-from<basic_const_iterator> I>
+      constexpr auto operator<=>(const I& y) const
+        requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I> &&
+                 three_way_comparable_with<Iterator, I>;
+    template<not-a-const-iterator I>
+      friend constexpr bool operator<(const I& x, const basic_const_iterator& y)
+        requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+    template<not-a-const-iterator I>
+      friend constexpr bool operator>(const I& x, const basic_const_iterator& y)
+        requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+    template<not-a-const-iterator I>
+      friend constexpr bool operator<=(const I& x, const basic_const_iterator& y)
+        requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+    template<not-a-const-iterator I>
+      friend constexpr bool operator>=(const I& x, const basic_const_iterator& y)
+        requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+    friend constexpr basic_const_iterator operator+(const basic_const_iterator& i,
+                                                    difference_type n)
+      requires random_access_iterator<Iterator>;
+    friend constexpr basic_const_iterator operator+(difference_type n,
+                                                    const basic_const_iterator& i)
+      requires random_access_iterator<Iterator>;
+    friend constexpr basic_const_iterator operator-(const basic_const_iterator& i,
+                                                    difference_type n)
+      requires random_access_iterator<Iterator>;
+    template<sized_sentinel_for<Iterator> S>
+      constexpr difference_type operator-(const S& y) const;
+    template<not-a-const-iterator S>
+      requires sized_sentinel_for<S, Iterator>
+      friend constexpr difference_type operator-(const S& x, const basic_const_iterator& y);
+    friend constexpr rvalue-reference iter_move(const basic_const_iterator& i)
+      noexcept(noexcept(static_cast<rvalue-reference>(ranges::iter_move(i.current_))))
+      {
+        return static_cast<rvalue-reference>(ranges::iter_move(i.current_));
+      }
+  };
+}
+```
+Given some type `I`, the concept *not-a-const-iterator* is defined as
+`false` if `I` is a specialization of `basic_const_iterator` and `true`
+otherwise.
+#### Member types <a id="const.iterators.types">[[const.iterators.types]]</a>
+`basic_const_iterator<Iterator>::iterator_concept` is defined as
+follows:
+- If `Iterator` models `contiguous_iterator`, then `iterator_concept`
+  denotes `contiguous_iterator_tag`.
+- Otherwise, if `Iterator` models `random_access_iterator`, then
+  `iterator_concept` denotes `random_access_iterator_tag`.
+- Otherwise, if `Iterator` models `bidirectional_iterator`, then
+  `iterator_concept` denotes `bidirectional_iterator_tag`.
+- Otherwise, if `Iterator` models `forward_iterator`, then
+  `iterator_concept` denotes `forward_iterator_tag`.
+- Otherwise, `iterator_concept` denotes `input_iterator_tag`.
+The member *typedef-name* `iterator_category` is defined if and only if
+`Iterator` models `forward_iterator`. In that case,
+`basic_const_iterator<Iterator>::iterator_category` denotes the type
+`iterator_traits<{}Iterator>::iterator_category`.
+#### Operations <a id="const.iterators.ops">[[const.iterators.ops]]</a>
+``` cpp
+constexpr basic_const_iterator(Iterator current);
+```
+*Effects:* Initializes *current\_* with `std::move(current)`.
+``` cpp
+template<convertible_to<Iterator> U>
+  constexpr basic_const_iterator(basic_const_iterator<U> current);
+```
+*Effects:* Initializes *current\_* with
+`std::move(current.`*`current_`*`)`.
+``` cpp
+template<different-from<basic_const_iterator> T>
+  requires convertible_to<T, Iterator>
+  constexpr basic_const_iterator(T&& current);
+```
+*Effects:* Initializes *current\_* with `std::forward<T>(current)`.
+``` cpp
+constexpr const Iterator& base() const & noexcept;
+```
+*Effects:* Equivalent to: `return `*`current_`*`;`
+``` cpp
+constexpr Iterator base() &&;
+```
+*Effects:* Equivalent to: `return std::move(`*`current_`*`);`
+``` cpp
+constexpr reference operator*() const;
+```
+*Effects:* Equivalent to:
+`return static_cast<`*`reference`*`>(*`*`current_`*`);`
+``` cpp
+constexpr const auto* operator->() const
+  requires is_lvalue_reference_v<iter_reference_t<Iterator>> &&
+           same_as<remove_cvref_t<iter_reference_t<Iterator>>, value_type>;
+```
+*Returns:* If `Iterator` models `contiguous_iterator`,
+`to_address(`*`current_`*`)`; otherwise, `addressof(*`*`current_`*`)`.
+``` cpp
+constexpr basic_const_iterator& operator++();
+```
+*Effects:* Equivalent to:
+``` cpp
+++current_;
+return *this;
+```
+``` cpp
+constexpr void operator++(int);
+```
+*Effects:* Equivalent to: `++`*`current_`*`;`
+``` cpp
+constexpr basic_const_iterator operator++(int) requires forward_iterator<Iterator>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+++*this;
+return tmp;
+```
+``` cpp
+constexpr basic_const_iterator& operator--() requires bidirectional_iterator<Iterator>;
+```
+*Effects:* Equivalent to:
+``` cpp
+--current_;
+return *this;
+```
+``` cpp
+constexpr basic_const_iterator operator--(int) requires bidirectional_iterator<Iterator>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+--*this;
+return tmp;
+```
+``` cpp
+constexpr basic_const_iterator& operator+=(difference_type n)
+  requires random_access_iterator<Iterator>;
+constexpr basic_const_iterator& operator-=(difference_type n)
+  requires random_access_iterator<Iterator>;
+```
+Let *`op`* be the operator.
+*Effects:* Equivalent to:
+``` cpp
+current_ op n;
+return *this;
+```
+``` cpp
+constexpr reference operator[](difference_type n) const requires random_access_iterator<Iterator>
+```
+*Effects:* Equivalent to:
+`return static_cast<`*`reference`*`>(`*`current_`*`[n]);`
+``` cpp
+template<sentinel_for<Iterator> S>
+  constexpr bool operator==(const S& s) const;
+```
+*Effects:* Equivalent to: `return `*`current_`*` == s;`
+``` cpp
+constexpr bool operator<(const basic_const_iterator& y) const
+  requires random_access_iterator<Iterator>;
+constexpr bool operator>(const basic_const_iterator& y) const
+  requires random_access_iterator<Iterator>;
+constexpr bool operator<=(const basic_const_iterator& y) const
+  requires random_access_iterator<Iterator>;
+constexpr bool operator>=(const basic_const_iterator& y) const
+  requires random_access_iterator<Iterator>;
+constexpr auto operator<=>(const basic_const_iterator& y) const
+  requires random_access_iterator<Iterator> && three_way_comparable<Iterator>;
+```
+Let *`op`* be the operator.
+*Effects:* Equivalent to:
+`return `*`current_`*` `*`op`*` `*`y.current_`*`;`
+``` cpp
+template<different-from<basic_const_iterator> I>
+  constexpr bool operator<(const I& y) const
+    requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+template<different-from<basic_const_iterator> I>
+  constexpr bool operator>(const I& y) const
+    requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+template<different-from<basic_const_iterator> I>
+  constexpr bool operator<=(const I& y) const
+    requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+template<different-from<basic_const_iterator> I>
+  constexpr bool operator>=(const I& y) const
+    requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+template<different-from<basic_const_iterator> I>
+  constexpr auto operator<=>(const I& y) const
+    requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I> &&
+             three_way_comparable_with<Iterator, I>;
+```
+Let *`op`* be the operator.
+*Effects:* Equivalent to: `return `*`current_`*` `*`op`*` y;`
+``` cpp
+template<not-a-const-iterator I>
+  friend constexpr bool operator<(const I& x, const basic_const_iterator& y)
+    requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+template<not-a-const-iterator I>
+  friend constexpr bool operator>(const I& x, const basic_const_iterator& y)
+    requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+template<not-a-const-iterator I>
+  friend constexpr bool operator<=(const I& x, const basic_const_iterator& y)
+    requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+template<not-a-const-iterator I>
+  friend constexpr bool operator>=(const I& x, const basic_const_iterator& y)
+    requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
+```
+Let *`op`* be the operator.
+*Returns:* Equivalent to: `return x `*`op`*` y.`*`current_`*`;`
+``` cpp
+friend constexpr basic_const_iterator operator+(const basic_const_iterator& i, difference_type n)
+  requires random_access_iterator<Iterator>;
+friend constexpr basic_const_iterator operator+(difference_type n, const basic_const_iterator& i)
+  requires random_access_iterator<Iterator>;
+```
+*Effects:* Equivalent to:
+`return basic_const_iterator(i.`*`current_`*` + n);`
+``` cpp
+friend constexpr basic_const_iterator operator-(const basic_const_iterator& i, difference_type n)
+  requires random_access_iterator<Iterator>;
+```
+*Effects:* Equivalent to:
+`return basic_const_iterator(i.`*`current_`*` - n);`
+``` cpp
+template<sized_sentinel_for<Iterator> S>
+  constexpr difference_type operator-(const S& y) const;
+```
+*Effects:* Equivalent to: `return `*`current_`*` - y;`
+``` cpp
+template<not-a-const-iterator S>
+  requires sized_sentinel_for<S, Iterator>
+  friend constexpr difference_type operator-(const S& x, const basic_const_iterator& y);
+```
+*Effects:* Equivalent to: `return x - y.`*`current_`*`;`
 ### Move iterators and sentinels <a id="move.iterators">[[move.iterators]]</a>
+#### General <a id="move.iterators.general">[[move.iterators.general]]</a>
 Class template `move_iterator` is an iterator adaptor with the same
 behavior as the underlying iterator except that its indirection operator
 implicitly converts the value returned by the underlying iterator’s
 indirection operator to an rvalue. Some generic algorithms can be called
 with move iterators to replace copying with moving.
 namespace std {
   template<class Iterator>
   class move_iterator {
   public:
     using iterator_type     = Iterator;
+    using iterator_concept  = see below;
+    using iterator_category = see below;                      // not always present
     using value_type        = iter_value_t<Iterator>;
     using difference_type   = iter_difference_t<Iterator>;
     using pointer           = Iterator;
     using reference         = iter_rvalue_reference_t<Iterator>;
     constexpr move_iterator();
     constexpr explicit move_iterator(Iterator i);
     template<class U> constexpr move_iterator(const move_iterator<U>& u);
     template<class U> constexpr move_iterator& operator=(const move_iterator<U>& u);
+    constexpr const Iterator& base() const & noexcept;
+    constexpr Iterator base() &&;
     constexpr reference operator*() const;
     constexpr move_iterator& operator++();
     constexpr auto operator++(int);
     constexpr move_iterator& operator--();
     Iterator current;   // exposition only
   };
 }
 ```
+The member *typedef-name* `iterator_concept` is defined as follows:
+- If `Iterator` models `random_access_iterator`, then `iterator_concept`
+  denotes `random_access_iterator_tag`.
+- Otherwise, if `Iterator` models `bidirectional_iterator`, then
+  `iterator_concept` denotes `bidirectional_iterator_tag`.
+- Otherwise, if `Iterator` models `forward_iterator`, then
+  `iterator_concept` denotes `forward_iterator_tag`.
+- Otherwise, `iterator_concept` denotes `input_iterator_tag`.
+The member *typedef-name* `iterator_category` is defined if and only if
+the *qualified-id* `iterator_traits<Iterator>::iterator_category` is
+valid and denotes a type. In that case, `iterator_category` denotes
 - `random_access_iterator_tag` if the type
   `iterator_traits<{}Iterator>::iterator_category` models
   `derived_from<random_access_iterator_tag>`, and
 - `iterator_traits<{}Iterator>::iterator_category` otherwise.
 ``` cpp
 constexpr move_iterator();
 ```
+*Effects:* Value-initializes `current`.
 ``` cpp
 constexpr explicit move_iterator(Iterator i);
 ```
+*Effects:* Initializes `current` with `std::move(i)`.
 ``` cpp
 template<class U> constexpr move_iterator(const move_iterator<U>& u);
 ```
+*Constraints:* `is_same_v<U, Iterator>` is `false` and `const U&` models
+`convertible_to<Iterator>`.
+*Effects:* Initializes `current` with `u.current`.
 ``` cpp
 template<class U> constexpr move_iterator& operator=(const move_iterator<U>& u);
 ```
+*Constraints:* `is_same_v<U, Iterator>` is `false`, `const U&` models
+`convertible_to<Iterator>`, and `assignable_from<Iterator&, const U&>`
+is modeled.
+*Effects:* Assigns `u.current` to `current`.
+*Returns:* `*this`.
 #### Conversion <a id="move.iter.op.conv">[[move.iter.op.conv]]</a>
 ``` cpp
+constexpr const Iterator& base() const & noexcept;
 ```
 *Returns:* `current`.
 ``` cpp
 constexpr Iterator base() &&;
 ```
 ``` cpp
 constexpr reference operator[](difference_type n) const;
 ```
+*Effects:* Equivalent to: `return ranges::iter_move(current + n);`
 #### Navigation <a id="move.iter.nav">[[move.iter.nav]]</a>
 ``` cpp
 constexpr move_iterator& operator++();
 ``` cpp
 constexpr move_iterator& operator--();
 ```
+*Effects:* As if by `–current`.
 *Returns:* `*this`.
 ``` cpp
 constexpr move_iterator operator--(int);
 #### Non-member functions <a id="move.iter.nonmember">[[move.iter.nonmember]]</a>
 ``` cpp
 template<class Iterator1, class Iterator2>
+  constexpr auto operator-(
+ const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y)
       -> decltype(x.base() - y.base());
 template<sized_sentinel_for<Iterator> S>
   friend constexpr iter_difference_t<Iterator>
     operator-(const move_sentinel<S>& x, const move_iterator& y);
 template<sized_sentinel_for<Iterator> S>
 template<class Iterator>
   constexpr move_iterator<Iterator>
     operator+(iter_difference_t<Iterator> n, const move_iterator<Iterator>& x);
 ```
+*Constraints:* `x.base() + n` is well-formed and has type `Iterator`.
 *Returns:* `x + n`.
 ``` cpp
 friend constexpr iter_rvalue_reference_t<Iterator>
 Class template `move_sentinel` is a sentinel adaptor useful for denoting
 ranges together with `move_iterator`. When an input iterator type `I`
 and sentinel type `S` model `sentinel_for<S, I>`, `move_sentinel<S>` and
 `move_iterator<I>` model
+`sentinel_for<move_sentinel<S>, move_iterator<I>>` as well.
 [*Example 1*:
 A `move_if` algorithm is easily implemented with `copy_if` using
 `move_iterator` and `move_sentinel`:
 ``` cpp
 template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
          indirect_unary_predicate<I> Pred>
   requires indirectly_movable<I, O>
 void move_if(I first, S last, O out, Pred pred) {
+  ranges::copy_if(move_iterator<I>{std::move(first)}, move_sentinel<S>{last},
+                  std::move(out), pred);
 }
 ```
 — *end example*]
     template<class S2>
       requires assignable_from<S&, const S2&>
         constexpr move_sentinel& operator=(const move_sentinel<S2>& s);
     constexpr S base() const;
   private:
     S last;     // exposition only
   };
 }
 ```
 namespace std {
   template<input_or_output_iterator I, sentinel_for<I> S>
     requires (!same_as<I, S> && copyable<I>)
   class common_iterator {
   public:
+    constexpr common_iterator() requires default_initializable<I> = default;
     constexpr common_iterator(I i);
     constexpr common_iterator(S s);
     template<class I2, class S2>
       requires convertible_to<const I2&, I> && convertible_to<const S2&, S>
         constexpr common_iterator(const common_iterator<I2, S2>& x);
     template<class I2, class S2>
       requires convertible_to<const I2&, I> && convertible_to<const S2&, S> &&
                assignable_from<I&, const I2&> && assignable_from<S&, const S2&>
+ constexpr common_iterator& operator=(const common_iterator<I2, S2>& x);
+ constexpr decltype(auto) operator*();
+ constexpr decltype(auto) operator*() const
       requires dereferenceable<const I>;
+ constexpr auto operator->() const
       requires see below;
+ constexpr common_iterator& operator++();
+ constexpr decltype(auto) operator++(int);
     template<class I2, sentinel_for<I> S2>
       requires sentinel_for<S, I2>
+    friend constexpr bool operator==(
       const common_iterator& x, const common_iterator<I2, S2>& y);
     template<class I2, sentinel_for<I> S2>
       requires sentinel_for<S, I2> && equality_comparable_with<I, I2>
+    friend constexpr bool operator==(
       const common_iterator& x, const common_iterator<I2, S2>& y);
     template<sized_sentinel_for<I> I2, sized_sentinel_for<I> S2>
       requires sized_sentinel_for<S, I2>
+    friend constexpr iter_difference_t<I2> operator-(
       const common_iterator& x, const common_iterator<I2, S2>& y);
+    friend constexpr iter_rvalue_reference_t<I> iter_move(const common_iterator& i)
       noexcept(noexcept(ranges::iter_move(declval<const I&>())))
         requires input_iterator<I>;
     template<indirectly_swappable<I> I2, class S2>
+      friend constexpr void iter_swap(const common_iterator& x, const common_iterator<I2, S2>& y)
         noexcept(noexcept(ranges::iter_swap(declval<const I&>(), declval<const I2&>())));
   private:
     variant<I, S> v_;   // exposition only
   };
 The nested *typedef-name*s of the specialization of `iterator_traits`
 for `common_iterator<I, S>` are defined as follows.
 - `iterator_concept` denotes `forward_iterator_tag` if `I` models
   `forward_iterator`; otherwise it denotes `input_iterator_tag`.
+- `iterator_category` denotes `forward_iterator_tag` if the
+ *qualified-id* `iterator_traits<I>::iterator_category` is valid and
+ denotes a type that models `derived_from<forward_iterator_tag>`;
+ otherwise it denotes `input_iterator_tag`.
+- Let `a` denote an lvalue of type `const common_iterator<I, S>`. If the
+ expression `a.operator->()` is well-formed, then `pointer` denotes
+ `decltype(a.operator->())`. Otherwise, `pointer` denotes `void`.
 #### Constructors and conversions <a id="common.iter.const">[[common.iter.const]]</a>
 ``` cpp
 constexpr common_iterator(I i);
 ``` cpp
 template<class I2, class S2>
   requires convertible_to<const I2&, I> && convertible_to<const S2&, S> &&
            assignable_from<I&, const I2&> && assignable_from<S&, const S2&>
+ constexpr common_iterator& operator=(const common_iterator<I2, S2>& x);
 ```
 *Preconditions:* `x.v_.valueless_by_exception()` is `false`.
 *Effects:* Equivalent to:
 *Returns:* `*this`
 #### Accessors <a id="common.iter.access">[[common.iter.access]]</a>
 ``` cpp
+constexpr decltype(auto) operator*();
+constexpr decltype(auto) operator*() const
   requires dereferenceable<const I>;
 ```
+*Preconditions:* `holds_alternative<I>(v_)` is `true`.
 *Effects:* Equivalent to: `return *get<I>(v_);`
 ``` cpp
+constexpr auto operator->() const
   requires see below;
 ```
+The expression in the *requires-clause* is equivalent to:
 ``` cpp
 indirectly_readable<const I> &&
 (requires(const I& i) { i.operator->(); } ||
  is_reference_v<iter_reference_t<I>> ||
  constructible_from<iter_value_t<I>, iter_reference_t<I>>)
 ```
+*Preconditions:* `holds_alternative<I>(v_)` is `true`.
 *Effects:*
 - If `I` is a pointer type or if the expression
   `get<I>(v_).operator->()` is well-formed, equivalent to:
 - Otherwise, equivalent to: `return `*`proxy`*`(*get<I>(v_));` where
   *proxy* is the exposition-only class:
   ``` cpp
   class proxy {
     iter_value_t<I> keep_;
+ constexpr proxy(iter_reference_t<I>&& x)
       : keep_(std::move(x)) {}
   public:
+ constexpr const iter_value_t<I>* operator->() const noexcept {
       return addressof(keep_);
     }
   };
   ```
 #### Navigation <a id="common.iter.nav">[[common.iter.nav]]</a>
 ``` cpp
+constexpr common_iterator& operator++();
 ```
+*Preconditions:* `holds_alternative<I>(v_)` is `true`.
 *Effects:* Equivalent to `++get<I>(v_)`.
 *Returns:* `*this`.
 ``` cpp
+constexpr decltype(auto) operator++(int);
 ```
+*Preconditions:* `holds_alternative<I>(v_)` is `true`.
 *Effects:* If `I` models `forward_iterator`, equivalent to:
 ``` cpp
 common_iterator tmp = *this;
 ++*this;
 return tmp;
 ```
+Otherwise, if `requires(I& i) { { *i++ } -> `*`can-reference`*`; }` is
+`true` or
+``` cpp
+indirectly_readable<I> && constructible_from<iter_value_t<I>, iter_reference_t<I>> &&
+move_constructible<iter_value_t<I>>
+```
+is `false`, equivalent to:
+``` cpp
+return get<I>(v_)++;
+```
+Otherwise, equivalent to:
+``` cpp
+postfix-proxy p(**this);
+++*this;
+return p;
+```
+where *postfix-proxy* is the exposition-only class:
+``` cpp
+class postfix-proxy {
+  iter_value_t<I> keep_;
+  constexpr postfix-proxy(iter_reference_t<I>&& x)
+    : keep_(std::forward<iter_reference_t<I>>(x)) {}
+public:
+  constexpr const iter_value_t<I>& operator*() const noexcept {
+    return keep_;
+  }
+};
+```
 #### Comparisons <a id="common.iter.cmp">[[common.iter.cmp]]</a>
 ``` cpp
 template<class I2, sentinel_for<I> S2>
   requires sentinel_for<S, I2>
+friend constexpr bool operator==(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 ```
 *Preconditions:* `x.v_.valueless_by_exception()` and
 `y.v_.valueless_by_exception()` are each `false`.
 `y.v_.index()`.
 ``` cpp
 template<class I2, sentinel_for<I> S2>
   requires sentinel_for<S, I2> && equality_comparable_with<I, I2>
+friend constexpr bool operator==(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 ```
 *Preconditions:* `x.v_.valueless_by_exception()` and
 `y.v_.valueless_by_exception()` are each `false`.
 `y.v_.index()`.
 ``` cpp
 template<sized_sentinel_for<I> I2, sized_sentinel_for<I> S2>
   requires sized_sentinel_for<S, I2>
+friend constexpr iter_difference_t<I2> operator-(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 ```
 *Preconditions:* `x.v_.valueless_by_exception()` and
 `y.v_.valueless_by_exception()` are each `false`.
 *Returns:* `0` if i and j are each `1`, and otherwise
 `get<`i`>(x.v_) - get<`j`>(y.v_)`, where i is `x.v_.index()` and j is
 `y.v_.index()`.
+#### Customizations <a id="common.iter.cust">[[common.iter.cust]]</a>
 ``` cpp
+friend constexpr iter_rvalue_reference_t<I> iter_move(const common_iterator& i)
   noexcept(noexcept(ranges::iter_move(declval<const I&>())))
     requires input_iterator<I>;
 ```
+*Preconditions:* `holds_alternative<I>(i.v_)` is `true`.
 *Effects:* Equivalent to: `return ranges::iter_move(get<I>(i.v_));`
 ``` cpp
 template<indirectly_swappable<I> I2, class S2>
+  friend constexpr void iter_swap(const common_iterator& x, const common_iterator<I2, S2>& y)
     noexcept(noexcept(ranges::iter_swap(declval<const I&>(), declval<const I2&>())));
 ```
 *Preconditions:* `holds_alternative<I>(x.v_)` and
 `holds_alternative<I2>(y.v_)` are each `true`.
 *Effects:* Equivalent to
 `ranges::iter_swap(get<I>(x.v_), get<I2>(y.v_))`.
+### Default sentinel <a id="default.sentinel">[[default.sentinel]]</a>
 ``` cpp
 namespace std {
   struct default_sentinel_t { };
 }
 — *end example*]
 Two values `i1` and `i2` of types `counted_iterator<I1>` and
 `counted_iterator<I2>` refer to elements of the same sequence if and
+only if there exists some integer n such that
+`next(i1.base(), i1.count() + n)` and `next(i2.base(), i2.count() + n)`
 refer to the same (possibly past-the-end) element.
 ``` cpp
 namespace std {
   template<input_or_output_iterator I>
   class counted_iterator {
   public:
     using iterator_type = I;
+    using value_type = iter_value_t<I>;                         // present only
+                        // if I models indirectly_readable
+    using difference_type = iter_difference_t<I>;
+    using iterator_concept = typename I::iterator_concept;      // present only
+                        // if the qualified-id I::iterator_concept is valid and denotes a type
+    using iterator_category = typename I::iterator_category;    // present only
+                        // if the qualified-id I::iterator_category is valid and denotes a type
+    constexpr counted_iterator() requires default_initializable<I> = default;
     constexpr counted_iterator(I x, iter_difference_t<I> n);
     template<class I2>
       requires convertible_to<const I2&, I>
         constexpr counted_iterator(const counted_iterator<I2>& x);
     template<class I2>
       requires assignable_from<I&, const I2&>
         constexpr counted_iterator& operator=(const counted_iterator<I2>& x);
+    constexpr const I& base() const & noexcept;
     constexpr I base() &&;
     constexpr iter_difference_t<I> count() const noexcept;
     constexpr decltype(auto) operator*();
     constexpr decltype(auto) operator*() const
       requires dereferenceable<const I>;
+    constexpr auto operator->() const noexcept
+      requires contiguous_iterator<I>;
     constexpr counted_iterator& operator++();
+ constexpr decltype(auto) operator++(int);
     constexpr counted_iterator operator++(int)
       requires forward_iterator<I>;
     constexpr counted_iterator& operator--()
       requires bidirectional_iterator<I>;
     constexpr counted_iterator operator--(int)
   private:
     I current = I();                    // exposition only
     iter_difference_t<I> length = 0;    // exposition only
   };
   template<input_iterator I>
+    requires same_as<ITER_TRAITS(I), iterator_traits<I>>   // see [iterator.concepts.general]
   struct iterator_traits<counted_iterator<I>> : iterator_traits<I> {
+    using pointer = conditional_t<contiguous_iterator<I>,
+                                  add_pointer_t<iter_reference_t<I>>, void>;
   };
 }
 ```
 #### Constructors and conversions <a id="counted.iter.const">[[counted.iter.const]]</a>
 *Returns:* `*this`.
 #### Accessors <a id="counted.iter.access">[[counted.iter.access]]</a>
 ``` cpp
+constexpr const I& base() const & noexcept;
 ```
 *Effects:* Equivalent to: `return current;`
 ``` cpp
 constexpr decltype(auto) operator*();
 constexpr decltype(auto) operator*() const
   requires dereferenceable<const I>;
 ```
+*Preconditions:* `length > 0` is `true`.
 *Effects:* Equivalent to: `return *current;`
+``` cpp
+constexpr auto operator->() const noexcept
+  requires contiguous_iterator<I>;
+```
+*Effects:* Equivalent to: `return to_address(current);`
 ``` cpp
 constexpr decltype(auto) operator[](iter_difference_t<I> n) const
   requires random_access_iterator<I>;
 ```
 --length;
 return *this;
 ```
 ``` cpp
+constexpr decltype(auto) operator++(int);
 ```
 *Preconditions:* `length > 0`.
 *Effects:* Equivalent to:
   iter_move(const counted_iterator& i)
     noexcept(noexcept(ranges::iter_move(i.current)))
     requires input_iterator<I>;
 ```
+*Preconditions:* `i.length > 0` is `true`.
 *Effects:* Equivalent to: `return ranges::iter_move(i.current);`
 ``` cpp
 template<indirectly_swappable<I> I2>
   friend constexpr void
     iter_swap(const counted_iterator& x, const counted_iterator<I2>& y)
       noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
 ```
+*Preconditions:* Both `x.length > 0` and `y.length > 0` are `true`.
 *Effects:* Equivalent to `ranges::iter_swap(x.current, y.current)`.
+### Unreachable sentinel <a id="unreachable.sentinel">[[unreachable.sentinel]]</a>
 Class `unreachable_sentinel_t` can be used with any
 `weakly_incrementable` type to denote the “upper bound” of an unbounded
 interval.
 }
 ```
 ## Stream iterators <a id="stream.iterators">[[stream.iterators]]</a>
+### General <a id="stream.iterators.general">[[stream.iterators.general]]</a>
 To make it possible for algorithmic templates to work directly with
 input/output streams, appropriate iterator-like class templates are
 provided.
 [*Example 1*:
 — *end example*]
 ### Class template `istream_iterator` <a id="istream.iterator">[[istream.iterator]]</a>
+#### General <a id="istream.iterator.general">[[istream.iterator.general]]</a>
 The class template `istream_iterator` is an input iterator
 [[input.iterators]] that reads successive elements from the input stream
 for which it was constructed.
 ``` cpp
     using istream_type      = basic_istream<charT,traits>;
     constexpr istream_iterator();
     constexpr istream_iterator(default_sentinel_t);
     istream_iterator(istream_type& s);
+ constexpr istream_iterator(const istream_iterator& x) noexcept(see below);
     ~istream_iterator() = default;
     istream_iterator& operator=(const istream_iterator&) = default;
     const T& operator*() const;
     const T* operator->() const;
 *Effects:* Initializes `in_stream` with `addressof(s)`,
 value-initializes `value`, and then calls `operator++()`.
 ``` cpp
+constexpr istream_iterator(const istream_iterator& x) noexcept(see below);
 ```
+*Effects:* Initializes `in_stream` with `x.in_stream` and initializes
+`value` with `x.value`.
+*Remarks:* An invocation of this constructor may be used in a core
+constant expression if and only if the initialization of `value` from
+`x.value` is a constant subexpression [[defns.const.subexpr]]. The
+exception specification is equivalent to
+`is_nothrow_copy_constructible_v<T>`.
 ``` cpp
 ~istream_iterator() = default;
 ```
 *Returns:* `!i.in_stream`.
 ### Class template `ostream_iterator` <a id="ostream.iterator">[[ostream.iterator]]</a>
+#### General <a id="ostream.iterator.general">[[ostream.iterator.general]]</a>
 `ostream_iterator` writes (using `operator<<`) successive elements onto
 the output stream from which it was constructed. If it was constructed
 with `charT*` as a constructor argument, this string, called a
 *delimiter string*, is written to the stream after every `T` is written.
     using reference         = void;
     using char_type         = charT;
     using traits_type       = traits;
     using ostream_type      = basic_ostream<charT,traits>;
     ostream_iterator(ostream_type& s);
     ostream_iterator(ostream_type& s, const charT* delimiter);
     ostream_iterator(const ostream_iterator& x);
     ~ostream_iterator();
     ostream_iterator& operator=(const ostream_iterator&) = default;
     ostream_iterator& operator*();
     ostream_iterator& operator++();
     ostream_iterator& operator++(int);
   private:
+    basic_ostream<charT,traits>* out_stream; // exposition only
+    const charT* delim; // exposition only
   };
 }
 ```
 #### Constructors and destructor <a id="ostream.iterator.cons.des">[[ostream.iterator.cons.des]]</a>
 *Returns:* `*this`.
 ### Class template `istreambuf_iterator` <a id="istreambuf.iterator">[[istreambuf.iterator]]</a>
+#### General <a id="istreambuf.iterator.general">[[istreambuf.iterator.general]]</a>
 The class template `istreambuf_iterator` defines an input iterator
 [[input.iterators]] that reads successive *characters* from the
 streambuf for which it was constructed. `operator*` provides access to
 the current input character, if any. Each time `operator++` is
 evaluated, the iterator advances to the next input character. If the end
     using traits_type       = traits;
     using int_type          = typename traits::int_type;
     using streambuf_type    = basic_streambuf<charT,traits>;
     using istream_type      = basic_istream<charT,traits>;
+    // [istreambuf.iterator.proxy], class istreambuf_iterator::proxy
     class proxy;                          // exposition only
     constexpr istreambuf_iterator() noexcept;
     constexpr istreambuf_iterator(default_sentinel_t) noexcept;
     istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
 *Returns:* `i.equal(s)`.
 ### Class template `ostreambuf_iterator` <a id="ostreambuf.iterator">[[ostreambuf.iterator]]</a>
+#### General <a id="ostreambuf.iterator.general">[[ostreambuf.iterator.general]]</a>
 The class template `ostreambuf_iterator` writes successive *characters*
 onto the output stream from which it was constructed.
 ``` cpp
 namespace std {
     using char_type         = charT;
     using traits_type       = traits;
     using streambuf_type    = basic_streambuf<charT,traits>;
     using ostream_type      = basic_ostream<charT,traits>;
     ostreambuf_iterator(ostream_type& s) noexcept;
     ostreambuf_iterator(streambuf_type* s) noexcept;
     ostreambuf_iterator& operator=(charT c);
     ostreambuf_iterator& operator*();
     ostreambuf_iterator& operator++();
     ostreambuf_iterator& operator++(int);
     bool failed() const noexcept;
   private:
+    streambuf_type* sbuf_; // exposition only
   };
 }
 ```
 #### Constructors <a id="ostreambuf.iter.cons">[[ostreambuf.iter.cons]]</a>
 In addition to being available via inclusion of the `<iterator>` header,
 the function templates in [[iterator.range]] are available when any of
 the following headers are included: `<array>`, `<deque>`,
 `<forward_list>`, `<list>`, `<map>`, `<regex>`, `<set>`, `<span>`,
 `<string>`, `<string_view>`, `<unordered_map>`, `<unordered_set>`, and
+`<vector>`.
 ``` cpp
 template<class C> constexpr auto begin(C& c) -> decltype(c.begin());
 template<class C> constexpr auto begin(const C& c) -> decltype(c.begin());
 ```
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.lval]: expr.md#basic.lval
 [bidirectional.iterators]: #bidirectional.iterators
 [bidirectionaliterator]: #bidirectionaliterator
+[cmp.concept]: support.md#cmp.concept
 [common.iter.access]: #common.iter.access
 [common.iter.cmp]: #common.iter.cmp
 [common.iter.const]: #common.iter.const
 [common.iter.cust]: #common.iter.cust
 [common.iter.nav]: #common.iter.nav
 [common.iter.types]: #common.iter.types
 [common.iterator]: #common.iterator
 [concept.swappable]: concepts.md#concept.swappable
 [concepts.object]: concepts.md#concepts.object
+[const.iterators]: #const.iterators
+[const.iterators.alias]: #const.iterators.alias
+[const.iterators.general]: #const.iterators.general
+[const.iterators.iterator]: #const.iterators.iterator
+[const.iterators.ops]: #const.iterators.ops
+[const.iterators.types]: #const.iterators.types
 [containers]: containers.md#containers
 [counted.iter.access]: #counted.iter.access
 [counted.iter.cmp]: #counted.iter.cmp
 [counted.iter.const]: #counted.iter.const
 [counted.iter.cust]: #counted.iter.cust
 [counted.iter.nav]: #counted.iter.nav
 [counted.iterator]: #counted.iterator
 [cpp17.copyassignable]: #cpp17.copyassignable
 [cpp17.equalitycomparable]: #cpp17.equalitycomparable
 [customization.point.object]: library.md#customization.point.object
+[default.sentinel]: #default.sentinel
+[defns.const.subexpr]: intro.md#defns.const.subexpr
+[defns.projection]: intro.md#defns.projection
 [expr.call]: expr.md#expr.call
 [expr.const]: expr.md#expr.const
 [forward.iterators]: #forward.iterators
 [forwarditerator]: #forwarditerator
 [front.insert.iter.ops]: #front.insert.iter.ops
 [func.def]: utilities.md#func.def
 [incrementable.traits]: #incrementable.traits
 [indirectcallable]: #indirectcallable
 [indirectcallable.general]: #indirectcallable.general
 [indirectcallable.indirectinvocable]: #indirectcallable.indirectinvocable
+[indirectcallable.traits]: #indirectcallable.traits
 [input.iterators]: #input.iterators
 [inputiterator]: #inputiterator
 [insert.iter.ops]: #insert.iter.ops
 [insert.iterator]: #insert.iterator
 [insert.iterators]: #insert.iterators
+[insert.iterators.general]: #insert.iterators.general
 [inserter]: #inserter
 [iostream.format]: input.md#iostream.format
 [istream.iterator]: #istream.iterator
 [istream.iterator.cons]: #istream.iterator.cons
+[istream.iterator.general]: #istream.iterator.general
 [istream.iterator.ops]: #istream.iterator.ops
 [istreambuf.iterator]: #istreambuf.iterator
 [istreambuf.iterator.cons]: #istreambuf.iterator.cons
+[istreambuf.iterator.general]: #istreambuf.iterator.general
 [istreambuf.iterator.ops]: #istreambuf.iterator.ops
 [istreambuf.iterator.proxy]: #istreambuf.iterator.proxy
 [iterator]: #iterator
 [iterator.assoc.types]: #iterator.assoc.types
 [iterator.concept.bidir]: #iterator.concept.bidir
 [iterator.concept.winc]: #iterator.concept.winc
 [iterator.concept.writable]: #iterator.concept.writable
 [iterator.concepts]: #iterator.concepts
 [iterator.concepts.general]: #iterator.concepts.general
 [iterator.cpp17]: #iterator.cpp17
+[iterator.cpp17.general]: #iterator.cpp17.general
 [iterator.cust]: #iterator.cust
 [iterator.cust.move]: #iterator.cust.move
 [iterator.cust.swap]: #iterator.cust.swap
 [iterator.iterators]: #iterator.iterators
 [iterator.operations]: #iterator.operations
 [iterator.primitives]: #iterator.primitives
+[iterator.primitives.general]: #iterator.primitives.general
 [iterator.range]: #iterator.range
 [iterator.requirements]: #iterator.requirements
 [iterator.requirements.general]: #iterator.requirements.general
 [iterator.synopsis]: #iterator.synopsis
 [iterator.traits]: #iterator.traits
 [move.iter.op.comp]: #move.iter.op.comp
 [move.iter.op.conv]: #move.iter.op.conv
 [move.iter.requirements]: #move.iter.requirements
 [move.iterator]: #move.iterator
 [move.iterators]: #move.iterators
+[move.iterators.general]: #move.iterators.general
 [move.sent.ops]: #move.sent.ops
 [move.sentinel]: #move.sentinel
 [namespace.std]: library.md#namespace.std
+[numeric.limits]: support.md#numeric.limits
 [ostream.iterator]: #ostream.iterator
 [ostream.iterator.cons.des]: #ostream.iterator.cons.des
+[ostream.iterator.general]: #ostream.iterator.general
 [ostream.iterator.ops]: #ostream.iterator.ops
 [ostreambuf.iter.cons]: #ostreambuf.iter.cons
 [ostreambuf.iter.ops]: #ostreambuf.iter.ops
 [ostreambuf.iterator]: #ostreambuf.iterator
+[ostreambuf.iterator.general]: #ostreambuf.iterator.general
 [output.iterators]: #output.iterators
 [outputiterator]: #outputiterator
 [predef.iterators]: #predef.iterators
 [projected]: #projected
 [random.access.iterators]: #random.access.iterators
 [range.iter.op.advance]: #range.iter.op.advance
 [range.iter.op.distance]: #range.iter.op.distance
 [range.iter.op.next]: #range.iter.op.next
 [range.iter.op.prev]: #range.iter.op.prev
 [range.iter.ops]: #range.iter.ops
+[range.iter.ops.general]: #range.iter.ops.general
 [ranges]: ranges.md#ranges
 [readable.traits]: #readable.traits
 [reverse.iter.cmp]: #reverse.iter.cmp
 [reverse.iter.cons]: #reverse.iter.cons
 [reverse.iter.conv]: #reverse.iter.conv
 [reverse.iter.nav]: #reverse.iter.nav
 [reverse.iter.nonmember]: #reverse.iter.nonmember
 [reverse.iter.requirements]: #reverse.iter.requirements
 [reverse.iterator]: #reverse.iterator
 [reverse.iterators]: #reverse.iterators
+[reverse.iterators.general]: #reverse.iterators.general
 [std.iterator.tags]: #std.iterator.tags
 [stream.buffers]: input.md#stream.buffers
 [stream.iterators]: #stream.iterators
+[stream.iterators.general]: #stream.iterators.general
 [swappable.requirements]: library.md#swappable.requirements
 [temp.deduct]: temp.md#temp.deduct
 [temp.func.order]: temp.md#temp.func.order
 [temp.inst]: temp.md#temp.inst
 [unreachable.sentinel]: #unreachable.sentinel
 [utility.arg.requirements]: library.md#utility.arg.requirements
+[^1]: The sentinel denoting the end of a range can have the same type as
     the iterator denoting the beginning of the range, or a different
     type.
 [^2]: This definition applies to pointers, since pointers are iterators.
     The effect of dereferencing an iterator that has been invalidated is

Diff to HTML by rtfpessoa