[ranges] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpa9j4yfnd/{from.md → to.md} +1911 -318

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

@@ -21,552 +21,585 @@ components for range primitives and range generators as summarized in
 ## Header `<ranges>` synopsis <a id="ranges.syn">[[ranges.syn]]</a>
 ``` cpp
 #include <compare>              // see [compare.syn]
 #include <initializer_list>     // see [initializer.list.syn]
 #include <iterator>             // see [iterator.synopsis]
 namespace std::ranges {
   inline namespace unspecified {
     // [range.access], range access
-    inline constexpr unspecified begin = unspecified;                               // freestanding
-    inline constexpr unspecified end = unspecified;                                 // freestanding
-    inline constexpr unspecified cbegin = unspecified;                              // freestanding
-    inline constexpr unspecified cend = unspecified;                                // freestanding
-    inline constexpr unspecified rbegin = unspecified;                              // freestanding
-    inline constexpr unspecified rend = unspecified;                                // freestanding
-    inline constexpr unspecified crbegin = unspecified;                             // freestanding
-    inline constexpr unspecified crend = unspecified;                               // freestanding
-    inline constexpr unspecified size = unspecified;                                // freestanding
-    inline constexpr unspecified ssize = unspecified;                               // freestanding
-    inline constexpr unspecified empty = unspecified;                               // freestanding
-    inline constexpr unspecified data = unspecified;                                // freestanding
-    inline constexpr unspecified cdata = unspecified;                               // freestanding
   }
   // [range.range], ranges
   template<class T>
-    concept range = see below;                                                      // freestanding
   template<class T>
-    constexpr bool enable_borrowed_range = false;                                   // freestanding
   template<class T>
-    concept borrowed_range = see below;                                             // freestanding
   template<class T>
-    using iterator_t = decltype(ranges::begin(declval<T&>()));                      // freestanding
   template<range R>
-    using sentinel_t = decltype(ranges::end(declval<R&>()));                        // freestanding
   template<range R>
-    using const_iterator_t = const_iterator<iterator_t<R>>;                         // freestanding
   template<range R>
-    using const_sentinel_t = const_sentinel<sentinel_t<R>>;                         // freestanding
   template<range R>
-    using range_difference_t = iter_difference_t<iterator_t<R>>;                    // freestanding
   template<sized_range R>
-    using range_size_t = decltype(ranges::size(declval<R&>()));                     // freestanding
   template<range R>
-    using range_value_t = iter_value_t<iterator_t<R>>;                              // freestanding
   template<range R>
-    using range_reference_t = iter_reference_t<iterator_t<R>>;                      // freestanding
   template<range R>
-    using range_const_reference_t = iter_const_reference_t<iterator_t<R>>;          // freestanding
   template<range R>
-    using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R>>;        // freestanding
   template<range R>
-    using range_common_reference_t = iter_common_reference_t<iterator_t<R>>;        // freestanding
   // [range.sized], sized ranges
   template<class>
-    constexpr bool disable_sized_range = false;                                     // freestanding
   template<class T>
-    concept sized_range = see below;                                                // freestanding
   // [range.view], views
   template<class T>
-    constexpr bool enable_view = see below;                                         // freestanding
-  struct view_base {};                                                              // freestanding
   template<class T>
-    concept view = see below;                                                       // freestanding
   // [range.refinements], other range refinements
   template<class R, class T>
-    concept output_range = see below;                                               // freestanding
   template<class T>
-    concept input_range = see below;                                                // freestanding
   template<class T>
-    concept forward_range = see below;                                              // freestanding
   template<class T>
-    concept bidirectional_range = see below;                                        // freestanding
   template<class T>
-    concept random_access_range = see below;                                        // freestanding
   template<class T>
-    concept contiguous_range = see below;                                           // freestanding
   template<class T>
-    concept common_range = see below;                                               // freestanding
   template<class T>
-    concept viewable_range = see below;                                             // freestanding
   template<class T>
-    concept constant_range = see below;                                             // freestanding
   // [view.interface], class template view_interface
   template<class D>
     requires is_class_v<D> && same_as<D, remove_cv_t<D>>
-  class view_interface;                                                             // freestanding
   // [range.subrange], sub-ranges
-  enum class subrange_kind : bool { unsized, sized };                               // freestanding
   template<input_or_output_iterator I, sentinel_for<I> S = I, subrange_kind K = see below>
     requires (K == subrange_kind::sized || !sized_sentinel_for<S, I>)
-  class subrange;                                                                   // freestanding
   template<class I, class S, subrange_kind K>
-    constexpr bool enable_borrowed_range<subrange<I, S, K>> = true;                 // freestanding
   template<size_t N, class I, class S, subrange_kind K>
     requires ((N == 0 && copyable<I>) || N == 1)
-    constexpr auto get(const subrange<I, S, K>& r);                                 // freestanding
   template<size_t N, class I, class S, subrange_kind K>
     requires (N < 2)
-    constexpr auto get(subrange<I, S, K>&& r);                                      // freestanding
 }
 namespace std {
-  using ranges::get;                                                                // freestanding
 }
 namespace std::ranges {
   // [range.dangling], dangling iterator handling
-  struct dangling;                                                                  // freestanding
   // [range.elementsof], class template elements_of
   template<range R, class Allocator = allocator<byte>>
-    struct elements_of;
   template<range R>
-    using borrowed_iterator_t = see below;                                          // freestanding
   template<range R>
-    using borrowed_subrange_t = see below;                                          // freestanding
   // [range.utility.conv], range conversions
   template<class C, input_range R, class... Args> requires (!view<C>)
-    constexpr C to(R&& r, Args&&... args);                                          // freestanding
   template<template<class...> class C, input_range R, class... Args>
-    constexpr auto to(R&& r, Args&&... args);                                       // freestanding
   template<class C, class... Args> requires (!view<C>)
-    constexpr auto to(Args&&... args);                                              // freestanding
   template<template<class...> class C, class... Args>
-    constexpr auto to(Args&&... args);                                              // freestanding
   // [range.empty], empty view
   template<class T>
     requires is_object_v<T>
-  class empty_view;                                                                 // freestanding
   template<class T>
-    constexpr bool enable_borrowed_range<empty_view<T>> = true;                     // freestanding
   namespace views {
     template<class T>
-      constexpr empty_view<T> empty{};                                              // freestanding
   }
   // [range.single], single view
   template<move_constructible T>
     requires is_object_v<T>
-  class single_view;                                                                // freestanding
-  namespace views { inline constexpr unspecified single = unspecified; }            // freestanding
   template<bool Const, class T>
     using maybe-const = conditional_t<Const, const T, T>;   // exposition only
   // [range.iota], iota view
   template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>
     requires weakly-equality-comparable-with<W, Bound> && copyable<W>
-  class iota_view;                                                                  // freestanding
   template<class W, class Bound>
-    constexpr bool enable_borrowed_range<iota_view<W, Bound>> = true;               // freestanding
-  namespace views { inline constexpr unspecified iota = unspecified; }              // freestanding
   // [range.repeat], repeat view
   template<move_constructible T, semiregular Bound = unreachable_sentinel_t>
     requires see below
-  class repeat_view;                                                                // freestanding
-  namespace views { inline constexpr unspecified repeat = unspecified; }            // freestanding
   // [range.istream], istream view
   template<movable Val, class CharT, class Traits = char_traits<CharT>>
     requires see below
-  class basic_istream_view;
   template<class Val>
-    using istream_view = basic_istream_view<Val, char>;
   template<class Val>
-    using wistream_view = basic_istream_view<Val, wchar_t>;
-  namespace views { template<class T> constexpr unspecified istream = unspecified; }
   // [range.adaptor.object], range adaptor objects
   template<class D>
     requires is_class_v<D> && same_as<D, remove_cv_t<D>>
-  class range_adaptor_closure { };                                                  // freestanding
   // [range.all], all view
   namespace views {
-    inline constexpr unspecified all = unspecified;                                 // freestanding
     template<viewable_range R>
-      using all_t = decltype(all(declval<R>()));                                    // freestanding
   }
   // [range.ref.view], ref view
   template<range R>
     requires is_object_v<R>
-  class ref_view;                                                                   // freestanding
   template<class T>
-    constexpr bool enable_borrowed_range<ref_view<T>> = true;                       // freestanding
   // [range.owning.view], owning view
   template<range R>
     requires see below
-  class owning_view;                                                                // freestanding
   template<class T>
-    constexpr bool enable_borrowed_range<owning_view<T>> =                          // freestanding
       enable_borrowed_range<T>;
   // [range.as.rvalue], as rvalue view
   template<view V>
     requires input_range<V>
-  class as_rvalue_view;                                                             // freestanding
   template<class T>
-    constexpr bool enable_borrowed_range<as_rvalue_view<T>> =                       // freestanding
       enable_borrowed_range<T>;
-  namespace views { inline constexpr unspecified as_rvalue = unspecified; }         // freestanding
   // [range.filter], filter view
   template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred>
     requires view<V> && is_object_v<Pred>
-  class filter_view;                                                                // freestanding
-  namespace views { inline constexpr unspecified filter = unspecified; }            // freestanding
   // [range.transform], transform view
   template<input_range V, move_constructible F>
     requires view<V> && is_object_v<F> &&
              regular_invocable<F&, range_reference_t<V>> &&
              can-reference<invoke_result_t<F&, range_reference_t<V>>>
-  class transform_view;                                                             // freestanding
-  namespace views { inline constexpr unspecified transform = unspecified; }         // freestanding
   // [range.take], take view
-  template<view> class take_view;                                                   // freestanding
   template<class T>
-    constexpr bool enable_borrowed_range<take_view<T>> =                            // freestanding
       enable_borrowed_range<T>;
-  namespace views { inline constexpr unspecified take = unspecified; }              // freestanding
   // [range.take.while], take while view
   template<view V, class Pred>
     requires input_range<V> && is_object_v<Pred> &&
              indirect_unary_predicate<const Pred, iterator_t<V>>
-    class take_while_view;                                                          // freestanding
-  namespace views { inline constexpr unspecified take_while = unspecified; }        // freestanding
   // [range.drop], drop view
   template<view V>
-    class drop_view;                                                                // freestanding
   template<class T>
-    constexpr bool enable_borrowed_range<drop_view<T>> =                            // freestanding
       enable_borrowed_range<T>;
-  namespace views { inline constexpr unspecified drop = unspecified; }              // freestanding
   // [range.drop.while], drop while view
   template<view V, class Pred>
     requires input_range<V> && is_object_v<Pred> &&
              indirect_unary_predicate<const Pred, iterator_t<V>>
-    class drop_while_view;                                                          // freestanding
   template<class T, class Pred>
-    constexpr bool enable_borrowed_range<drop_while_view<T, Pred>> =                // freestanding
       enable_borrowed_range<T>;
-  namespace views { inline constexpr unspecified drop_while = unspecified; }        // freestanding
   // [range.join], join view
   template<input_range V>
     requires view<V> && input_range<range_reference_t<V>>
-  class join_view;                                                                  // freestanding
-  namespace views { inline constexpr unspecified join = unspecified; }              // freestanding
   // [range.join.with], join with view
-  template<class R, class P>
-    concept compatible-joinable-ranges = see below; // 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;                                                             // freestanding
-  namespace views { inline constexpr unspecified join_with = unspecified; }         // freestanding
   // [range.lazy.split], lazy split view
   template<class R>
     concept tiny-range = see below;   // exposition only
   template<input_range V, forward_range Pattern>
     requires view<V> && view<Pattern> &&
              indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&
              (forward_range<V> || tiny-range<Pattern>)
-  class lazy_split_view;                                                            // freestanding
   // [range.split], split view
   template<forward_range V, forward_range Pattern>
     requires view<V> && view<Pattern> &&
              indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>
-  class split_view;                                                                 // freestanding
   namespace views {
-    inline constexpr unspecified lazy_split = unspecified;                          // freestanding
-    inline constexpr unspecified split = unspecified;                               // freestanding
   }
   // [range.counted], counted view
-  namespace views { inline constexpr unspecified counted = unspecified; }           // freestanding
   // [range.common], common view
   template<view V>
     requires (!common_range<V> && copyable<iterator_t<V>>)
-  class common_view;                                                                // freestanding
   template<class T>
-    constexpr bool enable_borrowed_range<common_view<T>> =                          // freestanding
       enable_borrowed_range<T>;
-  namespace views { inline constexpr unspecified common = unspecified; }            // freestanding
   // [range.reverse], reverse view
   template<view V>
     requires bidirectional_range<V>
-  class reverse_view;                                                               // freestanding
   template<class T>
-    constexpr bool enable_borrowed_range<reverse_view<T>> =                         // freestanding
       enable_borrowed_range<T>;
-  namespace views { inline constexpr unspecified reverse = unspecified; }           // freestanding
   // [range.as.const], as const view
   template<input_range R>
-    constexpr auto& possibly-const-range(R& r) { // exposition only
-      if constexpr (constant_range<const R> && !constant_range<R>) {
         return const_cast<const R&>(r);
       } else {
         return r;
       }
     }
   template<view V>
     requires input_range<V>
-  class as_const_view;                                                              // freestanding
   template<class T>
-    constexpr bool enable_borrowed_range<as_const_view<T>> =                        // freestanding
       enable_borrowed_range<T>;
-  namespace views { inline constexpr unspecified as_const = unspecified; }          // freestanding
   // [range.elements], elements view
   template<input_range V, size_t N>
     requires see below
-  class elements_view;                                                              // freestanding
   template<class T, size_t N>
-    constexpr bool enable_borrowed_range<elements_view<T, N>> =                     // freestanding
       enable_borrowed_range<T>;
   template<class R>
-    using keys_view = elements_view<R, 0>;                                          // freestanding
   template<class R>
-    using values_view = elements_view<R, 1>;                                        // freestanding
   namespace views {
     template<size_t N>
-      constexpr unspecified elements = unspecified;                                 // freestanding
-    inline constexpr auto keys = elements<0>;                                       // freestanding
-    inline constexpr auto values = elements<1>;                                     // freestanding
   }
   // [range.enumerate], enumerate view
-  template<input_range View>
-    requires view<View>
-  class enumerate_view;                                                             // freestanding
   template<class View>
-    constexpr bool enable_borrowed_range<enumerate_view<View>> =                    // freestanding
       enable_borrowed_range<View>;
-  namespace views { inline constexpr unspecified enumerate = unspecified; }         // freestanding
   // [range.zip], zip view
   template<input_range... Views>
     requires (view<Views> && ...) && (sizeof...(Views) > 0)
-  class zip_view;                                                                   // freestanding
   template<class... Views>
-    constexpr bool enable_borrowed_range<zip_view<Views...>> =                      // freestanding
       (enable_borrowed_range<Views> && ...);
-  namespace views { inline constexpr unspecified zip = unspecified; }               // freestanding
   // [range.zip.transform], zip transform view
   template<move_constructible F, input_range... Views>
     requires (view<Views> && ...) && (sizeof...(Views) > 0) && is_object_v<F> &&
              regular_invocable<F&, range_reference_t<Views>...> &&
              can-reference<invoke_result_t<F&, range_reference_t<Views>...>>
-  class zip_transform_view;                                                         // freestanding
-  namespace views { inline constexpr unspecified zip_transform = unspecified; }     // freestanding
   // [range.adjacent], adjacent view
   template<forward_range V, size_t N>
     requires view<V> && (N > 0)
-  class adjacent_view;                                                              // freestanding
   template<class V, size_t N>
-    constexpr bool enable_borrowed_range<adjacent_view<V, N>> =                     // freestanding
       enable_borrowed_range<V>;
   namespace views {
     template<size_t N>
-      constexpr unspecified adjacent = unspecified;                                 // freestanding
-    inline constexpr auto pairwise = adjacent<2>;                                   // freestanding
   }
   // [range.adjacent.transform], adjacent transform view
   template<forward_range V, move_constructible F, size_t N>
     requires see below
-  class adjacent_transform_view;                                                    // freestanding
   namespace views {
     template<size_t N>
-      constexpr unspecified adjacent_transform = unspecified;                       // freestanding
-    inline constexpr auto pairwise_transform = adjacent_transform<2>;               // freestanding
   }
   // [range.chunk], chunk view
   template<view V>
     requires input_range<V>
-  class chunk_view;                                                                 // freestanding
   template<view V>
     requires forward_range<V>
-  class chunk_view<V>;                                                              // freestanding
   template<class V>
-    constexpr bool enable_borrowed_range<chunk_view<V>> =                           // freestanding
       forward_range<V> && enable_borrowed_range<V>;
-  namespace views { inline constexpr unspecified chunk = unspecified; }             // freestanding
   // [range.slide], slide view
   template<forward_range V>
     requires view<V>
-  class slide_view;                                                                 // freestanding
   template<class V>
-    constexpr bool enable_borrowed_range<slide_view<V>> =
-      enable_borrowed_range<V>;                                                     // freestanding
-  namespace views { inline constexpr unspecified slide = unspecified; }             // freestanding
   // [range.chunk.by], chunk by view
   template<forward_range V, indirect_binary_predicate<iterator_t<V>, iterator_t<V>> Pred>
     requires view<V> && is_object_v<Pred>
-  class chunk_by_view;                                                              // freestanding
-  namespace views { inline constexpr unspecified chunk_by = unspecified; }          // freestanding
   // [range.stride], stride view
   template<input_range V>
     requires view<V>
-  class stride_view;                                                                // freestanding
   template<class V>
-    constexpr bool enable_borrowed_range<stride_view<V>> =                          // freestanding
       enable_borrowed_range<V>;
-  namespace views { inline constexpr unspecified stride = unspecified; }            // freestanding
   // [range.cartesian], cartesian product view
   template<input_range First, forward_range... Vs>
     requires (view<First> && ... && view<Vs>)
-  class cartesian_product_view;                                                     // freestanding
-  namespace views { inline constexpr unspecified cartesian_product = unspecified; } // freestanding
 }
 namespace std {
-  namespace views = ranges::views;                                                  // freestanding
-  template<class T> struct tuple_size;                                              // freestanding
-  template<size_t I, class T> struct tuple_element;                                 // freestanding
   template<class I, class S, ranges::subrange_kind K>
-  struct tuple_size<ranges::subrange<I, S, K>>                                      // freestanding
     : integral_constant<size_t, 2> {};
   template<class I, class S, ranges::subrange_kind K>
-  struct tuple_element<0, ranges::subrange<I, S, K>> {                              // freestanding
-    using type = I;                                                                 // freestanding
   };
   template<class I, class S, ranges::subrange_kind K>
-  struct tuple_element<1, ranges::subrange<I, S, K>> {                              // freestanding
-    using type = S;                                                                 // freestanding
   };
   template<class I, class S, ranges::subrange_kind K>
-  struct tuple_element<0, const ranges::subrange<I, S, K>> {                        // freestanding
-    using type = I;                                                                 // freestanding
   };
   template<class I, class S, ranges::subrange_kind K>
-  struct tuple_element<1, const ranges::subrange<I, S, K>> {                        // freestanding
-    using type = S;                                                                 // freestanding
   };
-  struct from_range_t { explicit from_range_t() = default; };                       // freestanding
-  inline constexpr from_range_t from_range{};                                       // freestanding
 }
 ```
 Within this Clause, for an integer-like type `X`
 [[iterator.concept.winc]], `make-unsigned-like-t<X>` denotes
