[range.utility] - C++20 → C++23

Files changed (1) hide show

tmp/tmpq1l01rne/{from.md → to.md} +296 -82

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

@@ -1,9 +1,11 @@
 ## Range utilities <a id="range.utility">[[range.utility]]</a>
-The components in this subclause 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:
@@ -18,40 +20,67 @@ template<class 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 not-same-as = // exposition only
     !same_as<remove_cvref_t<T>, remove_cvref_t<U>>;
 ```
 ### View interface <a id="view.interface">[[view.interface]]</a>
-The class template `view_interface` is a helper for defining `view`-like
 types that offer a container-like interface. It is parameterized with
 the type that is derived from it.
 ``` cpp
 namespace std::ranges {
   template<class D>
     requires is_class_v<D> && same_as<D, remove_cv_t<D>>
-  class view_interface : public view_base {
   private:
     constexpr D& derived() noexcept {               // exposition only
       return static_cast<D&>(*this);
     }
     constexpr const D& derived() const noexcept {   // exposition only
       return static_cast<const D&>(*this);
     }
   public:
-    constexpr bool empty() requires forward_range<D> {
         return ranges::begin(derived()) == ranges::end(derived());
     }
-    constexpr bool empty() const requires forward_range<const D> {
         return ranges::begin(derived()) == ranges::end(derived());
     }
     constexpr explicit operator bool()
       requires requires { ranges::empty(derived()); } {
         return !ranges::empty(derived());
       }
     constexpr explicit operator bool() const
@@ -67,15 +96,15 @@ namespace std::ranges {
         return to_address(ranges::begin(derived()));
       }
     constexpr auto size() requires forward_range<D> &&
       sized_sentinel_for<sentinel_t<D>, iterator_t<D>> {
-        return ranges::end(derived()) - ranges::begin(derived());
       }
     constexpr auto size() const requires forward_range<const D> &&
       sized_sentinel_for<sentinel_t<const D>, iterator_t<const D>> {
-        return ranges::end(derived()) - ranges::begin(derived());
       }
     constexpr decltype(auto) front() requires forward_range<D>;
     constexpr decltype(auto) front() const requires forward_range<const D>;
@@ -106,99 +135,87 @@ 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()`.
 *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()`.
 *Effects:* Equivalent to:
 `return *ranges::prev(ranges::end(`*`derived`*`()));`
 ### Sub-ranges <a id="range.subrange">[[range.subrange]]</a>
 The `subrange` class template combines together an iterator and a
 sentinel into a single object that models the `view` concept.
 Additionally, it models the `sized_range` concept when the final
 template parameter is `subrange_kind::sized`.
 ``` cpp
 namespace std::ranges {
   template<class From, class To>
     concept convertible-to-non-slicing =                    // exposition only
       convertible_to<From, To> &&
-      !(is_pointer_v<decay_t<From>> &&
-        is_pointer_v<decay_t<To>> &&
-        not-same-as<remove_pointer_t<decay_t<From>>, remove_pointer_t<decay_t<To>>>);
-  template<class T>
-    concept pair-like =                                     // exposition only
-      !is_reference_v<T> && requires(T t) {
-        typename tuple_size<T>::type;                       // ensures tuple_size<T> is complete
-        requires derived_from<tuple_size<T>, integral_constant<size_t, 2>>;
-        typename tuple_element_t<0, remove_const_t<T>>;
-        typename tuple_element_t<1, remove_const_t<T>>;
-        { get<0>(t) } -> convertible_to<const tuple_element_t<0, T>&>;
-        { get<1>(t) } -> convertible_to<const tuple_element_t<1, T>&>;
-      };
   template<class T, class U, class V>
     concept pair-like-convertible-from =                    // exposition only
-      !range<T> && pair-like<T> &&
       constructible_from<T, U, V> &&
       convertible-to-non-slicing<U, tuple_element_t<0, T>> &&
       convertible_to<V, tuple_element_t<1, T>>;
-  template<class T>
-    concept iterator-sentinel-pair =                        // exposition only
-      !range<T> && pair-like<T> &&
-      sentinel_for<tuple_element_t<1, T>, tuple_element_t<0, T>>;
   template<input_or_output_iterator I, sentinel_for<I> S = I, subrange_kind K =
       sized_sentinel_for<S, I> ? subrange_kind::sized : subrange_kind::unsized>
     requires (K == subrange_kind::sized || !sized_sentinel_for<S, I>)
   class subrange : public view_interface<subrange<I, S, K>> {
   private:
     static constexpr bool StoreSize =                       // exposition only
       K == subrange_kind::sized && !sized_sentinel_for<S, I>;
     I begin_ = I();                                         // exposition only
     S end_ = S();                                           // exposition only
     make-unsigned-like-t<iter_difference_t<I>> size_ = 0;   // exposition only; present only
- // when StoreSize is true
   public:
-    subrange() = default;
     constexpr subrange(convertible-to-non-slicing<I> auto i, S s) requires (!StoreSize);
     constexpr subrange(convertible-to-non-slicing<I> auto i, S s,
                        make-unsigned-like-t<iter_difference_t<I>> n)
       requires (K == subrange_kind::sized);
-    template<not-same-as<subrange> R>
       requires borrowed_range<R> &&
                convertible-to-non-slicing<iterator_t<R>, I> &&
                convertible_to<sentinel_t<R>, S>
     constexpr subrange(R&& r) requires (!StoreSize || sized_range<R>);
     template<borrowed_range R>
       requires convertible-to-non-slicing<iterator_t<R>, I> &&
                convertible_to<sentinel_t<R>, S>
     constexpr subrange(R&& r, make-unsigned-like-t<iter_difference_t<I>> n)
       requires (K == subrange_kind::sized)
-        : subrange{ranges::begin(r), ranges::end(r), n}
-    {}
-    template<not-same-as<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>);
@@ -221,38 +238,19 @@ namespace std::ranges {
   template<input_or_output_iterator I, sentinel_for<I> S>
     subrange(I, S, make-unsigned-like-t<iter_difference_t<I>>) ->
       subrange<I, S, subrange_kind::sized>;
-  template<iterator-sentinel-pair P>
-    subrange(P) -> subrange<tuple_element_t<0, P>, tuple_element_t<1, P>>;
-  template<iterator-sentinel-pair P>
-    subrange(P, make-unsigned-like-t<iter_difference_t<tuple_element_t<0, P>>>) ->
-      subrange<tuple_element_t<0, P>, tuple_element_t<1, P>, subrange_kind::sized>;
   template<borrowed_range R>
     subrange(R&&) ->
       subrange<iterator_t<R>, sentinel_t<R>,
                (sized_range<R> || sized_sentinel_for<sentinel_t<R>, iterator_t<R>>)
                  ? subrange_kind::sized : subrange_kind::unsized>;
   template<borrowed_range R>
     subrange(R&&, make-unsigned-like-t<range_difference_t<R>>) ->
       subrange<iterator_t<R>, sentinel_t<R>, subrange_kind::sized>;
-  template<size_t N, class I, class S, subrange_kind K>
-    requires (N < 2)
-    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;
 }
 ```
 #### Constructors and conversions <a id="range.subrange.ctor">[[range.subrange.ctor]]</a>
@@ -270,35 +268,36 @@ constexpr subrange(convertible-to-non-slicing<I> auto i, S s,
                    make-unsigned-like-t<iter_difference_t<I>> n)
   requires (K == subrange_kind::sized);
 ```
 *Preconditions:* \[`i`, `s`) is a valid range, and
-`n == `*`to-unsigned-like`*`(ranges::distance(i, s))`.
 *Effects:* Initializes *begin\_* with `std::move(i)` and *end\_* with
 `s`. If *StoreSize* is `true`, initializes *size\_* with `n`.
 [*Note 1*: Accepting the length of the range and storing it to later
 return from `size()` enables `subrange` to model `sized_range` even when
 it stores an iterator and sentinel that do not model
 `sized_sentinel_for`. — *end note*]
 ``` cpp
-template<not-same-as<subrange> R>
   requires borrowed_range<R> &&
            convertible-to-non-slicing<iterator_t<R>, I> &&
            convertible_to<sentinel_t<R>, S>
 constexpr subrange(R&& r) requires (!StoreSize || sized_range<R>);
 ```
 *Effects:* Equivalent to:
-- If *StoreSize* is `true`, `subrange{r, ranges::size(r)}`.
-- Otherwise, `subrange{ranges::begin(r), ranges::end(r)}`.
 ``` cpp
-template<not-same-as<subrange> PairLike>
   requires pair-like-convertible-from<PairLike, const I&, const S&>
 constexpr operator PairLike() const;
 ```
 *Effects:* Equivalent to: `return PairLike(`*`begin_`*`, `*`end_`*`);`
@@ -381,28 +380,29 @@ return tmp;
 constexpr subrange& advance(iter_difference_t<I> n);
 ```
 *Effects:* Equivalent to:
-- If *StoreSize* is `true`,
 ``` cpp
 auto d = n - ranges::advance(begin_, n, end_);
- if (d >= 0)
   size_ -= to-unsigned-like(d);
-  else
-    size_ += to-unsigned-like(-d);
-  return *this;
-  ```
-- Otherwise,
-  ``` cpp
-  ranges::advance(begin_, n, end_);
 return *this;
 ```
 ``` cpp
 template<size_t N, class I, class S, subrange_kind K>
-  requires (N < 2)
   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);
 ```
@@ -416,24 +416,23 @@ else
   return r.end();
 ```
 ### Dangling iterator handling <a id="range.dangling">[[range.dangling]]</a>
-The tag type `dangling` is used together with the template aliases
-`borrowed_iterator_t` and `borrowed_subrange_t` to indicate that an
-algorithm that typically returns an iterator into or subrange of a
-`range` argument does not return an iterator or subrange which could
-potentially reference a range whose lifetime has ended for a particular
-rvalue `range` argument which does not model `borrowed_range`
-[[range.range]].
 ``` cpp
 namespace std::ranges {
   struct dangling {
     constexpr dangling() noexcept = default;
- template<class... Args>
-      constexpr dangling(Args&&...) noexcept { }
   };
 }
 ```
 [*Example 1*:
@@ -443,17 +442,232 @@ vector<int> f();
 auto result1 = ranges::find(f(), 42);                                   // #1
 static_assert(same_as<decltype(result1), ranges::dangling>);
 auto vec = f();
 auto result2 = ranges::find(vec, 42);                                   // #2
 static_assert(same_as<decltype(result2), vector<int>::iterator>);
-auto result3 = ranges::find(subrange{vec}, 42); // #3
 static_assert(same_as<decltype(result3), vector<int>::iterator>);
 ```
 The call to `ranges::find` at \#1 returns `ranges::dangling` since `f()`
-is an rvalue `vector`; the `vector` could potentially be destroyed
 before a returned iterator is dereferenced. However, the calls at \#2
 and \#3 both return iterators since the lvalue `vec` and specializations
 of `subrange` model `borrowed_range`.
 — *end example*]

 ## 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:
 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>>;
+template<class R>
+  concept range-with-movable-references =                   // exposition only
+    input_range<R> && move_constructible<range_reference_t<R>> &&
+    move_constructible<range_rvalue_reference_t<R>>;
 ```
 ### View interface <a id="view.interface">[[view.interface]]</a>
+#### General <a id="view.interface.general">[[view.interface.general]]</a>
+The class template `view_interface` is a helper for defining view-like
 types that offer a container-like interface. It is parameterized with
 the type that is derived from it.
 ``` cpp
 namespace std::ranges {
   template<class D>
     requires is_class_v<D> && same_as<D, remove_cv_t<D>>
+  class view_interface {
   private:
     constexpr D& derived() noexcept {               // exposition only
       return static_cast<D&>(*this);
     }
     constexpr const D& derived() const noexcept {   // exposition only
       return static_cast<const D&>(*this);
     }
   public:
+    constexpr bool empty() requires sized_range<D> || forward_range<D> {
+      if constexpr (sized_range<D>)
+        return ranges::size(derived()) == 0;
+      else
         return ranges::begin(derived()) == ranges::end(derived());
     }
+    constexpr bool empty() const requires sized_range<const D> || forward_range<const D> {
+      if constexpr (sized_range<const D>)
+        return ranges::size(derived()) == 0;
+      else
         return ranges::begin(derived()) == ranges::end(derived());
     }
+    constexpr auto cbegin() requires input_range<D> {
+      return ranges::cbegin(derived());
+    }
+    constexpr auto cbegin() const requires input_range<const D> {
+      return ranges::cbegin(derived());
+    }
+    constexpr auto cend() requires input_range<D> {
+      return ranges::cend(derived());
+    }
+    constexpr auto cend() const requires input_range<const D> {
+      return ranges::cend(derived());
+    }
     constexpr explicit operator bool()
       requires requires { ranges::empty(derived()); } {
         return !ranges::empty(derived());
       }
     constexpr explicit operator bool() const
         return to_address(ranges::begin(derived()));
       }
     constexpr auto size() requires forward_range<D> &&
       sized_sentinel_for<sentinel_t<D>, iterator_t<D>> {
+        return to-unsigned-like(ranges::end(derived()) - ranges::begin(derived()));
       }
     constexpr auto size() const requires forward_range<const D> &&
       sized_sentinel_for<sentinel_t<const D>, iterator_t<const D>> {
+        return to-unsigned-like(ranges::end(derived()) - ranges::begin(derived()));
       }
     constexpr decltype(auto) front() requires forward_range<D>;
     constexpr decltype(auto) front() const requires forward_range<const D>;
 ``` 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>
+#### General <a id="range.subrange.general">[[range.subrange.general]]</a>
 The `subrange` class template combines together an iterator and a
 sentinel into a single object that models the `view` concept.
 Additionally, it models the `sized_range` concept when the final
 template parameter is `subrange_kind::sized`.
 ``` cpp
 namespace std::ranges {
+  template<class From, class To>
+    concept uses-nonqualification-pointer-conversion =      // exposition only
+      is_pointer_v<From> && is_pointer_v<To> &&
+      !convertible_to<remove_pointer_t<From>(*)[], remove_pointer_t<To>(*)[]>;
   template<class From, class To>
     concept convertible-to-non-slicing =                    // exposition only
       convertible_to<From, To> &&
+      !uses-nonqualification-pointer-conversion<decay_t<From>, decay_t<To>>;
   template<class T, class U, class V>
     concept pair-like-convertible-from =                    // exposition only
+      !range<T> && !is_reference_v<T> && pair-like<T> &&
       constructible_from<T, U, V> &&
       convertible-to-non-slicing<U, tuple_element_t<0, T>> &&
       convertible_to<V, tuple_element_t<1, T>>;
   template<input_or_output_iterator I, sentinel_for<I> S = I, subrange_kind K =
       sized_sentinel_for<S, I> ? subrange_kind::sized : subrange_kind::unsized>
     requires (K == subrange_kind::sized || !sized_sentinel_for<S, I>)
   class subrange : public view_interface<subrange<I, S, K>> {
   private:
     static constexpr bool StoreSize =                       // exposition only
       K == subrange_kind::sized && !sized_sentinel_for<S, I>;
     I begin_ = I();                                         // exposition only
     S end_ = S();                                           // exposition only
     make-unsigned-like-t<iter_difference_t<I>> size_ = 0;   // exposition only; present only
+ // if StoreSize is true
   public:
+    subrange() requires default_initializable<I> = default;
     constexpr subrange(convertible-to-non-slicing<I> auto i, S s) requires (!StoreSize);
     constexpr subrange(convertible-to-non-slicing<I> auto i, S s,
                        make-unsigned-like-t<iter_difference_t<I>> n)
       requires (K == subrange_kind::sized);
+    template<different-from<subrange> R>
       requires borrowed_range<R> &&
                convertible-to-non-slicing<iterator_t<R>, I> &&
                convertible_to<sentinel_t<R>, S>
     constexpr subrange(R&& r) requires (!StoreSize || sized_range<R>);
     template<borrowed_range R>
       requires convertible-to-non-slicing<iterator_t<R>, I> &&
                convertible_to<sentinel_t<R>, S>
     constexpr subrange(R&& r, make-unsigned-like-t<iter_difference_t<I>> n)
       requires (K == subrange_kind::sized)
+        : subrange{ranges::begin(r), ranges::end(r), n} {}
+    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>);
   template<input_or_output_iterator I, sentinel_for<I> S>
     subrange(I, S, make-unsigned-like-t<iter_difference_t<I>>) ->
       subrange<I, S, subrange_kind::sized>;
   template<borrowed_range R>
     subrange(R&&) ->
       subrange<iterator_t<R>, sentinel_t<R>,
                (sized_range<R> || sized_sentinel_for<sentinel_t<R>, iterator_t<R>>)
                  ? subrange_kind::sized : subrange_kind::unsized>;
   template<borrowed_range R>
     subrange(R&&, make-unsigned-like-t<range_difference_t<R>>) ->
       subrange<iterator_t<R>, sentinel_t<R>, subrange_kind::sized>;
 }
 ```
 #### Constructors and conversions <a id="range.subrange.ctor">[[range.subrange.ctor]]</a>
                    make-unsigned-like-t<iter_difference_t<I>> n)
   requires (K == subrange_kind::sized);
 ```
 *Preconditions:* \[`i`, `s`) is a valid range, and
+`n == `*`to-unsigned-like`*`(ranges::distance(i, s))` is `true`.
 *Effects:* Initializes *begin\_* with `std::move(i)` and *end\_* with
 `s`. If *StoreSize* is `true`, initializes *size\_* with `n`.
 [*Note 1*: Accepting the length of the range and storing it to later
 return from `size()` enables `subrange` to model `sized_range` even when
 it stores an iterator and sentinel that do not model
 `sized_sentinel_for`. — *end note*]
 ``` cpp
+template<different-from<subrange> R>
   requires borrowed_range<R> &&
            convertible-to-non-slicing<iterator_t<R>, I> &&
            convertible_to<sentinel_t<R>, S>
 constexpr subrange(R&& r) requires (!StoreSize || sized_range<R>);
 ```
 *Effects:* Equivalent to:
+- If *StoreSize* is `true`,
+ `subrange(r, static_cast<decltype(`*`size_`*`)>(ranges::size(r)))`.
+- Otherwise, `subrange(ranges::begin(r), ranges::end(r))`.
 ``` cpp
+template<different-from<subrange> PairLike>
   requires pair-like-convertible-from<PairLike, const I&, const S&>
 constexpr operator PairLike() const;
 ```
 *Effects:* Equivalent to: `return PairLike(`*`begin_`*`, `*`end_`*`);`
 constexpr subrange& advance(iter_difference_t<I> n);
 ```
 *Effects:* Equivalent to:
 ``` cpp
+if constexpr (bidirectional_iterator<I>) {
+  if (n < 0) {
+    ranges::advance(begin_, n);
+    if constexpr (StoreSize)
+      size_ += to-unsigned-like(-n);
+    return *this;
+  }
+}
 auto d = n - ranges::advance(begin_, n, end_);
+if constexpr (StoreSize)
   size_ -= to-unsigned-like(d);
 return *this;
 ```
 ``` cpp
 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);
 ```
   return r.end();
 ```
 ### Dangling iterator handling <a id="range.dangling">[[range.dangling]]</a>
+The type `dangling` is used together with the template aliases
+`borrowed_iterator_t` and `borrowed_subrange_t`. When an algorithm that
+typically returns an iterator into, or a subrange of, a range argument
+is called with an rvalue range argument that does not model
+`borrowed_range` [[range.range]], the return value possibly refers to a
+range whose lifetime has ended. In such cases, the type `dangling` is
+returned instead of an iterator or subrange.
 ``` cpp
 namespace std::ranges {
   struct dangling {
     constexpr dangling() noexcept = default;
+ constexpr dangling(auto&&...) noexcept {}
   };
 }
 ```
 [*Example 1*:
 auto result1 = ranges::find(f(), 42);                                   // #1
 static_assert(same_as<decltype(result1), ranges::dangling>);
 auto vec = f();
 auto result2 = ranges::find(vec, 42);                                   // #2
 static_assert(same_as<decltype(result2), vector<int>::iterator>);
+auto result3 = ranges::find(ranges::subrange{vec}, 42); // #3
 static_assert(same_as<decltype(result3), vector<int>::iterator>);
 ```
 The call to `ranges::find` at \#1 returns `ranges::dangling` since `f()`
+is an rvalue `vector`; it is possible for the `vector` to be destroyed
 before a returned iterator is dereferenced. However, the calls at \#2
 and \#3 both return iterators since the lvalue `vec` and specializations
 of `subrange` model `borrowed_range`.
 — *end example*]
+For a type `R` that models `range`:
+- if `R` models `borrowed_range`, then `borrowed_iterator_t<R>` denotes
+  `iterator_t<R>`, and `borrowed_subrange_t<R>` denotes
+  `subrange<iterator_t<R>>`;
+- otherwise, both `borrowed_iterator_t<R>` and `borrowed_subrange_t<R>`
+  denote `dangling`.
+### Class template `elements_of` <a id="range.elementsof">[[range.elementsof]]</a>
+Specializations of `elements_of` encapsulate a range and act as a tag in
+overload sets to disambiguate when a range should be treated as a
+sequence rather than a single value.
+[*Example 1*:
+``` cpp
+template<bool YieldElements>
+generator<any> f(ranges::input_range auto&& r) {
+  if constexpr (YieldElements)
+    co_yield ranges::elements_of(r);        // yield each element of r
+  else
+    co_yield r;                             // yield r as a single value
+}
+```
+— *end example*]
+``` cpp
+namespace std::ranges {
+  template<range R, class Allocator = allocator<byte>>
+  struct elements_of {
+    [[no_unique_address]] R range;
+    [[no_unique_address]] Allocator allocator = Allocator();
+  };
+  template<class R, class Allocator = allocator<byte>>
+    elements_of(R&&, Allocator = Allocator()) -> elements_of<R&&, Allocator>;
+}
+```
+### Range conversions <a id="range.utility.conv">[[range.utility.conv]]</a>
+#### General <a id="range.utility.conv.general">[[range.utility.conv.general]]</a>
+The range conversion functions construct an object (usually a container)
+from a range, by using a constructor taking a range, a `from_range_t`
+tagged constructor, or a constructor taking a pair of iterators, or by
+inserting each element of the range into the default-constructed object.
+`ranges::to` is applied recursively, allowing the conversion of a range
+of ranges.
+[*Example 1*:
+``` cpp
+string_view str = "the quick brown fox";
+auto words = views::split(str, ' ') | to<vector<string>>();
+// words is vector<string>{"the", "quick", "brown", "fox"}
+```
+— *end example*]
+Let *`reservable-container`* be defined as follows:
+``` cpp
+template<class Container>
+constexpr bool reservable-container =          // exposition only
+  sized_range<Container> &&
+  requires(Container& c, range_size_t<Container> n) {
+    c.reserve(n);
+    { 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>
+``` cpp
+template<class C, input_range R, class... Args> requires (!view<C>)
+  constexpr C to(R&& r, Args&&... args);
+```
+*Mandates:* `C` is a cv-unqualified class type.
+*Returns:* An object of type `C` constructed from the elements of `r` in
+the following manner:
+- If `C` does not satisfy `input_range` or
+  `convertible_to<range_reference_t<R>, range_value_t<C>>` is `true`:
+  - If `constructible_from<C, R, Args...>` is `true`:
+    ``` cpp
+    C(std::forward<R>(r), std::forward<Args>(args)...)
+    ```
+  - Otherwise, if `constructible_from<C, from_range_t, R, Args...>` is
+    `true`:
+    ``` cpp
+    C(from_range, std::forward<R>(r), std::forward<Args>(args)...)
+    ```
+  - Otherwise, if
+    - `common_range<R>` is `true`,
+    - the *qualified-id*
+      `iterator_traits<iterator_t<R>>::iterator_category` is valid and
+      denotes a type that models `derived_from<input_iterator_tag>`, and
+    - `constructible_from<C, iterator_t<R>, sentinel_t<R>, Args...>` is
+      `true`:
+    ``` 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.
+``` cpp
+template<template<class...> class C, input_range R, class... Args>
+  constexpr auto to(R&& r, Args&&... args);
+```
+Let *input-iterator* be an exposition-only type:
+``` cpp
+struct input-iterator {                        // exposition only
+  using iterator_category = input_iterator_tag;
+  using value_type = range_value_t<R>;
+  using difference_type = ptrdiff_t;
+  using pointer = add_pointer_t<range_reference_t<R>>;
+  using reference = range_reference_t<R>;
+  reference operator*() const;
+  pointer operator->() const;
+  input-iterator& operator++();
+  input-iterator operator++(int);
+  bool operator==(const input-iterator&) const;
+};
+```
+[*Note 1*: *input-iterator* meets the syntactic requirements of
+*Cpp17InputIterator*. — *end note*]
+Let *`DEDUCE_EXPR`* be defined as follows:
+- `C(declval<R>(), declval<Args>()...)` if that is a valid expression,
+- otherwise, `C(from_range, declval<R>(), declval<Args>()...)` if that
+  is a valid expression,
+- otherwise,
+  ``` cpp
+  C(declval<input-iterator>(), declval<input-iterator>(), declval<Args>()...)
+  ```
+  if that is a valid expression,
+- otherwise, the program is ill-formed.
+*Returns:*
+`to<decltype(`*`DEDUCE_EXPR`*`)>(std::forward<R>(r), std::forward<Args>(args)...)`.
+#### `ranges::to` adaptors <a id="range.utility.conv.adaptors">[[range.utility.conv.adaptors]]</a>
+``` cpp
+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);
+```
+*Mandates:* For the first overload, `C` is a cv-unqualified class type.
+*Returns:* A range adaptor closure object [[range.adaptor.object]] `f`
+that is a perfect forwarding call
+wrapper [[term.perfect.forwarding.call.wrapper]] with the following
+properties:
+- It has no target object.
+- Its bound argument entities `bound_args` consist of objects of types
+  `decay_t<Args>...` direct-non-list-initialized with
+  `std::forward<Args>(args)...`, respectively.
+- Its call pattern is `to<C>(r, bound_args...)`, where `r` is the
+  argument used in a function call expression of `f`.

Diff to HTML by rtfpessoa