[range.adaptors] - C++17 → C++20

Files changed (1) hide show

tmp/tmp4d3n8rwt/{from.md → to.md} +3135 -0

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

	@@ -0,0 +1,3135 @@

+## Range adaptors <a id="range.adaptors">[[range.adaptors]]</a>
+This subclause defines *range adaptors*, which are utilities that
+transform a `range` into a `view` with custom behaviors. These adaptors
+can be chained to create pipelines of range transformations that
+evaluate lazily as the resulting view is iterated.
+Range adaptors are declared in namespace `std::ranges::views`.
+The bitwise operator is overloaded for the purpose of creating adaptor
+chain pipelines. The adaptors also support function call syntax with
+equivalent semantics.
+[*Example 1*:
+``` cpp
+vector<int> ints{0,1,2,3,4,5};
+auto even = [](int i){ return 0 == i % 2; };
+auto square = [](int i) { return i * i; };
+for (int i : ints | views::filter(even) | views::transform(square)) {
+  cout << i << ' '; // prints: 0 4 16
+}
+assert(ranges::equal(ints | views::filter(even), views::filter(ints, even)));
+```
+— *end example*]
+### Range adaptor objects <a id="range.adaptor.object">[[range.adaptor.object]]</a>
+A *range adaptor closure object* is a unary function object that accepts
+a `viewable_range` argument and returns a `view`. For a range adaptor
+closure object `C` and an expression `R` such that `decltype((R))`
+models `viewable_range`, the following expressions are equivalent and
+yield a `view`:
+``` cpp
+C(R)
+R | C
+```
+Given an additional range adaptor closure object `D`, the expression
+`C | D` is well-formed and produces another range adaptor closure object
+such that the following two expressions are equivalent:
+``` cpp
+R | C | D
+R | (C | D)
+```
+A *range adaptor object* is a customization point object
+[[customization.point.object]] that accepts a `viewable_range` as its
+first argument and returns a `view`.
+If a range adaptor object accepts only one argument, then it is a range
+adaptor closure object.
+If a range adaptor object accepts more than one argument, then the
+following expressions are equivalent:
+``` cpp
+adaptor(range, args...)
+adaptor(args...)(range)
+range | adaptor(args...)
+```
+In this case, `adaptor(args...)` is a range adaptor closure object.
+### Semiregular wrapper <a id="range.semi.wrap">[[range.semi.wrap]]</a>
+Many types in this subclause are specified in terms of an
+exposition-only class template *`semiregular-box`*. `semiregular-box<T>`
+behaves exactly like `optional<T>` with the following differences:
+- `semiregular-box<T>` constrains its type parameter `T` with
+  `copy_constructible<T> && is_object_v<T>`.
+- If `T` models `default_initializable`, the default constructor of
+  `semiregular-box<T>` is equivalent to:
+  ``` cpp
+  constexpr semiregular-box() noexcept(is_nothrow_default_constructible_v<T>)
+    : semiregular-box{in_place}
+  { }
+  ```
+- If `assignable_from<T&, const T&>` is not modeled, the copy assignment
+  operator is equivalent to:
+  ``` cpp
+  semiregular-box& operator=(const semiregular-box& that)
+    noexcept(is_nothrow_copy_constructible_v<T>)
+  {
+    if (that) emplace(*that);
+    else reset();
+    return *this;
+  }
+  ```
+- If `assignable_from<T&, T>` is not modeled, the move assignment
+  operator is equivalent to:
+  ``` cpp
+  semiregular-box& operator=(semiregular-box&& that)
+    noexcept(is_nothrow_move_constructible_v<T>)
+  {
+    if (that) emplace(std::move(*that));
+    else reset();
+    return *this;
+  }
+  ```
+### All view <a id="range.all">[[range.all]]</a>
+`views::all` returns a `view` that includes all elements of its `range`
+argument.
+The name `views::all` denotes a range adaptor object
+[[range.adaptor.object]]. Given a subexpression `E`, the expression
+`views::all(E)` is expression-equivalent to:
+- `decay-copy(E)` if the decayed type of `E` models `view`.
+- Otherwise, `ref_view{E}` if that expression is well-formed.
+- Otherwise, `subrange{E}`.
+#### Class template `ref_view` <a id="range.ref.view">[[range.ref.view]]</a>
+`ref_view` is a `view` of the elements of some other `range`.
+``` cpp
+namespace std::ranges {
+  template<range R>
+    requires is_object_v<R>
+  class ref_view : public view_interface<ref_view<R>> {
+  private:
+    R* r_ = nullptr;            // exposition only
+  public:
+    constexpr ref_view() noexcept = default;
+    template<not-same-as<ref_view> T>
+      requires see below
+    constexpr ref_view(T&& t);
+    constexpr R& base() const { return *r_; }
+    constexpr iterator_t<R> begin() const { return ranges::begin(*r_); }
+    constexpr sentinel_t<R> end() const { return ranges::end(*r_); }
+    constexpr bool empty() const
+      requires requires { ranges::empty(*r_); }
+    { 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>
+    ref_view(R&) -> ref_view<R>;
+}
+```
+``` cpp
+template<not-same-as<ref_view> T>
+  requires see below
+constexpr ref_view(T&& t);
+```
+*Remarks:* Let *`FUN`* denote the exposition-only functions
+``` cpp
+void FUN(R&);
+void FUN(R&&) = delete;
+```
+The expression in the *requires-clause* is equivalent to
+``` cpp
+convertible_to<T, R&> && requires { FUN(declval<T>()); }
+```
+*Effects:* Initializes *r\_* with
+`addressof(static_cast<R&>(std::forward<T>(t)))`.
+### Filter view <a id="range.filter">[[range.filter]]</a>
+#### Overview <a id="range.filter.overview">[[range.filter.overview]]</a>
+`filter_view` presents a `view` of the elements of an underlying
+sequence that satisfy a predicate.
+The name `views::filter` denotes a range adaptor object
+[[range.adaptor.object]]. Given subexpressions `E` and `P`, the
+expression `views::filter(E, P)` is expression-equivalent to
+`filter_view{E, P}`.
+[*Example 1*:
+``` cpp
+vector<int> is{ 0, 1, 2, 3, 4, 5, 6 };
+filter_view evens{is, [](int i) { return 0 == i % 2; }};
+for (int i : evens)
+  cout << i << ' '; // prints: 0 2 4 6
+```
+— *end example*]
+#### Class template `filter_view` <a id="range.filter.view">[[range.filter.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred>
+    requires view<V> && is_object_v<Pred>
+  class filter_view : public view_interface<filter_view<V, Pred>> {
+  private:
+    V base_ = V();                      // exposition only
+    semiregular-box<Pred> pred_;  // exposition only
+    // [range.filter.iterator], class filter_view::iterator
+    class iterator;                     // exposition only
+    // [range.filter.sentinel], class filter_view::sentinel
+    class sentinel;                     // exposition only
+  public:
+    filter_view() = default;
+    constexpr filter_view(V base, Pred pred);
+    constexpr V base() const& requires copy_constructible<V> { return base_; }
+    constexpr V base() && { return std::move(base_); }
+    constexpr const Pred& pred() const;
+    constexpr iterator begin();
+    constexpr auto end() {
+      if constexpr (common_range<V>)
+        return iterator{*this, ranges::end(base_)};
+      else
+        return sentinel{*this};
+    }
+  };
+  template<class R, class Pred>
+    filter_view(R&&, Pred) -> filter_view<views::all_t<R>, Pred>;
+}
+```
+``` cpp
+constexpr filter_view(V base, Pred pred);
+```
+*Effects:* Initializes *base\_* with `std::move(base)` and initializes
+*pred\_* with `std::move(pred)`.
+``` cpp
+constexpr const Pred& pred() const;
+```
+*Effects:* Equivalent to: `return *`*`pred_`*`;`
+``` cpp
+constexpr iterator begin();
+```
+*Preconditions:* `pred_.has_value()`.
+*Returns:* `{*this, ranges::find_if(`*`base_`*`, ref(*`*`pred_`*`))}`.
+*Remarks:* In order to provide the amortized constant time complexity
+required by the `range` concept when `filter_view` models
+`forward_range`, this function caches the result within the
+`filter_view` for use on subsequent calls.
+#### Class `filter_view::iterator` <a id="range.filter.iterator">[[range.filter.iterator]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred>
+    requires view<V> && is_object_v<Pred>
+  class filter_view<V, Pred>::iterator {
+  private:
+    iterator_t<V> current_ = iterator_t<V>();   // exposition only
+    filter_view* parent_ = nullptr;             // exposition only
+  public:
+    using iterator_concept  = see below;
+    using iterator_category = see below;
+    using value_type        = range_value_t<V>;
+    using difference_type   = range_difference_t<V>;
+    iterator() = default;
+    constexpr iterator(filter_view& parent, iterator_t<V> current);
+    constexpr iterator_t<V> base() const &
+      requires copyable<iterator_t<V>>;
+    constexpr iterator_t<V> base() &&;
+    constexpr range_reference_t<V> operator*() const;
+    constexpr iterator_t<V> operator->() const
+      requires has-arrow<iterator_t<V>> && copyable<iterator_t<V>>;
+    constexpr iterator& operator++();
+    constexpr void operator++(int);
+    constexpr iterator operator++(int) requires forward_range<V>;
+    constexpr iterator& operator--() requires bidirectional_range<V>;
+    constexpr iterator operator--(int) requires bidirectional_range<V>;
+    friend constexpr bool operator==(const iterator& x, const iterator& y)
+      requires equality_comparable<iterator_t<V>>;
+    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>>;
+  };
+}
+```
+Modification of the element a `filter_view::iterator` denotes is
+permitted, but results in undefined behavior if the resulting value does
+not satisfy the filter predicate.
+`iterator::iterator_concept` is defined as follows:
+- If `V` models `bidirectional_range`, then `iterator_concept` denotes
+  `bidirectional_iterator_tag`.
+- Otherwise, if `V` models `forward_range`, then `iterator_concept`
+  denotes `forward_iterator_tag`.
+- Otherwise, `iterator_concept` denotes `input_iterator_tag`.
+`iterator::iterator_category` is defined as follows:
+- Let `C` denote the type
+  `iterator_traits<iterator_t<V>>::iterator_category`.
+- If `C` models `derived_from<bidirectional_iterator_tag>`, then
+  `iterator_category` denotes `bidirectional_iterator_tag`.
+- Otherwise, if `C` models `derived_from<forward_iterator_tag>`, then
+  `iterator_category` denotes `forward_iterator_tag`.
+- Otherwise, `iterator_category` denotes `C`.
+``` cpp
+constexpr iterator(filter_view& parent, iterator_t<V> current);
+```
+*Effects:* Initializes *current\_* with `std::move(current)` and
+*parent\_* with `addressof(parent)`.
+``` cpp
+constexpr iterator_t<V> base() const &
+  requires copyable<iterator_t<V>>;
+```
+*Effects:* Equivalent to: `return `*`current_`*`;`
+``` cpp
+constexpr iterator_t<V> base() &&;
+```
+*Effects:* Equivalent to: `return std::move(current_);`
+``` cpp
+constexpr range_reference_t<V> operator*() const;
+```
+*Effects:* Equivalent to: `return *`*`current_`*`;`
+``` cpp
+constexpr iterator_t<V> operator->() const
+  requires has-arrow<iterator_t<V>> && copyable<iterator_t<V>>;
+```
+*Effects:* Equivalent to: `return `*`current_`*`;`
+``` cpp
+constexpr iterator& operator++();
+```
+*Effects:* Equivalent to:
+``` cpp
+current_ = ranges::find_if(std::move(++current_), ranges::end(parent_->base_),
+                           ref(*parent_->pred_));
+return *this;
+```
+``` cpp
+constexpr void operator++(int);
+```
+*Effects:* Equivalent to `++*this`.
+``` cpp
+constexpr iterator operator++(int) requires forward_range<V>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+++*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator--() requires bidirectional_range<V>;
+```
+*Effects:* Equivalent to:
+``` cpp
+do
+  --current_;
+while (!invoke(*parent_->pred_, *current_));
+return *this;
+```
+``` cpp
+constexpr iterator operator--(int) requires bidirectional_range<V>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+--*this;
+return tmp;
+```
+``` cpp
+friend constexpr bool operator==(const iterator& x, const iterator& y)
+  requires equality_comparable<iterator_t<V>>;
+```
+*Effects:* Equivalent to: `return x.`*`current_`*` == y.`*`current_`*`;`
+``` 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 `filter_view::sentinel` <a id="range.filter.sentinel">[[range.filter.sentinel]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred>
+    requires view<V> && is_object_v<Pred>
+  class filter_view<V, Pred>::sentinel {
+  private:
+    sentinel_t<V> end_ = sentinel_t<V>();       // exposition only
+  public:
+    sentinel() = default;
+    constexpr explicit sentinel(filter_view& parent);
+    constexpr sentinel_t<V> base() const;
+    friend constexpr bool operator==(const iterator& x, const sentinel& y);
+  };
+}
+```
+``` cpp
+constexpr explicit sentinel(filter_view& parent);
+```
+*Effects:* Initializes *end\_* with `ranges::end(parent.`*`base_`*`)`.
+``` cpp
+constexpr sentinel_t<V> base() const;
+```
+*Effects:* Equivalent to: `return `*`end_`*`;`
+``` cpp
+friend constexpr bool operator==(const iterator& x, const sentinel& y);
+```
+*Effects:* Equivalent to: `return x.`*`current_`*` == y.`*`end_`*`;`
+### Transform view <a id="range.transform">[[range.transform]]</a>
+#### Overview <a id="range.transform.overview">[[range.transform.overview]]</a>
+`transform_view` presents a `view` of an underlying sequence after
+applying a transformation function to each element.
+The name `views::transform` denotes a range adaptor object
+[[range.adaptor.object]]. Given subexpressions `E` and `F`, the
+expression `views::transform(E, F)` is expression-equivalent to
+`transform_view{E, F}`.
+[*Example 1*:
+``` cpp
+vector<int> is{ 0, 1, 2, 3, 4 };
+transform_view squares{is, [](int i) { return i * i; }};
+for (int i : squares)
+  cout << i << ' '; // prints: 0 1 4 9 16
+```
+— *end example*]
+#### Class template `transform_view` <a id="range.transform.view">[[range.transform.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V, copy_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 : public view_interface<transform_view<V, F>> {
+  private:
+    // [range.transform.iterator], class template transform_view::iterator
+    template<bool> struct iterator;             // exposition only
+    // [range.transform.sentinel], class template transform_view::sentinel
+    template<bool> struct sentinel;             // exposition only
+    V base_ = V();                              // exposition only
+    semiregular-box<F> fun_;                    // exposition only
+  public:
+    transform_view() = default;
+    constexpr transform_view(V base, F fun);
+    constexpr V base() const& requires copy_constructible<V> { return base_; }
+    constexpr V base() && { return std::move(base_); }
+    constexpr iterator<false> begin();
+    constexpr iterator<true> begin() const
+      requires range<const V> &&
+               regular_invocable<const F&, range_reference_t<const V>>;
+    constexpr sentinel<false> end();
+    constexpr iterator<false> end() requires common_range<V>;
+    constexpr sentinel<true> end() const
+      requires range<const V> &&
+               regular_invocable<const F&, range_reference_t<const V>>;
+    constexpr iterator<true> end() const
+      requires common_range<const V> &&
+               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>;
+}
+```
+``` cpp
+constexpr transform_view(V base, F fun);
+```
+*Effects:* Initializes *base\_* with `std::move(base)` and *fun\_* with
+`std::move(fun)`.
+``` cpp
+constexpr iterator<false> begin();
+```
+*Effects:* Equivalent to:
+``` cpp
+return iterator<false>{*this, ranges::begin(base_)};
+```
+``` cpp
+constexpr iterator<true> begin() const
+  requires range<const V> &&
+           regular_invocable<const F&, range_reference_t<const V>>;
+```
+*Effects:* Equivalent to:
+``` cpp
+return iterator<true>{*this, ranges::begin(base_)};
+```
+``` cpp
+constexpr sentinel<false> end();
+```
+*Effects:* Equivalent to:
+``` cpp
+return sentinel<false>{ranges::end(base_)};
+```
+``` cpp
+constexpr iterator<false> end() requires common_range<V>;
+```
+*Effects:* Equivalent to:
+``` cpp
+return iterator<false>{*this, ranges::end(base_)};
+```
+``` cpp
+constexpr sentinel<true> end() const
+  requires range<const V> &&
+           regular_invocable<const F&, range_reference_t<const V>>;
+```
+*Effects:* Equivalent to:
+``` cpp
+return sentinel<true>{ranges::end(base_)};
+```
+``` cpp
+constexpr iterator<true> end() const
+  requires common_range<const V> &&
+           regular_invocable<const F&, range_reference_t<const V>>;
+```
+*Effects:* Equivalent to:
+``` cpp
+return iterator<true>{*this, ranges::end(base_)};
+```
+#### Class template `transform_view::iterator` <a id="range.transform.iterator">[[range.transform.iterator]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V, copy_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>>>
+  template<bool Const>
+  class transform_view<V, F>::iterator {
+  private:
+    using Parent =                              // exposition only
+      conditional_t<Const, const transform_view, transform_view>;
+    using Base   =                              // exposition only
+      conditional_t<Const, const V, V>;
+    iterator_t<Base> current_ =                 // exposition only
+      iterator_t<Base>();
+    Parent* parent_ = nullptr;                  // exposition only
+  public:
+    using iterator_concept  = see below;
+    using iterator_category = see below;
+    using value_type        =
+      remove_cvref_t<invoke_result_t<F&, range_reference_t<Base>>>;
+    using difference_type   = range_difference_t<Base>;
+    iterator() = default;
+    constexpr iterator(Parent& parent, iterator_t<Base> current);
+    constexpr iterator(iterator<!Const> i)
+      requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
+    constexpr iterator_t<Base> base() const &
+      requires copyable<iterator_t<Base>>;
+    constexpr iterator_t<Base> base() &&;
+    constexpr decltype(auto) operator*() const
+    { return invoke(*parent_->fun_, *current_); }
+    constexpr iterator& operator++();
+    constexpr void operator++(int);
+    constexpr iterator operator++(int) requires forward_range<Base>;
+    constexpr iterator& operator--() requires bidirectional_range<Base>;
+    constexpr iterator operator--(int) requires bidirectional_range<Base>;
+    constexpr iterator& operator+=(difference_type n)
+      requires random_access_range<Base>;
+    constexpr iterator& operator-=(difference_type n)
+      requires random_access_range<Base>;
+    constexpr decltype(auto) operator[](difference_type n) const
+      requires random_access_range<Base>
+    { return invoke(*parent_->fun_, current_[n]); }
+    friend constexpr bool operator==(const iterator& x, const iterator& y)
+      requires equality_comparable<iterator_t<Base>>;
+    friend constexpr bool operator<(const iterator& x, const iterator& y)
+      requires random_access_range<Base>;
+    friend constexpr bool operator>(const iterator& x, const iterator& y)
+      requires random_access_range<Base>;
+    friend constexpr bool operator<=(const iterator& x, const iterator& y)
+      requires random_access_range<Base>;
+    friend constexpr bool operator>=(const iterator& x, const iterator& y)
+      requires random_access_range<Base>;
+    friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+      requires random_access_range<Base> && three_way_comparable<iterator_t<Base>>;
+    friend constexpr iterator operator+(iterator i, difference_type n)
+      requires random_access_range<Base>;
+    friend constexpr iterator operator+(difference_type n, iterator i)
+      requires random_access_range<Base>;
+    friend constexpr iterator operator-(iterator i, difference_type n)
+      requires random_access_range<Base>;
+    friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+      requires random_access_range<Base>;
+    friend constexpr decltype(auto) iter_move(const iterator& i)
+      noexcept(noexcept(invoke(*i.parent_->fun_, *i.current_)))
+    {
+      if constexpr (is_lvalue_reference_v<decltype(*i)>)
+        return std::move(*i);
+      else
+        return *i;
+    }
+    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>>;
+  };
+}
+```
+`iterator::iterator_concept` is defined as follows:
+- If `V` models `random_access_range`, then `iterator_concept` denotes
+  `random_access_iterator_tag`.
+- Otherwise, if `V` models `bidirectional_range`, then
+  `iterator_concept` denotes `bidirectional_iterator_tag`.
+- Otherwise, if `V` models `forward_range`, then `iterator_concept`
+  denotes `forward_iterator_tag`.
+- Otherwise, `iterator_concept` denotes `input_iterator_tag`.
+`iterator::iterator_category` is defined as follows: Let `C` denote the
+type `iterator_traits<iterator_t<Base>>::iterator_category`.
+- If
+  `is_lvalue_reference_v<invoke_result_t<F&, range_reference_t<Base>>>`
+  is `true`, then
+  - if `C` models `derived_from<contiguous_iterator_tag>`,
+    `iterator_category` denotes `random_access_iterator_tag`;
+  - otherwise, `iterator_category` denotes `C`.
+- Otherwise, `iterator_category` denotes `input_iterator_tag`.
+``` cpp
+constexpr iterator(Parent& parent, iterator_t<Base> current);
+```
+*Effects:* Initializes *current\_* with `std::move(current)` and
+*parent\_* with `addressof(parent)`.
+``` cpp
+constexpr iterator(iterator<!Const> i)
+  requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
+```
+*Effects:* Initializes *current\_* with `std::move(i.`*`current_`*`)`
+and *parent\_* with `i.`*`parent_`*.
+``` cpp
+constexpr iterator_t<Base> base() const &
+  requires copyable<iterator_t<Base>>;
+```
+*Effects:* Equivalent to: `return `*`current_`*`;`
+``` cpp
+constexpr iterator_t<Base> base() &&;
+```
+*Effects:* Equivalent to: `return std::move(current_);`
+``` cpp
+constexpr iterator& operator++();
+```
+*Effects:* Equivalent to:
+``` cpp
+++current_;
+return *this;
+```
+``` cpp
+constexpr void operator++(int);
+```
+*Effects:* Equivalent to `++current_`.
+``` cpp
+constexpr iterator operator++(int) requires forward_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+++*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator--() requires bidirectional_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+--current_;
+return *this;
+```
+``` cpp
+constexpr iterator operator--(int) requires bidirectional_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+--*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator+=(difference_type n)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+current_ += n;
+return *this;
+```
+``` cpp
+constexpr iterator& operator-=(difference_type n)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+current_ -= n;
+return *this;
+```
+``` cpp
+friend constexpr bool operator==(const iterator& x, const iterator& y)
+  requires equality_comparable<iterator_t<Base>>;
+```
+*Effects:* Equivalent to: `return x.`*`current_`*` == y.`*`current_`*`;`
+``` cpp
+friend constexpr bool operator<(const iterator& x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return x.`*`current_`*` < y.`*`current_`*`;`
+``` cpp
+friend constexpr bool operator>(const iterator& x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return y < x;`
+``` cpp
+friend constexpr bool operator<=(const iterator& x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return !(y < x);`
+``` cpp
+friend constexpr bool operator>=(const iterator& x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return !(x < y);`
+``` cpp
+friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+  requires random_access_range<Base> && three_way_comparable<iterator_t<Base>>;
+```
+*Effects:* Equivalent to:
+`return x.`*`current_`*` <=> y.`*`current_`*`;`
+``` cpp
+friend constexpr iterator operator+(iterator i, difference_type n)
+  requires random_access_range<Base>;
+friend constexpr iterator operator+(difference_type n, iterator i)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to:
+`return iterator{*i.`*`parent_`*`, i.`*`current_`*` + n};`
+``` cpp
+friend constexpr iterator operator-(iterator i, difference_type n)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to:
+`return iterator{*i.`*`parent_`*`, i.`*`current_`*` - n};`
+``` cpp
+friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return x.`*`current_`*` - y.`*`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_`*`)`.
+#### Class template `transform_view::sentinel` <a id="range.transform.sentinel">[[range.transform.sentinel]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V, copy_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>>>
+  template<bool Const>
+  class transform_view<V, F>::sentinel {
+  private:
+    using Parent =                                      // exposition only
+      conditional_t<Const, const transform_view, transform_view>;
+    using Base = conditional_t<Const, const V, V>;      // exposition only
+    sentinel_t<Base> end_ = sentinel_t<Base>();         // exposition only
+  public:
+    sentinel() = default;
+    constexpr explicit sentinel(sentinel_t<Base> end);
+    constexpr sentinel(sentinel<!Const> i)
+      requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+    constexpr sentinel_t<Base> base() const;
+    friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);
+    friend constexpr range_difference_t<Base>
+      operator-(const iterator<Const>& x, const sentinel& y)
+        requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
+    friend constexpr range_difference_t<Base>
+      operator-(const sentinel& y, const iterator<Const>& x)
+        requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
+  };
+}
+```
+``` cpp
+constexpr explicit sentinel(sentinel_t<Base> end);
+```
+*Effects:* Initializes *end\_* with `end`.
+``` cpp
+constexpr sentinel(sentinel<!Const> i)
+  requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+```
+*Effects:* Initializes *end\_* with `std::move(i.`*`end_`*`)`.
+``` cpp
+constexpr sentinel_t<Base> base() const;
+```
+*Effects:* Equivalent to: `return `*`end_`*`;`
+``` cpp
+friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);
+```
+*Effects:* Equivalent to: `return x.`*`current_`*` == y.`*`end_`*`;`
+``` cpp
+friend constexpr range_difference_t<Base>
+  operator-(const iterator<Const>& x, const sentinel& y)
+    requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
+```
+*Effects:* Equivalent to: `return x.`*`current_`*` - y.`*`end_`*`;`
+``` cpp
+friend constexpr range_difference_t<Base>
+  operator-(const sentinel& y, const iterator<Const>& x)
+    requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
+```
+*Effects:* Equivalent to: `return y.`*`end_`*` - x.`*`current_`*`;`
+### Take view <a id="range.take">[[range.take]]</a>
+#### Overview <a id="range.take.overview">[[range.take.overview]]</a>
+`take_view` produces a `view` of the first N elements from another
+`view`, or all the elements if the adapted `view` contains fewer than N.
+The name `views::take` denotes a range adaptor object
+[[range.adaptor.object]]. Let `E` and `F` be expressions, let `T` be
+`remove_cvref_t<decltype((E))>`, and let `D` be
+`range_difference_t<decltype((E))>`. If `decltype((F))` does not model
+`convertible_to<D>`, `views::take(E, F)` is ill-formed. Otherwise, the
+expression `views::take(E, F)` is expression-equivalent to:
+- If `T` is a specialization of `ranges::empty_view`
+  [[range.empty.view]], then `((void) F, decay-copy(E))`.
+- Otherwise, if `T` models `random_access_range` and `sized_range` and
+  is
+  - a specialization of `span` [[views.span]] where
+    `T::extent == dynamic_extent`,
+  - a specialization of `basic_string_view` [[string.view]],
+  - a specialization of `ranges::iota_view` [[range.iota.view]], or
+  - a specialization of `ranges::subrange` [[range.subrange]],
+  then
+  `T{ranges::begin(E), ranges::begin(E) + min<D>(ranges::size(E), F)}`,
+  except that `E` is evaluated only once.
+- Otherwise, `ranges::take_view{E, F}`.
+[*Example 1*:
+``` cpp
+vector<int> is{0,1,2,3,4,5,6,7,8,9};
+take_view few{is, 5};
+for (int i : few)
+  cout << i << ' '; // prints: 0 1 2 3 4
+```
+— *end example*]
+#### Class template `take_view` <a id="range.take.view">[[range.take.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<view V>
+  class take_view : public view_interface<take_view<V>> {
+  private:
+    V base_ = V();                                      // exposition only
+    range_difference_t<V> count_ = 0;                   // exposition only
+    // [range.take.sentinel], class template take_view::sentinel
+    template<bool> struct sentinel;                     // exposition only
+  public:
+    take_view() = default;
+    constexpr take_view(V base, range_difference_t<V> count);
+    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 (sized_range<V>) {
+        if constexpr (random_access_range<V>)
+          return ranges::begin(base_);
+        else {
+          auto sz = size();
+          return counted_iterator{ranges::begin(base_), sz};
+        }
+      } else
+        return counted_iterator{ranges::begin(base_), count_};
+    }
+    constexpr auto begin() const requires range<const V> {
+      if constexpr (sized_range<const V>) {
+        if constexpr (random_access_range<const V>)
+          return ranges::begin(base_);
+        else {
+          auto sz = size();
+          return counted_iterator{ranges::begin(base_), sz};
+        }
+      } else
+        return counted_iterator{ranges::begin(base_), count_};
+    }
+    constexpr auto end() requires (!simple-view<V>) {
+      if constexpr (sized_range<V>) {
+        if constexpr (random_access_range<V>)
+          return ranges::begin(base_) + size();
+        else
+          return default_sentinel;
+      } else
+        return sentinel<false>{ranges::end(base_)};
+    }
+    constexpr auto end() const requires range<const V> {
+      if constexpr (sized_range<const V>) {
+        if constexpr (random_access_range<const V>)
+          return ranges::begin(base_) + size();
+        else
+          return default_sentinel;
+      } else
+        return sentinel<true>{ranges::end(base_)};
+    }
+    constexpr auto size() requires sized_range<V> {
+      auto n = ranges::size(base_);
+      return ranges::min(n, static_cast<decltype(n)>(count_));
+    }
+    constexpr auto size() const requires sized_range<const V> {
+      auto n = ranges::size(base_);
+      return ranges::min(n, static_cast<decltype(n)>(count_));
+    }
+  };
+  template<range R>
+    take_view(R&&, range_difference_t<R>)
+      -> take_view<views::all_t<R>>;
+}
+```
+``` cpp
+constexpr take_view(V base, range_difference_t<V> count);
+```
+*Effects:* Initializes *base\_* with `std::move(base)` and *count\_*
+with `count`.
+#### Class template `take_view::sentinel` <a id="range.take.sentinel">[[range.take.sentinel]]</a>
+``` cpp
+namespace std::ranges {
+  template<view V>
+  template<bool Const>
+  class take_view<V>::sentinel {
+  private:
+    using Base = conditional_t<Const, const V, V>;      // exposition only
+    using CI = counted_iterator<iterator_t<Base>>;      // exposition only
+    sentinel_t<Base> end_ = sentinel_t<Base>();         // exposition only
+  public:
+    sentinel() = default;
+    constexpr explicit sentinel(sentinel_t<Base> end);
+    constexpr sentinel(sentinel<!Const> s)
+      requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+    constexpr sentinel_t<Base> base() const;
+    friend constexpr bool operator==(const CI& y, const sentinel& x);
+  };
+}
+```
+``` cpp
+constexpr explicit sentinel(sentinel_t<Base> end);
+```
+*Effects:* Initializes *end\_* with `end`.
+``` cpp
+constexpr sentinel(sentinel<!Const> s)
+  requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+```
+*Effects:* Initializes *end\_* with `std::move(s.`*`end_`*`)`.
+``` cpp
+constexpr sentinel_t<Base> base() const;
+```
+*Effects:* Equivalent to: `return `*`end_`*`;`
+``` cpp
+friend constexpr bool operator==(const CI& y, const sentinel& x);
+```
+*Effects:* Equivalent to:
+`return y.count() == 0 || y.base() == x.`*`end_`*`;`
+### Take while view <a id="range.take.while">[[range.take.while]]</a>
+#### Overview <a id="range.take.while.overview">[[range.take.while.overview]]</a>
+Given a unary predicate `pred` and a `view` `r`, `take_while_view`
+produces a `view` of the range \[`begin(r)`,
+`ranges::find_if_not(r, pred)`).
+The name `views::take_while` denotes a range adaptor object
+[[range.adaptor.object]]. Given subexpressions `E` and `F`, the
+expression `views::take_while(E, F)` is expression-equivalent to
+`take_while_view{E, F}`.
+[*Example 1*:
+``` cpp
+auto input = istringstream{"0 1 2 3 4 5 6 7 8 9"};
+auto small = [](const auto x) noexcept { return x < 5; };
+auto small_ints = istream_view<int>(input) | views::take_while(small);
+for (const auto i : small_ints) {
+  cout << i << ' ';                             // prints 0 1 2 3 4
+}
+auto i = 0;
+input >> i;
+cout << i;                                      // prints 6
+```
+— *end example*]
+#### Class template `take_while_view` <a id="range.take.while.view">[[range.take.while.view]]</a>
+``` cpp
+namespace std::ranges {
+  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 : public view_interface<take_while_view<V, Pred>> {
+    // [range.take.while.sentinel], class template take_while_view::sentinel
+    template<bool> class sentinel;                      // exposition only
+    V base_ = V();                                      // exposition only
+    semiregular-box<Pred> pred_;                        // exposition only
+  public:
+    take_while_view() = default;
+    constexpr take_while_view(V base, Pred pred);
+    constexpr V base() const& requires copy_constructible<V> { return base_; }
+    constexpr V base() && { return std::move(base_); }
+    constexpr const Pred& pred() const;
+    constexpr auto begin() requires (!simple-view<V>)
+    { return ranges::begin(base_); }
+    constexpr auto begin() const requires range<const V>
+    { return ranges::begin(base_); }
+    constexpr auto end() requires (!simple-view<V>)
+    { return sentinel<false>(ranges::end(base_), addressof(*pred_)); }
+    constexpr auto end() const requires range<const V>
+    { return sentinel<true>(ranges::end(base_), addressof(*pred_)); }
+  };
+  template<class R, class Pred>
+    take_while_view(R&&, Pred) -> take_while_view<views::all_t<R>, Pred>;
+}
+```
+``` cpp
+constexpr take_while_view(V base, Pred pred);
+```
+*Effects:* Initializes *base\_* with `std::move(base)` and *pred\_* with
+`std::move(pred)`.
+``` cpp
+constexpr const Pred& pred() const;
+```
+*Effects:* Equivalent to: `return *`*`pred_`*`;`
+#### Class template `take_while_view::sentinel` <a id="range.take.while.sentinel">[[range.take.while.sentinel]]</a>
+``` cpp
+namespace std::ranges {
+  template<view V, class Pred>
+    requires input_range<V> && is_object_v<Pred> &&
+             indirect_unary_predicate<const Pred, iterator_t<V>>
+  template<bool Const>
+  class take_while_view<V, Pred>::sentinel {            // exposition only
+    using Base = conditional_t<Const, const V, V>;      // exposition only
+    sentinel_t<Base> end_ = sentinel_t<Base>();         // exposition only
+    const Pred* pred_ = nullptr;                        // exposition only
+  public:
+    sentinel() = default;
+    constexpr explicit sentinel(sentinel_t<Base> end, const Pred* pred);
+    constexpr sentinel(sentinel<!Const> s)
+      requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+    constexpr sentinel_t<Base> base() const { return end_; }
+    friend constexpr bool operator==(const iterator_t<Base>& x, const sentinel& y);
+  };
+}
+```
+``` cpp
+constexpr explicit sentinel(sentinel_t<Base> end, const Pred* pred);
+```
+*Effects:* Initializes *end\_* with `end` and *pred\_* with `pred`.
+``` cpp
+constexpr sentinel(sentinel<!Const> s)
+  requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+```
+*Effects:* Initializes *end\_* with `s.`*`end_`* and *pred\_* with
+`s.`*`pred_`*.
+``` cpp
+friend constexpr bool operator==(const iterator_t<Base>& x, const sentinel& y);
+```
+*Effects:* Equivalent to:
+`return y.`*`end_`*` == x || !invoke(*y.`*`pred_`*`, *x);`
+### Drop view <a id="range.drop">[[range.drop]]</a>
+#### Overview <a id="range.drop.overview">[[range.drop.overview]]</a>
+`drop_view` produces a `view` excluding the first N elements from
+another `view`, or an empty range if the adapted `view` contains fewer
+than N elements.
+The name `views::drop` denotes a range adaptor object
+[[range.adaptor.object]]. Let `E` and `F` be expressions, let `T` be
+`remove_cvref_t<decltype((E))>`, and let `D` be
+`range_difference_t<decltype((E))>`. If `decltype((F))` does not model
+`convertible_to<D>`, `views::drop(E, F)` is ill-formed. Otherwise, the
+expression `views::drop(E, F)` is expression-equivalent to:
+- If `T` is a specialization of `ranges::empty_view`
+  [[range.empty.view]], then `((void) F, decay-copy(E))`.
+- Otherwise, if `T` models `random_access_range` and `sized_range` and
+  is
+  - a specialization of `span` [[views.span]] where
+    `T::extent == dynamic_extent`,
+  - a specialization of `basic_string_view` [[string.view]],
+  - a specialization of `ranges::iota_view` [[range.iota.view]], or
+  - a specialization of `ranges::subrange` [[range.subrange]],
+  then
+  `T{ranges::begin(E) + min<D>(ranges::size(E), F), ranges::end(E)}`,
+  except that `E` is evaluated only once.
+- Otherwise, `ranges::drop_view{E, F}`.
+[*Example 1*:
+``` cpp
+auto ints = views::iota(0) | views::take(10);
+auto latter_half = drop_view{ints, 5};
+for (auto i : latter_half) {
+  cout << i << ' ';                             // prints 5 6 7 8 9
+}
+```
+— *end example*]
+#### Class template `drop_view` <a id="range.drop.view">[[range.drop.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<view V>
+  class drop_view : public view_interface<drop_view<V>> {
+  public:
+    drop_view() = default;
+    constexpr drop_view(V base, range_difference_t<V> count);
+    constexpr V base() const& requires copy_constructible<V> { return base_; }
+    constexpr V base() && { return std::move(base_); }
+    constexpr auto begin()
+      requires (!(simple-view<V> && random_access_range<V>));
+    constexpr auto begin() const
+      requires random_access_range<const V>;
+    constexpr auto end()
+      requires (!simple-view<V>)
+    { return ranges::end(base_); }
+    constexpr auto end() const
+      requires range<const V>
+    { return ranges::end(base_); }
+    constexpr auto size()
+      requires sized_range<V>
+    {
+      const auto s = ranges::size(base_);
+      const auto c = static_cast<decltype(s)>(count_);
+      return s < c ? 0 : s - c;
+    }
+    constexpr auto size() const
+      requires sized_range<const V>
+    {
+      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
+  };
+  template<class R>
+    drop_view(R&&, range_difference_t<R>) -> drop_view<views::all_t<R>>;
+}
+```
+``` cpp
+constexpr drop_view(V base, range_difference_t<V> count);
+```
+*Preconditions:* `count >= 0` is `true`.
+*Effects:* Initializes *base\_* with `std::move(base)` and *count\_*
+with `count`.
+``` cpp
+constexpr auto begin()
+  requires (!(simple-view<V> && random_access_range<V>));
+constexpr auto begin() const
+  requires random_access_range<const V>;
+```
+*Returns:*
+`ranges::next(ranges::begin(base_), count_, ranges::end(base_))`.
+*Remarks:* In order to provide the amortized constant-time complexity
+required by the `range` concept when `drop_view` models `forward_range`,
+the first overload caches the result within the `drop_view` for use on
+subsequent calls.
+[*Note 1*: Without this, applying a `reverse_view` over a `drop_view`
+would have quadratic iteration complexity. — *end note*]
+### Drop while view <a id="range.drop.while">[[range.drop.while]]</a>
+#### Overview <a id="range.drop.while.overview">[[range.drop.while.overview]]</a>
+Given a unary predicate `pred` and a `view` `r`, `drop_while_view`
+produces a `view` of the range \[`ranges::find_if_not(r, pred)`,
+`ranges::end(r)`).
+The name `views::drop_while` denotes a range adaptor object
+[[range.adaptor.object]]. Given subexpressions `E` and `F`, the
+expression `views::drop_while(E, F)` is expression-equivalent to
+`drop_while_view{E, F}`.
+[*Example 1*:
+``` cpp
+constexpr auto source = "  \t   \t   \t   hello there";
+auto is_invisible = [](const auto x) { return x == ' ' || x == '\t'; };
+auto skip_ws = drop_while_view{source, is_invisible};
+for (auto c : skip_ws) {
+  cout << c;                                    // prints hello there with no leading space
+}
+```
+— *end example*]
+#### Class template `drop_while_view` <a id="range.drop.while.view">[[range.drop.while.view]]</a>
+``` cpp
+namespace std::ranges {
+  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 : public view_interface<drop_while_view<V, Pred>> {
+  public:
+    drop_while_view() = default;
+    constexpr drop_while_view(V base, Pred pred);
+    constexpr V base() const& requires copy_constructible<V> { return base_; }
+    constexpr V base() && { return std::move(base_); }
+    constexpr const Pred& pred() const;
+    constexpr auto begin();
+    constexpr auto end()
+    { return ranges::end(base_); }
+  private:
+    V base_ = V();                                      // exposition only
+    semiregular-box<Pred> pred_;                        // exposition only
+  };
+  template<class R, class Pred>
+    drop_while_view(R&&, Pred) -> drop_while_view<views::all_t<R>, Pred>;
+}
+```
+``` cpp
+constexpr drop_while_view(V base, Pred pred);
+```
+*Effects:* Initializes *base\_* with `std::move(base)` and *pred\_* with
+`std::move(pred)`.
+``` cpp
+constexpr const Pred& pred() const;
+```
+*Effects:* Equivalent to: `return *`*`pred_`*`;`
+``` cpp
+constexpr auto begin();
+```
+*Returns:* `ranges::find_if_not(base_, cref(*pred_))`.
+*Remarks:* In order to provide the amortized constant-time complexity
+required by the `range` concept when `drop_while_view` models
+`forward_range`, the first call caches the result within the
+`drop_while_view` for use on subsequent calls.
+[*Note 1*: Without this, applying a `reverse_view` over a
+`drop_while_view` would have quadratic iteration
+complexity. — *end note*]
+### Join view <a id="range.join">[[range.join]]</a>
+#### Overview <a id="range.join.overview">[[range.join.overview]]</a>
+`join_view` flattens a `view` of ranges into a `view`.
+The name `views::join` denotes a range adaptor object
+[[range.adaptor.object]]. Given a subexpression `E`, the expression
+`views::join(E)` is expression-equivalent to `join_view{E}`.
+[*Example 1*:
+``` cpp
+vector<string> ss{"hello", " ", "world", "!"};
+join_view greeting{ss};
+for (char ch : greeting)
+  cout << ch;                                   // prints: hello world!
+```
+— *end example*]
+#### Class template `join_view` <a id="range.join.view">[[range.join.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V>
+    requires view<V> && input_range<range_reference_t<V>> &&
+             (is_reference_v<range_reference_t<V>> ||
+              view<range_value_t<V>>)
+  class join_view : public view_interface<join_view<V>> {
+  private:
+    using InnerRng =                    // exposition only
+      range_reference_t<V>;
+    // [range.join.iterator], class template join_view::iterator
+    template<bool Const>
+      struct iterator;                  // exposition only
+    // [range.join.sentinel], class template join_view::sentinel
+    template<bool Const>
+      struct sentinel;                  // exposition only
+    V base_ = V();                      // exposition only
+    views::all_t<InnerRng> inner_ =     // exposition only, present only when !is_reference_v<InnerRng>
+      views::all_t<InnerRng>();
+  public:
+    join_view() = default;
+    constexpr explicit join_view(V base);
+    constexpr V base() const& requires copy_constructible<V> { return base_; }
+    constexpr V base() && { return std::move(base_); }
+    constexpr auto begin() {
+      constexpr bool use_const = simple-view<V> &&
+                                 is_reference_v<range_reference_t<V>>;
+      return iterator<use_const>{*this, ranges::begin(base_)};
+    }
+    constexpr auto begin() const
+    requires input_range<const V> &&
+             is_reference_v<range_reference_t<const V>> {
+      return iterator<true>{*this, ranges::begin(base_)};
+    }
+    constexpr auto end() {
+      if constexpr (forward_range<V> &&
+                    is_reference_v<InnerRng> && forward_range<InnerRng> &&
+                    common_range<V> && common_range<InnerRng>)
+        return iterator<simple-view<V>>{*this, ranges::end(base_)};
+      else
+        return sentinel<simple-view<V>>{*this};
+    }
+    constexpr auto end() const
+    requires input_range<const V> &&
+             is_reference_v<range_reference_t<const V>> {
+      if constexpr (forward_range<const V> &&
+                    is_reference_v<range_reference_t<const V>> &&
+                    forward_range<range_reference_t<const V>> &&
+                    common_range<const V> &&
+                    common_range<range_reference_t<const V>>)
+        return iterator<true>{*this, ranges::end(base_)};
+      else
+        return sentinel<true>{*this};
+    }
+  };
+  template<class R>
+    explicit join_view(R&&) -> join_view<views::all_t<R>>;
+}
+```
+``` cpp
+constexpr explicit join_view(V base);
+```
+*Effects:* Initializes *base\_* with `std::move(base)`.
+#### Class template `join_view::iterator` <a id="range.join.iterator">[[range.join.iterator]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V>
+    requires view<V> && input_range<range_reference_t<V>> &&
+             (is_reference_v<range_reference_t<V>> ||
+              view<range_value_t<V>>)
+  template<bool Const>
+  struct join_view<V>::iterator {
+  private:
+    using Parent =                                              // exposition only
+      conditional_t<Const, const join_view, join_view>;
+    using Base   = conditional_t<Const, const V, V>;            // exposition only
+    static constexpr bool ref-is-glvalue =                      // exposition only
+      is_reference_v<range_reference_t<Base>>;
+    iterator_t<Base> outer_ = iterator_t<Base>();               // exposition only
+    iterator_t<range_reference_t<Base>> inner_ =                // exposition only
+      iterator_t<range_reference_t<Base>>();
+    Parent* parent_ = nullptr;                                  // exposition only
+    constexpr void satisfy();                                   // exposition only
+  public:
+    using iterator_concept  = see below;
+    using iterator_category = see below;
+    using value_type        = range_value_t<range_reference_t<Base>>;
+    using difference_type   = see below;
+    iterator() = default;
+    constexpr iterator(Parent& parent, iterator_t<Base> outer);
+    constexpr iterator(iterator<!Const> i)
+      requires Const &&
+               convertible_to<iterator_t<V>, iterator_t<Base>> &&
+               convertible_to<iterator_t<InnerRng>,
+                              iterator_t<range_reference_t<Base>>>;
+    constexpr decltype(auto) operator*() const { return *inner_; }
+    constexpr iterator_t<Base> operator->() const
+      requires has-arrow<iterator_t<Base>> && copyable<iterator_t<Base>>;
+    constexpr iterator& operator++();
+    constexpr void operator++(int);
+    constexpr iterator operator++(int)
+      requires ref-is-glvalue && forward_range<Base> &&
+               forward_range<range_reference_t<Base>>;
+    constexpr iterator& operator--()
+      requires ref-is-glvalue && bidirectional_range<Base> &&
+               bidirectional_range<range_reference_t<Base>> &&
+               common_range<range_reference_t<Base>>;
+    constexpr iterator operator--(int)
+      requires ref-is-glvalue && bidirectional_range<Base> &&
+               bidirectional_range<range_reference_t<Base>> &&
+               common_range<range_reference_t<Base>>;
+    friend constexpr bool operator==(const iterator& x, const iterator& y)
+      requires ref-is-glvalue && equality_comparable<iterator_t<Base>> &&
+               equality_comparable<iterator_t<range_reference_t<Base>>>;
+    friend constexpr decltype(auto) iter_move(const iterator& i)
+    noexcept(noexcept(ranges::iter_move(i.inner_))) {
+      return ranges::iter_move(i.inner_);
+    }
+    friend constexpr void iter_swap(const iterator& x, const iterator& y)
+      noexcept(noexcept(ranges::iter_swap(x.inner_, y.inner_)));
+  };
+}
+```
+`iterator::iterator_concept` is defined as follows:
+- If *`ref-is-glvalue`* is `true` and *`Base`* and
+  `range_reference_t<Base>` each model `bidirectional_range`, then
+  `iterator_concept` denotes `bidirectional_iterator_tag`.
+- Otherwise, if *`ref-is-glvalue`* is `true` and *`Base`* and
+  `range_reference_t<Base>` each model , then `iterator_concept` denotes
+  `forward_iterator_tag`.
+- Otherwise, `iterator_concept` denotes `input_iterator_tag`.
+`iterator::iterator_category` is defined as follows:
+- Let *OUTERC* denote
+  `iterator_traits<iterator_t<Base>>::iterator_category`, and let
+  *INNERC* denote
+  `iterator_traits<iterator_t<range_reference_t<Base>>>::iterator_category`.
+- If *`ref-is-glvalue`* is `true` and *OUTERC* and *INNERC* each model
+  `derived_from<bidirectional_iterator_tag>`, `iterator_category`
+  denotes `bidirectional_iterator_tag`.
+- Otherwise, if *`ref-is-glvalue`* is `true` and *OUTERC* and *INNERC*
+  each model `derived_from<forward_iterator_tag>`, `iterator_category`
+  denotes `forward_iterator_tag`.
+- Otherwise, if *OUTERC* and *INNERC* each model
+  `derived_from<input_iterator_tag>`, `iterator_category` denotes
+  `input_iterator_tag`.
+- Otherwise, `iterator_category` denotes `output_iterator_tag`.
+`iterator::difference_type` denotes the type:
+``` cpp
+common_type_t<
+  range_difference_t<Base>,
+  range_difference_t<range_reference_t<Base>>>
+```
+`join_view` iterators use the *`satisfy`* function to skip over empty
+inner ranges.
+``` cpp
+constexpr void satisfy();       // exposition only
+```
+*Effects:* Equivalent to:
+``` cpp
+auto update_inner = [this](range_reference_t<Base> x) -> auto& {
+  if constexpr (ref-is-glvalue) // x is a reference
+    return x;
+  else
+    return (parent_->inner_ = views::all(std::move(x)));
+};
+for (; outer_ != ranges::end(parent_->base_); ++outer_) {
+  auto& inner = update_inner(*outer_);
+  inner_ = ranges::begin(inner);
+  if (inner_ != ranges::end(inner))
+    return;
+}
+if constexpr (ref-is-glvalue)
+  inner_ = iterator_t<range_reference_t<Base>>();
+```
+``` cpp
+constexpr iterator(Parent& parent, iterator_t<Base> outer);
+```
+*Effects:* Initializes *outer\_* with `std::move(outer)` and *parent\_*
+with `addressof(parent)`; then calls *`satisfy`*`()`.
+``` cpp
+constexpr iterator(iterator<!Const> i)
+  requires Const &&
+           convertible_to<iterator_t<V>, iterator_t<Base>> &&
+           convertible_to<iterator_t<InnerRng>,
+                          iterator_t<range_reference_t<Base>>>;
+```
+*Effects:* Initializes *outer\_* with `std::move(i.`*`outer_`*`)`,
+*inner\_* with `std::move(i.`*`inner_`*`)`, and *parent\_* with
+`i.`*`parent_`*.
+``` cpp
+constexpr iterator_t<Base> operator->() const
+  requires has-arrow<iterator_t<Base>> && copyable<iterator_t<Base>>;
+```
+*Effects:* Equivalent to `return `*`inner_`*`;`
+``` cpp
+constexpr iterator& operator++();
+```
+Let *`inner-range`* be:
+- If *ref-is-glvalue* is `true`, `*`*`outer_`*.
+- Otherwise, *`parent_`*`->`*`inner_`*.
+*Effects:* Equivalent to:
+``` cpp
+auto&& inner_rng = inner-range;
+if (++inner_ == ranges::end(inner_rng)) {
+  ++outer_;
+  satisfy();
+}
+return *this;
+```
+``` cpp
+constexpr void operator++(int);
+```
+*Effects:* Equivalent to: `++*this`.
+``` cpp
+constexpr iterator operator++(int)
+  requires ref-is-glvalue && forward_range<Base> &&
+           forward_range<range_reference_t<Base>>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+++*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator--()
+  requires ref-is-glvalue && bidirectional_range<Base> &&
+           bidirectional_range<range_reference_t<Base>> &&
+           common_range<range_reference_t<Base>>;
+```
+*Effects:* Equivalent to:
+``` cpp
+if (outer_ == ranges::end(parent_->base_))
+  inner_ = ranges::end(*--outer_);
+while (inner_ == ranges::begin(*outer_))
+  inner_ = ranges::end(*--outer_);
+--inner_;
+return *this;
+```
+``` cpp
+constexpr iterator operator--(int)
+  requires ref-is-glvalue && bidirectional_range<Base> &&
+           bidirectional_range<range_reference_t<Base>> &&
+           common_range<range_reference_t<Base>>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+--*this;
+return tmp;
+```
+``` cpp
+friend constexpr bool operator==(const iterator& x, const iterator& y)
+  requires ref-is-glvalue && equality_comparable<iterator_t<Base>> &&
+           equality_comparable<iterator_t<range_reference_t<Base>>>;
+```
+*Effects:* Equivalent to:
+`return x.`*`outer_`*` == y.`*`outer_`*` && x.`*`inner_`*` == y.`*`inner_`*`;`
+``` cpp
+friend constexpr void iter_swap(const iterator& x, const iterator& y)
+  noexcept(noexcept(ranges::iter_swap(x.inner_, y.inner_)));
+```
+*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 {
+  template<input_range V>
+    requires view<V> && input_range<range_reference_t<V>> &&
+             (is_reference_v<range_reference_t<V>> ||
+              view<range_value_t<V>>)
+  template<bool Const>
+  struct join_view<V>::sentinel {
+  private:
+    using Parent =                                      // exposition only
+      conditional_t<Const, const join_view, join_view>;
+    using Base   = conditional_t<Const, const V, V>;    // exposition only
+    sentinel_t<Base> end_ = sentinel_t<Base>();         // exposition only
+  public:
+    sentinel() = default;
+    constexpr explicit sentinel(Parent& parent);
+    constexpr sentinel(sentinel<!Const> s)
+      requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+    friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);
+  };
+}
+```
+``` cpp
+constexpr explicit sentinel(Parent& parent);
+```
+*Effects:* Initializes *end\_* with `ranges::end(parent.`*`base_`*`)`.
+``` cpp
+constexpr sentinel(sentinel<!Const> s)
+  requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+```
+*Effects:* Initializes *end\_* with `std::move(s.`*`end_`*`)`.
+``` cpp
+friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);
+```
+*Effects:* Equivalent to: `return x.`*`outer_`*` == y.`*`end_`*`;`
+### Split view <a id="range.split">[[range.split]]</a>
+#### Overview <a id="range.split.overview">[[range.split.overview]]</a>
+`split_view` takes a `view` and a delimiter, and splits the `view` into
+subranges on the delimiter. The delimiter can be a single element or a
+`view` of elements.
+The name `views::split` denotes a range adaptor object
+[[range.adaptor.object]]. Given subexpressions `E` and `F`, the
+expression `views::split(E, F)` is expression-equivalent to
+`split_view{E, F}`.
+[*Example 1*:
+``` cpp
+string str{"the quick brown fox"};
+split_view sentence{str, ' '};
+for (auto word : sentence) {
+  for (char ch : word)
+    cout << ch;
+  cout << '*';
+}
+// The above prints: the*quick*brown*fox*
+```
+— *end example*]
+#### Class template `split_view` <a id="range.split.view">[[range.split.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<auto> struct require-constant;       // exposition only
+  template<class R>
+  concept tiny-range =                          // exposition only
+    sized_range<R> &&
+    requires { typename require-constant<remove_reference_t<R>::size()>; } &&
+    (remove_reference_t<R>::size() <= 1);
+  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 split_view : public view_interface<split_view<V, Pattern>> {
+  private:
+    V base_ = V();                              // exposition only
+    Pattern pattern_ = Pattern();               // exposition only
+    iterator_t<V> current_ = iterator_t<V>();   // exposition only, present only if !forward_range<V>
+    // [range.split.outer], class template split_view::outer-iterator
+    template<bool> struct outer-iterator;       // exposition only
+    // [range.split.inner], class template split_view::inner-iterator
+    template<bool> struct inner-iterator;       // exposition only
+  public:
+    split_view() = default;
+    constexpr split_view(V base, Pattern pattern);
+    template<input_range R>
+      requires constructible_from<V, views::all_t<R>> &&
+               constructible_from<Pattern, single_view<range_value_t<R>>>
+    constexpr split_view(R&& r, range_value_t<R> e);
+    constexpr V base() const& requires copy_constructible<V> { return base_; }
+    constexpr V base() && { return std::move(base_); }
+    constexpr auto begin() {
+      if constexpr (forward_range<V>)
+        return outer-iterator<simple-view<V>>{*this, ranges::begin(base_)};
+      else {
+        current_ = ranges::begin(base_);
+        return outer-iterator<false>{*this};
+      }
+    }
+    constexpr auto begin() const requires forward_range<V> && forward_range<const V> {
+      return outer-iterator<true>{*this, ranges::begin(base_)};
+    }
+    constexpr auto end() requires forward_range<V> && common_range<V> {
+      return outer-iterator<simple-view<V>>{*this, ranges::end(base_)};
+    }
+    constexpr auto end() const {
+      if constexpr (forward_range<V> && forward_range<const V> && common_range<const V>)
+        return outer-iterator<true>{*this, ranges::end(base_)};
+      else
+        return default_sentinel;
+    }
+  };
+  template<class R, class P>
+    split_view(R&&, P&&) -> split_view<views::all_t<R>, views::all_t<P>>;
+  template<input_range R>
+    split_view(R&&, range_value_t<R>)
+      -> split_view<views::all_t<R>, single_view<range_value_t<R>>>;
+}
+```
+``` cpp
+constexpr split_view(V base, Pattern pattern);
+```
+*Effects:* Initializes *base\_* with `std::move(base)`, and *pattern\_*
+with `std::move(pattern)`.
+``` cpp
+template<input_range R>
+  requires constructible_from<V, views::all_t<R>> &&
+           constructible_from<Pattern, single_view<range_value_t<R>>>
+constexpr split_view(R&& r, range_value_t<R> e);
+```
+*Effects:* Initializes *base\_* with `views::all(std::forward<R>(r))`,
+and *pattern\_* with `single_view{std::move(e)}`.
+#### Class template `split_view::outer-iterator` <a id="range.split.outer">[[range.split.outer]]</a>
+``` cpp
+namespace std::ranges {
+  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>)
+  template<bool Const>
+  struct split_view<V, Pattern>::outer-iterator {
+  private:
+    using Parent =                          // exposition only
+      conditional_t<Const, const split_view, split_view>;
+    using Base   =                          // exposition only
+      conditional_t<Const, const V, V>;
+    Parent* parent_ = nullptr;              // exposition only
+    iterator_t<Base> current_ =             // exposition only, present only if V models forward_range
+      iterator_t<Base>();
+  public:
+    using iterator_concept  =
+      conditional_t<forward_range<Base>, forward_iterator_tag, input_iterator_tag>;
+    using iterator_category = input_iterator_tag;
+    // [range.split.outer.value], class split_view::outer-iterator::value_type
+    struct value_type;
+    using difference_type   = range_difference_t<Base>;
+    outer-iterator() = default;
+    constexpr explicit outer-iterator(Parent& parent)
+      requires (!forward_range<Base>);
+    constexpr outer-iterator(Parent& parent, iterator_t<Base> current)
+      requires forward_range<Base>;
+    constexpr outer-iterator(outer-iterator<!Const> i)
+      requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
+    constexpr value_type operator*() const;
+    constexpr outer-iterator& operator++();
+    constexpr decltype(auto) operator++(int) {
+      if constexpr (forward_range<Base>) {
+        auto tmp = *this;
+        ++*this;
+        return tmp;
+      } else
+        ++*this;
+    }
+    friend constexpr bool operator==(const outer-iterator& x, const outer-iterator& y)
+      requires forward_range<Base>;
+    friend constexpr bool operator==(const outer-iterator& x, default_sentinel_t);
+  };
+}
+```
+Many of the following specifications refer to the notional member
+*current* of *`outer-iterator`*. *current* is equivalent to *`current_`*
+if `V` models `forward_range`, and `parent_->current_` otherwise.
+``` cpp
+constexpr explicit outer-iterator(Parent& parent)
+  requires (!forward_range<Base>);
+```
+*Effects:* Initializes *parent\_* with `addressof(parent)`.
+``` cpp
+constexpr outer-iterator(Parent& parent, iterator_t<Base> current)
+  requires forward_range<Base>;
+```
+*Effects:* Initializes *parent\_* with `addressof(parent)` and
+*current\_* with `std::move(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;
+```
+*Effects:* Equivalent to: `return value_type{*this};`
+``` cpp
+constexpr outer-iterator& operator++();
+```
+*Effects:* Equivalent to:
+``` cpp
+const auto end = ranges::end(parent_->base_);
+if (current == end) return *this;
+const auto [pbegin, pend] = subrange{parent_->pattern_};
+if (pbegin == pend) ++current;
+else {
+  do {
+    auto [b, p] = ranges::mismatch(std::move(current), end, pbegin, pend);
+    current = std::move(b);
+    if (p == pend) {
+      break;            // The pattern matched; skip it
+    }
+  } while (++current != end);
+}
+return *this;
+```
+``` cpp
+friend constexpr bool operator==(const outer-iterator& x, const outer-iterator& y)
+  requires forward_range<Base>;
+```
+*Effects:* Equivalent to: `return x.`*`current_`*` == y.`*`current_`*`;`
+``` cpp
+friend constexpr bool operator==(const outer-iterator& x, default_sentinel_t);
+```
+*Effects:* Equivalent to:
+`return x.`*`current`*` == ranges::end(x.`*`parent_`*`->`*`base_`*`);`
+#### Class `split_view::outer-iterator::value_type` <a id="range.split.outer.value">[[range.split.outer.value]]</a>
+``` cpp
+namespace std::ranges {
+  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>)
+  template<bool Const>
+  struct 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 requires copyable<outer-iterator>;
+    constexpr inner-iterator<Const> begin() requires (!copyable<outer-iterator>);
+    constexpr default_sentinel_t end() const;
+  };
+}
+```
+``` cpp
+constexpr explicit value_type(outer-iterator i);
+```
+*Effects:* Initializes *i\_* with `std::move(i)`.
+``` cpp
+constexpr inner-iterator<Const> begin() const requires copyable<outer-iterator>;
+```
+*Effects:* Equivalent to:
+`return `*`inner-iterator`*`<Const>{`*`i_`*`};`
+``` cpp
+constexpr inner-iterator<Const> begin() requires (!copyable<outer-iterator>);
+```
+*Effects:* Equivalent to:
+`return `*`inner-iterator`*`<Const>{std::move(`*`i_`*`)};`
+``` cpp
+constexpr default_sentinel_t end() const;
+```
+*Effects:* Equivalent to: `return default_sentinel;`
+#### Class template `split_view::inner-iterator` <a id="range.split.inner">[[range.split.inner]]</a>
+``` cpp
+namespace std::ranges {
+  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>)
+  template<bool Const>
+  struct split_view<V, Pattern>::inner-iterator {
+  private:
+    using Base = conditional_t<Const, const V, 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 below;
+    using value_type        = range_value_t<Base>;
+    using difference_type   = range_difference_t<Base>;
+    inner-iterator() = default;
+    constexpr explicit inner-iterator(outer-iterator<Const> i);
+    constexpr decltype(auto) operator*() const { return *i_.current; }
+    constexpr inner-iterator& operator++();
+    constexpr decltype(auto) operator++(int) {
+      if constexpr (forward_range<V>) {
+        auto tmp = *this;
+        ++*this;
+        return tmp;
+      } else
+        ++*this;
+    }
+    friend constexpr bool operator==(const inner-iterator& x, const inner-iterator& y)
+      requires forward_range<Base>;
+    friend constexpr bool operator==(const inner-iterator& x, default_sentinel_t);
+    friend constexpr decltype(auto) iter_move(const inner-iterator& i)
+    noexcept(noexcept(ranges::iter_move(i.i_.current))) {
+      return ranges::iter_move(i.i_.current);
+    }
+    friend constexpr void iter_swap(const inner-iterator& x, const inner-iterator& y)
+      noexcept(noexcept(ranges::iter_swap(x.i_.current, y.i_.current)))
+      requires indirectly_swappable<iterator_t<Base>>;
+  };
+}
+```
+The *typedef-name* `iterator_category` denotes:
+- `forward_iterator_tag` if
+  `iterator_traits<iterator_t<Base>>::iterator_category` models
+  `derived_from<forward_iterator_tag>`;
+- otherwise, `iterator_traits<iterator_t<Base>>::iterator_category`.
+``` cpp
+constexpr explicit inner-iterator(outer-iterator<Const> i);
+```
+*Effects:* Initializes *i\_* with `std::move(i)`.
+``` cpp
+constexpr inner-iterator& operator++();
+```
+*Effects:* Equivalent to:
+``` cpp
+incremented_ = true;
+if constexpr (!forward_range<Base>) {
+  if constexpr (Pattern::size() == 0) {
+    return *this;
+  }
+}
+++i_.current;
+return *this;
+```
+``` cpp
+friend constexpr bool operator==(const inner-iterator& x, const inner-iterator& y)
+  requires forward_range<Base>;
+```
+*Effects:* Equivalent to:
+`return x.`*`i_`*`.`*`current`*` == y.`*`i_`*`.`*`current`*`;`
+``` cpp
+friend constexpr bool operator==(const inner-iterator& x, default_sentinel_t);
+```
+*Effects:* Equivalent to:
+``` cpp
+auto [pcur, pend] = subrange{x.i_.parent_->pattern_};
+auto end = ranges::end(x.i_.parent_->base_);
+if constexpr (tiny-range<Pattern>) {
+  const auto & cur = x.i_.current;
+  if (cur == end) return true;
+  if (pcur == pend) return x.incremented_;
+  return *cur == *pcur;
+} else {
+  auto cur = x.i_.current;
+  if (cur == end) return true;
+  if (pcur == pend) return x.incremented_;
+  do {
+    if (*cur != *pcur) return false;
+    if (++pcur == pend) return true;
+  } while (++cur != end);
+  return false;
+}
+```
+``` cpp
+friend constexpr void iter_swap(const inner-iterator& x, const inner-iterator& y)
+  noexcept(noexcept(ranges::iter_swap(x.i_.current, y.i_.current)))
+  requires indirectly_swappable<iterator_t<Base>>;
+```
+*Effects:* Equivalent to
+`ranges::iter_swap(x.`*`i_`*`.`*`current`*`, y.`*`i_`*`.`*`current`*`)`.
+### 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`.
+The name `views::counted` denotes a customization point object
+[[customization.point.object]]. Let `E` and `F` be expressions, let `T`
+be `decay_t<decltype((E))>`, and let `D` be `iter_difference_t<T>`. If
+`decltype((F))` does not model `convertible_to<D>`,
+`views::counted(E, F)` is ill-formed.
+[*Note 1*: This case can result in substitution failure when
+`views::counted(E, F)` appears in the immediate context of a template
+instantiation. — *end note*]
+Otherwise, `views::counted(E, F)` is expression-equivalent to:
+- If `T` models `contiguous_iterator`, then
+  `span{to_address(E), static_cast<D>(F)}`.
+- Otherwise, if `T` models `random_access_iterator`, then
+  `subrange{E, E + static_cast<D>(F)}`, except that `E` is evaluated
+  only once.
+- Otherwise, `subrange{counted_iterator{E, F}, default_sentinel}`.
+### Common view <a id="range.common">[[range.common]]</a>
+#### Overview <a id="range.common.overview">[[range.common.overview]]</a>
+`common_view` takes a `view` which has different types for its iterator
+and sentinel and turns it into a `view` of the same elements with an
+iterator and sentinel of the same type.
+[*Note 1*: `common_view` is useful for calling legacy algorithms that
+expect a range’s iterator and sentinel types to be the
+same. — *end note*]
+The name `views::common` denotes a range adaptor object
+[[range.adaptor.object]]. Given a subexpression `E`, the expression
+`views::common(E)` is expression-equivalent to:
+- `views::all(E)`, if `decltype((E))` models `common_range` and
+  `views::all(E)` is a well-formed expression.
+- Otherwise, `common_view{E}`.
+[*Example 1*:
+``` cpp
+// Legacy algorithm:
+template<class ForwardIterator>
+size_t count(ForwardIterator first, ForwardIterator last);
+template<forward_range R>
+void my_algo(R&& r) {
+  auto&& common = common_view{r};
+  auto cnt = count(common.begin(), common.end());
+  // ...
+}
+```
+— *end example*]
+#### Class template `common_view` <a id="range.common.view">[[range.common.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<view V>
+    requires (!common_range<V> && copyable<iterator_t<V>>)
+  class common_view : public view_interface<common_view<V>> {
+  private:
+    V base_ = V();  // exposition only
+  public:
+    common_view() = default;
+    constexpr explicit common_view(V r);
+    template<viewable_range R>
+      requires (!common_range<R> && constructible_from<V, views::all_t<R>>)
+    constexpr explicit common_view(R&& 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_));
+    }
+    constexpr auto begin() const requires range<const V> {
+      if constexpr (random_access_range<const V> && sized_range<const V>)
+        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::size(base_);
+      else
+        return common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::end(base_));
+    }
+    constexpr auto end() const requires range<const V> {
+      if constexpr (random_access_range<const V> && sized_range<const V>)
+        return ranges::begin(base_) + ranges::size(base_);
+      else
+        return common_iterator<iterator_t<const V>, sentinel_t<const V>>(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_);
+    }
+  };
+  template<class R>
+    common_view(R&&) -> common_view<views::all_t<R>>;
+}
+```
+``` cpp
+constexpr explicit common_view(V base);
+```
+*Effects:* Initializes *base\_* with `std::move(base)`.
+``` cpp
+template<viewable_range R>
+  requires (!common_range<R> && constructible_from<V, views::all_t<R>>)
+constexpr explicit common_view(R&& r);
+```
+*Effects:* Initializes *base\_* with `views::all(std::forward<R>(r))`.
+### Reverse view <a id="range.reverse">[[range.reverse]]</a>
+#### Overview <a id="range.reverse.overview">[[range.reverse.overview]]</a>
+`reverse_view` takes a bidirectional `view` and produces another `view`
+that 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-qualified
+  ``` cpp
+  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};
+reverse_view rv {is};
+for (int i : rv)
+  cout << i << ' '; // prints: 4 3 2 1 0
+```
+— *end example*]
+#### Class template `reverse_view` <a id="range.reverse.view">[[range.reverse.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<view V>
+    requires bidirectional_range<V>
+  class reverse_view : public view_interface<reverse_view<V>> {
+  private:
+    V base_ = V();  // exposition only
+  public:
+    reverse_view() = default;
+    constexpr explicit reverse_view(V r);
+    constexpr V base() const& requires copy_constructible<V> { return base_; }
+    constexpr V base() && { return std::move(base_); }
+    constexpr reverse_iterator<iterator_t<V>> begin();
+    constexpr reverse_iterator<iterator_t<V>> begin() requires common_range<V>;
+    constexpr auto begin() const requires common_range<const V>;
+    constexpr reverse_iterator<iterator_t<V>> end();
+    constexpr auto end() const requires common_range<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>
+    reverse_view(R&&) -> reverse_view<views::all_t<R>>;
+}
+```
+``` cpp
+constexpr explicit reverse_view(V base);
+```
+*Effects:* Initializes *base\_* with `std::move(base)`.
+``` cpp
+constexpr reverse_iterator<iterator_t<V>> begin();
+```
+*Returns:*
+``` cpp
+make_reverse_iterator(ranges::next(ranges::begin(base_), ranges::end(base_)))
+```
+*Remarks:* In order to provide the amortized constant time complexity
+required by the `range` concept, this function caches the result within
+the `reverse_view` for use on subsequent calls.
+``` cpp
+constexpr reverse_iterator<iterator_t<V>> begin() requires common_range<V>;
+constexpr auto begin() const requires common_range<const V>;
+```
+*Effects:* Equivalent to:
+`return make_reverse_iterator(ranges::end(base_));`
+``` cpp
+constexpr reverse_iterator<iterator_t<V>> end();
+constexpr auto end() const requires common_range<const V>;
+```
+*Effects:* Equivalent to:
+`return make_reverse_iterator(ranges::begin(base_));`
+### Elements view <a id="range.elements">[[range.elements]]</a>
+#### Overview <a id="range.elements.overview">[[range.elements.overview]]</a>
+`elements_view` takes a `view` of tuple-like values and a `size_t`, and
+produces a `view` with a value-type of the Nᵗʰ element of the adapted
+`view`’s value-type.
+The name `views::elements<N>` denotes a range adaptor object
+[[range.adaptor.object]]. Given a subexpression `E` and constant
+expression `N`, the expression `views::elements<N>(E)` is
+expression-equivalent to
+`elements_view<views::all_t<decltype((E))>, N>{E}`.
+[*Example 1*:
+``` cpp
+auto historical_figures = map{
+  {"Lovelace"sv, 1815},
+  {"Turing"sv, 1912},
+  {"Babbage"sv, 1791},
+  {"Hamilton"sv, 1936}
+};
+auto names = historical_figures | views::elements<0>;
+for (auto&& name : names) {
+  cout << name << ' ';          // prints Babbage Hamilton Lovelace Turing
+}
+auto birth_years = historical_figures | views::elements<1>;
+for (auto&& born : birth_years) {
+  cout << born << ' ';          // prints 1791 1936 1815 1912
+}
+```
+— *end example*]
+`keys_view` is an alias for `elements_view<views::all_t<R>, 0>`, and is
+useful for extracting keys from associative containers.
+[*Example 2*:
+``` cpp
+auto names = keys_view{historical_figures};
+for (auto&& name : names) {
+  cout << name << ' ';          // prints Babbage Hamilton Lovelace Turing
+}
+```
+— *end example*]
+`values_view` is an alias for `elements_view<views::all_t<R>, 1>`, and
+is useful for extracting values from associative containers.
+[*Example 3*:
+``` cpp
+auto is_even = [](const auto x) { return x % 2 == 0; };
+cout << ranges::count_if(values_view{historical_figures}, is_even);     // prints 2
+```
+— *end example*]
+#### Class template `elements_view` <a id="range.elements.view">[[range.elements.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<class T, size_t N>
+  concept has-tuple-element =                   // exposition only
+    requires(T t) {
+      typename tuple_size<T>::type;
+      requires N < tuple_size_v<T>;
+      typename tuple_element_t<N, T>;
+      { get<N>(t) } -> convertible_to<const tuple_element_t<N, T>&>;
+    };
+  template<input_range V, size_t N>
+    requires view<V> && has-tuple-element<range_value_t<V>, N> &&
+             has-tuple-element<remove_reference_t<range_reference_t<V>>, N>
+  class elements_view : public view_interface<elements_view<V, N>> {
+  public:
+    elements_view() = default;
+    constexpr explicit elements_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>)
+    { return iterator<false>(ranges::begin(base_)); }
+    constexpr auto begin() const requires simple-view<V>
+    { return iterator<true>(ranges::begin(base_)); }
+    constexpr auto end()
+    { return sentinel<false>{ranges::end(base_)}; }
+    constexpr auto end() requires common_range<V>
+    { return iterator<false>{ranges::end(base_)}; }
+    constexpr auto end() const requires range<const V>
+    { return sentinel<true>{ranges::end(base_)}; }
+    constexpr auto end() const requires common_range<const V>
+    { return iterator<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_); }
+  private:
+    // [range.elements.iterator], class template elements_view::iterator
+    template<bool> struct iterator;                     // exposition only
+    // [range.elements.sentinel], class template elements_view::sentinel
+    template<bool> struct sentinel;                     // exposition only
+    V base_ = V();                                      // exposition only
+  };
+}
+```
+``` cpp
+constexpr explicit elements_view(V base);
+```
+*Effects:* Initializes *base\_* with `std::move(base)`.
+#### Class template `elements_view::iterator` <a id="range.elements.iterator">[[range.elements.iterator]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V, size_t N>
+    requires view<V> && has-tuple-element<range_value_t<V>, N> &&
+             has-tuple-element<remove_reference_t<range_reference_t<V>>, N>
+  template<bool Const>
+  class elements_view<V, N>::iterator {                 // exposition only
+    using Base = conditional_t<Const, const V, V>;      // exposition only
+    iterator_t<Base> current_ = iterator_t<Base>();
+  public:
+    using iterator_category = typename iterator_traits<iterator_t<Base>>::iterator_category;
+    using value_type = remove_cvref_t<tuple_element_t<N, range_value_t<Base>>>;
+    using difference_type = range_difference_t<Base>;
+    iterator() = default;
+    constexpr explicit iterator(iterator_t<Base> current);
+    constexpr iterator(iterator<!Const> i)
+      requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
+    constexpr iterator_t<Base> base() const&
+      requires copyable<iterator_t<Base>>;
+    constexpr iterator_t<Base> base() &&;
+    constexpr decltype(auto) operator*() const
+    { return get<N>(*current_); }
+    constexpr iterator& operator++();
+    constexpr void operator++(int) requires (!forward_range<Base>);
+    constexpr iterator operator++(int) requires forward_range<Base>;
+    constexpr iterator& operator--() requires bidirectional_range<Base>;
+    constexpr iterator operator--(int) requires bidirectional_range<Base>;
+    constexpr iterator& operator+=(difference_type x)
+      requires random_access_range<Base>;
+    constexpr iterator& operator-=(difference_type x)
+      requires random_access_range<Base>;
+    constexpr decltype(auto) operator[](difference_type n) const
+      requires random_access_range<Base>
+    { return get<N>(*(current_ + n)); }
+    friend constexpr bool operator==(const iterator& x, const iterator& y)
+      requires equality_comparable<iterator_t<Base>>;
+    friend constexpr bool operator<(const iterator& x, const iterator& y)
+      requires random_access_range<Base>;
+    friend constexpr bool operator>(const iterator& x, const iterator& y)
+      requires random_access_range<Base>;
+    friend constexpr bool operator<=(const iterator& y, const iterator& y)
+      requires random_access_range<Base>;
+    friend constexpr bool operator>=(const iterator& x, const iterator& y)
+      requires random_access_range<Base>;
+    friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+      requires random_access_range<Base> && three_way_comparable<iterator_t<Base>>;
+    friend constexpr iterator operator+(const iterator& x, difference_type y)
+      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)
+      requires random_access_range<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() const&
+  requires copyable<iterator_t<Base>>;
+```
+*Effects:* Equivalent to: `return `*`current_`*`;`
+``` cpp
+constexpr iterator_t<Base> base() &&;
+```
+*Effects:* Equivalent to: `return std::move(`*`current_`*`);`
+``` cpp
+constexpr iterator& operator++();
+```
+*Effects:* Equivalent to:
+``` cpp
+++current_;
+return *this;
+```
+``` cpp
+constexpr void operator++(int) requires (!forward_range<Base>);
+```
+*Effects:* Equivalent to: `++`*`current_`*.
+``` cpp
+constexpr iterator operator++(int) requires forward_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto temp = *this;
+++current_;
+return temp;
+```
+``` cpp
+constexpr iterator& operator--() requires bidirectional_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+--current_;
+return *this;
+```
+``` cpp
+constexpr iterator operator--(int) requires bidirectional_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto temp = *this;
+--current_;
+return temp;
+```
+``` cpp
+constexpr iterator& operator+=(difference_type n);
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+current_ += n;
+return *this;
+```
+``` cpp
+constexpr iterator& operator-=(difference_type n)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+current_ -= n;
+return *this;
+```
+``` cpp
+friend constexpr bool operator==(const iterator& x, const iterator& y)
+  requires equality_comparable<Base>;
+```
+*Effects:* Equivalent to: `return x.`*`current_`*` == y.`*`current_`*`;`
+``` cpp
+friend constexpr bool operator<(const iterator& x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return x.`*`current_`*` < y.`*`current_`*`;`
+``` cpp
+friend constexpr bool operator>(const iterator& x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return y < x;`
+``` cpp
+friend constexpr bool operator<=(const iterator& x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return !(y < x);`
+``` cpp
+friend constexpr bool operator>=(const iterator& x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return !(x < y);`
+``` cpp
+friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+  requires random_access_range<Base> && three_way_comparable<iterator_t<Base>>;
+```
+*Effects:* Equivalent to:
+`return x.`*`current_`*` <=> y.`*`current_`*`;`
+``` cpp
+friend constexpr iterator operator+(const iterator& x, difference_type y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return iterator{x} += y;`
+``` cpp
+friend constexpr iterator operator+(difference_type x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return y + x;`
+``` cpp
+constexpr iterator operator-(const iterator& x, difference_type y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return iterator{x} -= y;`
+``` cpp
+constexpr difference_type operator-(const iterator& x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return x.`*`current_`*` - y.`*`current_`*`;`
+#### Class template `elements_view::sentinel` <a id="range.elements.sentinel">[[range.elements.sentinel]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V, size_t N>
+    requires view<V> && has-tuple-element<range_value_t<V>, N> &&
+             has-tuple-element<remove_reference_t<range_reference_t<V>>, N>
+  template<bool Const>
+  class elements_view<V, N>::sentinel {                 // exposition only
+  private:
+    using Base = conditional_t<Const, const V, V>;      // exposition only
+    sentinel_t<Base> end_ = sentinel_t<Base>();         // exposition only
+  public:
+    sentinel() = default;
+    constexpr explicit sentinel(sentinel_t<Base> end);
+    constexpr sentinel(sentinel<!Const> other)
+      requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+    constexpr sentinel_t<Base> base() const;
+    friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);
+    friend constexpr range_difference_t<Base>
+      operator-(const iterator<Const>& x, const sentinel& y)
+        requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
+    friend constexpr range_difference_t<Base>
+      operator-(const sentinel& x, const iterator<Const>& y)
+        requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
+  };
+}
+```
+``` cpp
+constexpr explicit sentinel(sentinel_t<Base> end);
+```
+*Effects:* Initializes *end\_* with `end`.
+``` cpp
+constexpr sentinel(sentinel<!Const> other)
+  requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+```
+*Effects:* Initializes *end\_* with `std::move(other.`*`end_`*`)`.
+``` cpp
+constexpr sentinel_t<Base> base() const;
+```
+*Effects:* Equivalent to: `return `*`end_`*`;`
+``` cpp
+friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);
+```
+*Effects:* Equivalent to: `return x.`*`current_`*` == y.`*`end_`*`;`
+``` cpp
+friend constexpr range_difference_t<Base>
+  operator-(const iterator<Const>& x, const sentinel& y)
+    requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
+```
+*Effects:* Equivalent to: `return x.`*`current_`*` - y.`*`end_`*`;`
+``` cpp
+friend constexpr range_difference_t<Base>
+  operator-(const sentinel& x, const iterator<Const>& y)
+    requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
+```
+*Effects:* Equivalent to: `return x.`*`end_`*` - y.`*`current_`*`;`
+<!-- Link reference definitions -->
+[basic.compound]: basic.md#basic.compound
+[concepts.equality]: concepts.md#concepts.equality
+[containers]: containers.md#containers
+[conv.rval]: expr.md#conv.rval
+[customization.point.object]: library.md#customization.point.object
+[dcl.array]: dcl.md#dcl.array
+[expr.const]: expr.md#expr.const
+[iterator.concept.bidir]: iterators.md#iterator.concept.bidir
+[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
+[iterator.concept.sizedsentinel]: iterators.md#iterator.concept.sizedsentinel
+[iterator.concept.winc]: iterators.md#iterator.concept.winc
+[iterator.requirements.general]: iterators.md#iterator.requirements.general
+[namespace.std]: library.md#namespace.std
+[range.access]: #range.access
+[range.access.begin]: #range.access.begin
+[range.access.cbegin]: #range.access.cbegin
+[range.access.cend]: #range.access.cend
+[range.access.crbegin]: #range.access.crbegin
+[range.access.crend]: #range.access.crend
+[range.access.end]: #range.access.end
+[range.access.rbegin]: #range.access.rbegin
+[range.access.rend]: #range.access.rend
+[range.adaptor.object]: #range.adaptor.object
+[range.adaptors]: #range.adaptors
+[range.all]: #range.all
+[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
+[range.drop.while]: #range.drop.while
+[range.drop.while.overview]: #range.drop.while.overview
+[range.drop.while.view]: #range.drop.while.view
+[range.elements]: #range.elements
+[range.elements.iterator]: #range.elements.iterator
+[range.elements.overview]: #range.elements.overview
+[range.elements.sentinel]: #range.elements.sentinel
+[range.elements.view]: #range.elements.view
+[range.empty]: #range.empty
+[range.empty.overview]: #range.empty.overview
+[range.empty.view]: #range.empty.view
+[range.factories]: #range.factories
+[range.filter]: #range.filter
+[range.filter.iterator]: #range.filter.iterator
+[range.filter.overview]: #range.filter.overview
+[range.filter.sentinel]: #range.filter.sentinel
+[range.filter.view]: #range.filter.view
+[range.iota]: #range.iota
+[range.iota.iterator]: #range.iota.iterator
+[range.iota.overview]: #range.iota.overview
+[range.iota.sentinel]: #range.iota.sentinel
+[range.iota.view]: #range.iota.view
+[range.istream]: #range.istream
+[range.istream.iterator]: #range.istream.iterator
+[range.istream.overview]: #range.istream.overview
+[range.istream.view]: #range.istream.view
+[range.join]: #range.join
+[range.join.iterator]: #range.join.iterator
+[range.join.overview]: #range.join.overview
+[range.join.sentinel]: #range.join.sentinel
+[range.join.view]: #range.join.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.req]: #range.req
+[range.req.general]: #range.req.general
+[range.reverse]: #range.reverse
+[range.reverse.overview]: #range.reverse.overview
+[range.reverse.view]: #range.reverse.view
+[range.semi.wrap]: #range.semi.wrap
+[range.single]: #range.single
+[range.single.overview]: #range.single.overview
+[range.single.view]: #range.single.view
+[range.sized]: #range.sized
+[range.split]: #range.split
+[range.split.inner]: #range.split.inner
+[range.split.outer]: #range.split.outer
+[range.split.outer.value]: #range.split.outer.value
+[range.split.overview]: #range.split.overview
+[range.split.view]: #range.split.view
+[range.subrange]: #range.subrange
+[range.subrange.access]: #range.subrange.access
+[range.subrange.ctor]: #range.subrange.ctor
+[range.summary]: #range.summary
+[range.take]: #range.take
+[range.take.overview]: #range.take.overview
+[range.take.sentinel]: #range.take.sentinel
+[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
+[range.utility]: #range.utility
+[range.utility.helpers]: #range.utility.helpers
+[range.view]: #range.view
+[ranges]: #ranges
+[ranges.general]: #ranges.general
+[ranges.syn]: #ranges.syn
+[string.view]: strings.md#string.view
+[view.interface]: #view.interface
+[view.interface.members]: #view.interface.members
+[views.span]: containers.md#views.span

Diff to HTML by rtfpessoa