@@ -584,11 +617,11 @@ type of the same width as `X`.
 ### General <a id="range.access.general">[[range.access.general]]</a>
 In addition to being available via inclusion of the `<ranges>` header,
 the customization point objects in [[range.access]] are available when
-`<iterator>` is included.
 Within [[range.access]], the *reified object* of a subexpression `E`
 denotes
 - the same object as `E` if `E` is a glvalue, or
@@ -846,10 +879,37 @@ denotes the reified object for `E`. If `ranges::size(t)` is ill-formed,
 `ranges::ssize(E)` is ill-formed. Otherwise let `D` be
 `make-signed-like-t<decltype(ranges::{}size(t))>`, or `ptrdiff_t` if it
 is wider than that type; `ranges::ssize(E)` is expression-equivalent to
 `static_cast<D>(ranges::size(t))`.
 ### `ranges::empty` <a id="range.prim.empty">[[range.prim.empty]]</a>
 The name `ranges::empty` denotes a customization point object
 [[customization.point.object]].
@@ -906,11 +966,11 @@ pointer to object type. — *end note*]
 ### `ranges::cdata` <a id="range.prim.cdata">[[range.prim.cdata]]</a>
 ``` cpp
 template<class T>
-constexpr auto as-const-pointer(const T* p) { return p; } // exposition only
 ```
 The name `ranges::cdata` denotes a customization point object
 [[customization.point.object]]. Given a subexpression `E` with type `T`,
 let `t` be an lvalue that denotes the reified object for `E`. Then:
@@ -964,14 +1024,10 @@ template<class T>
       ranges::begin(t);         // sometimes equality-preserving (see below)
       ranges::end(t);
     };
 ```
-The required expressions `ranges::begin(t)` and `ranges::end(t)` of the
-`range` concept do not require implicit expression
-variations [[concepts.equality]].
 Given an expression `t` such that `decltype((t))` is `T&`, `T` models
 `range` only if
 - \[`ranges::begin(t)`, `ranges::end(t)`) denotes a
   range [[iterator.requirements.general]],
@@ -1025,20 +1081,48 @@ models `borrowed_range` because
 - `S`’s iterators do not have validity tied to the lifetime of an `S`
   object because they are “borrowed” from some other range.
 — *end example*]
 ### Sized ranges <a id="range.sized">[[range.sized]]</a>
-The `sized_range` concept refines `range` with the requirement that the
-number of elements in the range can be determined in amortized constant
-time using `ranges::size`.
 ``` cpp
 template<class T>
   concept sized_range =
- range<T> && requires(T& t) { ranges::size(t); };
 ```
 Given an lvalue `t` of type `remove_reference_t<T>`, `T` models
 `sized_range` only if
@@ -1060,11 +1144,11 @@ template<class>
 *Remarks:* Pursuant to [[namespace.std]], users may specialize
 `disable_sized_range` for cv-unqualified program-defined types. Such
 specializations shall be usable in constant expressions [[expr.const]]
 and have type `const bool`.
-[*Note 1*: `disable_sized_range` allows use of range types with the
 library that satisfy but do not in fact model
 `sized_range`. — *end note*]
 ### Views <a id="range.view">[[range.view]]</a>
@@ -1076,11 +1160,11 @@ constructing range adaptor pipelines [[range.adaptors]].
 template<class T>
   concept view =
     range<T> && movable<T> && enable_view<T>;
 ```
