[range.adaptors] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpo_3wurqs/{from.md → to.md} +1520 -75

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

@@ -157,11 +157,11 @@ exactly like `optional<T>` with the following differences:
 - Otherwise, `movable-box<T>` should store only a `T` if either `T`
   models `movable` or `is_nothrow_move_constructible_v<T>` is `true`.
 ### Non-propagating cache <a id="range.nonprop.cache">[[range.nonprop.cache]]</a>
-Some types in subclause [[range.adaptors]] are specified in terms of an
 exposition-only class template *`non-propagating-{}cache`*.
 `non-propagating-cache<T>` behaves exactly like `optional<T>` with the
 following differences:
 - `non-propagating-cache<T>` constrains its type parameter `T` with
@@ -236,10 +236,20 @@ namespace std::ranges {
   template<class T>
   constexpr T& as-lvalue(T&& t) {                   // exposition only
     return static_cast<T&>(t);
   }
 }
 ```
 ### All view <a id="range.all">[[range.all]]</a>
@@ -283,10 +293,13 @@ namespace std::ranges {
     { return ranges::empty(*r_); }
     constexpr auto size() const requires sized_range<R>
     { return ranges::size(*r_); }
     constexpr auto data() const requires contiguous_range<R>
     { return ranges::data(*r_); }
   };
   template<class R>
@@ -356,10 +369,15 @@ namespace std::ranges {
     constexpr auto size() requires sized_range<R>
     { return ranges::size(r_); }
     constexpr auto size() const requires sized_range<const R>
     { return ranges::size(r_); }
     constexpr auto data() requires contiguous_range<R>
     { return ranges::data(r_); }
     constexpr auto data() const requires contiguous_range<const R>
     { return ranges::data(r_); }
   };
@@ -384,11 +402,11 @@ to replace copying with moving.
 The name `views::as_rvalue` denotes a range adaptor object
 [[range.adaptor.object]]. Let `E` be an expression and let `T` be
 `decltype((E))`. The expression `views::as_rvalue(E)` is
 expression-equivalent to:
-- `views::all(E)` if
   `same_as<range_rvalue_reference_t<T>, range_reference_t<T>>` is
   `true`.
 - Otherwise, `as_rvalue_view(E)`.
 [*Example 1*:
@@ -438,10 +456,15 @@ namespace std::ranges {
       }
     }
     constexpr auto size() requires sized_range<V> { return ranges::size(base_); }
     constexpr auto size() const requires sized_range<const V> { return ranges::size(base_); }
   };
   template<class R>
     as_rvalue_view(R&&) -> as_rvalue_view<views::all_t<R>>;
 }
@@ -825,10 +848,15 @@ namespace std::ranges {
                regular_invocable<const F&, range_reference_t<const V>>;
     constexpr auto size() requires sized_range<V> { return ranges::size(base_); }
     constexpr auto size() const requires sized_range<const V>
     { return ranges::size(base_); }
   };
   template<class R, class F>
     transform_view(R&&, F) -> transform_view<views::all_t<R>, F>;
 }
@@ -1408,10 +1436,26 @@ namespace std::ranges {
     constexpr auto size() const requires sized_range<const V> {
       auto n = ranges::size(base_);
       return ranges::min(n, static_cast<decltype(n)>(count_));
     }
   };
   template<class R>
     take_view(R&&, range_difference_t<R>)
       -> take_view<views::all_t<R>>;
@@ -1661,12 +1705,12 @@ expression `views::drop(E, F)` is expression-equivalent to:
   then
   `U(ranges::begin(E) + std::min<D>(ranges::distance(E), F), ranges::end(E))`,
   except that `E` is evaluated only once, where `U` is
   `span<typename T::element_type>` if `T` is a specialization of `span`
   and `T` otherwise.
-- Otherwise, if `T` is a specialization of `subrange` [[range.subrange]]
- that models `random_access_range` and `sized_range`, then
   `T(ranges::begin(E) + std::min<D>(ranges::distance(E), F), ranges::{}end(E),
   to-unsigned-like(ranges::distance(E) -
   std::min<D>(ranges::distance(E), F)))`, except that `E` and `F` are
   each evaluated only once.
 - Otherwise, if `T` is a specialization of `repeat_view`
@@ -1727,10 +1771,20 @@ namespace std::ranges {
       const auto s = ranges::size(base_);
       const auto c = static_cast<decltype(s)>(count_);
       return s < c ? 0 : s - c;
     }
   private:
     V base_ = V();                              // exposition only
     range_difference_t<V> count_ = 0;           // exposition only
   };
@@ -2233,11 +2287,11 @@ friend constexpr void iter_swap(const iterator& x, const iterator& y)
   noexcept(noexcept(ranges::iter_swap(*x.inner_, *y.inner_)))
   requires indirectly_swappable<InnerIter>;
 ```
 *Effects:* Equivalent to:
