[iterators] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp2_fnllq6/{from.md → to.md} +181 -155

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

@@ -75,10 +75,11 @@ namespace std {
   // [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
@@ -159,14 +160,15 @@ namespace std {
     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
@@ -311,11 +313,11 @@ namespace std {
   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>
@@ -401,11 +403,11 @@ namespace std {
   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
@@ -489,15 +491,15 @@ namespace std {
     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
@@ -505,25 +507,25 @@ namespace std {
 }
 ```
 ## Iterator requirements <a id="iterator.requirements">[[iterator.requirements]]</a>
-### In general <a id="iterator.requirements.general">[[iterator.requirements.general]]</a>
 Iterators are a generalization of pointers that allow a C++ program to
 work with different data structures (for example, containers and ranges)
 in a uniform manner. To be able to construct template algorithms that
 work correctly and efficiently on different types of data structures,
 the library formalizes not just the interfaces but also the semantics
 and complexity assumptions of iterators. An input iterator `i` supports
 the expression `*i`, resulting in a value of some object type `T`,
 called the *value type* of the iterator. An output iterator `i` has a
-non-empty set of types that are `indirectly_writable` to the iterator;
-for each such type `T`, the expression `*i = o` is valid where `o` is a
-value of type `T`. For every iterator type `X`, there is a corresponding
-signed integer-like type [[iterator.concept.winc]] called the
-*difference type* of the iterator.
 Since iterators are an abstraction of pointers, their semantics are a
 generalization of most of the semantics of pointers in C++. This ensures
 that every function template that takes iterators works as well with
 regular pointers. This document defines six categories of iterators,
@@ -620,25 +622,41 @@ 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
 realizable for a given category in constant time (amortized). Therefore,
 requirement tables and concept definitions for the iterators do not
 specify complexity.
-Destruction of a non-forward iterator may invalidate pointers and
-references previously obtained from that iterator.
 An *invalid iterator* is an iterator that may be singular.[^2]
-Iterators are called *constexpr iterators* if all operations provided to
-meet iterator category requirements are constexpr functions.
-[*Note 3*: For example, the types “pointer to `int`” and
-`reverse_iterator<int*>` are constexpr iterators. — *end note*]
 ### Associated types <a id="iterator.assoc.types">[[iterator.assoc.types]]</a>
 #### Incrementable traits <a id="incrementable.traits">[[incrementable.traits]]</a>
@@ -669,11 +687,11 @@ namespace std {
     : incrementable_traits<I> { };
   template<class T>
     requires requires { typename T::difference_type; }
   struct incrementable_traits<T> {
-    using difference_type = typename T::difference_type;
   };
   template<class T>
     requires (!requires { typename T::difference_type; } &&
               requires(const T& a, const T& b) { { a - b } -> integral; })
@@ -874,27 +892,27 @@ The members of a specialization `iterator_traits<I>` generated from the
 - If `I` has valid [[temp.deduct]] member types `difference_type`,
   `value_type`, `reference`, and `iterator_category`, then
   `iterator_traits<I>` has the following publicly accessible members:
   ``` cpp
-  using iterator_category = typename I::iterator_category;
-  using value_type        = typename I::value_type;
-  using difference_type   = typename I::difference_type;
   using pointer           = see below;
-  using reference         = typename I::reference;
   ```
   If the *qualified-id* `I::pointer` is valid and denotes a type, then
   `iterator_traits<I>::pointer` names that type; otherwise, it names
   `void`.
 - Otherwise, if `I` satisfies the exposition-only concept
   `cpp17-input-iterator`, `iterator_traits<I>` has the following
   publicly accessible members:
   ``` cpp
   using iterator_category = see below;
-  using value_type        = typename indirectly_readable_traits<I>::value_type;
-  using difference_type   = typename incrementable_traits<I>::difference_type;
   using pointer           = see below;
   using reference         = see below;
   ```
   - If the *qualified-id* `I::pointer` is valid and denotes a type,
@@ -964,16 +982,14 @@ To implement a generic `reverse` function, a C++ program can do the
 following:
 ``` cpp
 template<class BI>
 void reverse(BI first, BI last) {
-  typename iterator_traits<BI>::difference_type n =
-    distance(first, last);
   --n;
   while (n > 0) {
-    typename iterator_traits<BI>::value_type
-     tmp = *first;
     *first++ = *--last;
     *last = tmp;
     n -= 2;
   }
 }
@@ -1008,11 +1024,11 @@ ill-formed, no diagnostic required.
 The name `ranges::iter_swap` denotes a customization point object
 [[customization.point.object]] that exchanges the values
 [[concept.swappable]] denoted by its arguments.
-Let *`iter-exchange-move`* be the exposition-only function:
 ``` cpp
 template<class X, class Y>
   constexpr iter_value_t<X> iter-exchange-move(X&& x, Y&& y)
     noexcept(noexcept(iter_value_t<X>(iter_move(x))) &&
@@ -1108,11 +1124,11 @@ Types that are indirectly readable by applying `operator*` model the
 `indirectly_readable` concept, including pointers, smart pointers, and
 iterators.
 ``` cpp
 template<class In>
-  concept indirectly-readable-impl =
     requires(const In in) {
       typename iter_value_t<In>;
       typename iter_reference_t<In>;
       typename iter_rvalue_reference_t<In>;
       { *in } -> same_as<iter_reference_t<In>>;
@@ -1150,11 +1166,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.
@@ -1303,19 +1319,19 @@ a signed-integer-like type.
 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
 - The expressions `++i` and `i++` have the same domain.
 - 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
@@ -1329,12 +1345,13 @@ be used with istreams as the source of the input data through the
 The `incrementable` concept specifies requirements on types that can be
 incremented with the pre- and post-increment operators. The increment
 operations are required to be equality-preserving, and the type is
 required to be `equality_comparable`.
-[*Note 1*: This supersedes the annotations on the increment expressions
-in the definition of `weakly_incrementable`. — *end note*]
 ``` cpp
 template<class I>
   concept incrementable =
     regular<I> &&
@@ -1343,11 +1360,11 @@ template<class I>
       { i++ } -> same_as<I>;
     };
 ```
 Let `a` and `b` be incrementable objects of type `I`. `I` models
-`incrementable` only if
 - If `bool(a == b)` then `bool(a++ == b)`.
 - If `bool(a == b)` then `bool(((void)a++, a) == ++b)`.
 [*Note 2*: The requirement that `a` equals `b` implies `++a` equals
@@ -1392,11 +1409,11 @@ template<class S, class I>
     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.
@@ -1426,11 +1443,11 @@ template<class S, class I>
 ```
 Let `i` be an iterator of type `I`, and `s` a sentinel of type `S` such
 that \[`i`, `s`) denotes a range. Let N be the smallest number of
 applications of `++i` necessary to make `bool(i == s)` be `true`. `S`
-and `I` model `sized_sentinel_for<S, I>` only if
 - If N is representable by `iter_difference_t<I>`, then `s - i` is
   well-defined and equals N.
 - If -N is representable by `iter_difference_t<I>`, then `i - s` is
   well-defined and equals -N.
@@ -1534,11 +1551,11 @@ end of the same empty sequence. — *end note*]
 Pointers and references obtained from a forward iterator into a range
 \[`i`, `s`) shall remain valid while \[`i`, `s`) continues to denote a
 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`.
@@ -1605,11 +1622,11 @@ template<class I>
 ```
 Let `a` and `b` be valid iterators of type `I` such that `b` is
 reachable from `a` after `n` applications of `++a`, let `D` be
 `iter_difference_t<I>`, and let `n` denote a value of type `D`. `I`
-models `random_access_iterator` only if
 - `(a += n)` is equal to `b`.
 - `addressof(a += n)` is equal to `addressof(a)`.
 - `(a + n)` is equal to `(a += n)`.
 - For any two positive values `x` and `y` of type `D`, if
@@ -1649,10 +1666,11 @@ non-dereferenceable iterator of type `I` such that `b` is reachable from
 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)`.
@@ -1679,11 +1697,11 @@ 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
@@ -1738,12 +1756,12 @@ 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
-if
 - `X` meets the *Cpp17InputIterator* requirements [[input.iterators]],
 - `X` meets the *Cpp17DefaultConstructible* requirements
   [[utility.arg.requirements]],
 - if `X` is a mutable iterator, `reference` is a reference to `T`; if
@@ -1759,11 +1777,11 @@ the same type.
 [*Note 1*: Value-initialized iterators behave as if they refer past the
 end of the same empty sequence. — *end note*]
 Two dereferenceable iterators `a` and `b` of type `X` offer the
-*multi-pass guarantee* if:
 - `a == b` implies `++a == ++b` and
 - `X` is a pointer type or the expression `(void)++X(a), *a` is
   equivalent to the expression `*a`.
@@ -1824,86 +1842,82 @@ namespace std {
     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
 namespace std {
-  template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>
-  struct projected {
       using value_type = remove_cvref_t<indirect_result_t<Proj&, I>>;
       indirect_result_t<Proj&, I> operator*() const;    // not defined
     };
-  template<weakly_incrementable I, class Proj>
-  struct incrementable_traits<projected<I, Proj>> {
-    using difference_type = iter_difference_t<I>;
   };
 }
 ```
 ### Common algorithm requirements <a id="alg.req">[[alg.req]]</a>
@@ -2222,38 +2236,12 @@ 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.
-[*Example 2*:
-``` cpp
-void foo() {
-    using namespace std::ranges;
-    std::vector<int> vec{1,2,3};
-    distance(begin(vec), end(vec));     // #1
-}
-```
-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
 template<input_or_output_iterator I>
@@ -2327,11 +2315,17 @@ number of increments.
 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);
 ```
@@ -2421,11 +2415,11 @@ namespace std {
     using iterator_type     = Iterator;
     using iterator_concept  = see below;
     using iterator_category = see below;
     using value_type        = iter_value_t<Iterator>;
     using difference_type   = iter_difference_t<Iterator>;
-    using pointer           = typename iterator_traits<Iterator>::pointer;
     using reference         = iter_reference_t<Iterator>;
     constexpr reverse_iterator();
     constexpr explicit reverse_iterator(Iterator x);
     template<class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
@@ -2498,14 +2492,11 @@ are instantiated [[temp.inst]].
 ``` cpp
 constexpr reverse_iterator();
 ```
-*Effects:* Value-initializes `current`. Iterator operations applied to
-the resulting iterator have defined behavior if and only if the
-corresponding operations are defined on a value-initialized iterator of
-type `Iterator`.
 ``` cpp
 constexpr explicit reverse_iterator(Iterator x);
 ```
@@ -2831,10 +2822,12 @@ the iterator points to in a container. `back_inserter`,
 `front_inserter`, and `inserter` are three functions making the insert
 iterators out of a container.
 #### Class template `back_insert_iterator` <a id="back.insert.iterator">[[back.insert.iterator]]</a>
 ``` cpp
 namespace std {
   template<class Container>
   class back_insert_iterator {
   protected:
@@ -2905,10 +2898,12 @@ template<class Container>
 *Returns:* `back_insert_iterator<Container>(x)`.
 #### Class template `front_insert_iterator` <a id="front.insert.iterator">[[front.insert.iterator]]</a>
 ``` cpp
 namespace std {
   template<class Container>
   class front_insert_iterator {
   protected:
@@ -2979,10 +2974,12 @@ template<class Container>
 *Returns:* `front_insert_iterator<Container>(x)`.
 #### Class template `insert_iterator` <a id="insert.iterator">[[insert.iterator]]</a>
 ``` cpp
 namespace std {
   template<class Container>
   class insert_iterator {
   protected:
@@ -3161,10 +3158,17 @@ namespace std {
       requires random_access_iterator<Iterator>;
     template<sentinel_for<Iterator> S>
       constexpr bool operator==(const S& s) const;
     constexpr bool operator<(const basic_const_iterator& y) const
       requires random_access_iterator<Iterator>;
     constexpr bool operator>(const basic_const_iterator& y) const
       requires random_access_iterator<Iterator>;
     constexpr bool operator<=(const basic_const_iterator& y) const
@@ -3382,10 +3386,26 @@ template<sentinel_for<Iterator> S>
   constexpr bool operator==(const S& s) const;
 ```
 *Effects:* Equivalent to: `return `*`current_`*` == s;`
 ``` cpp
 constexpr bool operator<(const basic_const_iterator& y) const
   requires random_access_iterator<Iterator>;
 constexpr bool operator>(const basic_const_iterator& y) const
   requires random_access_iterator<Iterator>;
@@ -3440,11 +3460,11 @@ template<not-a-const-iterator I>
     requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
 ```
 Let *`op`* be the operator.
-*Returns:* Equivalent to: `return x `*`op`*` y.`*`current_`*`;`
 ``` cpp
 friend constexpr basic_const_iterator operator+(const basic_const_iterator& i, difference_type n)
   requires random_access_iterator<Iterator>;
 friend constexpr basic_const_iterator operator+(difference_type n, const basic_const_iterator& i)
@@ -3994,11 +4014,11 @@ namespace std {
     template<sized_sentinel_for<I> I2, sized_sentinel_for<I> S2>
       requires sized_sentinel_for<S, I2>
     friend constexpr iter_difference_t<I2> operator-(
       const common_iterator& x, const common_iterator<I2, S2>& y);
-    friend constexpr iter_rvalue_reference_t<I> iter_move(const common_iterator& i)
       noexcept(noexcept(ranges::iter_move(declval<const I&>())))
         requires input_iterator<I>;
     template<indirectly_swappable<I> I2, class S2>
       friend constexpr void iter_swap(const common_iterator& x, const common_iterator<I2, S2>& y)
         noexcept(noexcept(ranges::iter_swap(declval<const I&>(), declval<const I2&>())));
@@ -4013,30 +4033,34 @@ namespace std {
   };
   template<input_iterator I, class S>
   struct iterator_traits<common_iterator<I, S>> {
     using iterator_concept = see below;
-    using iterator_category = see below;
     using value_type = iter_value_t<I>;
     using difference_type = iter_difference_t<I>;
     using pointer = see below;
     using reference = iter_reference_t<I>;
   };
 }
 ```
 #### Associated types <a id="common.iter.types">[[common.iter.types]]</a>
-The nested *typedef-name*s of the specialization of `iterator_traits`
-for `common_iterator<I, S>` are defined as follows.
 - `iterator_concept` denotes `forward_iterator_tag` if `I` models
   `forward_iterator`; otherwise it denotes `input_iterator_tag`.
-- `iterator_category` denotes `forward_iterator_tag` if the
-  *qualified-id* `iterator_traits<I>::iterator_category` is valid and
-  denotes a type that models `derived_from<forward_iterator_tag>`;
-  otherwise it denotes `input_iterator_tag`.
 - Let `a` denote an lvalue of type `const common_iterator<I, S>`. If the
   expression `a.operator->()` is well-formed, then `pointer` denotes
   `decltype(a.operator->())`. Otherwise, `pointer` denotes `void`.
 #### Constructors and conversions <a id="common.iter.const">[[common.iter.const]]</a>
@@ -4059,11 +4083,11 @@ constexpr common_iterator(S s);
 template<class I2, class S2>
   requires convertible_to<const I2&, I> && convertible_to<const S2&, S>
     constexpr common_iterator(const common_iterator<I2, S2>& x);
 ```
-*Preconditions:* `x.v_.valueless_by_exception()` is `false`.
 *Effects:* Initializes `v_` as if by
 `v_{in_place_index<`i`>, get<`i`>(x.v_)}`, where i is `x.v_.index()`.
 ``` cpp
@@ -4071,30 +4095,30 @@ template<class I2, class S2>
   requires convertible_to<const I2&, I> && convertible_to<const S2&, S> &&
            assignable_from<I&, const I2&> && assignable_from<S&, const S2&>
     constexpr common_iterator& operator=(const common_iterator<I2, S2>& x);
 ```
-*Preconditions:* `x.v_.valueless_by_exception()` is `false`.
 *Effects:* Equivalent to:
 - If `v_.index() == x.v_.index()`, then `get<`i`>(v_) = get<`i`>(x.v_)`.
 - Otherwise, `v_.emplace<`i`>(get<`i`>(x.v_))`.
 where i is `x.v_.index()`.
-*Returns:* `*this`
 #### Accessors <a id="common.iter.access">[[common.iter.access]]</a>
 ``` cpp
 constexpr decltype(auto) operator*();
 constexpr decltype(auto) operator*() const
   requires dereferenceable<const I>;
 ```
-*Preconditions:* `holds_alternative<I>(v_)` is `true`.
 *Effects:* Equivalent to: `return *get<I>(v_);`
 ``` cpp
 constexpr auto operator->() const
@@ -4108,11 +4132,11 @@ indirectly_readable<const I> &&
 (requires(const I& i) { i.operator->(); } ||
  is_reference_v<iter_reference_t<I>> ||
  constructible_from<iter_value_t<I>, iter_reference_t<I>>)
 ```
-*Preconditions:* `holds_alternative<I>(v_)` is `true`.
 *Effects:*
 - If `I` is a pointer type or if the expression
   `get<I>(v_).operator->()` is well-formed, equivalent to:
@@ -4141,21 +4165,21 @@ indirectly_readable<const I> &&
 ``` cpp
 constexpr common_iterator& operator++();
 ```
-*Preconditions:* `holds_alternative<I>(v_)` is `true`.
 *Effects:* Equivalent to `++get<I>(v_)`.
 *Returns:* `*this`.
 ``` cpp
 constexpr decltype(auto) operator++(int);
 ```
-*Preconditions:* `holds_alternative<I>(v_)` is `true`.
 *Effects:* If `I` models `forward_iterator`, equivalent to:
 ``` cpp
 common_iterator tmp = *this;
@@ -4206,12 +4230,12 @@ template<class I2, sentinel_for<I> S2>
   requires sentinel_for<S, I2>
 friend constexpr bool operator==(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 ```
-*Preconditions:* `x.v_.valueless_by_exception()` and
-`y.v_.valueless_by_exception()` are each `false`.
 *Returns:* `true` if i` == `j, and otherwise
 `get<`i`>(x.v_) == get<`j`>(y.v_)`, where i is `x.v_.index()` and j is
 `y.v_.index()`.
@@ -4220,12 +4244,12 @@ template<class I2, sentinel_for<I> S2>
   requires sentinel_for<S, I2> && equality_comparable_with<I, I2>
 friend constexpr bool operator==(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 ```
-*Preconditions:* `x.v_.valueless_by_exception()` and
-`y.v_.valueless_by_exception()` are each `false`.
 *Returns:* `true` if i and j are each `1`, and otherwise
 `get<`i`>(x.v_) == get<`j`>(y.v_)`, where i is `x.v_.index()` and j is
 `y.v_.index()`.
@@ -4234,37 +4258,37 @@ template<sized_sentinel_for<I> I2, sized_sentinel_for<I> S2>
   requires sized_sentinel_for<S, I2>
 friend constexpr iter_difference_t<I2> operator-(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 ```
-*Preconditions:* `x.v_.valueless_by_exception()` and
-`y.v_.valueless_by_exception()` are each `false`.
 *Returns:* `0` if i and j are each `1`, and otherwise
 `get<`i`>(x.v_) - get<`j`>(y.v_)`, where i is `x.v_.index()` and j is
 `y.v_.index()`.
 #### Customizations <a id="common.iter.cust">[[common.iter.cust]]</a>
 ``` cpp
-friend constexpr iter_rvalue_reference_t<I> iter_move(const common_iterator& i)
   noexcept(noexcept(ranges::iter_move(declval<const I&>())))
     requires input_iterator<I>;
 ```
-*Preconditions:* `holds_alternative<I>(i.v_)` is `true`.
 *Effects:* Equivalent to: `return ranges::iter_move(get<I>(i.v_));`
 ``` cpp
 template<indirectly_swappable<I> I2, class S2>
   friend constexpr void iter_swap(const common_iterator& x, const common_iterator<I2, S2>& y)
     noexcept(noexcept(ranges::iter_swap(declval<const I&>(), declval<const I2&>())));
 ```
-*Preconditions:* `holds_alternative<I>(x.v_)` and
-`holds_alternative<I2>(y.v_)` are each `true`.
 *Effects:* Equivalent to
 `ranges::iter_swap(get<I>(x.v_), get<I2>(y.v_))`.
 ### Default sentinel <a id="default.sentinel">[[default.sentinel]]</a>
@@ -4315,13 +4339,13 @@ namespace std {
   public:
     using iterator_type = I;
     using value_type = iter_value_t<I>;                         // present only
                         // if I models indirectly_readable
     using difference_type = iter_difference_t<I>;
-    using iterator_concept = typename I::iterator_concept; // present only
                         // if the qualified-id I::iterator_concept is valid and denotes a type
-    using iterator_category = typename I::iterator_category; // present only
                         // if the qualified-id I::iterator_category is valid and denotes a type
     constexpr counted_iterator() requires default_initializable<I> = default;
     constexpr counted_iterator(I x, iter_difference_t<I> n);
     template<class I2>
       requires convertible_to<const I2&, I>
@@ -4362,30 +4386,30 @@ namespace std {
       requires random_access_iterator<I>;
     template<common_with<I> I2>
       friend constexpr iter_difference_t<I2> operator-(
         const counted_iterator& x, const counted_iterator<I2>& y);
     friend constexpr iter_difference_t<I> operator-(
-      const counted_iterator& x, default_sentinel_t);
     friend constexpr iter_difference_t<I> operator-(
-      default_sentinel_t, const counted_iterator& y);
     constexpr counted_iterator& operator-=(iter_difference_t<I> n)
       requires random_access_iterator<I>;
     constexpr decltype(auto) operator[](iter_difference_t<I> n) const
       requires random_access_iterator<I>;
     template<common_with<I> I2>
       friend constexpr bool operator==(
         const counted_iterator& x, const counted_iterator<I2>& y);
     friend constexpr bool operator==(
-      const counted_iterator& x, default_sentinel_t);
     template<common_with<I> I2>
       friend constexpr strong_ordering operator<=>(
         const counted_iterator& x, const counted_iterator<I2>& y);
-    friend constexpr iter_rvalue_reference_t<I> iter_move(const counted_iterator& i)
       noexcept(noexcept(ranges::iter_move(i.current)))
         requires input_iterator<I>;
     template<indirectly_swappable<I> I2>
       friend constexpr void iter_swap(const counted_iterator& x, const counted_iterator<I2>& y)
         noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
@@ -4408,11 +4432,11 @@ namespace std {
 ``` cpp
 constexpr counted_iterator(I i, iter_difference_t<I> n);
 ```
-*Preconditions:* `n >= 0`.
 *Effects:* Initializes `current` with `std::move(i)` and `length` with
 `n`.
 ``` cpp
@@ -4460,11 +4484,11 @@ constexpr iter_difference_t<I> count() const noexcept;
 constexpr decltype(auto) operator*();
 constexpr decltype(auto) operator*() const
   requires dereferenceable<const I>;
 ```
-*Preconditions:* `length > 0` is `true`.
 *Effects:* Equivalent to: `return *current;`
 ``` cpp
 constexpr auto operator->() const noexcept
@@ -4476,21 +4500,21 @@ constexpr auto operator->() const noexcept
 ``` cpp
 constexpr decltype(auto) operator[](iter_difference_t<I> n) const
   requires random_access_iterator<I>;
 ```
-*Preconditions:* `n < length`.
 *Effects:* Equivalent to: `return current[n];`
 #### Navigation <a id="counted.iter.nav">[[counted.iter.nav]]</a>
 ``` cpp
 constexpr counted_iterator& operator++();
 ```
-*Preconditions:* `length > 0`.
 *Effects:* Equivalent to:
 ``` cpp
 ++current;
@@ -4500,11 +4524,11 @@ return *this;
 ``` cpp
 constexpr decltype(auto) operator++(int);
 ```
-*Preconditions:* `length > 0`.
 *Effects:* Equivalent to:
 ``` cpp
 --length;
@@ -4570,11 +4594,11 @@ friend constexpr counted_iterator operator+(
 ``` cpp
 constexpr counted_iterator& operator+=(iter_difference_t<I> n)
   requires random_access_iterator<I>;
 ```
-*Preconditions:* `n <= length`.
 *Effects:* Equivalent to:
 ``` cpp
 current += n;
@@ -4601,28 +4625,28 @@ sequence [[counted.iterator]].
 *Effects:* Equivalent to: `return y.length - x.length;`
 ``` cpp
 friend constexpr iter_difference_t<I> operator-(
-  const counted_iterator& x, default_sentinel_t);
 ```
 *Effects:* Equivalent to: `return -x.length;`
 ``` cpp
 friend constexpr iter_difference_t<I> operator-(
-  default_sentinel_t, const counted_iterator& y);
 ```
 *Effects:* Equivalent to: `return y.length;`
 ``` cpp
 constexpr counted_iterator& operator-=(iter_difference_t<I> n)
   requires random_access_iterator<I>;
 ```
-*Preconditions:* `-n <= length`.
 *Effects:* Equivalent to:
 ``` cpp
 current -= n;
@@ -4643,11 +4667,11 @@ sequence [[counted.iterator]].
 *Effects:* Equivalent to: `return x.length == y.length;`
 ``` cpp
 friend constexpr bool operator==(
-  const counted_iterator& x, default_sentinel_t);
 ```
 *Effects:* Equivalent to: `return x.length == 0;`
 ``` cpp
@@ -4665,28 +4689,28 @@ sequence [[counted.iterator]].
 because `length` counts down, not up. — *end note*]
 #### Customizations <a id="counted.iter.cust">[[counted.iter.cust]]</a>
 ``` cpp
-friend constexpr iter_rvalue_reference_t<I>
   iter_move(const counted_iterator& i)
     noexcept(noexcept(ranges::iter_move(i.current)))
     requires input_iterator<I>;
 ```
-*Preconditions:* `i.length > 0` is `true`.
 *Effects:* Equivalent to: `return ranges::iter_move(i.current);`
 ``` cpp
 template<indirectly_swappable<I> I2>
   friend constexpr void
     iter_swap(const counted_iterator& x, const counted_iterator<I2>& y)
       noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
 ```
-*Preconditions:* Both `x.length > 0` and `y.length > 0` are `true`.
 *Effects:* Equivalent to `ranges::iter_swap(x.current, y.current)`.
 ### Unreachable sentinel <a id="unreachable.sentinel">[[unreachable.sentinel]]</a>
@@ -5003,16 +5027,16 @@ namespace std {
   template<class charT, class traits = char_traits<charT>>
   class istreambuf_iterator {
   public:
     using iterator_category = input_iterator_tag;
     using value_type        = charT;
-    using difference_type   = typename traits::off_type;
     using pointer           = unspecified;
     using reference         = charT;
     using char_type         = charT;
     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
@@ -5226,14 +5250,14 @@ bool failed() const noexcept;
 ## Range access <a id="iterator.range">[[iterator.range]]</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());
 ```
@@ -5351,23 +5375,23 @@ template<class T, ptrdiff_t N> constexpr ptrdiff_t ssize(const T (&array)[N]) no
 ```
 *Returns:* `N`.
 ``` cpp
-template<class C> [[nodiscard]] constexpr auto empty(const C& c) -> decltype(c.empty());
 ```
 *Returns:* `c.empty()`.
 ``` cpp
-template<class T, size_t N> [[nodiscard]] constexpr bool empty(const T (&array)[N]) noexcept;
 ```
 *Returns:* `false`.
 ``` cpp
-template<class E> [[nodiscard]] constexpr bool empty(initializer_list<E> il) noexcept;
 ```
 *Returns:* `il.size() == 0`.
 ``` cpp
@@ -5388,25 +5412,26 @@ template<class E> constexpr const E* data(initializer_list<E> il) noexcept;
 ```
 *Returns:* `il.begin()`.
 <!-- Link reference definitions -->
 [alg.req]: #alg.req
 [alg.req.general]: #alg.req.general
 [alg.req.ind.cmp]: #alg.req.ind.cmp
 [alg.req.ind.copy]: #alg.req.ind.copy
 [alg.req.ind.move]: #alg.req.ind.move
 [alg.req.ind.swap]: #alg.req.ind.swap
 [alg.req.mergeable]: #alg.req.mergeable
 [alg.req.permutable]: #alg.req.permutable
 [alg.req.sortable]: #alg.req.sortable
 [back.insert.iter.ops]: #back.insert.iter.ops
 [back.insert.iterator]: #back.insert.iterator
 [back.inserter]: #back.inserter
 [basic.fundamental]: basic.md#basic.fundamental
 [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
@@ -5436,14 +5461,14 @@ template<class E> constexpr const E* data(initializer_list<E> il) noexcept;
 [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
 [front.insert.iterator]: #front.insert.iterator
 [front.inserter]: #front.inserter
 [func.def]: utilities.md#func.def
 [incrementable.traits]: #incrementable.traits
@@ -5451,10 +5476,11 @@ template<class E> constexpr const E* data(initializer_list<E> il) noexcept;
 [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

   // [iterator.concepts], iterator concepts
   // [iterator.concept.readable], concept indirectly_readable
   template<class In>
     concept indirectly_readable = see below;                                        // freestanding
+  // [indirectcallable.traits], indirect callable traits
   template<indirectly_readable T>
     using indirect-value-t = see below;         // exposition only
   template<indirectly_readable T>
     using iter_common_reference_t =                                                 // freestanding
     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>
+ using projected = see below; // freestanding
+  template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>
+  using projected_value_t =                                                         // freestanding
+    remove_cvref_t<invoke_result_t<Proj&, iter_value_t<I>&>>;
   // [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 Iterator>
     constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i);         // freestanding
   template<class Iterator1, class Iterator2>
     requires (!sized_sentinel_for<Iterator1, Iterator2>)
+    constexpr bool \libspec{disable_sized_sentinel_for}{reverse_iterator}<reverse_iterator<Iterator1>,          // freestanding
                                               reverse_iterator<Iterator2>> = true;
   // [insert.iterators], insert iterators
   template<class Container> class back_insert_iterator;                             // freestanding
   template<class Container>
   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 \libspec{disable_sized_sentinel_for}{move_iterator}<move_iterator<Iterator1>,             // freestanding
                                               move_iterator<Iterator2>> = true;
   template<semiregular S> class move_sentinel;                                      // freestanding
   // [iterators.common], common iterators
     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> constexpr auto
     empty(const C& c) -> decltype(c.empty());                                       // freestanding
+  template<class T, size_t N> constexpr bool
     empty(const T (&array)[N]) noexcept;                                            // freestanding
+  template<class E> 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
 }
 ```
 ## Iterator requirements <a id="iterator.requirements">[[iterator.requirements]]</a>
+### General <a id="iterator.requirements.general">[[iterator.requirements.general]]</a>
 Iterators are a generalization of pointers that allow a C++ program to
 work with different data structures (for example, containers and ranges)
 in a uniform manner. To be able to construct template algorithms that
 work correctly and efficiently on different types of data structures,
 the library formalizes not just the interfaces but also the semantics
 and complexity assumptions of iterators. An input iterator `i` supports
 the expression `*i`, resulting in a value of some object type `T`,
 called the *value type* of the iterator. An output iterator `i` has a
+non-empty set of types that are *writable* to the iterator; for each
+such type `T`, the expression `*i = o` is valid where `o` is a value of
+type `T`. For every iterator type `X`, there is a corresponding signed
+integer-like type [[iterator.concept.winc]] called the *difference type*
+of the iterator.
 Since iterators are an abstraction of pointers, their semantics are a
 generalization of most of the semantics of pointers in C++. This ensures
 that every function template that takes iterators works as well with
 regular pointers. This document defines six categories of iterators,
 is positive, `i` is dereferenceable, and `++i`+\[0, `–n`) is valid.
 The result of the application of library functions to invalid ranges is
 undefined.
+For an iterator `i` of a type that models `contiguous_iterator`
+[[iterator.concept.contiguous]], library functions are permitted to
+replace \[`i`, `s`) with \[`to_address(i)`,
+`to_address(i + ranges::distance(i, s))`), and to replace `i`+\[0, `n`)
+with \[`to_address(i)`, `to_address(i + n)`).
+[*Note 3*: This means a program cannot rely on any side effects of
+dereferencing a contiguous iterator `i`, because library functions might
+operate on pointers obtained by `to_address(i)` instead of operating on
+`i`. Similarly, a program cannot rely on any side effects of individual
+increments on a contiguous iterator `i`, because library functions might
+advance `i` only once. — *end note*]
 All the categories of iterators require only those functions that are
 realizable for a given category in constant time (amortized). Therefore,
 requirement tables and concept definitions for the iterators do not
 specify complexity.
+Destruction of an iterator may invalidate pointers and references
+previously obtained from that iterator if its type does not meet the
+*Cpp17ForwardIterator* requirements and does not model
+`forward_iterator`.
 An *invalid iterator* is an iterator that may be singular.[^2]
+Iterators meet the *constexpr iterator* requirements if all operations
+provided to meet iterator category requirements are constexpr functions.
+[*Note 4*: For example, the types “pointer to `int`” and
+`reverse_iterator<int*>` meet the constexpr iterator
+requirements. — *end note*]
 ### Associated types <a id="iterator.assoc.types">[[iterator.assoc.types]]</a>
 #### Incrementable traits <a id="incrementable.traits">[[incrementable.traits]]</a>
     : incrementable_traits<I> { };
   template<class T>
     requires requires { typename T::difference_type; }
   struct incrementable_traits<T> {
+    using difference_type = T::difference_type;
   };
   template<class T>
     requires (!requires { typename T::difference_type; } &&
               requires(const T& a, const T& b) { { a - b } -> integral; })
 - If `I` has valid [[temp.deduct]] member types `difference_type`,
   `value_type`, `reference`, and `iterator_category`, then
   `iterator_traits<I>` has the following publicly accessible members:
   ``` cpp
+  using iterator_category = I::iterator_category;
+  using value_type        = I::value_type;
+  using difference_type   = I::difference_type;
   using pointer           = see below;
+  using reference         = I::reference;
   ```
   If the *qualified-id* `I::pointer` is valid and denotes a type, then
   `iterator_traits<I>::pointer` names that type; otherwise, it names
   `void`.
 - Otherwise, if `I` satisfies the exposition-only concept
   `cpp17-input-iterator`, `iterator_traits<I>` has the following
   publicly accessible members:
   ``` cpp
   using iterator_category = see below;
+  using value_type        = indirectly_readable_traits<I>::value_type;
+  using difference_type   = incrementable_traits<I>::difference_type;
   using pointer           = see below;
   using reference         = see below;
   ```
   - If the *qualified-id* `I::pointer` is valid and denotes a type,
 following:
 ``` cpp
 template<class BI>
 void reverse(BI first, BI last) {
+  typename iterator_traits<BI>::difference_type n = distance(first, last);
   --n;
   while (n > 0) {
+    typename iterator_traits<BI>::value_type tmp = *first;
     *first++ = *--last;
     *last = tmp;
     n -= 2;
   }
 }
 The name `ranges::iter_swap` denotes a customization point object
 [[customization.point.object]] that exchanges the values
 [[concept.swappable]] denoted by its arguments.
+Let *`iter-exchange-move`* be the exposition-only function template:
 ``` cpp
 template<class X, class Y>
   constexpr iter_value_t<X> iter-exchange-move(X&& x, Y&& y)
     noexcept(noexcept(iter_value_t<X>(iter_move(x))) &&
 `indirectly_readable` concept, including pointers, smart pointers, and
 iterators.
 ``` cpp
 template<class In>
+  concept indirectly-readable-impl =                    // exposition only
     requires(const In in) {
       typename iter_value_t<In>;
       typename iter_reference_t<In>;
       typename iter_rvalue_reference_t<In>;
       { *in } -> same_as<iter_reference_t<In>>;
     };
 ```
 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.
 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:
 - The expressions `++i` and `i++` have the same domain.
 - 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 implementation 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
 The `incrementable` concept specifies requirements on types that can be
 incremented with the pre- and post-increment operators. The increment
 operations are required to be equality-preserving, and the type is
 required to be `equality_comparable`.
+[*Note 1*: This supersedes the “not required to be equality-preserving”
+comments on the increment expressions in the definition of
+`weakly_incrementable`. — *end note*]
 ``` cpp
 template<class I>
   concept incrementable =
     regular<I> &&
       { i++ } -> same_as<I>;
     };
 ```
 Let `a` and `b` be incrementable objects of type `I`. `I` models
+`incrementable` only if:
 - If `bool(a == b)` then `bool(a++ == b)`.
 - If `bool(a == b)` then `bool(((void)a++, a) == ++b)`.
 [*Note 2*: The requirement that `a` equals `b` implies `++a` equals
     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.
 ```
 Let `i` be an iterator of type `I`, and `s` a sentinel of type `S` such
 that \[`i`, `s`) denotes a range. Let N be the smallest number of
 applications of `++i` necessary to make `bool(i == s)` be `true`. `S`
+and `I` model `sized_sentinel_for<S, I>` only if:
 - If N is representable by `iter_difference_t<I>`, then `s - i` is
   well-defined and equals N.
 - If -N is representable by `iter_difference_t<I>`, then `i - s` is
   well-defined and equals -N.
 Pointers and references obtained from a forward iterator into a range
 \[`i`, `s`) shall remain valid while \[`i`, `s`) continues to denote a
 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`.
 ```
 Let `a` and `b` be valid iterators of type `I` such that `b` is
 reachable from `a` after `n` applications of `++a`, let `D` be
 `iter_difference_t<I>`, and let `n` denote a value of type `D`. `I`
+models `random_access_iterator` only if:
 - `(a += n)` is equal to `b`.
 - `addressof(a += n)` is equal to `addressof(a)`.
 - `(a + n)` is equal to `(a += n)`.
 - For any two positive values `x` and `y` of type `D`, if
 if
 - `to_address(a) == addressof(*a)`,
 - `to_address(b) == to_address(a) + D(b - a)`,
 - `to_address(c) == to_address(a) + D(c - a)`,
+- `to_address(I{})` is well-defined,
 - `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)`.
 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
 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 *Cpp17ForwardIterator*
+requirements if
 - `X` meets the *Cpp17InputIterator* requirements [[input.iterators]],
 - `X` meets the *Cpp17DefaultConstructible* requirements
   [[utility.arg.requirements]],
 - if `X` is a mutable iterator, `reference` is a reference to `T`; if
 [*Note 1*: Value-initialized iterators behave as if they refer past the
 end of the same empty sequence. — *end note*]
 Two dereferenceable iterators `a` and `b` of type `X` offer the
+*multi-pass guarantee* if
 - `a == b` implies `++a == ++b` and
 - `X` is a pointer type or the expression `(void)++X(a), *a` is
   equivalent to the expression `*a`.
     concept indirectly_unary_invocable =
       indirectly_readable<I> &&
       copy_constructible<F> &&
       invocable<F&, indirect-value-t<I>> &&
       invocable<F&, iter_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>> &&
       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>>;
   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>>;
   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>>;
   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>>;
 }
 ```
+#### Alias template `projected` <a id="projected">[[projected]]</a>
+Alias 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
 namespace std {
+  template<class I, class Proj>
+  struct projected-impl {                               // exposition only
+    struct type {                                       // exposition only
       using value_type = remove_cvref_t<indirect_result_t<Proj&, I>>;
+      using difference_type = iter_difference_t<I>;     // present only if I
+                                                        // models weakly_incrementable
       indirect_result_t<Proj&, I> operator*() const;    // not defined
     };
   };
+  template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>
+    using projected = projected-impl<I, Proj>::type;
 }
 ```
 ### Common algorithm requirements <a id="alg.req">[[alg.req]]</a>
 `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 entities defined in [[range.iter.ops]] are algorithm function
+objects [[alg.func.obj]].
 #### `ranges::advance` <a id="range.iter.op.advance">[[range.iter.op.advance]]</a>
 ``` cpp
 template<input_or_output_iterator I>
 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:
+``` cpp
+if constexpr (!is_array_v<remove_reference_t<I>>)
+  return last - first;
+else
+  return last - static_cast<decay_t<I>>(first);
+```
 ``` cpp
 template<range R>
   constexpr range_difference_t<R> ranges::distance(R&& r);
 ```
     using iterator_type     = Iterator;
     using iterator_concept  = see below;
     using iterator_category = see below;
     using value_type        = iter_value_t<Iterator>;
     using difference_type   = iter_difference_t<Iterator>;
+    using pointer           = iterator_traits<Iterator>::pointer;
     using reference         = iter_reference_t<Iterator>;
     constexpr reverse_iterator();
     constexpr explicit reverse_iterator(Iterator x);
     template<class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
 ``` cpp
 constexpr reverse_iterator();
 ```
+*Effects:* Value-initializes `current`.
 ``` cpp
 constexpr explicit reverse_iterator(Iterator x);
 ```
 `front_inserter`, and `inserter` are three functions making the insert
 iterators out of a container.
 #### Class template `back_insert_iterator` <a id="back.insert.iterator">[[back.insert.iterator]]</a>
+##### General <a id="back.insert.iter.general">[[back.insert.iter.general]]</a>
 ``` cpp
 namespace std {
   template<class Container>
   class back_insert_iterator {
   protected:
 *Returns:* `back_insert_iterator<Container>(x)`.
 #### Class template `front_insert_iterator` <a id="front.insert.iterator">[[front.insert.iterator]]</a>
+##### General <a id="front.insert.iter.general">[[front.insert.iter.general]]</a>
 ``` cpp
 namespace std {
   template<class Container>
   class front_insert_iterator {
   protected:
 *Returns:* `front_insert_iterator<Container>(x)`.
 #### Class template `insert_iterator` <a id="insert.iterator">[[insert.iterator]]</a>
+##### General <a id="insert.iter.general">[[insert.iter.general]]</a>
 ``` cpp
 namespace std {
   template<class Container>
   class insert_iterator {
   protected:
       requires random_access_iterator<Iterator>;
     template<sentinel_for<Iterator> S>
       constexpr bool operator==(const S& s) const;
+    template<not-a-const-iterator CI>
+      requires constant-iterator<CI> && convertible_to<Iterator const&, CI>
+    constexpr operator CI() const &;
+    template<not-a-const-iterator CI>
+      requires constant-iterator<CI> && convertible_to<Iterator, CI>
+    constexpr operator CI() &&;
     constexpr bool operator<(const basic_const_iterator& y) const
       requires random_access_iterator<Iterator>;
     constexpr bool operator>(const basic_const_iterator& y) const
       requires random_access_iterator<Iterator>;
     constexpr bool operator<=(const basic_const_iterator& y) const
   constexpr bool operator==(const S& s) const;
 ```
 *Effects:* Equivalent to: `return `*`current_`*` == s;`
+``` cpp
+template<not-a-const-iterator CI>
+  requires constant-iterator<CI> && convertible_to<Iterator const&, CI>
+constexpr operator CI() const &;
+```
+*Returns:* *current\_*.
+``` cpp
+template<not-a-const-iterator CI>
+  requires constant-iterator<CI> && convertible_to<Iterator, CI>
+constexpr operator CI() &&;
+```
+*Returns:* `std::move(`*`current_`*`)`.
 ``` cpp
 constexpr bool operator<(const basic_const_iterator& y) const
   requires random_access_iterator<Iterator>;
 constexpr bool operator>(const basic_const_iterator& y) const
   requires random_access_iterator<Iterator>;
     requires random_access_iterator<Iterator> && totally_ordered_with<Iterator, I>;
 ```
 Let *`op`* be the operator.
+*Effects:* Equivalent to: `return x `*`op`*` y.`*`current_`*`;`
 ``` cpp
 friend constexpr basic_const_iterator operator+(const basic_const_iterator& i, difference_type n)
   requires random_access_iterator<Iterator>;
 friend constexpr basic_const_iterator operator+(difference_type n, const basic_const_iterator& i)
     template<sized_sentinel_for<I> I2, sized_sentinel_for<I> S2>
       requires sized_sentinel_for<S, I2>
     friend constexpr iter_difference_t<I2> operator-(
       const common_iterator& x, const common_iterator<I2, S2>& y);
+    friend constexpr decltype(auto) iter_move(const common_iterator& i)
       noexcept(noexcept(ranges::iter_move(declval<const I&>())))
         requires input_iterator<I>;
     template<indirectly_swappable<I> I2, class S2>
       friend constexpr void iter_swap(const common_iterator& x, const common_iterator<I2, S2>& y)
         noexcept(noexcept(ranges::iter_swap(declval<const I&>(), declval<const I2&>())));
   };
   template<input_iterator I, class S>
   struct iterator_traits<common_iterator<I, S>> {
     using iterator_concept = see below;
+    using iterator_category = see below;  // not always present
     using value_type = iter_value_t<I>;
     using difference_type = iter_difference_t<I>;
     using pointer = see below;
     using reference = iter_reference_t<I>;
   };
 }
 ```
 #### Associated types <a id="common.iter.types">[[common.iter.types]]</a>
+The nested *typedef-name* `iterator_category` of the specialization of
+`iterator_traits` for `common_iterator<I, S>` is defined if and only if
+`iter_difference_t<I>` is an integral type. In that case,
+`iterator_category` denotes `forward_iterator_tag` if the *qualified-id*
+`iterator_traits<I>::iterator_category` is valid and denotes a type that
+models `derived_from<forward_iterator_tag>`; otherwise it denotes
+`input_iterator_tag`.
+The remaining nested *typedef-name*s of the specialization of
+`iterator_traits` for `common_iterator<I, S>` are defined as follows:
 - `iterator_concept` denotes `forward_iterator_tag` if `I` models
   `forward_iterator`; otherwise it denotes `input_iterator_tag`.
 - Let `a` denote an lvalue of type `const common_iterator<I, S>`. If the
   expression `a.operator->()` is well-formed, then `pointer` denotes
   `decltype(a.operator->())`. Otherwise, `pointer` denotes `void`.
 #### Constructors and conversions <a id="common.iter.const">[[common.iter.const]]</a>
 template<class I2, class S2>
   requires convertible_to<const I2&, I> && convertible_to<const S2&, S>
     constexpr common_iterator(const common_iterator<I2, S2>& x);
 ```
+`x.v_.valueless_by_exception()` is `false`.
 *Effects:* Initializes `v_` as if by
 `v_{in_place_index<`i`>, get<`i`>(x.v_)}`, where i is `x.v_.index()`.
 ``` cpp
   requires convertible_to<const I2&, I> && convertible_to<const S2&, S> &&
            assignable_from<I&, const I2&> && assignable_from<S&, const S2&>
     constexpr common_iterator& operator=(const common_iterator<I2, S2>& x);
 ```
+`x.v_.valueless_by_exception()` is `false`.
 *Effects:* Equivalent to:
 - If `v_.index() == x.v_.index()`, then `get<`i`>(v_) = get<`i`>(x.v_)`.
 - Otherwise, `v_.emplace<`i`>(get<`i`>(x.v_))`.
 where i is `x.v_.index()`.
+*Returns:* `*this`.
 #### Accessors <a id="common.iter.access">[[common.iter.access]]</a>
 ``` cpp
 constexpr decltype(auto) operator*();
 constexpr decltype(auto) operator*() const
   requires dereferenceable<const I>;
 ```
+`holds_alternative<I>(v_)` is `true`.
 *Effects:* Equivalent to: `return *get<I>(v_);`
 ``` cpp
 constexpr auto operator->() const
 (requires(const I& i) { i.operator->(); } ||
  is_reference_v<iter_reference_t<I>> ||
  constructible_from<iter_value_t<I>, iter_reference_t<I>>)
 ```
+`holds_alternative<I>(v_)` is `true`.
 *Effects:*
 - If `I` is a pointer type or if the expression
   `get<I>(v_).operator->()` is well-formed, equivalent to:
 ``` cpp
 constexpr common_iterator& operator++();
 ```
+`holds_alternative<I>(v_)` is `true`.
 *Effects:* Equivalent to `++get<I>(v_)`.
 *Returns:* `*this`.
 ``` cpp
 constexpr decltype(auto) operator++(int);
 ```
+`holds_alternative<I>(v_)` is `true`.
 *Effects:* If `I` models `forward_iterator`, equivalent to:
 ``` cpp
 common_iterator tmp = *this;
   requires sentinel_for<S, I2>
 friend constexpr bool operator==(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 ```
+`x.v_.valueless_by_exception()` and `y.v_.valueless_by_exception()` are
+each `false`.
 *Returns:* `true` if i` == `j, and otherwise
 `get<`i`>(x.v_) == get<`j`>(y.v_)`, where i is `x.v_.index()` and j is
 `y.v_.index()`.
   requires sentinel_for<S, I2> && equality_comparable_with<I, I2>
 friend constexpr bool operator==(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 ```
+`x.v_.valueless_by_exception()` and `y.v_.valueless_by_exception()` are
+each `false`.
 *Returns:* `true` if i and j are each `1`, and otherwise
 `get<`i`>(x.v_) == get<`j`>(y.v_)`, where i is `x.v_.index()` and j is
 `y.v_.index()`.
   requires sized_sentinel_for<S, I2>
 friend constexpr iter_difference_t<I2> operator-(
   const common_iterator& x, const common_iterator<I2, S2>& y);
 ```
+`x.v_.valueless_by_exception()` and `y.v_.valueless_by_exception()` are
+each `false`.
 *Returns:* `0` if i and j are each `1`, and otherwise
 `get<`i`>(x.v_) - get<`j`>(y.v_)`, where i is `x.v_.index()` and j is
 `y.v_.index()`.
 #### Customizations <a id="common.iter.cust">[[common.iter.cust]]</a>
 ``` cpp
+friend constexpr decltype(auto) iter_move(const common_iterator& i)
   noexcept(noexcept(ranges::iter_move(declval<const I&>())))
     requires input_iterator<I>;
 ```
+`holds_alternative<I>(i.v_)` is `true`.
 *Effects:* Equivalent to: `return ranges::iter_move(get<I>(i.v_));`
 ``` cpp
 template<indirectly_swappable<I> I2, class S2>
   friend constexpr void iter_swap(const common_iterator& x, const common_iterator<I2, S2>& y)
     noexcept(noexcept(ranges::iter_swap(declval<const I&>(), declval<const I2&>())));
 ```
+`holds_alternative<I>(x.v_)` and `holds_alternative<I2>(y.v_)` are each
+`true`.
 *Effects:* Equivalent to
 `ranges::iter_swap(get<I>(x.v_), get<I2>(y.v_))`.
 ### Default sentinel <a id="default.sentinel">[[default.sentinel]]</a>
   public:
     using iterator_type = I;
     using value_type = iter_value_t<I>;                         // present only
                         // if I models indirectly_readable
     using difference_type = iter_difference_t<I>;
+    using iterator_concept = I::iterator_concept; // present only
                         // if the qualified-id I::iterator_concept is valid and denotes a type
+    using iterator_category = I::iterator_category; // present only
                         // if the qualified-id I::iterator_category is valid and denotes a type
     constexpr counted_iterator() requires default_initializable<I> = default;
     constexpr counted_iterator(I x, iter_difference_t<I> n);
     template<class I2>
       requires convertible_to<const I2&, I>
       requires random_access_iterator<I>;
     template<common_with<I> I2>
       friend constexpr iter_difference_t<I2> operator-(
         const counted_iterator& x, const counted_iterator<I2>& y);
     friend constexpr iter_difference_t<I> operator-(
+      const counted_iterator& x, default_sentinel_t) noexcept;
     friend constexpr iter_difference_t<I> operator-(
+      default_sentinel_t, const counted_iterator& y) noexcept;
     constexpr counted_iterator& operator-=(iter_difference_t<I> n)
       requires random_access_iterator<I>;
     constexpr decltype(auto) operator[](iter_difference_t<I> n) const
       requires random_access_iterator<I>;
     template<common_with<I> I2>
       friend constexpr bool operator==(
         const counted_iterator& x, const counted_iterator<I2>& y);
     friend constexpr bool operator==(
+      const counted_iterator& x, default_sentinel_t) noexcept;
     template<common_with<I> I2>
       friend constexpr strong_ordering operator<=>(
         const counted_iterator& x, const counted_iterator<I2>& y);
+    friend constexpr decltype(auto) iter_move(const counted_iterator& i)
       noexcept(noexcept(ranges::iter_move(i.current)))
         requires input_iterator<I>;
     template<indirectly_swappable<I> I2>
       friend constexpr void iter_swap(const counted_iterator& x, const counted_iterator<I2>& y)
         noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
 ``` cpp
 constexpr counted_iterator(I i, iter_difference_t<I> n);
 ```
+`n >= 0` is `true`.
 *Effects:* Initializes `current` with `std::move(i)` and `length` with
 `n`.
 ``` cpp
 constexpr decltype(auto) operator*();
 constexpr decltype(auto) operator*() const
   requires dereferenceable<const I>;
 ```
+`length > 0` is `true`.
 *Effects:* Equivalent to: `return *current;`
 ``` cpp
 constexpr auto operator->() const noexcept
 ``` cpp
 constexpr decltype(auto) operator[](iter_difference_t<I> n) const
   requires random_access_iterator<I>;
 ```
+`n < length` is `true`.
 *Effects:* Equivalent to: `return current[n];`
 #### Navigation <a id="counted.iter.nav">[[counted.iter.nav]]</a>
 ``` cpp
 constexpr counted_iterator& operator++();
 ```
+`length > 0` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 ++current;
 ``` cpp
 constexpr decltype(auto) operator++(int);
 ```
+`length > 0` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 --length;
 ``` cpp
 constexpr counted_iterator& operator+=(iter_difference_t<I> n)
   requires random_access_iterator<I>;
 ```
+`n <= length` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 current += n;
 *Effects:* Equivalent to: `return y.length - x.length;`
 ``` cpp
 friend constexpr iter_difference_t<I> operator-(
+  const counted_iterator& x, default_sentinel_t) noexcept;
 ```
 *Effects:* Equivalent to: `return -x.length;`
 ``` cpp
 friend constexpr iter_difference_t<I> operator-(
+  default_sentinel_t, const counted_iterator& y) noexcept;
 ```
 *Effects:* Equivalent to: `return y.length;`
 ``` cpp
 constexpr counted_iterator& operator-=(iter_difference_t<I> n)
   requires random_access_iterator<I>;
 ```
+`-n <= length` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 current -= n;
 *Effects:* Equivalent to: `return x.length == y.length;`
 ``` cpp
 friend constexpr bool operator==(
+  const counted_iterator& x, default_sentinel_t) noexcept;
 ```
 *Effects:* Equivalent to: `return x.length == 0;`
 ``` cpp
 because `length` counts down, not up. — *end note*]
 #### Customizations <a id="counted.iter.cust">[[counted.iter.cust]]</a>
 ``` cpp
+friend constexpr decltype(auto)
   iter_move(const counted_iterator& i)
     noexcept(noexcept(ranges::iter_move(i.current)))
     requires input_iterator<I>;
 ```
+`i.length > 0` is `true`.
 *Effects:* Equivalent to: `return ranges::iter_move(i.current);`
 ``` cpp
 template<indirectly_swappable<I> I2>
   friend constexpr void
     iter_swap(const counted_iterator& x, const counted_iterator<I2>& y)
       noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
 ```
+Both `x.length > 0` and `y.length > 0` are `true`.
 *Effects:* Equivalent to `ranges::iter_swap(x.current, y.current)`.
 ### Unreachable sentinel <a id="unreachable.sentinel">[[unreachable.sentinel]]</a>
   template<class charT, class traits = char_traits<charT>>
   class istreambuf_iterator {
   public:
     using iterator_category = input_iterator_tag;
     using value_type        = charT;
+    using difference_type   = traits::off_type;
     using pointer           = unspecified;
     using reference         = charT;
     using char_type         = charT;
     using traits_type       = traits;
+    using int_type          = 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
 ## Range access <a id="iterator.range">[[iterator.range]]</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>`, `<flat_map>`,
+`<flat_set>`, `<forward_list>`, `<hive>`, `<inplace_vector>`, `<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());
 ```
 ```
 *Returns:* `N`.
 ``` cpp
+template<class C> constexpr auto empty(const C& c) -> decltype(c.empty());
 ```
 *Returns:* `c.empty()`.
 ``` cpp
+template<class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept;
 ```
 *Returns:* `false`.
 ``` cpp
+template<class E> constexpr bool empty(initializer_list<E> il) noexcept;
 ```
 *Returns:* `il.size() == 0`.
 ``` cpp
 ```
 *Returns:* `il.begin()`.
 <!-- Link reference definitions -->
+[alg.func.obj]: library.md#alg.func.obj
 [alg.req]: #alg.req
 [alg.req.general]: #alg.req.general
 [alg.req.ind.cmp]: #alg.req.ind.cmp
 [alg.req.ind.copy]: #alg.req.ind.copy
 [alg.req.ind.move]: #alg.req.ind.move
 [alg.req.ind.swap]: #alg.req.ind.swap
 [alg.req.mergeable]: #alg.req.mergeable
 [alg.req.permutable]: #alg.req.permutable
 [alg.req.sortable]: #alg.req.sortable
+[back.insert.iter.general]: #back.insert.iter.general
 [back.insert.iter.ops]: #back.insert.iter.ops
 [back.insert.iterator]: #back.insert.iterator
 [back.inserter]: #back.inserter
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lval]: expr.md#basic.lval
 [bidirectional.iterators]: #bidirectional.iterators
 [bidirectionaliterator]: #bidirectionaliterator
 [cmp.concept]: support.md#cmp.concept
 [common.iter.access]: #common.iter.access
 [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.const]: expr.md#expr.const
 [forward.iterators]: #forward.iterators
 [forwarditerator]: #forwarditerator
+[front.insert.iter.general]: #front.insert.iter.general
 [front.insert.iter.ops]: #front.insert.iter.ops
 [front.insert.iterator]: #front.insert.iterator
 [front.inserter]: #front.inserter
 [func.def]: utilities.md#func.def
 [incrementable.traits]: #incrementable.traits
 [indirectcallable.general]: #indirectcallable.general
 [indirectcallable.indirectinvocable]: #indirectcallable.indirectinvocable
 [indirectcallable.traits]: #indirectcallable.traits
 [input.iterators]: #input.iterators
 [inputiterator]: #inputiterator
+[insert.iter.general]: #insert.iter.general
 [insert.iter.ops]: #insert.iter.ops
 [insert.iterator]: #insert.iterator
 [insert.iterators]: #insert.iterators
 [insert.iterators.general]: #insert.iterators.general
 [inserter]: #inserter

Diff to HTML by rtfpessoa