-`T` models `view` only if:
 - `T` has 𝑂(1) move construction; and
 - move assignment of an object of type `T` is no more complex than
   destruction followed by move construction; and
 - if N copies and/or moves are made from an object of type `T` that
@@ -1124,12 +1208,12 @@ For a type `T`, *`is-derived-from-view-interface`*`<T>` is `true` if and
 only if `T` has exactly one public base class `view_interface<U>` for
 some type `U` and `T` has no base classes of type `view_interface<V>`
 for any other type `V`.
 *Remarks:* Pursuant to [[namespace.std]], users may specialize
-`enable_view` to `true` for cv-unqualified program-defined types which
-model `view`, and `false` for types which do not. Such specializations
 shall be usable in constant expressions [[expr.const]] and have type
 `const bool`.
 ### Other range refinements <a id="range.refinements">[[range.refinements]]</a>
@@ -1215,32 +1299,45 @@ type whose elements are not modifiable.
 template<class T>
   concept constant_range =
     input_range<T> && constant-iterator<iterator_t<T>>;
 ```
 ## Range utilities <a id="range.utility">[[range.utility]]</a>
 ### General <a id="range.utility.general">[[range.utility.general]]</a>
 The components in [[range.utility]] are general utilities for
 representing and manipulating ranges.
 ### Helper concepts <a id="range.utility.helpers">[[range.utility.helpers]]</a>
-Many of the types in subclause  [[range.utility]] are specified in terms
-of the following exposition-only concepts:
 ``` cpp
 template<class R>
   concept simple-view =                                     // exposition only
     view<R> && range<const R> &&
     same_as<iterator_t<R>, iterator_t<const R>> &&
     same_as<sentinel_t<R>, sentinel_t<const R>>;
 template<class I>
   concept has-arrow =                                       // exposition only
-    input_iterator<I> && (is_pointer_v<I> || requires(I i) { i.operator->(); });
 template<class T, class U>
   concept different-from =                                  // exposition only
     !same_as<remove_cvref_t<T>, remove_cvref_t<U>>;
@@ -1354,21 +1451,21 @@ shall be complete, and model both `derived_from<view_interface<D>>` and
 ``` cpp
 constexpr decltype(auto) front() requires forward_range<D>;
 constexpr decltype(auto) front() const requires forward_range<const D>;
 ```
-*Preconditions:* `!empty()` is `true`.
 *Effects:* Equivalent to: `return *ranges::begin(`*`derived`*`());`
 ``` cpp
 constexpr decltype(auto) back() requires bidirectional_range<D> && common_range<D>;
 constexpr decltype(auto) back() const
   requires bidirectional_range<const D> && common_range<const D>;
 ```
-*Preconditions:* `!empty()` is `true`.
 *Effects:* Equivalent to:
 `return *ranges::prev(ranges::end(`*`derived`*`()));`
 ### Sub-ranges <a id="range.subrange">[[range.subrange]]</a>
@@ -1435,21 +1532,21 @@ namespace std::ranges {
     template<different-from<subrange> PairLike>
       requires pair-like-convertible-from<PairLike, const I&, const S&>
     constexpr operator PairLike() const;
     constexpr I begin() const requires copyable<I>;
- [[nodiscard]] constexpr I begin() requires (!copyable<I>);
     constexpr S end() const;
     constexpr bool empty() const;
     constexpr make-unsigned-like-t<iter_difference_t<I>> size() const
       requires (K == subrange_kind::sized);
- [[nodiscard]] constexpr subrange next(iter_difference_t<I> n = 1) const &
       requires forward_iterator<I>;
- [[nodiscard]] constexpr subrange next(iter_difference_t<I> n = 1) &&;
- [[nodiscard]] constexpr subrange prev(iter_difference_t<I> n = 1) const
       requires bidirectional_iterator<I>;
     constexpr subrange& advance(iter_difference_t<I> n);
   };
   template<input_or_output_iterator I, sentinel_for<I> S>
@@ -1528,11 +1625,11 @@ constexpr I begin() const requires copyable<I>;
 ```
 *Effects:* Equivalent to: `return `*`begin_`*`;`
 ``` cpp
-[[nodiscard]] constexpr I begin() requires (!copyable<I>);
 ```
 *Effects:* Equivalent to: `return std::move(`*`begin_`*`);`
 ``` cpp
@@ -1557,11 +1654,11 @@ constexpr make-unsigned-like-t<iter_difference_t<I>> size() const
 - If *StoreSize* is `true`, equivalent to: `return `*`size_`*`;`
 - Otherwise, equivalent to:
   `return `*`to-unsigned-like`*`(`*`end_`*` - `*`begin_`*`);`
 ``` cpp
-[[nodiscard]] constexpr subrange next(iter_difference_t<I> n = 1) const &
   requires forward_iterator<I>;
 ```
 *Effects:* Equivalent to:
@@ -1570,22 +1667,22 @@ auto tmp = *this;
 tmp.advance(n);
 return tmp;
 ```
 ``` cpp
-[[nodiscard]] constexpr subrange next(iter_difference_t<I> n = 1) &&;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 advance(n);
 return std::move(*this);
 ```
 ``` cpp
-[[nodiscard]] constexpr subrange prev(iter_difference_t<I> n = 1) const
   requires bidirectional_iterator<I>;
 ```
 *Effects:* Equivalent to:
@@ -1749,30 +1846,38 @@ constexpr bool reservable-container =          // exposition only
     { c.capacity() } -> same_as<decltype(n)>;
     { c.max_size() } -> same_as<decltype(n)>;
   };
 ```
-Let *`container-insertable`* be defined as follows:
 ``` cpp
 template<class Container, class Ref>
-constexpr bool container-insertable =          // exposition only
   requires(Container& c, Ref&& ref) {
-    requires (requires { c.push_back(std::forward<Ref>(ref)); } ||
               requires { c.insert(c.end(), std::forward<Ref>(ref)); });
   };
 ```
-Let *`container-inserter`* be defined as follows:
 ``` cpp
-template<class Ref, class Container>
-constexpr auto container-inserter(Container& c) { // exposition only
- if constexpr (requires { c.push_back(declval<Ref>()); })
- return back_inserter(c);
     else
-    return inserter(c, c.end());
 }
 ```
 #### `ranges::to` <a id="range.utility.conv.to">[[range.utility.conv.to]]</a>
@@ -1808,21 +1913,22 @@ the following manner:
     ``` cpp
     C(ranges::begin(r), ranges::end(r), std::forward<Args>(args)...)
     ```
   - Otherwise, if
     - `constructible_from<C, Args...>` is `true`, and
-    - *`container-insertable`*`<C, range_reference_t<R>>` is `true`:
     ``` cpp
     C c(std::forward<Args>(args)...);
-    if constexpr (sized_range<R> && reservable-container<C>)
-      c.reserve(static_cast<range_size_t<C>>(ranges::size(r)));
-    ranges::copy(r, container-inserter<range_reference_t<R>>(c));
     ```
 - Otherwise, if `input_range<range_reference_t<R>>` is `true`:
   ``` cpp
-  to<C>(r | views::transform([](auto&& elem) {
     return to<range_value_t<C>>(std::forward<decltype(elem)>(elem));
   }), std::forward<Args>(args)...);
   ```
 - Otherwise, the program is ill-formed.
@@ -1973,10 +2079,11 @@ namespace std::ranges {
     constexpr T* begin() noexcept;
     constexpr const T* begin() const noexcept;
     constexpr T* end() noexcept;
     constexpr const T* end() const noexcept;
     static constexpr size_t size() noexcept;
     constexpr T* data() noexcept;
     constexpr const T* data() const noexcept;
   };
@@ -2018,10 +2125,16 @@ constexpr T* end() noexcept;
 constexpr const T* end() const noexcept;
 ```
 *Effects:* Equivalent to: `return data() + 1;`
 ``` cpp
 static constexpr size_t size() noexcept;
 ```
 *Effects:* Equivalent to: `return 1;`
@@ -2041,22 +2154,28 @@ constexpr const T* data() const noexcept;
 an initial value.
 The name `views::iota` denotes a customization point object
 [[customization.point.object]]. Given subexpressions `E` and `F`, the
 expressions `views::iota(E)` and `views::iota(E, F)` are
-expression-equivalent to `iota_view(E)` and `iota_view(E, F)`,
-respectively.
 [*Example 1*:
 ``` cpp
 for (int i : views::iota(1, 10))
   cout << i << ' '; // prints 1 2 3 4 5 6 7 8 9
 ```
 — *end example*]
 #### Class template `iota_view` <a id="range.iota.view">[[range.iota.view]]</a>
 ``` cpp
 namespace std::ranges {
   template<class I>
@@ -2086,10 +2205,11 @@ namespace std::ranges {
     constexpr iterator begin() const;
     constexpr auto end() const;
     constexpr iterator end() const requires same_as<W, Bound>;
     constexpr auto size() const requires see below;
   };
   template<class W, class Bound>
     requires (!is-integer-like<W> || !is-integer-like<Bound> ||
@@ -2233,10 +2353,16 @@ else
 constexpr iterator end() const requires same_as<W, Bound>;
 ```
 *Effects:* Equivalent to: `return `*`iterator`*`{`*`bound_`*`};`
 ``` cpp
 constexpr auto size() const requires see below;
 ```
 *Effects:* Equivalent to:
@@ -2599,12 +2725,12 @@ friend constexpr iter_difference_t<W> operator-(const sentinel& x, const iterato
 the same value.
 The name `views::repeat` denotes a customization point object
 [[customization.point.object]]. Given subexpressions `E` and `F`, the
 expressions `views::repeat(E)` and `views::repeat(E, F)` are
-expression-equivalent to `repeat_view(E)` and `repeat_view(E, F)`,
-respectively.
 [*Example 1*:
 ``` cpp
 for (int i : views::repeat(17, 4))
@@ -2651,12 +2777,12 @@ namespace std::ranges {
     constexpr unreachable_sentinel_t end() const noexcept;
     constexpr auto size() const requires (!same_as<Bound, unreachable_sentinel_t>);
   };
-  template<class T, class Bound>
-    repeat_view(T, Bound) -> repeat_view<T, Bound>;
 }
 ```
 ``` cpp
 constexpr explicit repeat_view(const T& value, Bound bound = Bound())
@@ -3215,11 +3341,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
@@ -3294,10 +3420,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>
@@ -3341,10 +3477,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>
@@ -3414,10 +3553,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_); }
   };
@@ -3442,11 +3586,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*:
@@ -3496,10 +3640,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>>;
 }
@@ -3883,10 +4032,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>;
 }
@@ -4466,10 +4620,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>>;
@@ -4719,12 +4889,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`
@@ -4785,10 +4955,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
   };
@@ -5291,11 +5471,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 {
@@ -5370,23 +5550,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
@@ -5428,11 +5602,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> &&
@@ -5443,11 +5618,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
@@ -5485,11 +5661,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
@@ -5588,11 +5764,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`.
@@ -5656,20 +5832,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
@@ -5686,11 +5862,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
@@ -5703,13 +5879,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*]
@@ -5765,27 +5941,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;
     }
   }
 }
@@ -5823,11 +5999,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
@@ -6072,12 +6248,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;
 ```
@@ -6152,14 +6329,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;
   };
 }
 ```
@@ -6197,11 +6373,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>;
@@ -6492,17 +6668,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++();
 ```
@@ -6577,10 +6753,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`.
@@ -6657,11 +7621,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_));
     }
@@ -6671,11 +7635,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_));
     }
@@ -6691,10 +7655,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>>;
 }