-`return ranges::iter_swap(*x.`*`inner_`*`, *y.`*`inner_`*`);`
 #### Class template `join_view::sentinel` <a id="range.join.sentinel">[[range.join.sentinel]]</a>
 ``` cpp
 namespace std::ranges {
@@ -2312,23 +2366,17 @@ for (char c : vs | views::join_with('-')) {
 #### Class template `join_with_view` <a id="range.join.with.view">[[range.join.with.view]]</a>
 ``` cpp
 namespace std::ranges {
-  template<class R, class P>
-  concept compatible-joinable-ranges =            // exposition only
-      common_with<range_value_t<R>, range_value_t<P>> &&
-      common_reference_with<range_reference_t<R>, range_reference_t<P>> &&
-      common_reference_with<range_rvalue_reference_t<R>, range_rvalue_reference_t<P>>;
   template<class R>
   concept bidirectional-common = bidirectional_range<R> && common_range<R>;    // exposition only
   template<input_range V, forward_range Pattern>
     requires view<V> && input_range<range_reference_t<V>>
           && view<Pattern>
-          && compatible-joinable-ranges<range_reference_t<V>, Pattern>
   class join_with_view : public view_interface<join_with_view<V, Pattern>> {
     using InnerRng = range_reference_t<V>;                  // exposition only
     V base_ = V();                                          // exposition only
     non-propagating-cache<iterator_t<V>> outer_it_;         // exposition only, present only
@@ -2370,11 +2418,12 @@ namespace std::ranges {
     }
     constexpr auto begin() const
       requires forward_range<const V> &&
                forward_range<const Pattern> &&
                is_reference_v<range_reference_t<const V>> &&
-               input_range<range_reference_t<const V>> {
       return iterator<true>{*this, ranges::begin(base_)};
     }
     constexpr auto end() {
       if constexpr (forward_range<V> &&
@@ -2385,11 +2434,12 @@ namespace std::ranges {
         return sentinel<simple-view<V> && simple-view<Pattern>>{*this};
     }
     constexpr auto end() const
       requires forward_range<const V> && forward_range<const Pattern> &&
                is_reference_v<range_reference_t<const V>> &&
-               input_range<range_reference_t<const V>> {
       using InnerConstRng = range_reference_t<const V>;
       if constexpr (forward_range<InnerConstRng> &&
                     common_range<const V> && common_range<InnerConstRng>)
         return iterator<true>{*this, ranges::end(base_)};
       else
@@ -2427,11 +2477,11 @@ and *pattern\_* with `views::single(std::move(e))`.
 ``` cpp
 namespace std::ranges {
   template<input_range V, forward_range Pattern>
     requires view<V> && input_range<range_reference_t<V>>
-          && view<Pattern> && compatible-joinable-ranges<range_reference_t<V>, Pattern>
   template<bool Const>
   class join_with_view<V, Pattern>::iterator {
     using Parent = maybe-const<Const, join_with_view>;                  // exposition only
     using Base = maybe-const<Const, V>;                                 // exposition only
     using InnerBase = range_reference_t<Base>;                          // exposition only
@@ -2530,11 +2580,11 @@ as follows:
                                     iter_reference_t<PatternIter>>>
   ```
   is `false`, `iterator_category` denotes `input_iterator_tag`.
 - Otherwise, if *OUTERC*, *INNERC*, and *PATTERNC* each model
-  `derived_from<bidirectional_iterator_category>` and *`InnerBase`* and
   *`PatternBase`* each model `common_range`, `iterator_category` denotes
   `bidirectional_iterator_tag`.
 - Otherwise, if *OUTERC*, *INNERC*, and *PATTERNC* each model
   `derived_from<forward_iterator_tag>`, `iterator_category` denotes
   `forward_iterator_tag`.
@@ -2598,20 +2648,20 @@ constexpr void satisfy();
 ``` cpp
 while (true) {
   if (inner_it_.index() == 0) {
     if (std::get<0>(inner_it_) != ranges::end(parent_->pattern_))
       break;
-    inner_it_.emplace<1>(ranges::begin(update-inner()));
   } else {
     if (std::get<1>(inner_it_) != ranges::end(get-inner()))
       break;
     if (++outer() == ranges::end(parent_->base_)) {
       if constexpr (ref-is-glvalue)
-        inner_it_.emplace<0>();
       break;
     }
-    inner_it_.emplace<0>(ranges::begin(parent_->pattern_));
   }
 }
 ```
 [*Note 1*: `join_with_view` iterators use the *satisfy* function to
@@ -2628,11 +2678,11 @@ constexpr explicit iterator(Parent& parent)
 first overload, also initializes *outer_it\_* with `std::move(outer)`.
 Then, equivalent to:
 ``` cpp
 if (outer() != ranges::end(parent_->base_)) {
-  inner_it_.emplace<1>(ranges::begin(update-inner()));
   satisfy();
 }
 ```
 ``` cpp
@@ -2645,13 +2695,13 @@ constexpr iterator(iterator<!Const> i)
 *Effects:* Initializes *outer_it\_* with `std::move(i.`*`outer_it_`*`)`
 and *parent\_* with `i.`*`parent_`*. Then, equivalent to:
 ``` cpp
 if (i.inner_it_.index() == 0)
-  inner_it_.emplace<0>(std::get<0>(std::move(i.inner_it_)));
 else
-  inner_it_.emplace<1>(std::get<1>(std::move(i.inner_it_)));
 ```
 [*Note 2*: `Const` can only be `true` when *Base* models
 `forward_range`. — *end note*]
@@ -2707,27 +2757,27 @@ constexpr iterator& operator--()
 *Effects:* Equivalent to:
 ``` cpp
 if (outer_it_ == ranges::end(parent_->base_)) {
   auto&& inner = *--outer_it_;
-  inner_it_.emplace<1>(ranges::end(inner));
 }
 while (true) {
   if (inner_it_.index() == 0) {
     auto& it = std::get<0>(inner_it_);
     if (it == ranges::begin(parent_->pattern_)) {
       auto&& inner = *--outer_it_;
-      inner_it_.emplace<1>(ranges::end(inner));
     } else {
       break;
     }
   } else {
     auto& it = std::get<1>(inner_it_);
     auto&& inner = *outer_it_;
     if (it == ranges::begin(inner)) {
-      inner_it_.emplace<0>(ranges::end(parent_->pattern_));
     } else {
       break;
     }
   }
 }
@@ -2765,11 +2815,11 @@ return x.outer_it_ == y.outer_it_ && x.inner_it_ == y.inner_it_;
 ``` cpp
 namespace std::ranges {
   template<input_range V, forward_range Pattern>
     requires view<V> && input_range<range_reference_t<V>>
-          && view<Pattern> && compatible-joinable-ranges<range_reference_t<V>, Pattern>
   template<bool Const>
   class join_with_view<V, Pattern>::sentinel {
     using Parent = maybe-const<Const, join_with_view>;  // exposition only
     using Base = maybe-const<Const, V>;                 // exposition only
     sentinel_t<Base> end_ = sentinel_t<Base>();         // exposition only
@@ -3014,12 +3064,13 @@ constexpr outer-iterator(Parent& parent, iterator_t<Base> current)
 ``` cpp
 constexpr outer-iterator(outer-iterator<!Const> i)
   requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
 ```
-*Effects:* Initializes *parent\_* with `i.`*`parent_`* and *current\_*
-with `std::move(i.`*`current_`*`)`.
 ``` cpp
 constexpr value_type operator*() const;
 ```
@@ -3094,14 +3145,13 @@ namespace std::ranges {
   struct lazy_split_view<V, Pattern>::outer-iterator<Const>::value_type
     : view_interface<value_type> {
   private:
     outer-iterator i_ = outer-iterator();               // exposition only
-  public:
-    value_type() = default;
-    constexpr explicit value_type(outer-iterator i);
     constexpr inner-iterator<Const> begin() const;
     constexpr default_sentinel_t end() const noexcept;
   };
 }
 ```
@@ -3139,11 +3189,11 @@ namespace std::ranges {
     using Base = maybe-const<Const, V>;                     // exposition only
     outer-iterator<Const> i_ = outer-iterator<Const>();     // exposition only
     bool incremented_ = false;                              // exposition only
   public:
-    using iterator_concept  = typename outer-iterator<Const>::iterator_concept;
     using iterator_category = see belownc;                    // present only if Base
                                                             // models forward_range
     using value_type        = range_value_t<Base>;
     using difference_type   = range_difference_t<Base>;
@@ -3434,17 +3484,17 @@ constexpr iterator(split_view& parent, iterator_t<V> current, subrange<iterator_
 ``` cpp
 constexpr iterator_t<V> base() const;
 ```
-*Effects:* Equivalent to `return `*`cur_`*`;`
 ``` cpp
 constexpr value_type operator*() const;
 ```
-*Effects:* Equivalent to `return {`*`cur_`*`, `*`next_`*`.begin()};`
 ``` cpp
 constexpr iterator& operator++();
 ```
@@ -3519,10 +3569,798 @@ friend constexpr bool operator==(const iterator& x, const sentinel& y);
 ```
 *Effects:* Equivalent to:
 `return x.`*`cur_`*` == y.`*`end_`*` && !x.`*`trailing_empty_`*`;`
 ### Counted view <a id="range.counted">[[range.counted]]</a>
 A counted view presents a view of the elements of the counted range
 [[iterator.requirements.general]] `i`+\[0, `n`) for an iterator `i` and
 non-negative integer `n`.
@@ -3599,11 +4437,11 @@ namespace std::ranges {
     constexpr explicit common_view(V r);
     constexpr V base() const & requires copy_constructible<V> { return base_; }
     constexpr V base() && { return std::move(base_); }
-    constexpr auto begin() {
       if constexpr (random_access_range<V> && sized_range<V>)
         return ranges::begin(base_);
       else
         return common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::begin(base_));
     }
@@ -3613,11 +4451,11 @@ namespace std::ranges {
         return ranges::begin(base_);
       else
         return common_iterator<iterator_t<const V>, sentinel_t<const V>>(ranges::begin(base_));
     }
-    constexpr auto end() {
       if constexpr (random_access_range<V> && sized_range<V>)
         return ranges::begin(base_) + ranges::distance(base_);
       else
         return common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::end(base_));
     }
@@ -3633,10 +4471,17 @@ namespace std::ranges {
       return ranges::size(base_);
     }
     constexpr auto size() const requires sized_range<const V> {
       return ranges::size(base_);
     }
   };
   template<class R>
     common_view(R&&) -> common_view<views::all_t<R>>;
 }
@@ -3658,25 +4503,20 @@ iterates the same elements in reverse order.
 The name `views::reverse` denotes a range adaptor object
 [[range.adaptor.object]]. Given a subexpression `E`, the expression
 `views::reverse(E)` is expression-equivalent to:
 - If the type of `E` is a (possibly cv-qualified) specialization of
-  `reverse_view`, equivalent to `E.base()`.
 - Otherwise, if the type of `E` is cv
   `subrange<reverse_iterator<I>, reverse_iterator<I>, K>` for some
   iterator type `I` and value `K` of type `subrange_kind`,
-  - if `K` is `subrange_kind::sized`, equivalent to:
-    ``` cpp
- subrange<I, I, K>(E.end().base(), E.begin().base(), E.size())
-    ```
-  - otherwise, equivalent to:
-    ``` cpp
-    subrange<I, I, K>(E.end().base(), E.begin().base())
-    ```
   However, in either case `E` is evaluated only once.
-- Otherwise, equivalent to `reverse_view{E}`.
 [*Example 1*:
 ``` cpp
 vector<int> is {0,1,2,3,4};
@@ -3716,10 +4556,17 @@ namespace std::ranges {
     }
     constexpr auto size() const requires sized_range<const V> {
       return ranges::size(base_);
     }
   };
   template<class R>
     reverse_view(R&&) -> reverse_view<views::all_t<R>>;
 }
@@ -3820,10 +4667,15 @@ namespace std::ranges {
     constexpr auto end() requires (!simple-view<V>) { return ranges::cend(base_); }
     constexpr auto end() const requires range<const V> { return ranges::cend(base_); }
     constexpr auto size() requires sized_range<V> { return ranges::size(base_); }
     constexpr auto size() const requires sized_range<const V> { return ranges::size(base_); }
   };
   template<class R>
     as_const_view(R&&) -> as_const_view<views::all_t<R>>;
 }
@@ -3944,10 +4796,16 @@ namespace std::ranges {
     { return ranges::size(base_); }
     constexpr auto size() const requires sized_range<const V>
     { return ranges::size(base_); }
   private:
     // [range.elements.iterator], class template elements_view::iterator
     template<bool> class iterator;                      // exposition only
     // [range.elements.sentinel], class template elements_view::sentinel
@@ -4336,13 +5194,13 @@ friend constexpr range_difference_t<maybe-const<OtherConst, V>>
 #### Overview <a id="range.enumerate.overview">[[range.enumerate.overview]]</a>
 `enumerate_view` is a view whose elements represent both the position
 and value from a sequence of elements.
-The name `views::enumerate` denotes a range adaptor object. Given a
-subexpression `E`, the expression `views::enumerate(E)` is
-expression-equivalent to
 `enumerate_view<views::all_t<decltype((E))>>(E)`.
 [*Example 1*:
 ``` cpp
@@ -4378,27 +5236,32 @@ namespace std::ranges {
     { return iterator<false>(ranges::begin(base_), 0); }
     constexpr auto begin() const requires range-with-movable-references<const V>
     { return iterator<true>(ranges::begin(base_), 0); }
     constexpr auto end() requires (!simple-view<V>) {
-      if constexpr (common_range<V> && sized_range<V>)
         return iterator<false>(ranges::end(base_), ranges::distance(base_));
       else
         return sentinel<false>(ranges::end(base_));
     }
     constexpr auto end() const requires range-with-movable-references<const V> {
-      if constexpr (common_range<const V> && sized_range<const V>)
         return iterator<true>(ranges::end(base_), ranges::distance(base_));
       else
         return sentinel<true>(ranges::end(base_));
     }
     constexpr auto size() requires sized_range<V>
     { return ranges::size(base_); }
     constexpr auto size() const requires sized_range<const V>
     { return ranges::size(base_); }
     constexpr V base() const & requires copy_constructible<V> { return base_; }
     constexpr V base() && { return std::move(base_); }
   };
   template<class R>
@@ -4474,11 +5337,11 @@ namespace std::ranges {
       requires random_access_range<Base>;
     friend constexpr iterator operator+(difference_type x, const iterator& y)
       requires random_access_range<Base>;
     friend constexpr iterator operator-(const iterator& x, difference_type y)
       requires random_access_range<Base>;
-    friend constexpr difference_type operator-(const iterator& x, const iterator& y);
     friend constexpr auto iter_move(const iterator& i)
       noexcept(noexcept(ranges::iter_move(i.current_)) &&
                is_nothrow_move_constructible_v<range_rvalue_reference_t<Base>>) {
       return tuple<difference_type,
@@ -4656,11 +5519,11 @@ auto temp = x;
 temp -= y;
 return temp;
 ```
 ``` cpp
-friend constexpr difference_type operator-(const iterator& x, const iterator& y);
 ```
 *Effects:* Equivalent to: `return x.`*`pos_`*` - y.`*`pos_`*`;`
 #### Class template `enumerate_view::sentinel` <a id="range.enumerate.sentinel">[[range.enumerate.sentinel]]</a>
@@ -4867,20 +5730,10 @@ return apply([](auto... sizes) {
 #### Class template `zip_view::iterator` <a id="range.zip.iterator">[[range.zip.iterator]]</a>
 ``` cpp
 namespace std::ranges {
-  template<bool Const, class... Views>
-    concept all-random-access =                 // exposition only
-      (random_access_range<maybe-const<Const, Views>> && ...);
-  template<bool Const, class... Views>
-    concept all-bidirectional =                 // exposition only
-      (bidirectional_range<maybe-const<Const, Views>> && ...);
-  template<bool Const, class... Views>
-    concept all-forward =                       // exposition only
-      (forward_range<maybe-const<Const, Views>> && ...);
   template<input_range... Views>
     requires (view<Views> && ...) && (sizeof...(Views) > 0)
   template<bool Const>
   class zip_view<Views...>::iterator {
     tuple<iterator_t<maybe-const<Const, Views>>...> current_;       // exposition only
@@ -5247,11 +6100,11 @@ template<bool OtherConst>
                                iterator_t<maybe-const<OtherConst, Views>>> && ...)
 friend constexpr common_type_t<range_difference_t<maybe-const<OtherConst, Views>>...>
   operator-(const sentinel& y, const iterator<OtherConst>& x);
 ```
-*Effects:* Equivalent to `return -(x - y);`
 ### Zip transform view <a id="range.zip.transform">[[range.zip.transform]]</a>
 #### Overview <a id="range.zip.transform.overview">[[range.zip.transform.overview]]</a>
@@ -5382,11 +6235,11 @@ namespace std::ranges {
     constexpr iterator(Parent& parent, ziperator<Const> inner);   // exposition only
   public:
     using iterator_category = see belownc;                        // not always present
-    using iterator_concept  = typename ziperator<Const>::iterator_concept;
     using value_type =
       remove_cvref_t<invoke_result_t<maybe-const<Const, F>&,
                                      range_reference_t<maybe-const<Const, Views>>...>>;
     using difference_type = range_difference_t<Base>;
@@ -5685,11 +6538,12 @@ resulting view is empty.
 The name `views::adjacent<N>` denotes a range adaptor object
 [[range.adaptor.object]]. Given a subexpression `E` and a constant
 expression `N`, the expression `views::adjacent<N>(E)` is
 expression-equivalent to
-- `((void)E, auto(views::empty<tuple<>>))` if `N` is equal to `0`,
 - otherwise, `adjacent_view<views::all_t<decltype((E))>, N>(E)`.
 [*Example 1*:
 ``` cpp
@@ -5753,10 +6607,13 @@ namespace std::ranges {
       }
     }
     constexpr auto size() requires sized_range<V>;
     constexpr auto size() const requires sized_range<const V>;
   };
 }
 ```
 ``` cpp
@@ -5778,10 +6635,25 @@ using CT = common_type_t<ST, size_t>;
 auto sz = static_cast<CT>(ranges::size(base_));
 sz -= std::min<CT>(sz, N - 1);
 return static_cast<ST>(sz);
 ```
 #### Class template `adjacent_view::iterator` <a id="range.adjacent.iterator">[[range.adjacent.iterator]]</a>
 ``` cpp
 namespace std::ranges {
   template<forward_range V, size_t N>
@@ -6174,13 +7046,14 @@ resulting view is empty.
 The name `views::adjacent_transform<N>` denotes a range adaptor object
 [[range.adaptor.object]]. Given subexpressions `E` and `F` and a
 constant expression `N`:
-- If `N` is equal to `0`, `views::adjacent_transform<N>(E, F)` is
- expression-equivalent to `((void)E, views::zip_transform(F))`, except
- that the evaluations of `E` and `F` are indeterminately sequenced.
 - Otherwise, the expression `views::adjacent_transform<N>(E, F)` is
   expression-equivalent to
   `adjacent_transform_view<views::all_t<decltype((E))>, decay_t<decltype((F))>, N>(E, F)`.
 [*Example 1*:
@@ -6221,11 +7094,11 @@ namespace std::ranges {
   public:
     adjacent_transform_view() = default;
     constexpr explicit adjacent_transform_view(V base, F fun);
-    constexpr V base() const & requires copy_constructible<InnerView> { return inner_.base(); }
     constexpr V base() && { return std::move(inner_).base(); }
     constexpr auto begin() {
       return iterator<false>(*this, inner_.begin());
     }
@@ -6259,10 +7132,18 @@ namespace std::ranges {
     }
     constexpr auto size() const requires sized_range<const InnerView> {
       return inner_.size();
     }
   };
 }
 ```
 ``` cpp
@@ -6289,11 +7170,11 @@ namespace std::ranges {
     constexpr iterator(Parent& parent, inner-iterator<Const> inner);    // exposition only
   public:
     using iterator_category = see below;
-    using iterator_concept  = typename inner-iterator<Const>::iterator_concept;
     using value_type =
       remove_cvref_t<invoke_result_t<maybe-const<Const, F>&,
                                      REPEAT(range_reference_t<Base>, N)...>>;
     using difference_type = range_difference_t<Base>;
@@ -6563,11 +7444,11 @@ constexpr sentinel(sentinel<!Const> i)
 template<bool OtherConst>
   requires sentinel_for<inner-sentinel<Const>, inner-iterator<OtherConst>>
 friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y);
 ```
-*Effects:* Equivalent to `return x.`*`inner_`*` == y.`*`inner_`*`;`
 ``` cpp
 template<bool OtherConst>
   requires sized_sentinel_for<inner-sentinel<Const>, inner-iterator<OtherConst>>
 friend constexpr range_difference_t<maybe-const<OtherConst, InnerView>>
@@ -6577,11 +7458,11 @@ template<bool OtherConst>
   requires sized_sentinel_for<inner-sentinel<Const>, inner-iterator<OtherConst>>
 friend constexpr range_difference_t<maybe-const<OtherConst, InnerView>>
   operator-(const sentinel& x, const iterator<OtherConst>& y);
 ```
-*Effects:* Equivalent to `return x.`*`inner_`*` - y.`*`inner_`*`;`
 ### Chunk view <a id="range.chunk">[[range.chunk]]</a>
 #### Overview <a id="range.chunk.overview">[[range.chunk.overview]]</a>
@@ -6650,10 +7531,13 @@ namespace std::ranges {
     constexpr outer-iterator begin();
     constexpr default_sentinel_t end() const noexcept;
     constexpr auto size() requires sized_range<V>;
     constexpr auto size() const requires sized_range<const V>;
   };
   template<class R>
     chunk_view(R&&, range_difference_t<R>) -> chunk_view<views::all_t<R>>;
 }
@@ -6695,10 +7579,22 @@ constexpr auto size() const requires sized_range<const V>;
 ``` cpp
 return to-unsigned-like(div-ceil(ranges::distance(base_), n_));
 ```
 #### Class `chunk_view::outer-iterator` <a id="range.chunk.outer.iter">[[range.chunk.outer.iter]]</a>
 ``` cpp
 namespace std::ranges {
   template<view V>
@@ -6814,10 +7710,12 @@ namespace std::ranges {
     constexpr inner-iterator begin() const noexcept;
     constexpr default_sentinel_t end() const noexcept;
     constexpr auto size() const
       requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
   };
 }
 ```
 ``` cpp
@@ -6848,10 +7746,20 @@ constexpr auto size() const
 ``` cpp
 return to-unsigned-like(ranges::min(parent_->remainder_,
                                 ranges::end(parent_->base_) - *parent_->current_));
 ```
 #### Class `chunk_view::inner-iterator` <a id="range.chunk.inner.iter">[[range.chunk.inner.iter]]</a>
 ``` cpp
 namespace std::ranges {
   template<view V>
@@ -7026,10 +7934,13 @@ namespace std::ranges {
       }
     }
     constexpr auto size() requires sized_range<V>;
     constexpr auto size() const requires sized_range<const V>;
   };
 }
 ```
 ``` cpp
@@ -7050,10 +7961,22 @@ constexpr auto size() const requires sized_range<const V>;
 ``` cpp
 return to-unsigned-like(div-ceil(ranges::distance(base_), n_));
 ```
 #### Class template `chunk_view::iterator` for forward ranges <a id="range.chunk.fwd.iter">[[range.chunk.fwd.iter]]</a>
 ``` cpp
 namespace std::ranges {
   template<view V>
@@ -7426,10 +8349,13 @@ namespace std::ranges {
       requires (!(simple-view<V> && slide-caches-nothing<const V>));
     constexpr auto end() const requires slide-caches-nothing<const V>;
     constexpr auto size() requires sized_range<V>;
     constexpr auto size() const requires sized_range<const V>;
   };
   template<class R>
     slide_view(R&&, range_difference_t<R>) -> slide_view<views::all_t<R>>;
 }
@@ -7513,10 +8439,24 @@ constexpr auto size() const requires sized_range<const V>;
 auto sz = ranges::distance(base_) - n_ + 1;
 if (sz < 0) sz = 0;
 return to-unsigned-like(sz);
 ```
 #### Class template `slide_view::iterator` <a id="range.slide.iterator">[[range.slide.iterator]]</a>
 ``` cpp
 namespace std::ranges {
   template<forward_range V>
@@ -8180,10 +9120,13 @@ namespace std::ranges {
       }
     }
     constexpr auto size() requires sized_range<V>;
     constexpr auto size() const requires sized_range<const V>;
   };
   template<class R>
     stride_view(R&&, range_difference_t<R>) -> stride_view<views::all_t<R>>;
 }
@@ -8213,10 +9156,22 @@ constexpr auto size() const requires sized_range<const V>;
 ``` cpp
 return to-unsigned-like(div-ceil(ranges::distance(base_), stride_));
 ```
 #### Class template `stride_view::iterator` <a id="range.stride.iterator">[[range.stride.iterator]]</a>
 ``` cpp
 namespace std::ranges {
   template<input_range V>
@@ -8374,11 +9329,11 @@ return *this;
 ``` cpp
 constexpr void operator++(int);
 ```
-*Effects:* Equivalent to: `++*this;`
 ``` cpp
 constexpr iterator operator++(int) requires forward_range<Base>;
 ```
@@ -8616,11 +9571,11 @@ namespace std::ranges {
   concept cartesian-product-is-bidirectional =          // exposition only
     (bidirectional_range<maybe-const<Const, First>> && ... &&
       (bidirectional_range<maybe-const<Const, Vs>>
         && cartesian-product-common-arg<maybe-const<Const, Vs>>));
-  template<class First, class... Vs>
   concept cartesian-product-is-common =                 // exposition only
     cartesian-product-common-arg<First>;
   template<class... Vs>
   concept cartesian-product-is-sized =                  // exposition only
@@ -9159,5 +10114,495 @@ ranges::iter_swap(std::get<i>(l.current_), std::get<i>(r.current_))
 the following expressions:
 - `noexcept(ranges::iter_swap(std::get<`i`>(l.`*`current_`*`), std::get<`i`>(r.`*`current_`*`)))`
   for every integer 0 ≤ i ≤ `sizeof...(Vs)`.

 - Otherwise, `movable-box<T>` should store only a `T` if either `T`
   models `movable` or `is_nothrow_move_constructible_v<T>` is `true`.
 ### Non-propagating cache <a id="range.nonprop.cache">[[range.nonprop.cache]]</a>
+Some types in [[range.adaptors]] are specified in terms of an
 exposition-only class template *`non-propagating-{}cache`*.
 `non-propagating-cache<T>` behaves exactly like `optional<T>` with the
 following differences:
 - `non-propagating-cache<T>` constrains its type parameter `T` with
   template<class T>
   constexpr T& as-lvalue(T&& t) {                   // exposition only
     return static_cast<T&>(t);
   }
+  template<bool Const, class... Views>
+    concept all-random-access =                     // exposition only
+      (random_access_range<maybe-const<Const, Views>> && ...);
+  template<bool Const, class... Views>
+    concept all-bidirectional =                     // exposition only
+      (bidirectional_range<maybe-const<Const, Views>> && ...);
+  template<bool Const, class... Views>
+    concept all-forward =                           // exposition only
+      (forward_range<maybe-const<Const, Views>> && ...);
 }
 ```
 ### All view <a id="range.all">[[range.all]]</a>
     { return ranges::empty(*r_); }
     constexpr auto size() const requires sized_range<R>
     { return ranges::size(*r_); }
+    constexpr auto reserve_hint() const requires approximately_sized_range<R>
+    { return ranges::reserve_hint(*r_); }
     constexpr auto data() const requires contiguous_range<R>
     { return ranges::data(*r_); }
   };
   template<class R>
     constexpr auto size() requires sized_range<R>
     { return ranges::size(r_); }
     constexpr auto size() const requires sized_range<const R>
     { return ranges::size(r_); }
+    constexpr auto reserve_hint() requires approximately_sized_range<R>
+    { return ranges::reserve_hint(r_); }
+    constexpr auto reserve_hint() const requires approximately_sized_range<const R>
+    { return ranges::reserve_hint(r_); }
     constexpr auto data() requires contiguous_range<R>
     { return ranges::data(r_); }
     constexpr auto data() const requires contiguous_range<const R>
     { return ranges::data(r_); }
   };
 The name `views::as_rvalue` denotes a range adaptor object
 [[range.adaptor.object]]. Let `E` be an expression and let `T` be
 `decltype((E))`. The expression `views::as_rvalue(E)` is
 expression-equivalent to:
+- `views::all(E)` if `T` models `input_range` and
   `same_as<range_rvalue_reference_t<T>, range_reference_t<T>>` is
   `true`.
 - Otherwise, `as_rvalue_view(E)`.
 [*Example 1*:
       }
     }
     constexpr auto size() requires sized_range<V> { return ranges::size(base_); }
     constexpr auto size() const requires sized_range<const V> { return ranges::size(base_); }
+    constexpr auto reserve_hint() requires approximately_sized_range<V>
+    { return ranges::reserve_hint(base_); }
+    constexpr auto reserve_hint() const requires approximately_sized_range<const V>
+    { return ranges::reserve_hint(base_); }
   };
   template<class R>
     as_rvalue_view(R&&) -> as_rvalue_view<views::all_t<R>>;
 }
                regular_invocable<const F&, range_reference_t<const V>>;
     constexpr auto size() requires sized_range<V> { return ranges::size(base_); }
     constexpr auto size() const requires sized_range<const V>
     { return ranges::size(base_); }
+    constexpr auto reserve_hint() requires approximately_sized_range<V>
+    { return ranges::reserve_hint(base_); }
+    constexpr auto reserve_hint() const requires approximately_sized_range<const V>
+    { return ranges::reserve_hint(base_); }
   };
   template<class R, class F>
     transform_view(R&&, F) -> transform_view<views::all_t<R>, F>;
 }
     constexpr auto size() const requires sized_range<const V> {
       auto n = ranges::size(base_);
       return ranges::min(n, static_cast<decltype(n)>(count_));
     }
+    constexpr auto reserve_hint() {
+      if constexpr (approximately_sized_range<V>) {
+        auto n = static_cast<range_difference_t<V>>(ranges::reserve_hint(base_));
+        return to-unsigned-like(ranges::min(n, count_));
+      }
+      return to-unsigned-like(count_);
+    }
+    constexpr auto reserve_hint() const {
+      if constexpr (approximately_sized_range<const V>) {
+        auto n = static_cast<range_difference_t<const V>>(ranges::reserve_hint(base_));
+        return to-unsigned-like(ranges::min(n, count_));
+      }
+      return to-unsigned-like(count_);
+    }
   };
   template<class R>
     take_view(R&&, range_difference_t<R>)
       -> take_view<views::all_t<R>>;
   then
   `U(ranges::begin(E) + std::min<D>(ranges::distance(E), F), ranges::end(E))`,
   except that `E` is evaluated only once, where `U` is
   `span<typename T::element_type>` if `T` is a specialization of `span`
   and `T` otherwise.
+- Otherwise, if `T` is a specialization of `subrange` that models
+  `random_access_range` and `sized_range`, then
   `T(ranges::begin(E) + std::min<D>(ranges::distance(E), F), ranges::{}end(E),
   to-unsigned-like(ranges::distance(E) -
   std::min<D>(ranges::distance(E), F)))`, except that `E` and `F` are
   each evaluated only once.
 - Otherwise, if `T` is a specialization of `repeat_view`
       const auto s = ranges::size(base_);
       const auto c = static_cast<decltype(s)>(count_);
       return s < c ? 0 : s - c;
     }
+    constexpr auto reserve_hint() requires approximately_sized_range<V> {
+      const auto s = static_cast<range_difference_t<V>>(ranges::reserve_hint(base_));
+      return to-unsigned-like(s < count_ ? 0 : s - count_);
+    }
+    constexpr auto reserve_hint() const requires approximately_sized_range<const V> {
+      const auto s = static_cast<range_difference_t<const V>>(ranges::reserve_hint(base_));
+      return to-unsigned-like(s < count_ ? 0 : s - count_);
+    }
   private:
     V base_ = V();                              // exposition only
     range_difference_t<V> count_ = 0;           // exposition only
   };
   noexcept(noexcept(ranges::iter_swap(*x.inner_, *y.inner_)))
   requires indirectly_swappable<InnerIter>;
 ```
 *Effects:* Equivalent to:
+`ranges::iter_swap(*x.`*`inner_`*`, *y.`*`inner_`*`);`
 #### Class template `join_view::sentinel` <a id="range.join.sentinel">[[range.join.sentinel]]</a>
 ``` cpp
 namespace std::ranges {
 #### Class template `join_with_view` <a id="range.join.with.view">[[range.join.with.view]]</a>
 ``` cpp
 namespace std::ranges {
   template<class R>
   concept bidirectional-common = bidirectional_range<R> && common_range<R>;    // exposition only
   template<input_range V, forward_range Pattern>
     requires view<V> && input_range<range_reference_t<V>>
           && view<Pattern>
+          && concatable<range_reference_t<V>, Pattern>
   class join_with_view : public view_interface<join_with_view<V, Pattern>> {
     using InnerRng = range_reference_t<V>;                  // exposition only
     V base_ = V();                                          // exposition only
     non-propagating-cache<iterator_t<V>> outer_it_;         // exposition only, present only
     }
     constexpr auto begin() const
       requires forward_range<const V> &&
                forward_range<const Pattern> &&
                is_reference_v<range_reference_t<const V>> &&
+               input_range<range_reference_t<const V>> &&
+               concatable<range_reference_t<const V>, const Pattern> {
       return iterator<true>{*this, ranges::begin(base_)};
     }
     constexpr auto end() {
       if constexpr (forward_range<V> &&
         return sentinel<simple-view<V> && simple-view<Pattern>>{*this};
     }
     constexpr auto end() const
       requires forward_range<const V> && forward_range<const Pattern> &&
                is_reference_v<range_reference_t<const V>> &&
+               input_range<range_reference_t<const V>> &&
+               concatable<range_reference_t<const V>, const Pattern> {
       using InnerConstRng = range_reference_t<const V>;
       if constexpr (forward_range<InnerConstRng> &&
                     common_range<const V> && common_range<InnerConstRng>)
         return iterator<true>{*this, ranges::end(base_)};
       else
 ``` cpp
 namespace std::ranges {
   template<input_range V, forward_range Pattern>
     requires view<V> && input_range<range_reference_t<V>>
+          && view<Pattern> && concatable<range_reference_t<V>, Pattern>
   template<bool Const>
   class join_with_view<V, Pattern>::iterator {
     using Parent = maybe-const<Const, join_with_view>;                  // exposition only
     using Base = maybe-const<Const, V>;                                 // exposition only
     using InnerBase = range_reference_t<Base>;                          // exposition only
                                     iter_reference_t<PatternIter>>>
   ```
   is `false`, `iterator_category` denotes `input_iterator_tag`.
 - Otherwise, if *OUTERC*, *INNERC*, and *PATTERNC* each model
+  `derived_from<bidirectional_iterator_tag>` and *`InnerBase`* and
   *`PatternBase`* each model `common_range`, `iterator_category` denotes
   `bidirectional_iterator_tag`.
 - Otherwise, if *OUTERC*, *INNERC*, and *PATTERNC* each model
   `derived_from<forward_iterator_tag>`, `iterator_category` denotes
   `forward_iterator_tag`.
 ``` cpp
 while (true) {
   if (inner_it_.index() == 0) {
     if (std::get<0>(inner_it_) != ranges::end(parent_->pattern_))
       break;
+    inner_it_.template emplace<1>(ranges::begin(update-inner()));
   } else {
     if (std::get<1>(inner_it_) != ranges::end(get-inner()))
       break;
     if (++outer() == ranges::end(parent_->base_)) {
       if constexpr (ref-is-glvalue)
+        inner_it_.template emplace<0>();
       break;
     }
+    inner_it_.template emplace<0>(ranges::begin(parent_->pattern_));
   }
 }
 ```
 [*Note 1*: `join_with_view` iterators use the *satisfy* function to
 first overload, also initializes *outer_it\_* with `std::move(outer)`.
 Then, equivalent to:
 ``` cpp
 if (outer() != ranges::end(parent_->base_)) {
+  inner_it_.template emplace<1>(ranges::begin(update-inner()));
   satisfy();
 }
 ```
 ``` cpp
 *Effects:* Initializes *outer_it\_* with `std::move(i.`*`outer_it_`*`)`
 and *parent\_* with `i.`*`parent_`*. Then, equivalent to:
 ``` cpp
 if (i.inner_it_.index() == 0)
+  inner_it_.template emplace<0>(std::get<0>(std::move(i.inner_it_)));
 else
+  inner_it_.template emplace<1>(std::get<1>(std::move(i.inner_it_)));
 ```
 [*Note 2*: `Const` can only be `true` when *Base* models
 `forward_range`. — *end note*]
 *Effects:* Equivalent to:
 ``` cpp
 if (outer_it_ == ranges::end(parent_->base_)) {
   auto&& inner = *--outer_it_;
+  inner_it_.template emplace<1>(ranges::end(inner));
 }
 while (true) {
   if (inner_it_.index() == 0) {
     auto& it = std::get<0>(inner_it_);
     if (it == ranges::begin(parent_->pattern_)) {
       auto&& inner = *--outer_it_;
+      inner_it_.template emplace<1>(ranges::end(inner));
     } else {
       break;
     }
   } else {
     auto& it = std::get<1>(inner_it_);
     auto&& inner = *outer_it_;
     if (it == ranges::begin(inner)) {
+      inner_it_.template emplace<0>(ranges::end(parent_->pattern_));
     } else {
       break;
     }
   }
 }
 ``` cpp
 namespace std::ranges {
   template<input_range V, forward_range Pattern>
     requires view<V> && input_range<range_reference_t<V>>
+          && view<Pattern> && concatable<range_reference_t<V>, Pattern>
   template<bool Const>
   class join_with_view<V, Pattern>::sentinel {
     using Parent = maybe-const<Const, join_with_view>;  // exposition only
     using Base = maybe-const<Const, V>;                 // exposition only
     sentinel_t<Base> end_ = sentinel_t<Base>();         // exposition only
 ``` cpp
 constexpr outer-iterator(outer-iterator<!Const> i)
   requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
 ```
+*Effects:* Initializes *parent\_* with `i.`*`parent_`*, *current\_* with
+`std::move(i.`*`current_`*`)`, and *trailing_empty\_* with
+`i.`*`trailing_empty_`*.
 ``` cpp
 constexpr value_type operator*() const;
 ```
   struct lazy_split_view<V, Pattern>::outer-iterator<Const>::value_type
     : view_interface<value_type> {
   private:
     outer-iterator i_ = outer-iterator();               // exposition only
+    constexpr explicit value_type(outer-iterator i);    // exposition only
+  public:
     constexpr inner-iterator<Const> begin() const;
     constexpr default_sentinel_t end() const noexcept;
   };
 }
 ```
     using Base = maybe-const<Const, V>;                     // exposition only
     outer-iterator<Const> i_ = outer-iterator<Const>();     // exposition only
     bool incremented_ = false;                              // exposition only
   public:
+    using iterator_concept  = outer-iterator<Const>::iterator_concept;
     using iterator_category = see belownc;                    // present only if Base
                                                             // models forward_range
     using value_type        = range_value_t<Base>;
     using difference_type   = range_difference_t<Base>;
 ``` cpp
 constexpr iterator_t<V> base() const;
 ```
+*Effects:* Equivalent to: `return `*`cur_`*`;`
 ``` cpp
 constexpr value_type operator*() const;
 ```
+*Effects:* Equivalent to: `return {`*`cur_`*`, `*`next_`*`.begin()};`
 ``` cpp
 constexpr iterator& operator++();
 ```
 ```
 *Effects:* Equivalent to:
 `return x.`*`cur_`*` == y.`*`end_`*` && !x.`*`trailing_empty_`*`;`
+### Concat view <a id="range.concat">[[range.concat]]</a>
+#### Overview <a id="range.concat.overview">[[range.concat.overview]]</a>
+`concat_view` presents a view that concatenates all the underlying
+ranges.
+The name `views::concat` denotes a customization point object
+[[customization.point.object]]. Given a pack of subexpressions `Es...`,
+the expression `views::concat(Es...)` is expression-equivalent to
+- `views::all(Es...)` if `Es` is a pack with only one element whose type
+  models `input_range`,
+- otherwise, `concat_view(Es...)`.
+[*Example 1*:
+``` cpp
+vector<int> v1{1, 2, 3}, v2{4, 5}, v3{};
+array a{6, 7, 8};
+auto s = views::single(9);
+for (auto&& i : views::concat(v1, v2, v3, a, s)) {
+  print("{} ", i);      // prints 1 2 3 4 5 6 7 8 9
+}
+```
+— *end example*]
+#### Class template `concat_view` <a id="range.concat.view">[[range.concat.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<class... Rs>
+  using concat-reference-t = common_reference_t<range_reference_t<Rs>...>;      // exposition only
+  template<class... Rs>
+  using concat-value-t = common_type_t<range_value_t<Rs>...>;                   // exposition only
+  template<class... Rs>
+  using concat-rvalue-reference-t =                                             // exposition only
+    common_reference_t<range_rvalue_reference_t<Rs>...>;
+  template<class... Rs>
+    concept concat-indirectly-readable = see below;     // exposition only
+  template<class... Rs>
+    concept concatable = see below;                     // exposition only
+  template<bool Const, class... Rs>
+    concept concat-is-random-access = see below;        // exposition only
+  template<bool Const, class... Rs>
+    concept concat-is-bidirectional = see below;        // exposition only
+  template<input_range... Views>
+    requires (view<Views> && ...) && (sizeof...(Views) > 0) &&
+              concatable<Views...>
+  class concat_view : public view_interface<concat_view<Views...>> {
+    tuple<Views...> views_;                                             // exposition only
+    // [range.concat.iterator], class template concat_view::iterator
+    template<bool> class iterator;                                      // exposition only
+  public:
+    constexpr concat_view() = default;
+    constexpr explicit concat_view(Views... views);
+    constexpr iterator<false> begin() requires (!(simple-view<Views> && ...));
+    constexpr iterator<true> begin() const
+      requires (range<const Views> && ...) && concatable<const Views...>;
+    constexpr auto end() requires (!(simple-view<Views> && ...));
+    constexpr auto end() const
+      requires (range<const Views> && ...) && concatable<const Views...>;
+    constexpr auto size() requires (sized_range<Views> && ...);
+    constexpr auto size() const requires (sized_range<const Views> && ...);
+  };
+  template<class... R>
+    concat_view(R&&...) -> concat_view<views::all_t<R>...>;
+}
+```
+``` cpp
+template<class... Rs>
+  concept concat-indirectly-readable = see below;                           // exposition only
+```
+The exposition-only `concat-indirectly-readable` concept is equivalent
+to:
+``` cpp
+template<class Ref, class RRef, class It>
+  concept concat-indirectly-readable-impl =                         // exposition only
+    requires (const It it) {
+      { *it } -> convertible_to<Ref>;
+      { ranges::iter_move(it) } -> convertible_to<RRef>;
+    };
+template<class... Rs>
+  concept concat-indirectly-readable =                              // exposition only
+    common_reference_with<concat-reference-t<Rs...>&&,
+                          concat-value-t<Rs...>&> &&
+    common_reference_with<concat-reference-t<Rs...>&&,
+                          concat-rvalue-reference-t<Rs...>&&> &&
+    common_reference_with<concat-rvalue-reference-t<Rs...>&&,
+                          concat-value-t<Rs...> const&> &&
+    (concat-indirectly-readable-impl<concat-reference-t<Rs...>,
+                                     concat-rvalue-reference-t<Rs...>,
+                                     iterator_t<Rs>> && ...);
+```
+``` cpp
+template<class... Rs>
+  concept concatable = see below;                                           // exposition only
+```
+The exposition-only `concatable` concept is equivalent to:
+``` cpp
+template<class... Rs>
+  concept concatable = requires {                                   // exposition only
+    typename concat-reference-t<Rs...>;
+    typename concat-value-t<Rs...>;
+    typename concat-rvalue-reference-t<Rs...>;
+  } && concat-indirectly-readable<Rs...>;
+```
+``` cpp
+template<bool Const, class... Rs>
+  concept concat-is-random-access = see below;                              // exposition only
+```
+Let `Fs` be the pack that consists of all elements of `Rs` except the
+last element, then *`concat-is-random-access`* is equivalent to:
+``` cpp
+template<bool Const, class... Rs>
+  concept concat-is-random-access =                                 // exposition only
+    all-random-access<Const, Rs...> &&
+    (common_range<maybe-const<Const, Fs>> && ...);
+```
+``` cpp
+template<bool Const, class... Rs>
+  concept concat-is-bidirectional = see below;                              // exposition only
+```
+Let `Fs` be the pack that consists of all elements of `Rs` except the
+last element, then *`concat-is-bidirectional`* is equivalent to:
+``` cpp
+template<bool Const, class... Rs>
+  concept concat-is-bidirectional =                                 // exposition only
+    all-bidirectional<Const, Rs...> &&
+    (common_range<maybe-const<Const, Fs>> && ...);
+```
+``` cpp
+constexpr explicit concat_view(Views... views);
+```
+*Effects:* Initializes *views\_* with `std::move(views)...`.
+``` cpp
+constexpr iterator<false> begin() requires (!(simple-view<Views> && ...));
+constexpr iterator<true> begin() const
+  requires (range<const Views> && ...) && concatable<const Views...>;
+```
+*Effects:* Let *is-const* be `true` for the const-qualified overload,
+and `false` otherwise. Equivalent to:
+``` cpp
+iterator<is-const> it(this, in_place_index<0>, ranges::begin(std::get<0>(views_)));
+it.template satisfy<0>();
+return it;
+```
+``` cpp
+constexpr auto end() requires (!(simple-view<Views> && ...));
+constexpr auto end() const
+  requires (range<const Views> && ...) && concatable<const Views...>;
+```
+*Effects:* Let *is-const* be `true` for the const-qualified overload,
+and `false` otherwise. Equivalent to:
+``` cpp
+constexpr auto N = sizeof...(Views);
+if constexpr (common_range<maybe-const<is-const, Views...[N - 1]>>) {
+  return iterator<is-const>(this, in_place_index<N - 1>,
+                            ranges::end(std::get<N - 1>(views_)));
+} else {
+  return default_sentinel;
+}
+```
+``` cpp
+constexpr auto size() requires (sized_range<Views> && ...);
+constexpr auto size() const requires (sized_range<const Views> && ...);
+```
+*Effects:* Equivalent to:
+``` cpp
+return apply(
+  [](auto... sizes) {
+    using CT = make-unsigned-like-t<common_type_t<decltype(sizes)...>>;
+    return (CT(sizes) + ...);
+  },
+  tuple-transform(ranges::size, views_));
+```
+#### Class `concat_view::iterator` <a id="range.concat.iterator">[[range.concat.iterator]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range... Views>
+    requires (view<Views> && ...) && (sizeof...(Views) > 0) &&
+              concatable<Views...>
+  template<bool Const>
+  class concat_view<Views...>::iterator {
+  public:
+    using iterator_category = see below;                                // not always present
+    using iterator_concept = see below;
+    using value_type = concat-value-t<maybe-const<Const, Views>...>;
+    using difference_type = common_type_t<range_difference_t<maybe-const<Const, Views>>...>;
+  private:
+    using base-iter =                                                       // exposition only
+      variant<iterator_t<maybe-const<Const, Views>>...>;
+    maybe-const<Const, concat_view>* parent_ = nullptr;                     // exposition only
+    base-iter it_;                                                          // exposition only
+    template<size_t N>
+      constexpr void satisfy();                                             // exposition only
+    template<size_t N>
+      constexpr void prev();                                                // exposition only
+    template<size_t N>
+      constexpr void advance-fwd(difference_type offset,                    // exposition only
+                                 difference_type steps);
+    template<size_t N>
+      constexpr void advance-bwd(difference_type offset,                    // exposition only
+                                 difference_type steps);
+    template<class... Args>
+      constexpr explicit iterator(maybe-const<Const, concat_view>* parent,  // exposition only
+                                  Args&&... args)
+        requires constructible_from<base-iter, Args&&...>;
+  public:
+    iterator() = default;
+    constexpr iterator(iterator<!Const> i)
+      requires Const && (convertible_to<iterator_t<Views>, iterator_t<const Views>> && ...);
+    constexpr decltype(auto) operator*() const;
+    constexpr iterator& operator++();
+    constexpr void operator++(int);
+    constexpr iterator operator++(int)
+      requires all-forward<Const, Views...>;
+    constexpr iterator& operator--()
+      requires concat-is-bidirectional<Const, Views...>;
+    constexpr iterator operator--(int)
+      requires concat-is-bidirectional<Const, Views...>;
+    constexpr iterator& operator+=(difference_type n)
+      requires concat-is-random-access<Const, Views...>;
+    constexpr iterator& operator-=(difference_type n)
+      requires concat-is-random-access<Const, Views...>;
+    constexpr decltype(auto) operator[](difference_type n) const
+      requires concat-is-random-access<Const, Views...>;
+    friend constexpr bool operator==(const iterator& x, const iterator& y)
+      requires (equality_comparable<iterator_t<maybe-const<Const, Views>>> && ...);
+    friend constexpr bool operator==(const iterator& it, default_sentinel_t);
+    friend constexpr bool operator<(const iterator& x, const iterator& y)
+      requires all-random-access<Const, Views...>;
+    friend constexpr bool operator>(const iterator& x, const iterator& y)
+      requires all-random-access<Const, Views...>;
+    friend constexpr bool operator<=(const iterator& x, const iterator& y)
+      requires all-random-access<Const, Views...>;
+    friend constexpr bool operator>=(const iterator& x, const iterator& y)
+      requires all-random-access<Const, Views...>;
+    friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+      requires (all-random-access<Const, Views...> &&
+                (three_way_comparable<iterator_t<maybe-const<Const, Views>>> && ...));
+    friend constexpr iterator operator+(const iterator& it, difference_type n)
+      requires concat-is-random-access<Const, Views...>;
+    friend constexpr iterator operator+(difference_type n, const iterator& it)
+      requires concat-is-random-access<Const, Views...>;
+    friend constexpr iterator operator-(const iterator& it, difference_type n)
+      requires concat-is-random-access<Const, Views...>;
+    friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+      requires concat-is-random-access<Const, Views...>;
+    friend constexpr difference_type operator-(const iterator& x, default_sentinel_t)
+      requires see below;
+    friend constexpr difference_type operator-(default_sentinel_t, const iterator& x)
+      requires see below;
+    friend constexpr decltype(auto) iter_move(const iterator& it) noexcept(see below);
+    friend constexpr void iter_swap(const iterator& x, const iterator& y) noexcept(see below)
+      requires see below;
+  };
+}
+```
+`iterator::iterator_concept` is defined as follows:
+- If `concat-is-random-access<Const, Views...>` is modeled, then
+  `iterator_concept` denotes `random_access_iterator_tag`.
+- Otherwise, if `concat-is-bidirectional<Const, Views...>` is modeled,
+  then `iterator_concept` denotes `bidirectional_iterator_tag`.
+- Otherwise, if `all-forward<Const, Views...>` is modeled, 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
+`all-forward<Const, Views...>` is modeled. In that case,
+`iterator::iterator_category` is defined as follows:
+- If `is_reference_v<concat-reference-t<maybe-const<Const, Views>...>>`
+  is `false`, then `iterator_category` denotes `input_iterator_tag`.
+- Otherwise, let `Cs` denote the pack of types
+  `iterator_traits<iterator_t<maybe-const<Const, Views>>>::iterator_category...`.
+  - If
+    `(derived_from<Cs, random_access_iterator_tag> && ...) && concat-is-random-ac-{cess}<Const, Views...>`
+    is `true`, `iterator_category` denotes `random_access_iterator_tag`.
+  - Otherwise, if
+    `(derived_from<Cs, bidirectional_iterator_tag> && ...) && concat-is-{bidirectional}<Const, Views...>`
+    is `true`, `iterator_category` denotes `bidirectional_iterator_tag`.
+  - Otherwise, if `(derived_from<Cs, forward_iterator_tag> && ...)` is
+    `true`, `iterator_category` denotes `forward_iterator_tag`.
+  - Otherwise, `iterator_category` denotes `input_iterator_tag`.
+``` cpp
+template<size_t N>
+  constexpr void satisfy();
+```
+*Effects:* Equivalent to:
+``` cpp
+if constexpr (N < (sizeof...(Views) - 1)) {
+  if (std::get<N>(it_) == ranges::end(std::get<N>(parent_->views_))) {
+    it_.template emplace<N + 1>(ranges::begin(std::get<N + 1>(parent_->views_)));
+    satisfy<N + 1>();
+  }
+}
+```
+``` cpp
+template<size_t N>
+  constexpr void prev();
+```
+*Effects:* Equivalent to:
+``` cpp
+if constexpr (N == 0) {
+  --std::get<0>(it_);
+} else {
+  if (std::get<N>(it_) == ranges::begin(std::get<N>(parent_->views_))) {
+    it_.template emplace<N - 1>(ranges::end(std::get<N - 1>(parent_->views_)));
+    prev<N - 1>();
+  } else {
+    --std::get<N>(it_);
+  }
+}
+```
+``` cpp
+template<size_t N>
+  constexpr void advance-fwd(difference_type offset, difference_type steps);
+```
+*Effects:* Equivalent to:
+``` cpp
+using underlying_diff_type = iter_difference_t<variant_alternative_t<N, base-iter>>;
+if constexpr (N == sizeof...(Views) - 1) {
+  std::get<N>(it_) += static_cast<underlying_diff_type>(steps);
+} else {
+  auto n_size = ranges::distance(std::get<N>(parent_->views_));
+  if (offset + steps < n_size) {
+    std::get<N>(it_) += static_cast<underlying_diff_type>(steps);
+  } else {
+    it_.template emplace<N + 1>(ranges::begin(std::get<N + 1>(parent_->views_)));
+    advance-fwd<N + 1>(0, offset + steps - n_size);
+  }
+}
+```
+``` cpp
+template<size_t N>
+  constexpr void advance-bwd(difference_type offset, difference_type steps);
+```
+*Effects:* Equivalent to:
+``` cpp
+using underlying_diff_type = iter_difference_t<variant_alternative_t<N, base-iter>>;
+if constexpr (N == 0) {
+  std::get<N>(it_) -= static_cast<underlying_diff_type>(steps);
+} else {
+  if (offset >= steps) {
+    std::get<N>(it_) -= static_cast<underlying_diff_type>(steps);
+  } else {
+    auto prev_size = ranges::distance(std::get<N - 1>(parent_->views_));
+    it_.template emplace<N - 1>(ranges::end(std::get<N - 1>(parent_->views_)));
+    advance-bwd<N - 1>(prev_size, steps - offset);
+  }
+}
+```
+``` cpp
+template<class... Args>
+  constexpr explicit iterator(maybe-const<Const, concat_view>* parent,
+                              Args&&... args)
+    requires constructible_from<base-iter, Args&&...>;
+```
+*Effects:* Initializes *parent\_* with `parent`, and initializes *it\_*
+with `std::forward<Args>(args)...`.
+``` cpp
+constexpr iterator(iterator<!Const> it)
+  requires Const &&
+           (convertible_to<iterator_t<Views>, iterator_t<const Views>> && ...);
+```
+*Preconditions:* `it.`*`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Initializes *parent\_* with `it.`*`parent_`*, and let i be
+`it.`*`it_`*`.index()`, initializes *it\_* with
+*`base-iter`*`(in_place_index<`i`>, std::get<`i`>(std::move(it.`*`it_`*`)))`.
+``` cpp
+constexpr decltype(auto) operator*() const;
+```
+*Preconditions:* *`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+using reference = concat-reference-t<maybe-const<Const, Views>...>;
+return std::visit([](auto&& it) -> reference { return *it; },
+                  it_);
+```
+``` cpp
+constexpr iterator& operator++();
+```
+*Preconditions:* *`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Let i be *`it_`*`.index()`. Equivalent to:
+``` cpp
+++std::get<i>(it_);
+satisfy<i>();
+return *this;
+```
+``` cpp
+constexpr void operator++(int);
+```
+*Effects:* Equivalent to:
+``` cpp
+++*this;
+```
+``` cpp
+constexpr iterator operator++(int)
+  requires all-forward<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+++*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator--()
+  requires concat-is-bidirectional<Const, Views...>;
+```
+*Preconditions:* *`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Let i be *`it_`*`.index()`. Equivalent to:
+``` cpp
+prev<i>();
+return *this;
+```
+``` cpp
+constexpr iterator operator--(int)
+  requires concat-is-bidirectional<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+--*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator+=(difference_type n)
+  requires concat-is-random-access<Const, Views...>;
+```
+*Preconditions:* *`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Let i be *`it_`*`.index()`. Equivalent to:
+``` cpp
+if (n > 0) {
+  advance-fwd<i>(std::get<i>(it_) - ranges::begin(std::get<i>(parent_->views_)), n);
+} else if (n < 0) {
+  advance-bwd<i>(std::get<i>(it_) - ranges::begin(std::get<i>(parent_->views_)), -n);
+}
+return *this;
+```
+``` cpp
+constexpr iterator& operator-=(difference_type n)
+  requires concat-is-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+*this += -n;
+return *this;
+```
+``` cpp
+constexpr decltype(auto) operator[](difference_type n) const
+  requires concat-is-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+return *((*this) + n);
+```
+``` cpp
+friend constexpr bool operator==(const iterator& x, const iterator& y)
+  requires (equality_comparable<iterator_t<maybe-const<Const, Views>>> && ...);
+```
+*Preconditions:* `x.`*`it_`*`.valueless_by_exception()` and
+`y.`*`it_`*`.valueless_by_exception()` are each `false`.
+*Effects:* Equivalent to:
+``` cpp
+return x.it_ == y.it_;
+```
+``` cpp
+friend constexpr bool operator==(const iterator& it, default_sentinel_t);
+```
+*Preconditions:* `it.`*`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+constexpr auto last_idx = sizeof...(Views) - 1;
+return it.it_.index() == last_idx &&
+       std::get<last_idx>(it.it_) == ranges::end(std::get<last_idx>(it.parent_->views_));
+```
+``` cpp
+friend constexpr bool operator<(const iterator& x, const iterator& y)
+  requires all-random-access<Const, Views...>;
+friend constexpr bool operator>(const iterator& x, const iterator& y)
+  requires all-random-access<Const, Views...>;
+friend constexpr bool operator<=(const iterator& x, const iterator& y)
+  requires all-random-access<Const, Views...>;
+friend constexpr bool operator>=(const iterator& x, const iterator& y)
+  requires all-random-access<Const, Views...>;
+friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+  requires (all-random-access<Const, Views...> &&
+            (three_way_comparable<iterator_t<maybe-const<Const, Views>>> && ...));
+```
+*Preconditions:* `x.`*`it_`*`.valueless_by_exception()` and
+`y.`*`it_`*`.valueless_by_exception()` are each `false`.
+Let op be the operator.
+*Effects:* Equivalent to:
+``` cpp
+return x.it_ op y.it_;
+```
+``` cpp
+friend constexpr iterator operator+(const iterator& it, difference_type n)
+  requires concat-is-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto temp = it;
+temp += n;
+return temp;
+```
+``` cpp
+friend constexpr iterator operator+(difference_type n, const iterator& it)
+  requires concat-is-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+return it + n;
+```
+``` cpp
+friend constexpr iterator operator-(const iterator& it, difference_type n)
+  requires concat-is-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto temp = it;
+temp -= n;
+return temp;
+```
+``` cpp
+friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+  requires concat-is-random-access<Const, Views...>;
+```
+*Preconditions:* `x.`*`it_`*`.valueless_by_exception()` and
+`y.`*`it_`*`.valueless_by_exception()` are each `false`.
+*Effects:* Let i_`x` denote `x.`*`it_`*`.index()` and i_`y` denote
+`y.`*`it_`*`.index()`.
+- If i_`x`` > `i_`y`, let d_`y` be
+  `ranges::distance(std::get<`i_`y``>(y.`*`it_`*`), ranges::end(std::get<`i_`y``>(y.`*`parent_`*`->`*`views_`*`)))`,
+  d_`x` be
+  `ranges::distance(ranges::begin(std::get<`i_`x``>(x.`*`parent_`*`->`*`views_`*`)), std::get<`i_`x``>(x.`*`it_`*`))`.
+  Let s denote the sum of the sizes of all the ranges
+  `std::get<`i`>(x.`*`parent_`*`->`*`views_`*`)` for every integer i in
+  the range \[i_`y`` + 1`, i_`x`) if there is any, and `0` otherwise, of
+  type `difference_type`, equivalent to:
+  ``` cpp
+  return $d_y$ + s + $d_x$;
+  ```
+- otherwise, if i_`x`` < `i_`y` is `true`, equivalent to:
+  ``` cpp
+  return -(y - x);
+  ```
+- otherwise, equivalent to:
+  ``` cpp
+  return std::get<$i_x$>(x.it_) - std::get<$i_y$>(y.it_);
+  ```
+``` cpp
+friend constexpr difference_type operator-(const iterator& x, default_sentinel_t)
+  requires see below;
+```
+*Preconditions:* `x.`*`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Let i_`x` denote `x.`*`it_`*`.index()`, d_`x` be
+`ranges::distance(std::get<`i_`x``>(x.`*`it_`*`), ranges::end(std::get<`i_`x``>(x.`*`parent_`*`->`*`views_`*`)))`.
+Let s denote the sum of the sizes of all the ranges
+`std::get<`i`>(x.`*`parent_`*`->`*`views_`*`)` for every integer i in
+the range \[i_`x`` + 1`, `sizeof...(Views)`) if there is any, and `0`
+otherwise, of type difference_type, equivalent to:
+``` cpp
+return -($d_x$ + s);
+```
+*Remarks:* Let `Fs` be the pack that consists of all elements of `Views`
+except the first element, the expression in the *requires-clause* is
+equivalent to:
+``` cpp
+(sized_sentinel_for<sentinel_t<maybe-const<Const, Views>>,
+                    iterator_t<maybe-const<Const, Views>>> && ...) &&
+(sized_range<maybe-const<Const, Fs>> && ...)
+```
+``` cpp
+friend constexpr difference_type operator-(default_sentinel_t, const iterator& x)
+  requires see below;
+```
+*Effects:* Equivalent to:
+``` cpp
+return -(x - default_sentinel);
+```
+*Remarks:* Let `Fs` be the pack that consists of all elements of `Views`
+except the first element, the expression in the *requires-clause* is
+equivalent to:
+``` cpp
+(sized_sentinel_for<sentinel_t<maybe-const<Const, Views>>,
+                    iterator_t<maybe-const<Const, Views>>> && ...) &&
+(sized_range<maybe-const<Const, Fs>> && ...)
+```
+``` cpp
+friend constexpr decltype(auto) iter_move(const iterator& it) noexcept(see below);
+```
+*Preconditions:* `it.`*`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+return std::visit([](const auto& i)
+                  -> concat-rvalue-reference-t<maybe-const<Const, Views>...> {
+                    return ranges::iter_move(i);
+                  },
+                  it.it_);
+```
+*Remarks:* The exception specification is equivalent to:
+``` cpp
+((is_nothrow_invocable_v<decltype(ranges::iter_move),
+                         const iterator_t<maybe-const<Const, Views>>&> &&
+  is_nothrow_convertible_v<range_rvalue_reference_t<maybe-const<Const, Views>>,
+                           concat-rvalue-reference-t<maybe-const<Const, Views>...>>) &&
+ ...)
+```
+``` cpp
+friend constexpr void iter_swap(const iterator& x, const iterator& y) noexcept(see below)
+  requires see below;
+```
+*Preconditions:* `x.`*`it_`*`.valueless_by_exception()` and
+`y.`*`it_`*`.valueless_by_exception()` are each `false`.
+*Effects:* Equivalent to:
+``` cpp
+std::visit([&](const auto& it1, const auto& it2) {
+             if constexpr (is_same_v<decltype(it1), decltype(it2)>) {
+               ranges::iter_swap(it1, it2);
+             } else {
+               ranges::swap(*x, *y);
+             }
+           },
+           x.it_, y.it_);
+```
+*Remarks:* The exception specification is equivalent to
+``` cpp
+(noexcept(ranges::swap(*x, *y)) && ... && noexcept(ranges::iter_swap(its, its)))
+```
+where `its` is a pack of lvalues of type
+`const iterator_t<`*`maybe-const`*`<Const, Views>>` respectively.
+The expression in the *requires-clause* is equivalent to
+``` cpp
+swappable_with<iter_reference_t<iterator>, iter_reference_t<iterator>> &&
+(... && indirectly_swappable<iterator_t<maybe-const<Const, Views>>>)
+```
 ### Counted view <a id="range.counted">[[range.counted]]</a>
 A counted view presents a view of the elements of the counted range
 [[iterator.requirements.general]] `i`+\[0, `n`) for an iterator `i` and
 non-negative integer `n`.
     constexpr explicit common_view(V r);
     constexpr V base() const & requires copy_constructible<V> { return base_; }
     constexpr V base() && { return std::move(base_); }
+    constexpr auto begin() requires (!simple-view<V>) {
       if constexpr (random_access_range<V> && sized_range<V>)
         return ranges::begin(base_);
       else
         return common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::begin(base_));
     }
         return ranges::begin(base_);
       else
         return common_iterator<iterator_t<const V>, sentinel_t<const V>>(ranges::begin(base_));
     }
+    constexpr auto end() requires (!simple-view<V>) {
       if constexpr (random_access_range<V> && sized_range<V>)
         return ranges::begin(base_) + ranges::distance(base_);
       else
         return common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::end(base_));
     }
       return ranges::size(base_);
     }
     constexpr auto size() const requires sized_range<const V> {
       return ranges::size(base_);
     }
+    constexpr auto reserve_hint() requires approximately_sized_range<V> {
+      return ranges::reserve_hint(base_);
+    }
+    constexpr auto reserve_hint() const requires approximately_sized_range<const V> {
+      return ranges::reserve_hint(base_);
+    }
   };
   template<class R>
     common_view(R&&) -> common_view<views::all_t<R>>;
 }
 The name `views::reverse` denotes a range adaptor object
 [[range.adaptor.object]]. Given a subexpression `E`, the expression
 `views::reverse(E)` is expression-equivalent to:
 - If the type of `E` is a (possibly cv-qualified) specialization of
+  `reverse_view`, then `E.base()`.
 - Otherwise, if the type of `E` is cv
   `subrange<reverse_iterator<I>, reverse_iterator<I>, K>` for some
   iterator type `I` and value `K` of type `subrange_kind`,
+  - if `K` is `subrange_kind::sized`, then
+    `subrange<I, I, K>(E.end().base(), E.begin().base(), E.size())`;
+  - otherwise, `subrange<I, I, K>(E.end().base(), E.begin().base())`.
   However, in either case `E` is evaluated only once.
+- Otherwise, `reverse_view{E}`.
 [*Example 1*:
 ``` cpp
 vector<int> is {0,1,2,3,4};
     }
     constexpr auto size() const requires sized_range<const V> {
       return ranges::size(base_);
     }
+    constexpr auto reserve_hint() requires approximately_sized_range<V> {
+      return ranges::reserve_hint(base_);
+    }
+    constexpr auto reserve_hint() const requires approximately_sized_range<const V> {
+      return ranges::reserve_hint(base_);
+    }
   };
   template<class R>
     reverse_view(R&&) -> reverse_view<views::all_t<R>>;
 }
     constexpr auto end() requires (!simple-view<V>) { return ranges::cend(base_); }
     constexpr auto end() const requires range<const V> { return ranges::cend(base_); }
     constexpr auto size() requires sized_range<V> { return ranges::size(base_); }
     constexpr auto size() const requires sized_range<const V> { return ranges::size(base_); }
+    constexpr auto reserve_hint() requires approximately_sized_range<V>
+    { return ranges::reserve_hint(base_); }
+    constexpr auto reserve_hint() const requires approximately_sized_range<const V>
+    { return ranges::reserve_hint(base_); }
   };
   template<class R>
     as_const_view(R&&) -> as_const_view<views::all_t<R>>;
 }
     { return ranges::size(base_); }
     constexpr auto size() const requires sized_range<const V>
     { return ranges::size(base_); }
+    constexpr auto reserve_hint() requires approximately_sized_range<V>
+    { return ranges::reserve_hint(base_); }
+    constexpr auto reserve_hint() const requires approximately_sized_range<const V>
+    { return ranges::reserve_hint(base_); }
   private:
     // [range.elements.iterator], class template elements_view::iterator
     template<bool> class iterator;                      // exposition only
     // [range.elements.sentinel], class template elements_view::sentinel
 #### Overview <a id="range.enumerate.overview">[[range.enumerate.overview]]</a>
 `enumerate_view` is a view whose elements represent both the position
 and value from a sequence of elements.
+The name `views::enumerate` denotes a range adaptor object
+[[range.adaptor.object]]. Given a subexpression `E`, the expression
+`views::enumerate(E)` is expression-equivalent to
 `enumerate_view<views::all_t<decltype((E))>>(E)`.
 [*Example 1*:
 ``` cpp
     { return iterator<false>(ranges::begin(base_), 0); }
     constexpr auto begin() const requires range-with-movable-references<const V>
     { return iterator<true>(ranges::begin(base_), 0); }
     constexpr auto end() requires (!simple-view<V>) {
+      if constexpr (forward_range<V> && common_range<V> && sized_range<V>)
         return iterator<false>(ranges::end(base_), ranges::distance(base_));
       else
         return sentinel<false>(ranges::end(base_));
     }
     constexpr auto end() const requires range-with-movable-references<const V> {
+      if constexpr (forward_range<const V> && common_range<const V> && sized_range<const V>)
         return iterator<true>(ranges::end(base_), ranges::distance(base_));
       else
         return sentinel<true>(ranges::end(base_));
     }
     constexpr auto size() requires sized_range<V>
     { return ranges::size(base_); }
     constexpr auto size() const requires sized_range<const V>
     { return ranges::size(base_); }
+    constexpr auto reserve_hint() requires approximately_sized_range<V>
+    { return ranges::reserve_hint(base_); }
+    constexpr auto reserve_hint() const requires approximately_sized_range<const V>
+    { return ranges::reserve_hint(base_); }
     constexpr V base() const & requires copy_constructible<V> { return base_; }
     constexpr V base() && { return std::move(base_); }
   };
   template<class R>
       requires random_access_range<Base>;
     friend constexpr iterator operator+(difference_type x, const iterator& y)
       requires random_access_range<Base>;
     friend constexpr iterator operator-(const iterator& x, difference_type y)
       requires random_access_range<Base>;
+    friend constexpr difference_type operator-(const iterator& x, const iterator& y) noexcept;
     friend constexpr auto iter_move(const iterator& i)
       noexcept(noexcept(ranges::iter_move(i.current_)) &&
                is_nothrow_move_constructible_v<range_rvalue_reference_t<Base>>) {
       return tuple<difference_type,
 temp -= y;
 return temp;
 ```
 ``` cpp
+friend constexpr difference_type operator-(const iterator& x, const iterator& y) noexcept;
 ```
 *Effects:* Equivalent to: `return x.`*`pos_`*` - y.`*`pos_`*`;`
 #### Class template `enumerate_view::sentinel` <a id="range.enumerate.sentinel">[[range.enumerate.sentinel]]</a>
 #### Class template `zip_view::iterator` <a id="range.zip.iterator">[[range.zip.iterator]]</a>
 ``` cpp
 namespace std::ranges {
   template<input_range... Views>
     requires (view<Views> && ...) && (sizeof...(Views) > 0)
   template<bool Const>
   class zip_view<Views...>::iterator {
     tuple<iterator_t<maybe-const<Const, Views>>...> current_;       // exposition only
                                iterator_t<maybe-const<OtherConst, Views>>> && ...)
 friend constexpr common_type_t<range_difference_t<maybe-const<OtherConst, Views>>...>
   operator-(const sentinel& y, const iterator<OtherConst>& x);
 ```
+*Effects:* Equivalent to: `return -(x - y);`
 ### Zip transform view <a id="range.zip.transform">[[range.zip.transform]]</a>
 #### Overview <a id="range.zip.transform.overview">[[range.zip.transform.overview]]</a>
     constexpr iterator(Parent& parent, ziperator<Const> inner);   // exposition only
   public:
     using iterator_category = see belownc;                        // not always present
+    using iterator_concept  = ziperator<Const>::iterator_concept;
     using value_type =
       remove_cvref_t<invoke_result_t<maybe-const<Const, F>&,
                                      range_reference_t<maybe-const<Const, Views>>...>>;
     using difference_type = range_difference_t<Base>;
 The name `views::adjacent<N>` denotes a range adaptor object
 [[range.adaptor.object]]. Given a subexpression `E` and a constant
 expression `N`, the expression `views::adjacent<N>(E)` is
 expression-equivalent to
+- `((void)E, auto(views::empty<tuple<>>))` if `N` is equal to `0` and
+  `decltype((E))` models `forward_range`,
 - otherwise, `adjacent_view<views::all_t<decltype((E))>, N>(E)`.
 [*Example 1*:
 ``` cpp
       }
     }
     constexpr auto size() requires sized_range<V>;
     constexpr auto size() const requires sized_range<const V>;
+    constexpr auto reserve_hint() requires approximately_sized_range<V>;
+    constexpr auto reserve_hint() const requires approximately_sized_range<const V>;
   };
 }
 ```
 ``` cpp
 auto sz = static_cast<CT>(ranges::size(base_));
 sz -= std::min<CT>(sz, N - 1);
 return static_cast<ST>(sz);
 ```
+``` cpp
+constexpr auto reserve_hint() requires approximately_sized_range<V>;
+constexpr auto reserve_hint() const requires approximately_sized_range<const V>;
+```
+*Effects:* Equivalent to:
+``` cpp
+using DT = range_difference_t<decltype((base_))>;
+using CT = common_type_t<DT, size_t>;
+auto sz = static_cast<CT>(ranges::reserve_hint(base_));
+sz -= std::min<CT>(sz, N - 1);
+return to-unsigned-like(sz);
+```
 #### Class template `adjacent_view::iterator` <a id="range.adjacent.iterator">[[range.adjacent.iterator]]</a>
 ``` cpp
 namespace std::ranges {
   template<forward_range V, size_t N>
 The name `views::adjacent_transform<N>` denotes a range adaptor object
 [[range.adaptor.object]]. Given subexpressions `E` and `F` and a
 constant expression `N`:
+- If `N` is equal to `0` and `decltype((E))` models `forward_range`,
+  `views::adjacent_transform<N>(E, F)` is expression-equivalent to
+  `((void)E, views::zip_transform(F))`, except that the evaluations of
+  `E` and `F` are indeterminately sequenced.
 - Otherwise, the expression `views::adjacent_transform<N>(E, F)` is
   expression-equivalent to
   `adjacent_transform_view<views::all_t<decltype((E))>, decay_t<decltype((F))>, N>(E, F)`.
 [*Example 1*:
   public:
     adjacent_transform_view() = default;
     constexpr explicit adjacent_transform_view(V base, F fun);
+    constexpr V base() const & requires copy_constructible<V> { return inner_.base(); }
     constexpr V base() && { return std::move(inner_).base(); }
     constexpr auto begin() {
       return iterator<false>(*this, inner_.begin());
     }
     }
     constexpr auto size() const requires sized_range<const InnerView> {
       return inner_.size();
     }
+    constexpr auto reserve_hint() requires approximately_sized_range<InnerView> {
+      return inner_.reserve_hint();
+    }
+    constexpr auto reserve_hint() const requires approximately_sized_range<const InnerView> {
+      return inner_.reserve_hint();
+    }
   };
 }
 ```
 ``` cpp
     constexpr iterator(Parent& parent, inner-iterator<Const> inner);    // exposition only
   public:
     using iterator_category = see below;
+    using iterator_concept  = inner-iterator<Const>::iterator_concept;
     using value_type =
       remove_cvref_t<invoke_result_t<maybe-const<Const, F>&,
                                      REPEAT(range_reference_t<Base>, N)...>>;
     using difference_type = range_difference_t<Base>;
 template<bool OtherConst>
   requires sentinel_for<inner-sentinel<Const>, inner-iterator<OtherConst>>
 friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y);
 ```
+*Effects:* Equivalent to: `return x.`*`inner_`*` == y.`*`inner_`*`;`
 ``` cpp
 template<bool OtherConst>
   requires sized_sentinel_for<inner-sentinel<Const>, inner-iterator<OtherConst>>
 friend constexpr range_difference_t<maybe-const<OtherConst, InnerView>>
   requires sized_sentinel_for<inner-sentinel<Const>, inner-iterator<OtherConst>>
 friend constexpr range_difference_t<maybe-const<OtherConst, InnerView>>
   operator-(const sentinel& x, const iterator<OtherConst>& y);
 ```
+*Effects:* Equivalent to: `return x.`*`inner_`*` - y.`*`inner_`*`;`
 ### Chunk view <a id="range.chunk">[[range.chunk]]</a>
 #### Overview <a id="range.chunk.overview">[[range.chunk.overview]]</a>
     constexpr outer-iterator begin();
     constexpr default_sentinel_t end() const noexcept;
     constexpr auto size() requires sized_range<V>;
     constexpr auto size() const requires sized_range<const V>;
+    constexpr auto reserve_hint() requires approximately_sized_range<V>;
+    constexpr auto reserve_hint() const requires approximately_sized_range<const V>;
   };
   template<class R>
     chunk_view(R&&, range_difference_t<R>) -> chunk_view<views::all_t<R>>;
 }
 ``` cpp
 return to-unsigned-like(div-ceil(ranges::distance(base_), n_));
 ```
+``` cpp
+constexpr auto reserve_hint() requires approximately_sized_range<V>;
+constexpr auto reserve_hint() const requires approximately_sized_range<const V>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto s = static_cast<range_difference_t<decltype((base_))>>(ranges::reserve_hint(base_));
+return to-unsigned-like(div-ceil(s, n_));
+```
 #### Class `chunk_view::outer-iterator` <a id="range.chunk.outer.iter">[[range.chunk.outer.iter]]</a>
 ``` cpp
 namespace std::ranges {
   template<view V>
     constexpr inner-iterator begin() const noexcept;
     constexpr default_sentinel_t end() const noexcept;
     constexpr auto size() const
       requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
+    constexpr auto reserve_hint() const noexcept;
   };
 }
 ```
 ``` cpp
 ``` cpp
 return to-unsigned-like(ranges::min(parent_->remainder_,
                                 ranges::end(parent_->base_) - *parent_->current_));
 ```
+``` cpp
+constexpr auto reserve_hint() const noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+return to-unsigned-like(parent_->remainder_);
+```
 #### Class `chunk_view::inner-iterator` <a id="range.chunk.inner.iter">[[range.chunk.inner.iter]]</a>
 ``` cpp
 namespace std::ranges {
   template<view V>
       }
     }
     constexpr auto size() requires sized_range<V>;
     constexpr auto size() const requires sized_range<const V>;
+    constexpr auto reserve_hint() requires approximately_sized_range<V>;
+    constexpr auto reserve_hint() const requires approximately_sized_range<const V>;
   };
 }
 ```
 ``` cpp
 ``` cpp
 return to-unsigned-like(div-ceil(ranges::distance(base_), n_));
 ```
+``` cpp
+constexpr auto reserve_hint() requires approximately_sized_range<V>;
+constexpr auto reserve_hint() const requires approximately_sized_range<const V>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto s = static_cast<range_difference_t<decltype((base_))>>(ranges::reserve_hint(base_));
+return to-unsigned-like(div-ceil(s, n_));
+```
 #### Class template `chunk_view::iterator` for forward ranges <a id="range.chunk.fwd.iter">[[range.chunk.fwd.iter]]</a>
 ``` cpp
 namespace std::ranges {
   template<view V>
       requires (!(simple-view<V> && slide-caches-nothing<const V>));
     constexpr auto end() const requires slide-caches-nothing<const V>;
     constexpr auto size() requires sized_range<V>;
     constexpr auto size() const requires sized_range<const V>;
+    constexpr auto reserve_hint() requires approximately_sized_range<V>;
+    constexpr auto reserve_hint() const requires approximately_sized_range<const V>;
   };
   template<class R>
     slide_view(R&&, range_difference_t<R>) -> slide_view<views::all_t<R>>;
 }
 auto sz = ranges::distance(base_) - n_ + 1;
 if (sz < 0) sz = 0;
 return to-unsigned-like(sz);
 ```
+``` cpp
+constexpr auto reserve_hint() requires approximately_sized_range<V>;
+constexpr auto reserve_hint() const requires approximately_sized_range<const V>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto sz = static_cast<range_difference_t<decltype((base_))>>(ranges::reserve_hint(base_)) -
+                                                             n_ + 1;
+if (sz < 0) sz = 0;
+return to-unsigned-like(sz);
+```
 #### Class template `slide_view::iterator` <a id="range.slide.iterator">[[range.slide.iterator]]</a>
 ``` cpp
 namespace std::ranges {
   template<forward_range V>
       }
     }
     constexpr auto size() requires sized_range<V>;
     constexpr auto size() const requires sized_range<const V>;