@@ -6716,25 +7687,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};
@@ -6774,10 +7740,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>>;
 }
@@ -6878,10 +7851,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>>;
 }
@@ -7002,10 +7980,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
@@ -7394,13 +8378,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
@@ -7436,27 +8420,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>
@@ -7532,11 +8521,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,
@@ -7714,11 +8703,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>
@@ -7925,20 +8914,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
@@ -8305,11 +9284,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>
@@ -8440,11 +9419,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>;
@@ -8743,11 +9722,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
@@ -8811,10 +9791,13 @@ namespace std::ranges {
       }
     }
     constexpr auto size() requires sized_range<V>;
     constexpr auto size() const requires sized_range<const V>;
   };
 }
 ```
 ``` cpp
@@ -8836,10 +9819,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>
@@ -9232,13 +10230,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*:
@@ -9279,11 +10278,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());
     }
@@ -9317,10 +10316,18 @@ namespace std::ranges {
     }
     constexpr auto size() const requires sized_range<const InnerView> {
       return inner_.size();
     }
   };
 }
 ```
 ``` cpp
@@ -9347,11 +10354,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>;
@@ -9621,11 +10628,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>>
@@ -9635,11 +10642,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>
@@ -9708,10 +10715,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>>;
 }
@@ -9753,10 +10763,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>
@@ -9872,10 +10894,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
@@ -9906,10 +10930,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>
@@ -10084,10 +11118,13 @@ namespace std::ranges {
       }
     }
     constexpr auto size() requires sized_range<V>;
     constexpr auto size() const requires sized_range<const V>;
   };
 }
 ```
 ``` cpp
@@ -10108,10 +11145,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>
@@ -10484,10 +11533,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>>;
 }
@@ -10571,10 +11623,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>
@@ -11238,10 +12304,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>>;
 }
@@ -11271,10 +12340,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>
@@ -11432,11 +12513,11 @@ return *this;
 ``` cpp
 constexpr void operator++(int);
 ```
-*Effects:* Equivalent to: `++*this;`
 ``` cpp
 constexpr iterator operator++(int) requires forward_range<Base>;
 ```
@@ -11674,11 +12755,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
@@ -12217,10 +13298,500 @@ 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)`.
 ## Range generators <a id="coro.generator">[[coro.generator]]</a>
 ### Overview <a id="coroutine.generator.overview">[[coroutine.generator.overview]]</a>
 Class template `generator` presents a view of the elements yielded by
@@ -12252,29 +13823,29 @@ void f() {
 ### Header `<generator>` synopsis <a id="generator.syn">[[generator.syn]]</a>
 ``` cpp
 namespace std {
   // [coro.generator.class], class template generator
-  template<class Ref, class V = void, class Allocator = void>
     class generator;
   namespace pmr {
-    template<class R, class V = void>
-      using generator = std::generator<R, V, polymorphic_allocator<>>;
   }
 }
 ```
 ### Class template `generator` <a id="coro.generator.class">[[coro.generator.class]]</a>
 ``` cpp
 namespace std {
-  template<class Ref, class V = void, class Allocator = void>
-  class generator : public ranges::view_interface<generator<Ref, V, Allocator>> {
   private:
-    using value = conditional_t<is_void_v<V>, remove_cvref_t<Ref>, V>;  // exposition only
-    using reference = conditional_t<is_void_v<V>, Ref&&, Ref>;          // exposition only
     // [coro.generator.iterator], class generator::iterator
     class iterator;                                                     // exposition only
   public:
@@ -12333,11 +13904,11 @@ undefined.
 generator(generator&& other) noexcept;
 ```
 *Effects:* Initializes *coroutine\_* with
 `exchange(other.`*`coroutine_`*`, {})` and *active\_* with
-`exchange(other.active_, nullptr)`.
 [*Note 1*: Iterators previously obtained from `other` are not
 invalidated; they become iterators into `*this`. — *end note*]
 ``` cpp
@@ -12397,12 +13968,12 @@ default_sentinel_t end() const noexcept;
 ### Class `generator::promise_type` <a id="coro.generator.promise">[[coro.generator.promise]]</a>
 ``` cpp
 namespace std {
-  template<class Ref, class V, class Allocator>
-  class generator<Ref, V, Allocator>::promise_type {
   public:
     generator get_return_object() noexcept;
     suspend_always initial_suspend() const noexcept { return {}; }
     auto final_suspend() noexcept;
@@ -12414,29 +13985,30 @@ namespace std {
         constructible_from<remove_cvref_t<yielded>, const remove_reference_t<yielded>&>;
     template<class R2, class V2, class Alloc2, class Unused>
       requires same_as<typename generator<R2, V2, Alloc2>::yielded, yielded>
         auto yield_value(ranges::elements_of<generator<R2, V2, Alloc2>&&, Unused> g) noexcept;
     template<ranges::input_range R, class Alloc>
       requires convertible_to<ranges::range_reference_t<R>, yielded>
-        auto yield_value(ranges::elements_of<R, Alloc> r) noexcept;
     void await_transform() = delete;
     void return_void() const noexcept {}
     void unhandled_exception();
     void* operator new(size_t size)
       requires same_as<Allocator, void> || default_initializable<Allocator>;
     template<class Alloc, class... Args>
-      requires same_as<Allocator, void> || convertible_to<const Alloc&, Allocator>
       void* operator new(size_t size, allocator_arg_t, const Alloc& alloc, const Args&...);
     template<class This, class Alloc, class... Args>
-      requires same_as<Allocator, void> || convertible_to<const Alloc&, Allocator>
       void* operator new(size_t size, const This&, allocator_arg_t, const Alloc& alloc,
                          const Args&...);
     void operator delete(void* pointer, size_t size) noexcept;
@@ -12503,10 +14075,13 @@ object.
 ``` cpp
 template<class R2, class V2, class Alloc2, class Unused>
   requires same_as<typename generator<R2, V2, Alloc2>::yielded, yielded>
   auto yield_value(ranges::elements_of<generator<R2, V2, Alloc2>&&, Unused> g) noexcept;
 ```
 *Preconditions:* A handle referring to the coroutine whose promise
 object is `*this` is at the top of `*`*`active_`* of some `generator`
 object `x`. The coroutine referred to by `g.range.`*`coroutine_`* is
@@ -12519,24 +14094,24 @@ into which `g.range` is moved, whose member `await_ready` returns
 execution of the coroutine referred to by `g.range.`*`coroutine_`*, and
 whose member `await_resume` evaluates `rethrow_exception(`*`except_`*`)`
 if `bool(`*`except_`*`)` is `true`. If `bool(`*`except_`*`)` is `false`,
 the `await_resume` member has no effects.
-*Remarks:* A *yield-expression* that calls this function has type `void`
-[[expr.yield]].
 ``` cpp
 template<ranges::input_range R, class Alloc>
   requires convertible_to<ranges::range_reference_t<R>, yielded>
-  auto yield_value(ranges::elements_of<R, Alloc> r) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 auto nested = [](allocator_arg_t, Alloc, ranges::iterator_t<R> i, ranges::sentinel_t<R> s)
-  -> generator<yielded, ranges::range_value_t<R>, Alloc> {
     for (; i != s; ++i) {
       co_yield static_cast<yielded>(*i);
     }
   };
 return yield_value(ranges::elements_of(nested(
@@ -12561,15 +14136,13 @@ is `*this` is the sole element of `*x.`*`active_`*, equivalent to
 ``` cpp
 void* operator new(size_t size)
   requires same_as<Allocator, void> || default_initializable<Allocator>;
 template<class Alloc, class... Args>
-  requires same_as<Allocator, void> || convertible_to<const Alloc&, Allocator>
   void* operator new(size_t size, allocator_arg_t, const Alloc& alloc, const Args&...);
 template<class This, class Alloc, class... Args>
-  requires same_as<Allocator, void> || convertible_to<const Alloc&, Allocator>
   void* operator new(size_t size, const This&, allocator_arg_t, const Alloc& alloc,
                      const Args&...);
 ```
 Let `A` be
@@ -12580,11 +14153,14 @@ Let `A` be
 Let `B` be `allocator_traits<A>::template rebind_alloc<U>` where `U` is
 an unspecified type whose size and alignment are both
 \_\_STDCPP_DEFAULT_NEW_ALIGNMENT\_\_.
-*Mandates:* `allocator_traits<B>::pointer` is a pointer type.
 *Effects:* Initializes an allocator `b` of type `B` with `A(alloc)`, for
 the overloads with a function parameter `alloc`, and with `A()`
 otherwise. Uses `b` to allocate storage for the smallest array of `U`
 sufficient to provide storage for a coroutine state of size `size`, and
@@ -12606,12 +14182,12 @@ allocator equivalent to that used to allocate it.
 ### Class `generator::iterator` <a id="coro.generator.iterator">[[coro.generator.iterator]]</a>
 ``` cpp
 namespace std {
-  template<class Ref, class V, class Allocator>
-  class generator<Ref, V, Allocator>::iterator {
   public:
     using value_type = value;
     using difference_type = ptrdiff_t;
     iterator(iterator&& other) noexcept;
@@ -12678,10 +14254,11 @@ friend bool operator==(const iterator& i, default_sentinel_t);
 ```
 *Effects:* Equivalent to: `return i.`*`coroutine_`*`.done();`
 <!-- Link reference definitions -->
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [concepts.equality]: concepts.md#concepts.equality
 [containers]: containers.md#containers
 [conv.rval]: expr.md#conv.rval
 [coro.generator]: #coro.generator
@@ -12695,10 +14272,11 @@ friend bool operator==(const iterator& i, default_sentinel_t);
 [dcl.init.general]: dcl.md#dcl.init.general
 [expr.await]: expr.md#expr.await
 [expr.const]: expr.md#expr.const
 [expr.yield]: expr.md#expr.yield
 [generator.syn]: #generator.syn
 [iterator.concept.bidir]: iterators.md#iterator.concept.bidir
 [iterator.concept.forward]: iterators.md#iterator.concept.forward
 [iterator.concept.iterator]: iterators.md#iterator.concept.iterator
 [iterator.concept.output]: iterators.md#iterator.concept.output
 [iterator.concept.random.access]: iterators.md#iterator.concept.random.access
@@ -12730,16 +14308,22 @@ friend bool operator==(const iterator& i, default_sentinel_t);
 [range.adjacent.transform.sentinel]: #range.adjacent.transform.sentinel
 [range.adjacent.transform.view]: #range.adjacent.transform.view
 [range.adjacent.view]: #range.adjacent.view
 [range.all]: #range.all
 [range.all.general]: #range.all.general
 [range.as.const]: #range.as.const
 [range.as.const.overview]: #range.as.const.overview
 [range.as.const.view]: #range.as.const.view
 [range.as.rvalue]: #range.as.rvalue
 [range.as.rvalue.overview]: #range.as.rvalue.overview
 [range.as.rvalue.view]: #range.as.rvalue.view
 [range.cartesian]: #range.cartesian
 [range.cartesian.iterator]: #range.cartesian.iterator
 [range.cartesian.overview]: #range.cartesian.overview
 [range.cartesian.view]: #range.cartesian.view
 [range.chunk]: #range.chunk
@@ -12755,10 +14339,14 @@ friend bool operator==(const iterator& i, default_sentinel_t);
 [range.chunk.view.fwd]: #range.chunk.view.fwd
 [range.chunk.view.input]: #range.chunk.view.input
 [range.common]: #range.common
 [range.common.overview]: #range.common.overview
 [range.common.view]: #range.common.view
 [range.counted]: #range.counted
 [range.dangling]: #range.dangling
 [range.drop]: #range.drop
 [range.drop.overview]: #range.drop.overview
 [range.drop.view]: #range.drop.view
@@ -12816,10 +14404,11 @@ friend bool operator==(const iterator& i, default_sentinel_t);
 [range.owning.view]: #range.owning.view
 [range.prim.cdata]: #range.prim.cdata
 [range.prim.data]: #range.prim.data
 [range.prim.empty]: #range.prim.empty
 [range.prim.size]: #range.prim.size
 [range.prim.ssize]: #range.prim.ssize
 [range.range]: #range.range
 [range.ref.view]: #range.ref.view
 [range.refinements]: #range.refinements
 [range.repeat]: #range.repeat
@@ -12860,10 +14449,14 @@ friend bool operator==(const iterator& i, default_sentinel_t);
 [range.take.view]: #range.take.view
 [range.take.while]: #range.take.while
 [range.take.while.overview]: #range.take.while.overview
 [range.take.while.sentinel]: #range.take.while.sentinel
 [range.take.while.view]: #range.take.while.view
 [range.transform]: #range.transform
 [range.transform.iterator]: #range.transform.iterator
 [range.transform.overview]: #range.transform.overview
 [range.transform.sentinel]: #range.transform.sentinel
 [range.transform.view]: #range.transform.view

 ## Header `<ranges>` synopsis <a id="ranges.syn">[[ranges.syn]]</a>
 ``` cpp
+// mostly freestanding
 #include <compare>              // see [compare.syn]
 #include <initializer_list>     // see [initializer.list.syn]
 #include <iterator>             // see [iterator.synopsis]
 namespace std::ranges {
   inline namespace unspecified {
     // [range.access], range access
+    inline constexpr unspecified begin = unspecified;
+    inline constexpr unspecified end = unspecified;
+    inline constexpr unspecified cbegin = unspecified;
+    inline constexpr unspecified cend = unspecified;
+    inline constexpr unspecified rbegin = unspecified;
+    inline constexpr unspecified rend = unspecified;
+    inline constexpr unspecified crbegin = unspecified;
+    inline constexpr unspecified crend = unspecified;
+    inline constexpr unspecified size = unspecified;
+    inline constexpr unspecified reserve_hint = unspecified;
+    inline constexpr unspecified ssize = unspecified;
+    inline constexpr unspecified empty = unspecified;
+    inline constexpr unspecified data = unspecified;
+    inline constexpr unspecified cdata = unspecified;
   }
   // [range.range], ranges
   template<class T>
+    concept range = see below;
   template<class T>
+    constexpr bool enable_borrowed_range = false;
   template<class T>
+    concept borrowed_range = see below;
   template<class T>
+    using iterator_t = decltype(ranges::begin(declval<T&>()));
   template<range R>
+    using sentinel_t = decltype(ranges::end(declval<R&>()));
   template<range R>
+    using const_iterator_t = decltype(ranges::cbegin(declval<R&>()));
   template<range R>
+    using const_sentinel_t = decltype(ranges::cend(declval<R&>()));
   template<range R>
+    using range_difference_t = iter_difference_t<iterator_t<R>>;
   template<sized_range R>
+    using range_size_t = decltype(ranges::size(declval<R&>()));
   template<range R>
+    using range_value_t = iter_value_t<iterator_t<R>>;
   template<range R>
+    using range_reference_t = iter_reference_t<iterator_t<R>>;
   template<range R>
+    using range_const_reference_t = iter_const_reference_t<iterator_t<R>>;
   template<range R>
+    using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R>>;
   template<range R>
+    using range_common_reference_t = iter_common_reference_t<iterator_t<R>>;
   // [range.sized], sized ranges
   template<class>
+    constexpr bool disable_sized_range = false;
   template<class T>
+    concept approximately_sized_range = see below;
+  template<class T>
+    concept sized_range = see below;
   // [range.view], views
   template<class T>
+    constexpr bool enable_view = see below;
+  struct view_base {};
   template<class T>
+    concept view = see below;
   // [range.refinements], other range refinements
   template<class R, class T>
+    concept output_range = see below;
   template<class T>
+    concept input_range = see below;
   template<class T>
+    concept forward_range = see below;
   template<class T>
+    concept bidirectional_range = see below;
   template<class T>
+    concept random_access_range = see below;
   template<class T>
+    concept contiguous_range = see below;
   template<class T>
+    concept common_range = see below;
   template<class T>
+    concept viewable_range = see below;
   template<class T>
+    concept constant_range = see below;
+  template<class T>
+    concept sized-random-access-range = see belownc;              // exposition only
   // [view.interface], class template view_interface
   template<class D>
     requires is_class_v<D> && same_as<D, remove_cv_t<D>>
+  class view_interface;
   // [range.subrange], sub-ranges
+  enum class subrange_kind : bool { unsized, sized };
   template<input_or_output_iterator I, sentinel_for<I> S = I, subrange_kind K = see below>
     requires (K == subrange_kind::sized || !sized_sentinel_for<S, I>)
+  class subrange;
   template<class I, class S, subrange_kind K>
+    constexpr bool \libspec{enable_borrowed_range}{subrange}<subrange<I, S, K>> = true;
   template<size_t N, class I, class S, subrange_kind K>
     requires ((N == 0 && copyable<I>) || N == 1)
+    constexpr auto get(const subrange<I, S, K>& r);
   template<size_t N, class I, class S, subrange_kind K>
     requires (N < 2)
+    constexpr auto get(subrange<I, S, K>&& r);
 }
 namespace std {
+  using ranges::get;
 }
 namespace std::ranges {
   // [range.dangling], dangling iterator handling
+  struct dangling;
   // [range.elementsof], class template elements_of
   template<range R, class Allocator = allocator<byte>>
+    struct elements_of;                                                             // hosted
   template<range R>
+    using borrowed_iterator_t = see below;
   template<range R>
+    using borrowed_subrange_t = see below;
   // [range.utility.conv], range conversions
   template<class C, input_range R, class... Args> requires (!view<C>)
+    constexpr C to(R&& r, Args&&... args);
   template<template<class...> class C, input_range R, class... Args>
+    constexpr auto to(R&& r, Args&&... args);
   template<class C, class... Args> requires (!view<C>)
+    constexpr auto to(Args&&... args);
   template<template<class...> class C, class... Args>
+    constexpr auto to(Args&&... args);
   // [range.empty], empty view
   template<class T>
     requires is_object_v<T>
+  class empty_view;
   template<class T>
+    constexpr bool \libspec{enable_borrowed_range}{empty_view}<empty_view<T>> = true;
   namespace views {
     template<class T>
+      constexpr empty_view<T> empty{};
   }
   // [range.single], single view
   template<move_constructible T>
     requires is_object_v<T>
+  class single_view;
+  namespace views { inline constexpr unspecified single = unspecified; }
   template<bool Const, class T>
     using maybe-const = conditional_t<Const, const T, T>;   // exposition only
   // [range.iota], iota view
   template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>
     requires weakly-equality-comparable-with<W, Bound> && copyable<W>
+  class iota_view;
   template<class W, class Bound>
+    constexpr bool \libspec{enable_borrowed_range}{iota_view}<iota_view<W, Bound>> = true;
+  namespace views {
+    inline constexpr unspecified iota = unspecified;
+    inline constexpr unspecified indices = unspecified;
+  }
   // [range.repeat], repeat view
   template<move_constructible T, semiregular Bound = unreachable_sentinel_t>
     requires see below
+  class repeat_view;
+  namespace views { inline constexpr unspecified repeat = unspecified; }
   // [range.istream], istream view
   template<movable Val, class CharT, class Traits = char_traits<CharT>>
     requires see below
+  class basic_istream_view;                                                         // hosted
   template<class Val>
+    using istream_view = basic_istream_view<Val, char>;                             // hosted
   template<class Val>
+    using wistream_view = basic_istream_view<Val, wchar_t>;                         // hosted
+  namespace views {
+    template<class T> constexpr unspecified istream = unspecified;                  // hosted
+  }
   // [range.adaptor.object], range adaptor objects
   template<class D>
     requires is_class_v<D> && same_as<D, remove_cv_t<D>>
+  class range_adaptor_closure { };
   // [range.all], all view
   namespace views {
+    inline constexpr unspecified all = unspecified;
     template<viewable_range R>
+      using all_t = decltype(all(declval<R>()));
   }
   // [range.ref.view], ref view
   template<range R>
     requires is_object_v<R>
+  class ref_view;
   template<class T>
+    constexpr bool \libspec{enable_borrowed_range}{ref_view}<ref_view<T>> = true;
   // [range.owning.view], owning view
   template<range R>
     requires see below
+  class owning_view;
   template<class T>
+    constexpr bool \libspec{enable_borrowed_range}{owning_view}<owning_view<T>> =
       enable_borrowed_range<T>;
   // [range.as.rvalue], as rvalue view
   template<view V>
     requires input_range<V>
+  class as_rvalue_view;
   template<class T>
+    constexpr bool \libspec{enable_borrowed_range}{as_rvalue_view}<as_rvalue_view<T>> =
       enable_borrowed_range<T>;
+  namespace views { inline constexpr unspecified as_rvalue = unspecified; }
   // [range.filter], filter view
   template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred>
     requires view<V> && is_object_v<Pred>
+  class filter_view;
+  namespace views { inline constexpr unspecified filter = unspecified; }
   // [range.transform], transform view
   template<input_range V, move_constructible F>
     requires view<V> && is_object_v<F> &&
              regular_invocable<F&, range_reference_t<V>> &&
              can-reference<invoke_result_t<F&, range_reference_t<V>>>
+  class transform_view;
+  namespace views { inline constexpr unspecified transform = unspecified; }
   // [range.take], take view
+  template<view> class take_view;
   template<class T>
+    constexpr bool \libspec{enable_borrowed_range}{take_view}<take_view<T>> =
       enable_borrowed_range<T>;
+  namespace views { inline constexpr unspecified take = unspecified; }
   // [range.take.while], take while view
   template<view V, class Pred>
     requires input_range<V> && is_object_v<Pred> &&
              indirect_unary_predicate<const Pred, iterator_t<V>>
+    class take_while_view;
+  namespace views { inline constexpr unspecified take_while = unspecified; }
   // [range.drop], drop view
   template<view V>
+    class drop_view;
   template<class T>
+    constexpr bool \libspec{enable_borrowed_range}{drop_view}<drop_view<T>> =
       enable_borrowed_range<T>;
+  namespace views { inline constexpr unspecified drop = unspecified; }
   // [range.drop.while], drop while view
   template<view V, class Pred>
     requires input_range<V> && is_object_v<Pred> &&
              indirect_unary_predicate<const Pred, iterator_t<V>>
+    class drop_while_view;
   template<class T, class Pred>
+    constexpr bool \libspec{enable_borrowed_range}{drop_while_view}<drop_while_view<T, Pred>> =
       enable_borrowed_range<T>;
+  namespace views { inline constexpr unspecified drop_while = unspecified; }
   // [range.join], join view
   template<input_range V>
     requires view<V> && input_range<range_reference_t<V>>
+  class join_view;
+  namespace views { inline constexpr unspecified join = unspecified; }
   // [range.join.with], join with view
   template<input_range V, forward_range Pattern>
+    requires see below
+  class join_with_view;
+  namespace views { inline constexpr unspecified join_with = unspecified; }
   // [range.lazy.split], lazy split view
   template<class R>
     concept tiny-range = see below;   // exposition only
   template<input_range V, forward_range Pattern>
     requires view<V> && view<Pattern> &&
              indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&
              (forward_range<V> || tiny-range<Pattern>)
+  class lazy_split_view;
   // [range.split], split view
   template<forward_range V, forward_range Pattern>
     requires view<V> && view<Pattern> &&
              indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>
+  class split_view;
   namespace views {
+    inline constexpr unspecified lazy_split = unspecified;
+    inline constexpr unspecified split = unspecified;
   }
+  // [range.concat], concat view
+  template<input_range... Views>
+    requires see below
+  class concat_view;
+  namespace views { inline constexpr unspecified concat = unspecified; }
   // [range.counted], counted view
+  namespace views { inline constexpr unspecified counted = unspecified; }
   // [range.common], common view
   template<view V>
     requires (!common_range<V> && copyable<iterator_t<V>>)
+  class common_view;
   template<class T>
+    constexpr bool \libspec{enable_borrowed_range}{common_view}<common_view<T>> =
       enable_borrowed_range<T>;
+  namespace views { inline constexpr unspecified common = unspecified; }
   // [range.reverse], reverse view
   template<view V>
     requires bidirectional_range<V>
+  class reverse_view;
   template<class T>
+    constexpr bool \libspec{enable_borrowed_range}{reverse_view}<reverse_view<T>> =
       enable_borrowed_range<T>;
+  namespace views { inline constexpr unspecified reverse = unspecified; }
   // [range.as.const], as const view
   template<input_range R>
+    constexpr auto& possibly-const-range(R& r) noexcept { // exposition only
+      if constexpr (input_range<const R>) {
         return const_cast<const R&>(r);
       } else {
         return r;
       }
     }
   template<view V>
     requires input_range<V>
+  class as_const_view;
   template<class T>
+    constexpr bool \libspec{enable_borrowed_range}{as_const_view}<as_const_view<T>> =
       enable_borrowed_range<T>;
+  namespace views { inline constexpr unspecified as_const = unspecified; }
   // [range.elements], elements view
   template<input_range V, size_t N>
     requires see below
+  class elements_view;
   template<class T, size_t N>
+    constexpr bool \libspec{enable_borrowed_range}{elements_view}<elements_view<T, N>> =
       enable_borrowed_range<T>;
   template<class R>
+    using keys_view = elements_view<R, 0>;
   template<class R>
+    using values_view = elements_view<R, 1>;
   namespace views {
     template<size_t N>
+      constexpr unspecified elements = unspecified;
+    inline constexpr auto keys = elements<0>;
+    inline constexpr auto values = elements<1>;
   }
   // [range.enumerate], enumerate view
+  template<view V>
+    requires see below
+  class enumerate_view;
   template<class View>
+    constexpr bool \libspec{enable_borrowed_range}{enumerate_view}<enumerate_view<View>> =
       enable_borrowed_range<View>;
+  namespace views { inline constexpr unspecified enumerate = unspecified; }
   // [range.zip], zip view
   template<input_range... Views>
     requires (view<Views> && ...) && (sizeof...(Views) > 0)
+  class zip_view;
   template<class... Views>
+    constexpr bool \libspec{enable_borrowed_range}{zip_view}<zip_view<Views...>> =
       (enable_borrowed_range<Views> && ...);
+  namespace views { inline constexpr unspecified zip = unspecified; }
   // [range.zip.transform], zip transform view
   template<move_constructible F, input_range... Views>
     requires (view<Views> && ...) && (sizeof...(Views) > 0) && is_object_v<F> &&
              regular_invocable<F&, range_reference_t<Views>...> &&
              can-reference<invoke_result_t<F&, range_reference_t<Views>...>>
+  class zip_transform_view;
+  namespace views { inline constexpr unspecified zip_transform = unspecified; }
   // [range.adjacent], adjacent view
   template<forward_range V, size_t N>
     requires view<V> && (N > 0)
+  class adjacent_view;
   template<class V, size_t N>
+    constexpr bool \libspec{enable_borrowed_range}{adjacent_view}<adjacent_view<V, N>> =
       enable_borrowed_range<V>;
   namespace views {
     template<size_t N>
+      constexpr unspecified adjacent = unspecified;
+    inline constexpr auto pairwise = adjacent<2>;
   }
   // [range.adjacent.transform], adjacent transform view
   template<forward_range V, move_constructible F, size_t N>
     requires see below
+  class adjacent_transform_view;
   namespace views {
     template<size_t N>
+      constexpr unspecified adjacent_transform = unspecified;
+    inline constexpr auto pairwise_transform = adjacent_transform<2>;
   }
   // [range.chunk], chunk view
   template<view V>
     requires input_range<V>
+  class chunk_view;
   template<view V>
     requires forward_range<V>
+  class chunk_view<V>;
   template<class V>
+    constexpr bool \libspec{enable_borrowed_range}{chunk_view}<chunk_view<V>> =
       forward_range<V> && enable_borrowed_range<V>;
+  namespace views { inline constexpr unspecified chunk = unspecified; }
   // [range.slide], slide view
   template<forward_range V>
     requires view<V>
+  class slide_view;
   template<class V>
+    constexpr bool \libspec{enable_borrowed_range}{slide_view}<slide_view<V>> =
+      enable_borrowed_range<V>;
+  namespace views { inline constexpr unspecified slide = unspecified; }
   // [range.chunk.by], chunk by view
   template<forward_range V, indirect_binary_predicate<iterator_t<V>, iterator_t<V>> Pred>
     requires view<V> && is_object_v<Pred>
+  class chunk_by_view;
+  namespace views { inline constexpr unspecified chunk_by = unspecified; }
   // [range.stride], stride view
   template<input_range V>
     requires view<V>
+  class stride_view;
   template<class V>
+    constexpr bool \libspec{enable_borrowed_range}{stride_view}<stride_view<V>> =
       enable_borrowed_range<V>;
+  namespace views { inline constexpr unspecified stride = unspecified; }
   // [range.cartesian], cartesian product view
   template<input_range First, forward_range... Vs>
     requires (view<First> && ... && view<Vs>)
+  class cartesian_product_view;
+  namespace views { inline constexpr unspecified cartesian_product = unspecified; }
+  // [range.cache.latest], cache latest view
+  template<input_range V>
+    requires view<V>
+  class cache_latest_view;
+  namespace views { inline constexpr unspecified cache_latest = unspecified; }
+  // [range.to.input], to input view
+  template<input_range V>
+    requires view<V>
+  class to_input_view;
+  template<class V>
+    constexpr bool enable_borrowed_range<to_input_view<V>> =
+      enable_borrowed_range<V>;
+  namespace views { inline constexpr unspecified to_input = unspecified; }
 }
 namespace std {
+  namespace views = ranges::views;
+  template<class T> struct tuple_size;
+  template<size_t I, class T> struct tuple_element;
   template<class I, class S, ranges::subrange_kind K>
+  struct tuple_size<ranges::subrange<I, S, K>>
     : integral_constant<size_t, 2> {};
   template<class I, class S, ranges::subrange_kind K>
+  struct tuple_element<0, ranges::subrange<I, S, K>> {
+    using type = I;
   };
   template<class I, class S, ranges::subrange_kind K>
+  struct tuple_element<1, ranges::subrange<I, S, K>> {
+    using type = S;
   };
   template<class I, class S, ranges::subrange_kind K>
+  struct tuple_element<0, const ranges::subrange<I, S, K>> {
+    using type = I;
   };
   template<class I, class S, ranges::subrange_kind K>
+  struct tuple_element<1, const ranges::subrange<I, S, K>> {
+    using type = S;
   };
+  struct from_range_t { explicit from_range_t() = default; };
+  inline constexpr from_range_t from_range{};
 }
 ```
 Within this Clause, for an integer-like type `X`
 [[iterator.concept.winc]], `make-unsigned-like-t<X>` denotes
 ### General <a id="range.access.general">[[range.access.general]]</a>
 In addition to being available via inclusion of the `<ranges>` header,
 the customization point objects in [[range.access]] are available when
+the header `<iterator>` is included.
 Within [[range.access]], the *reified object* of a subexpression `E`
 denotes
 - the same object as `E` if `E` is a glvalue, or
 `ranges::ssize(E)` is ill-formed. Otherwise let `D` be
 `make-signed-like-t<decltype(ranges::{}size(t))>`, or `ptrdiff_t` if it
 is wider than that type; `ranges::ssize(E)` is expression-equivalent to
 `static_cast<D>(ranges::size(t))`.
+### `ranges::reserve_hint` <a id="range.prim.size.hint">[[range.prim.size.hint]]</a>
+The name `ranges::reserve_hint` denotes a customization point object
+[[customization.point.object]].
+Given a subexpression `E` with type `T`, let `t` be an lvalue that
+denotes the reified object for `E`. Then:
+- If `ranges::size(E)` is a valid expression, `ranges::reserve_hint(E)`
+  is expression-equivalent to `ranges::size(E)`.
+- Otherwise, if `auto(t.reserve_hint())` is a valid expression of
+  integer-like type [[iterator.concept.winc]], `ranges::reserve_hint(E)`
+  is expression-equivalent to `auto(t.reserve_hint())`.
+- Otherwise, if `T` is a class or enumeration type and
+  `auto(reserve_hint(t))` is a valid expression of integer-like type
+  where the meaning of `reserve_hint` is established as-if by performing
+  argument-dependent lookup only [[basic.lookup.argdep]], then
+  `ranges::reserve_hint(E)` is expression-equivalent to that expression.
+- Otherwise, `ranges::reserve_hint(E)` is ill-formed.
+[*Note 1*: Diagnosable ill-formed cases above result in substitution
+failure when `ranges::reserve_hint(E)` appears in the immediate context
+of a template instantiation. — *end note*]
+[*Note 2*: Whenever `ranges::reserve_hint(E)` is a valid expression,
+its type is integer-like. — *end note*]
 ### `ranges::empty` <a id="range.prim.empty">[[range.prim.empty]]</a>
 The name `ranges::empty` denotes a customization point object
 [[customization.point.object]].
 ### `ranges::cdata` <a id="range.prim.cdata">[[range.prim.cdata]]</a>
 ``` cpp
 template<class T>
+constexpr auto as-const-pointer(const T* p) noexcept { return p; } // exposition only
 ```
 The name `ranges::cdata` denotes a customization point object
 [[customization.point.object]]. Given a subexpression `E` with type `T`,
 let `t` be an lvalue that denotes the reified object for `E`. Then:
       ranges::begin(t);         // sometimes equality-preserving (see below)
       ranges::end(t);
     };
 ```
 Given an expression `t` such that `decltype((t))` is `T&`, `T` models
 `range` only if
 - \[`ranges::begin(t)`, `ranges::end(t)`) denotes a
   range [[iterator.requirements.general]],
 - `S`’s iterators do not have validity tied to the lifetime of an `S`
   object because they are “borrowed” from some other range.
 — *end example*]
+### Approximately sized ranges <a id="range.approximately.sized">[[range.approximately.sized]]</a>
+The `approximately_sized_range` concept refines `range` with the
+requirement that an approximation of the number of elements in the range
+can be determined in amortized constant time using
+`ranges::reserve_hint`.
+``` cpp
+template<class T>
+  concept approximately_sized_range =
+    range<T> && requires(T& t) { ranges::reserve_hint(t); };
+```
+Given an lvalue `t` of type `remove_reference_t<T>`, `T` models
+`approximately_sized_range` only if
+- `ranges::reserve_hint(t)` is amortized 𝑂(1), does not modify `t`, and
+  has a value that is not negative and is representable in
+  `range_difference_t<T>`, and
+- if `iterator_t<T>` models `forward_iterator`,
+  `ranges::reserve_hint(t)` is well-defined regardless of the evaluation
+  of `ranges::begin(t)`. \[*Note 1*: `ranges::reserve_hint(t)` is
+  otherwise not required to be well-defined after evaluating
+  `ranges::begin(t)`. For example, it is possible for
+  `ranges::reserve_hint(t)` to be well-defined for an whose iterator
+  type does not model `forward_iterator` only if evaluated before the
+  first call to `ranges::begin(t)`. — *end note*]
 ### Sized ranges <a id="range.sized">[[range.sized]]</a>
+The `sized_range` concept refines `approximately_sized_range` with the
+requirement that the number of elements in the range can be determined
+in amortized constant time using `ranges::size`.
 ``` cpp
 template<class T>
   concept sized_range =
+ approximately_sized_range<T> && requires(T& t) { ranges::size(t); };
 ```
 Given an lvalue `t` of type `remove_reference_t<T>`, `T` models
 `sized_range` only if
 *Remarks:* Pursuant to [[namespace.std]], users may specialize
 `disable_sized_range` for cv-unqualified program-defined types. Such
 specializations shall be usable in constant expressions [[expr.const]]
 and have type `const bool`.
+[*Note 1*: `disable_sized_range` allows use of `range` types with the
 library that satisfy but do not in fact model
 `sized_range`. — *end note*]
 ### Views <a id="range.view">[[range.view]]</a>
 template<class T>
   concept view =
     range<T> && movable<T> && enable_view<T>;
 ```
+`T` models `view` only if
 - `T` has 𝑂(1) move construction; and
 - move assignment of an object of type `T` is no more complex than
   destruction followed by move construction; and
 - if N copies and/or moves are made from an object of type `T` that
 only if `T` has exactly one public base class `view_interface<U>` for
 some type `U` and `T` has no base classes of type `view_interface<V>`
 for any other type `V`.
 *Remarks:* Pursuant to [[namespace.std]], users may specialize
+`enable_view` to `true` for cv-unqualified program-defined types that
+model `view`, and `false` for types that do not. Such specializations
 shall be usable in constant expressions [[expr.const]] and have type
 `const bool`.
 ### Other range refinements <a id="range.refinements">[[range.refinements]]</a>
 template<class T>
   concept constant_range =
     input_range<T> && constant-iterator<iterator_t<T>>;
 ```
+The exposition-only concept `sized-random-access-range` specifies the
+requirements of a `range` type that is sized and allows random access to
+its elements.
+``` cpp
+template<class T>
+  concept sized-random-access-range =           // exposition only
+    random_access_range<T> && sized_range<T>;
+```
+[*Note 1*: This concept constrains some parallel algorithm overloads;
+see [[algorithms]]. — *end note*]
 ## Range utilities <a id="range.utility">[[range.utility]]</a>
 ### General <a id="range.utility.general">[[range.utility.general]]</a>
 The components in [[range.utility]] are general utilities for
 representing and manipulating ranges.
 ### Helper concepts <a id="range.utility.helpers">[[range.utility.helpers]]</a>
+Many of the types in [[range.utility]] are specified in terms of the
+following exposition-only concepts:
 ``` cpp
 template<class R>
   concept simple-view =                                     // exposition only
     view<R> && range<const R> &&
     same_as<iterator_t<R>, iterator_t<const R>> &&
     same_as<sentinel_t<R>, sentinel_t<const R>>;
 template<class I>
   concept has-arrow =                                       // exposition only
+    input_iterator<I> && (is_pointer_v<I> || requires(const I i) { i.operator->(); });
 template<class T, class U>
   concept different-from =                                  // exposition only
     !same_as<remove_cvref_t<T>, remove_cvref_t<U>>;
 ``` cpp
 constexpr decltype(auto) front() requires forward_range<D>;
 constexpr decltype(auto) front() const requires forward_range<const D>;
 ```
+`!empty()` is `true`.
 *Effects:* Equivalent to: `return *ranges::begin(`*`derived`*`());`
 ``` cpp
 constexpr decltype(auto) back() requires bidirectional_range<D> && common_range<D>;
 constexpr decltype(auto) back() const
   requires bidirectional_range<const D> && common_range<const D>;
 ```
+`!empty()` is `true`.
 *Effects:* Equivalent to:
 `return *ranges::prev(ranges::end(`*`derived`*`()));`
 ### Sub-ranges <a id="range.subrange">[[range.subrange]]</a>
     template<different-from<subrange> PairLike>
       requires pair-like-convertible-from<PairLike, const I&, const S&>
     constexpr operator PairLike() const;
     constexpr I begin() const requires copyable<I>;
+    constexpr I begin() requires (!copyable<I>);
     constexpr S end() const;
     constexpr bool empty() const;
     constexpr make-unsigned-like-t<iter_difference_t<I>> size() const
       requires (K == subrange_kind::sized);
+    constexpr subrange next(iter_difference_t<I> n = 1) const &
       requires forward_iterator<I>;
+    constexpr subrange next(iter_difference_t<I> n = 1) &&;
+    constexpr subrange prev(iter_difference_t<I> n = 1) const
       requires bidirectional_iterator<I>;
     constexpr subrange& advance(iter_difference_t<I> n);
   };
   template<input_or_output_iterator I, sentinel_for<I> S>
 ```
 *Effects:* Equivalent to: `return `*`begin_`*`;`
 ``` cpp
+constexpr I begin() requires (!copyable<I>);
 ```
 *Effects:* Equivalent to: `return std::move(`*`begin_`*`);`
 ``` cpp
 - If *StoreSize* is `true`, equivalent to: `return `*`size_`*`;`
 - Otherwise, equivalent to:
   `return `*`to-unsigned-like`*`(`*`end_`*` - `*`begin_`*`);`
 ``` cpp
+constexpr subrange next(iter_difference_t<I> n = 1) const &
   requires forward_iterator<I>;
 ```
 *Effects:* Equivalent to:
 tmp.advance(n);
 return tmp;
 ```
 ``` cpp
+constexpr subrange next(iter_difference_t<I> n = 1) &&;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 advance(n);
 return std::move(*this);
 ```
 ``` cpp
+constexpr subrange prev(iter_difference_t<I> n = 1) const
   requires bidirectional_iterator<I>;
 ```
 *Effects:* Equivalent to:
     { c.capacity() } -> same_as<decltype(n)>;
     { c.max_size() } -> same_as<decltype(n)>;
   };
 ```
+Let *`container-appendable`* be defined as follows:
 ``` cpp
 template<class Container, class Ref>
+constexpr bool container-appendable =          // exposition only
   requires(Container& c, Ref&& ref) {
+    requires (requires { c.emplace_back(std::forward<Ref>(ref)); } ||
+              requires { c.push_back(std::forward<Ref>(ref)); } ||
+              requires { c.emplace(c.end(), std::forward<Ref>(ref)); } ||
               requires { c.insert(c.end(), std::forward<Ref>(ref)); });
   };
 ```
+Let *`container-append`* be defined as follows:
 ``` cpp
+template<class Container>
+constexpr auto container-append(Container& c) { // exposition only
+ return [&c]<class Ref>(Ref&& ref) {
+ if constexpr (requires { c.emplace_back(declval<Ref>()); })
+      c.emplace_back(std::forward<Ref>(ref));
+    else if constexpr (requires { c.push_back(declval<Ref>()); })
+      c.push_back(std::forward<Ref>(ref));
+    else if constexpr (requires { c.emplace(c.end(), declval<Ref>()); })
+      c.emplace(c.end(), std::forward<Ref>(ref));
     else
+      c.insert(c.end(), std::forward<Ref>(ref));
+  };
 }
 ```
 #### `ranges::to` <a id="range.utility.conv.to">[[range.utility.conv.to]]</a>
     ``` cpp
     C(ranges::begin(r), ranges::end(r), std::forward<Args>(args)...)
     ```
   - Otherwise, if
     - `constructible_from<C, Args...>` is `true`, and
+    - *`container-appendable`*`<C, range_reference_t<R>>` is `true`:
     ``` cpp
     C c(std::forward<Args>(args)...);
+    if constexpr (approximately_sized_range<R> && reservable-container<C>)
+      c.reserve(static_cast<range_size_t<C>>(ranges::reserve_hint(r)));
+    ranges::for_each(r, container-append(c));
     ```
+  - Otherwise, the program is ill-formed.
 - Otherwise, if `input_range<range_reference_t<R>>` is `true`:
   ``` cpp
+  to<C>(ref_view(r) | views::transform([](auto&& elem) {
     return to<range_value_t<C>>(std::forward<decltype(elem)>(elem));
   }), std::forward<Args>(args)...);
   ```
 - Otherwise, the program is ill-formed.
     constexpr T* begin() noexcept;
     constexpr const T* begin() const noexcept;
     constexpr T* end() noexcept;
     constexpr const T* end() const noexcept;
+    static constexpr bool empty() noexcept;
     static constexpr size_t size() noexcept;
     constexpr T* data() noexcept;
     constexpr const T* data() const noexcept;
   };
 constexpr const T* end() const noexcept;
 ```
 *Effects:* Equivalent to: `return data() + 1;`
+``` cpp
+static constexpr bool empty() noexcept;
+```
+*Effects:* Equivalent to: `return false;`
 ``` cpp
 static constexpr size_t size() noexcept;
 ```
 *Effects:* Equivalent to: `return 1;`
 an initial value.
 The name `views::iota` denotes a customization point object
 [[customization.point.object]]. Given subexpressions `E` and `F`, the
 expressions `views::iota(E)` and `views::iota(E, F)` are
+expression-equivalent to `iota_view<decay_t<decltype((E))>>(E)` and
+`iota_view(E, F)`, respectively.
 [*Example 1*:
 ``` cpp
 for (int i : views::iota(1, 10))
   cout << i << ' '; // prints 1 2 3 4 5 6 7 8 9
 ```
 — *end example*]
+The name `views::indices` denotes a customization point object
+[[customization.point.object]]. Given subexpression `E`, let `T` be
+`remove_cvref_t<decltype((E))>`. `views::indices(E)` is
+expression-equivalent to `views::iota(T(0), E)` if `is-integer-like<T>`
+is `true`, and ill-formed otherwise.
 #### Class template `iota_view` <a id="range.iota.view">[[range.iota.view]]</a>
 ``` cpp
 namespace std::ranges {
   template<class I>
     constexpr iterator begin() const;
     constexpr auto end() const;
     constexpr iterator end() const requires same_as<W, Bound>;
+    constexpr bool empty() const;
     constexpr auto size() const requires see below;
   };
   template<class W, class Bound>
     requires (!is-integer-like<W> || !is-integer-like<Bound> ||
 constexpr iterator end() const requires same_as<W, Bound>;
 ```
 *Effects:* Equivalent to: `return `*`iterator`*`{`*`bound_`*`};`
+``` cpp
+constexpr bool empty() const;
+```
+*Effects:* Equivalent to: `return `*`value_`*` == `*`bound_`*`;`
 ``` cpp
 constexpr auto size() const requires see below;
 ```
 *Effects:* Equivalent to:
 the same value.
 The name `views::repeat` denotes a customization point object
 [[customization.point.object]]. Given subexpressions `E` and `F`, the
 expressions `views::repeat(E)` and `views::repeat(E, F)` are
+expression-equivalent to `repeat_view<decay_t<decltype((E))>>(E)` and
+`repeat_view(E, F)`, respectively.
 [*Example 1*:
 ``` cpp
 for (int i : views::repeat(17, 4))
     constexpr unreachable_sentinel_t end() const noexcept;
     constexpr auto size() const requires (!same_as<Bound, unreachable_sentinel_t>);
   };
+  template<class T, class Bound = unreachable_sentinel_t>
+    repeat_view(T, Bound = Bound()) -> repeat_view<T, Bound>;
 }
 ```
 ``` cpp
 constexpr explicit repeat_view(const T& value, Bound bound = Bound())
 - 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_`*`);`
 ## Range generators <a id="coro.generator">[[coro.generator]]</a>
 ### Overview <a id="coroutine.generator.overview">[[coroutine.generator.overview]]</a>
 Class template `generator` presents a view of the elements yielded by
 ### Header `<generator>` synopsis <a id="generator.syn">[[generator.syn]]</a>
 ``` cpp
 namespace std {
   // [coro.generator.class], class template generator
+  template<class Ref, class Val = void, class Allocator = void>
     class generator;
   namespace pmr {
+    template<class Ref, class Val = void>
+      using generator = std::generator<Ref, Val, polymorphic_allocator<>>;
   }
 }
 ```
 ### Class template `generator` <a id="coro.generator.class">[[coro.generator.class]]</a>
 ``` cpp
 namespace std {
+  template<class Ref, class Val = void, class Allocator = void>
+  class generator : public ranges::view_interface<generator<Ref, Val, Allocator>> {
   private:
+    using value = conditional_t<is_void_v<Val>, remove_cvref_t<Ref>, Val>;  // exposition only
+    using reference = conditional_t<is_void_v<Val>, Ref&&, Ref>;          // exposition only
     // [coro.generator.iterator], class generator::iterator
     class iterator;                                                     // exposition only
   public:
 generator(generator&& other) noexcept;
 ```
 *Effects:* Initializes *coroutine\_* with
 `exchange(other.`*`coroutine_`*`, {})` and *active\_* with
+`exchange(other.`*`active_`*`, nullptr)`.
 [*Note 1*: Iterators previously obtained from `other` are not
 invalidated; they become iterators into `*this`. — *end note*]
 ``` cpp
 ### Class `generator::promise_type` <a id="coro.generator.promise">[[coro.generator.promise]]</a>
 ``` cpp
 namespace std {
+  template<class Ref, class Val, class Allocator>
+  class generator<Ref, Val, Allocator>::promise_type {
   public:
     generator get_return_object() noexcept;
     suspend_always initial_suspend() const noexcept { return {}; }
     auto final_suspend() noexcept;
         constructible_from<remove_cvref_t<yielded>, const remove_reference_t<yielded>&>;
     template<class R2, class V2, class Alloc2, class Unused>
       requires same_as<typename generator<R2, V2, Alloc2>::yielded, yielded>
         auto yield_value(ranges::elements_of<generator<R2, V2, Alloc2>&&, Unused> g) noexcept;
+    template<class R2, class V2, class Alloc2, class Unused>
+      requires same_as<typename generator<R2, V2, Alloc2>::yielded, yielded>
+        auto yield_value(ranges::elements_of<generator<R2, V2, Alloc2>&, Unused> g) noexcept;
     template<ranges::input_range R, class Alloc>
       requires convertible_to<ranges::range_reference_t<R>, yielded>
+        auto yield_value(ranges::elements_of<R, Alloc> r);
     void await_transform() = delete;
     void return_void() const noexcept {}
     void unhandled_exception();
     void* operator new(size_t size)
       requires same_as<Allocator, void> || default_initializable<Allocator>;
     template<class Alloc, class... Args>
       void* operator new(size_t size, allocator_arg_t, const Alloc& alloc, const Args&...);
     template<class This, class Alloc, class... Args>
       void* operator new(size_t size, const This&, allocator_arg_t, const Alloc& alloc,
                          const Args&...);
     void operator delete(void* pointer, size_t size) noexcept;
 ``` cpp
 template<class R2, class V2, class Alloc2, class Unused>
   requires same_as<typename generator<R2, V2, Alloc2>::yielded, yielded>
   auto yield_value(ranges::elements_of<generator<R2, V2, Alloc2>&&, Unused> g) noexcept;
+template<class R2, class V2, class Alloc2, class Unused>
+  requires same_as<typename generator<R2, V2, Alloc2>::yielded, yielded>
+  auto yield_value(ranges::elements_of<generator<R2, V2, Alloc2>&, Unused> g) noexcept;
 ```
 *Preconditions:* A handle referring to the coroutine whose promise
 object is `*this` is at the top of `*`*`active_`* of some `generator`
 object `x`. The coroutine referred to by `g.range.`*`coroutine_`* is
 execution of the coroutine referred to by `g.range.`*`coroutine_`*, and
 whose member `await_resume` evaluates `rethrow_exception(`*`except_`*`)`
 if `bool(`*`except_`*`)` is `true`. If `bool(`*`except_`*`)` is `false`,
 the `await_resume` member has no effects.
+*Remarks:* A *yield-expression* that calls one of these functions has
+type `void` [[expr.yield]].
 ``` cpp
 template<ranges::input_range R, class Alloc>
   requires convertible_to<ranges::range_reference_t<R>, yielded>
+  auto yield_value(ranges::elements_of<R, Alloc> r);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 auto nested = [](allocator_arg_t, Alloc, ranges::iterator_t<R> i, ranges::sentinel_t<R> s)
+  -> generator<yielded, void, Alloc> {
     for (; i != s; ++i) {
       co_yield static_cast<yielded>(*i);
     }
   };
 return yield_value(ranges::elements_of(nested(
 ``` cpp
 void* operator new(size_t size)
   requires same_as<Allocator, void> || default_initializable<Allocator>;
 template<class Alloc, class... Args>
   void* operator new(size_t size, allocator_arg_t, const Alloc& alloc, const Args&...);
 template<class This, class Alloc, class... Args>
   void* operator new(size_t size, const This&, allocator_arg_t, const Alloc& alloc,
                      const Args&...);
 ```
 Let `A` be
 Let `B` be `allocator_traits<A>::template rebind_alloc<U>` where `U` is
 an unspecified type whose size and alignment are both
 \_\_STDCPP_DEFAULT_NEW_ALIGNMENT\_\_.
+*Mandates:* `allocator_traits<B>::pointer` is a pointer type. For the
+overloads with a template parameter `Alloc`,
+`same_as<Allocator, void> || convertible_to<const Alloc&, Allocator>` is
+modeled.
 *Effects:* Initializes an allocator `b` of type `B` with `A(alloc)`, for
 the overloads with a function parameter `alloc`, and with `A()`
 otherwise. Uses `b` to allocate storage for the smallest array of `U`
 sufficient to provide storage for a coroutine state of size `size`, and
 ### Class `generator::iterator` <a id="coro.generator.iterator">[[coro.generator.iterator]]</a>
 ``` cpp
 namespace std {
+  template<class Ref, class Val, class Allocator>
+  class generator<Ref, Val, Allocator>::iterator {
   public:
     using value_type = value;
     using difference_type = ptrdiff_t;
     iterator(iterator&& other) noexcept;
 ```
 *Effects:* Equivalent to: `return i.`*`coroutine_`*`.done();`
 <!-- Link reference definitions -->
+[algorithms]: algorithms.md#algorithms
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [concepts.equality]: concepts.md#concepts.equality
 [containers]: containers.md#containers
 [conv.rval]: expr.md#conv.rval
 [coro.generator]: #coro.generator
 [dcl.init.general]: dcl.md#dcl.init.general
 [expr.await]: expr.md#expr.await
 [expr.const]: expr.md#expr.const
 [expr.yield]: expr.md#expr.yield
 [generator.syn]: #generator.syn
+[intro.races]: basic.md#intro.races
 [iterator.concept.bidir]: iterators.md#iterator.concept.bidir
 [iterator.concept.forward]: iterators.md#iterator.concept.forward
 [iterator.concept.iterator]: iterators.md#iterator.concept.iterator
 [iterator.concept.output]: iterators.md#iterator.concept.output
 [iterator.concept.random.access]: iterators.md#iterator.concept.random.access
 [range.adjacent.transform.sentinel]: #range.adjacent.transform.sentinel
 [range.adjacent.transform.view]: #range.adjacent.transform.view
 [range.adjacent.view]: #range.adjacent.view
 [range.all]: #range.all
 [range.all.general]: #range.all.general
+[range.approximately.sized]: #range.approximately.sized
 [range.as.const]: #range.as.const
 [range.as.const.overview]: #range.as.const.overview
 [range.as.const.view]: #range.as.const.view
 [range.as.rvalue]: #range.as.rvalue
 [range.as.rvalue.overview]: #range.as.rvalue.overview
 [range.as.rvalue.view]: #range.as.rvalue.view
+[range.cache.latest]: #range.cache.latest
+[range.cache.latest.iterator]: #range.cache.latest.iterator
+[range.cache.latest.overview]: #range.cache.latest.overview
+[range.cache.latest.sentinel]: #range.cache.latest.sentinel
+[range.cache.latest.view]: #range.cache.latest.view
 [range.cartesian]: #range.cartesian
 [range.cartesian.iterator]: #range.cartesian.iterator
 [range.cartesian.overview]: #range.cartesian.overview
 [range.cartesian.view]: #range.cartesian.view
 [range.chunk]: #range.chunk
 [range.chunk.view.fwd]: #range.chunk.view.fwd
 [range.chunk.view.input]: #range.chunk.view.input
 [range.common]: #range.common
 [range.common.overview]: #range.common.overview
 [range.common.view]: #range.common.view
+[range.concat]: #range.concat
+[range.concat.iterator]: #range.concat.iterator
+[range.concat.overview]: #range.concat.overview
+[range.concat.view]: #range.concat.view
 [range.counted]: #range.counted
 [range.dangling]: #range.dangling
 [range.drop]: #range.drop
 [range.drop.overview]: #range.drop.overview
 [range.drop.view]: #range.drop.view
 [range.owning.view]: #range.owning.view
 [range.prim.cdata]: #range.prim.cdata
 [range.prim.data]: #range.prim.data
 [range.prim.empty]: #range.prim.empty
 [range.prim.size]: #range.prim.size
+[range.prim.size.hint]: #range.prim.size.hint
 [range.prim.ssize]: #range.prim.ssize
 [range.range]: #range.range
 [range.ref.view]: #range.ref.view
 [range.refinements]: #range.refinements
 [range.repeat]: #range.repeat
 [range.take.view]: #range.take.view
 [range.take.while]: #range.take.while
 [range.take.while.overview]: #range.take.while.overview
 [range.take.while.sentinel]: #range.take.while.sentinel
 [range.take.while.view]: #range.take.while.view
+[range.to.input]: #range.to.input
+[range.to.input.iterator]: #range.to.input.iterator
+[range.to.input.overview]: #range.to.input.overview
+[range.to.input.view]: #range.to.input.view
 [range.transform]: #range.transform
 [range.transform.iterator]: #range.transform.iterator
 [range.transform.overview]: #range.transform.overview
 [range.transform.sentinel]: #range.transform.sentinel
 [range.transform.view]: #range.transform.view

Diff to HTML by rtfpessoa