+    constexpr auto reserve_hint() requires approximately_sized_range<V>;
+    constexpr auto reserve_hint() const requires approximately_sized_range<const V>;
   };
   template<class R>
     stride_view(R&&, range_difference_t<R>) -> stride_view<views::all_t<R>>;
 }
 ``` cpp
 return to-unsigned-like(div-ceil(ranges::distance(base_), stride_));
 ```
+``` cpp
+constexpr auto reserve_hint() requires approximately_sized_range<V>;
+constexpr auto reserve_hint() const requires approximately_sized_range<const V>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto s = static_cast<range_difference_t<decltype((base_))>>(ranges::reserve_hint(base_));
+return to-unsigned-like(div-ceil(s, stride_));
+```
 #### Class template `stride_view::iterator` <a id="range.stride.iterator">[[range.stride.iterator]]</a>
 ``` cpp
 namespace std::ranges {
   template<input_range V>
 ``` cpp
 constexpr void operator++(int);
 ```
+*Effects:* Equivalent to `++*this;`
 ``` cpp
 constexpr iterator operator++(int) requires forward_range<Base>;
 ```
   concept cartesian-product-is-bidirectional =          // exposition only
     (bidirectional_range<maybe-const<Const, First>> && ... &&
       (bidirectional_range<maybe-const<Const, Vs>>
         && cartesian-product-common-arg<maybe-const<Const, Vs>>));
+  template<class First, class...>
   concept cartesian-product-is-common =                 // exposition only
     cartesian-product-common-arg<First>;
   template<class... Vs>
   concept cartesian-product-is-sized =                  // exposition only
 the following expressions:
 - `noexcept(ranges::iter_swap(std::get<`i`>(l.`*`current_`*`), std::get<`i`>(r.`*`current_`*`)))`
   for every integer 0 ≤ i ≤ `sizeof...(Vs)`.
+### Cache latest view <a id="range.cache.latest">[[range.cache.latest]]</a>
+#### Overview <a id="range.cache.latest.overview">[[range.cache.latest.overview]]</a>
+`cache_latest_view` caches the last-accessed element of its underlying
+sequence so that the element does not have to be recomputed on repeated
+access.
+[*Note 1*: This is useful if computation of the element to produce is
+expensive. — *end note*]
+The name `views::cache_latest` denotes a range adaptor object
+[[range.adaptor.object]]. Let `E` be an expression. The expression
+`views::cache_latest(E)` is expression-equivalent to
+`cache_latest_view(E)`.
+#### Class template `cache_latest_view` <a id="range.cache.latest.view">[[range.cache.latest.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V>
+    requires view<V>
+  class cache_latest_view : public view_interface<cache_latest_view<V>> {
+    V base_ = V();                                                      // exposition only
+    using cache-t = conditional_t<is_reference_v<range_reference_t<V>>, // exposition only
+                                  add_pointer_t<range_reference_t<V>>,
+                                  range_reference_t<V>>;
+    non-propagating-cache<cache-t> cache_;                              // exposition only
+    // [range.cache.latest.iterator], class cache_latest_view::iterator
+    class iterator;                                                     // exposition only
+    // [range.cache.latest.sentinel], class cache_latest_view::sentinel
+    class sentinel;                                                     // exposition only
+  public:
+    cache_latest_view() requires default_initializable<V> = default;
+    constexpr explicit cache_latest_view(V base);
+    constexpr V base() const & requires copy_constructible<V> { return base_; }
+    constexpr V base() && { return std::move(base_); }
+    constexpr auto begin();
+    constexpr auto end();
+    constexpr auto size() requires sized_range<V>;
+    constexpr auto size() const requires sized_range<const V>;
+    constexpr auto reserve_hint() requires approximately_sized_range<V>;
+    constexpr auto reserve_hint() const requires approximately_sized_range<const V>;
+  };
+  template<class R>
+    cache_latest_view(R&&) -> cache_latest_view<views::all_t<R>>;
+}
+```
+``` cpp
+constexpr explicit cache_latest_view(V base);
+```
+*Effects:* Initializes *base\_* with `std::move(base)`.
+``` cpp
+constexpr auto begin();
+```
+*Effects:* Equivalent to: `return `*`iterator`*`(*this);`
+``` cpp
+constexpr auto end();
+```
+*Effects:* Equivalent to: `return `*`sentinel`*`(*this);`
+``` cpp
+constexpr auto size() requires sized_range<V>;
+constexpr auto size() const requires sized_range<const V>;
+```
+*Effects:* Equivalent to: `return ranges::size(`*`base_`*`);`
+``` cpp
+constexpr auto reserve_hint() requires approximately_sized_range<V>;
+constexpr auto reserve_hint() const requires approximately_sized_range<const V>;
+```
+*Effects:* Equivalent to: `return ranges::reserve_hint(`*`base_`*`);`
+#### Class `cache_latest_view::iterator` <a id="range.cache.latest.iterator">[[range.cache.latest.iterator]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V>
+    requires view<V>
+  class cache_latest_view<V>::iterator {
+    cache_latest_view* parent_;                                 // exposition only
+    iterator_t<V> current_;                                     // exposition only
+    constexpr explicit iterator(cache_latest_view& parent);     // exposition only
+  public:
+    using difference_type = range_difference_t<V>;
+    using value_type = range_value_t<V>;
+    using iterator_concept = input_iterator_tag;
+    iterator(iterator&&) = default;
+    iterator& operator=(iterator&&) = default;
+    constexpr iterator_t<V> base() &&;
+    constexpr const iterator_t<V>& base() const & noexcept;
+    constexpr range_reference_t<V>& operator*() const;
+    constexpr iterator& operator++();
+    constexpr void operator++(int);
+    friend constexpr range_rvalue_reference_t<V> iter_move(const iterator& i)
+      noexcept(noexcept(ranges::iter_move(i.current_)));
+    friend constexpr void iter_swap(const iterator& x, const iterator& y)
+      noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
+      requires indirectly_swappable<iterator_t<V>>;
+  };
+}
+```
+``` cpp
+constexpr explicit iterator(cache_latest_view& parent);
+```
+*Effects:* Initializes *current\_* with
+`ranges::begin(parent.`*`base_`*`)` and *parent\_* with
+`addressof(parent)`.
+``` cpp
+constexpr iterator_t<V> base() &&;
+```
+*Returns:* `std::move(`*`current_`*`)`.
+``` cpp
+constexpr const iterator_t<V>& base() const & noexcept;
+```
+*Returns:* *current\_*.
+``` cpp
+constexpr iterator& operator++();
+```
+*Effects:* Equivalent to:
+``` cpp
+parent_->cache_.reset();
+++current_;
+return *this;
+```
+``` cpp
+constexpr void operator++(int);
+```
+*Effects:* Equivalent to: `++*this`.
+``` cpp
+constexpr range_reference_t<V>& operator*() const;
+```
+*Effects:* Equivalent to:
+``` cpp
+if constexpr (is_reference_v<range_reference_t<V>>) {
+  if (!parent_->cache_) {
+    parent_->cache_ = addressof(as-lvalue(*current_));
+  }
+  return **parent_->cache_;
+} else {
+  if (!parent_->cache_) {
+    parent_->cache_.emplace-deref(current_);
+  }
+  return *parent_->cache_;
+}
+```
+[*Note 1*: Evaluations of `operator*` on the same iterator object can
+conflict [[intro.races]]. — *end note*]
+``` cpp
+friend constexpr range_rvalue_reference_t<V> iter_move(const iterator& i)
+  noexcept(noexcept(ranges::iter_move(i.current_)));
+```
+*Effects:* Equivalent to: `return ranges::iter_move(i.`*`current_`*`);`
+``` cpp
+friend constexpr void iter_swap(const iterator& x, const iterator& y)
+  noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
+  requires indirectly_swappable<iterator_t<V>>;
+```
+*Effects:* Equivalent to
+`ranges::iter_swap(x.`*`current_`*`, y.`*`current_`*`)`.
+#### Class `cache_latest_view::sentinel` <a id="range.cache.latest.sentinel">[[range.cache.latest.sentinel]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V>
+    requires view<V>
+  class cache_latest_view<V>::sentinel {
+    sentinel_t<V> end_ = sentinel_t<V>();                       // exposition only
+    constexpr explicit sentinel(cache_latest_view& parent);     // exposition only
+  public:
+    sentinel() = default;
+    constexpr sentinel_t<V> base() const;
+    friend constexpr bool operator==(const iterator& x, const sentinel& y);
+    friend constexpr range_difference_t<V> operator-(const iterator& x, const sentinel& y)
+      requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
+    friend constexpr range_difference_t<V> operator-(const sentinel& x, const iterator& y)
+      requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
+  };
+}
+```
+``` cpp
+constexpr explicit sentinel(cache_latest_view& parent);
+```
+*Effects:* Initializes *end\_* with `ranges::end(parent.`*`base_`*`)`.
+``` cpp
+constexpr sentinel_t<V> base() const;
+```
+*Returns:* *end\_*.
+``` cpp
+friend constexpr bool operator==(const iterator& x, const sentinel& y);
+```
+*Returns:* `x.`*`current_`*` == y.`*`end_`*.
+``` cpp
+friend constexpr range_difference_t<V> operator-(const iterator& x, const sentinel& y)
+  requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
+```
+*Returns:* `x.`*`current_`*` - y.`*`end_`*.
+``` cpp
+friend constexpr range_difference_t<V> operator-(const sentinel& x, const iterator& y)
+  requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
+```
+*Returns:* `x.`*`end_`*` - y.`*`current_`*.
+### To input view <a id="range.to.input">[[range.to.input]]</a>
+#### Overview <a id="range.to.input.overview">[[range.to.input.overview]]</a>
+`to_input_view` presents a view of an underlying sequence as an
+input-only non-common range.
+[*Note 1*: This is useful to avoid overhead that can be necessary to
+provide support for the operations needed for greater iterator
+strength. — *end note*]
+The name `views::to_input` denotes a range adaptor object
+[[range.adaptor.object]]. Let `E` be an expression and let `T` be
+`decltype((E))`. The expression `views::to_input(E)` is
+expression-equivalent to:
+- `views::all(E)` if `T` models `input_range`, does not satisfy
+  `common_range`, and does not satisfy `forward_range`.
+- Otherwise, `to_input_view(E)`.
+#### Class template `to_input_view` <a id="range.to.input.view">[[range.to.input.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V>
+    requires view<V>
+  class to_input_view : public view_interface<to_input_view<V>> {
+    V base_ = V();                        // exposition only
+    // [range.to.input.iterator], class template to_input_view::iterator
+    template<bool Const> class iterator;  // exposition only
+  public:
+    to_input_view() requires default_initializable<V> = default;
+    constexpr explicit to_input_view(V base);
+    constexpr V base() const & requires copy_constructible<V> { return base_; }
+    constexpr V base() && { return std::move(base_); }
+    constexpr auto begin() requires (!simple-view<V>);
+    constexpr auto begin() const requires range<const V>;
+    constexpr auto end() requires (!simple-view<V>);
+    constexpr auto end() const requires range<const V>;
+    constexpr auto size() requires sized_range<V>;
+    constexpr auto size() const requires sized_range<const V>;
+    constexpr auto reserve_hint() requires approximately_sized_range<V>;
+    constexpr auto reserve_hint() const requires approximately_sized_range<const V>;
+  };
+  template<class R>
+    to_input_view(R&&) -> to_input_view<views::all_t<R>>;
+}
+```
+``` cpp
+constexpr explicit to_input_view(V base);
+```
+*Effects:* Initializes *base\_* with `std::move(base)`.
+``` cpp
+constexpr auto begin() requires (!simple-view<V>);
+```
+*Effects:* Equivalent to:
+`return `*`iterator`*`<false>(ranges::begin(`*`base_`*`));`
+``` cpp
+constexpr auto begin() const requires range<const V>;
+```
+*Effects:* Equivalent to:
+`return `*`iterator`*`<true>(ranges::begin(`*`base_`*`));`
+``` cpp
+constexpr auto end() requires (!simple-view<V>);
+constexpr auto end() const requires range<const V>;
+```
+*Effects:* Equivalent to: `return ranges::end(`*`base_`*`);`
+``` cpp
+constexpr auto size() requires sized_range<V>;
+constexpr auto size() const requires sized_range<const V>;
+```
+*Effects:* Equivalent to: `return ranges::size(`*`base_`*`);`
+``` cpp
+constexpr auto reserve_hint() requires approximately_sized_range<V>;
+constexpr auto reserve_hint() const requires approximately_sized_range<const V>;
+```
+*Effects:* Equivalent to: `return ranges::reserve_hint(`*`base_`*`);`
+#### Class template `to_input_view::iterator` <a id="range.to.input.iterator">[[range.to.input.iterator]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V>
+    requires view<V>
+  template<bool Const>
+  class to_input_view<V>::iterator {
+    using Base = maybe-const<Const, V>;                         // exposition only
+    iterator_t<Base> current_ = iterator_t<Base>();             // exposition only
+    constexpr explicit iterator(iterator_t<Base> current);      // exposition only
+  public:
+    using difference_type = range_difference_t<Base>;
+    using value_type = range_value_t<Base>;
+    using iterator_concept = input_iterator_tag;
+    iterator() requires default_initializable<iterator_t<Base>> = default;
+    iterator(iterator&&) = default;
+    iterator& operator=(iterator&&) = default;
+    constexpr iterator(iterator<!Const> i)
+      requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
+    constexpr iterator_t<Base> base() &&;
+    constexpr const iterator_t<Base>& base() const & noexcept;
+    constexpr decltype(auto) operator*() const { return *current_; }
+    constexpr iterator& operator++();
+    constexpr void operator++(int);
+    friend constexpr bool operator==(const iterator& x, const sentinel_t<Base>& y);
+    friend constexpr difference_type operator-(const sentinel_t<Base>& y, const iterator& x)
+      requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
+    friend constexpr difference_type operator-(const iterator& x, const sentinel_t<Base>& y)
+      requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
+    friend constexpr range_rvalue_reference_t<Base> iter_move(const iterator& i)
+      noexcept(noexcept(ranges::iter_move(i.current_)));
+    friend constexpr void iter_swap(const iterator& x, const iterator& y)
+      noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
+      requires indirectly_swappable<iterator_t<Base>>;
+  };
+}
+```
+``` cpp
+constexpr explicit iterator(iterator_t<Base> current);
+```
+*Effects:* Initializes *current\_* with `std::move(current)`.
+``` cpp
+constexpr iterator(iterator<!Const> i)
+  requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
+```
+*Effects:* Initializes *current\_* with `std::move(i.`*`current_`*`)`.
+``` cpp
+constexpr iterator_t<Base> base() &&;
+```
+*Returns:* `std::move(`*`current_`*`)`.
+``` cpp
+constexpr const iterator_t<Base>& base() const & noexcept;
+```
+*Returns:* *current\_*.
+``` cpp
+constexpr iterator& operator++();
+```
+*Effects:* Equivalent to:
+``` cpp
+++current_;
+return *this;
+```
+``` cpp
+constexpr void operator++(int);
+```
+*Effects:* Equivalent to: `++*this;`
+``` cpp
+friend constexpr bool operator==(const iterator& x, const sentinel_t<Base>& y);
+```
+*Returns:* `x.`*`current_`*` == y`.
+``` cpp
+friend constexpr difference_type operator-(const sentinel_t<Base>& y, const iterator& x)
+  requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
+```
+*Returns:* `y - x.`*`current_`*.
+``` cpp
+friend constexpr difference_type operator-(const iterator& x, const sentinel_t<Base>& y)
+  requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
+```
+*Returns:* `x.`*`current_`*` - y`.
+``` cpp
+friend constexpr range_rvalue_reference_t<Base> iter_move(const iterator& i)
+  noexcept(noexcept(ranges::iter_move(i.current_)));
+```
+*Effects:* Equivalent to: `return ranges::iter_move(i.`*`current_`*`);`
+``` cpp
+friend constexpr void iter_swap(const iterator& x, const iterator& y)
+  noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
+  requires indirectly_swappable<iterator_t<Base>>;
+```
+*Effects:* Equivalent to:
+`ranges::iter_swap(x.`*`current_`*`, y.`*`current_`*`);`

Diff to HTML by rtfpessoa