23 Ranges library [ranges]

23.7 Range adaptors [range.adaptors]

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::view.

The bitwise OR operator is overloaded for the purpose of creating adaptor chain pipelines.

The adaptors also support function call syntax with equivalent semantics.

[ Example

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 | view::filter(even) | view::transform(square)) {
  cout << i << ' '; // prints: 0 4 16
}
assert(ranges::equal(ints | view::filter(even), view::filter(ints, even)));

— end example

]

23.7.1 Range adaptor objects [range.adaptor.object]

A range adaptor closure object is a unary function object that accepts a ViewableRange argument and returns a View.

For a range adaptor closure object C and an expression R such that decltype((R)) models ViewableRange, the following expressions are equivalent and yield a View:

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:

R | C | D
R | (C | D)

A range adaptor object is a customization point object ([customization.point.object]) that accepts a ViewableRange 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:

adaptor(range, args...)
adaptor(args...)(range)
range | adaptor(args...)

In this case, adaptor(args...) is a range adaptor closure object.

23.7.2 Semiregular wrapper [range.semi.wrap]

Many of the types in this subclause are specified in terms of an exposition-only class template semiregular.

semiregular<T> behaves exactly like optional<T> with the following differences:

(1.1)
semiregular<T> constrains its type parameter T with CopyConstructible<T> && is_object_v<T>.

(1.2)

If T models DefaultConstructible, the default constructor of semiregular<T> is equivalent to:

constexpr semiregular() noexcept(is_nothrow_default_constructible_v<T>)
  : semiregular{in_place}
{ }

(1.3)

If Assignable<T&, const T&> is not satisfied, the copy assignment operator is equivalent to:

semiregular& operator=(const semiregular& that)
  noexcept(is_nothrow_copy_constructible_v<T>)
{
  if (that) emplace(*that);
  else reset();
  return *this;
}

(1.4)

If Assignable<T&, T> is not satisfied, the move assignment operator is equivalent to:

semiregular& operator=(semiregular&& that)
  noexcept(is_nothrow_move_constructible_v<T>)
{
  if (that) emplace(std::move(*that));
  else reset();
  return *this;
}

23.7.3 All view [range.all]

view::all returns a View that includes all elements of its Range argument.

The name view::all denotes a range adaptor object ([range.adaptor.object]).

For some subexpression E, the expression view::all(E) is expression-equivalent to:

(2.1)
decay-copy(E) if the decayed type of E models View.
(2.2)
Otherwise, ref-view{E} if that expression is well-formed, where ref-view is the exposition-only View specified below.
(2.3)
Otherwise, subrange{E}.

23.7.3.1 ref-view [range.view.ref]

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 SizedRange<R>
    { return ranges::size(*r_); }

    constexpr auto data() const requires ContiguousRange<R>
    { return ranges::data(*r_); }

    friend constexpr iterator_t<R> begin(ref-view r)
    { return r.begin(); }

    friend constexpr sentinel_t<R> end(ref-view r)
    { return r.end(); }
  };
}

🔗

template<not-same-as<ref-view> T>
  requires see below
constexpr ref-view(T&& t);

Remarks: Let FUN denote the exposition-only functions

void FUN(R&);
void FUN(R&&) = delete;

The expression in the requires-clause is equivalent to

ConvertibleTo<T, R&> && requires { FUN(declval<T>()); }

Effects: Initializes r_ with addressof(static_cast<R&>(std::forward<T>(t))).

23.7.4 Filter view [range.filter]

23.7.4.1 Overview [range.filter.overview]

filter_view presents a View of an underlying sequence without the elements that fail to satisfy a predicate.

[ Example

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

]

23.7.4.2 Class template filter_view [range.filter.view]

namespace std::ranges {
  template<InputRange V, IndirectUnaryPredicate<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<Pred> pred_;    // exposition only

    class iterator;             // exposition only
    class sentinel;             // exposition only

  public:
    filter_view() = default;
    constexpr filter_view(V base, Pred pred);
    template<InputRange R>
      requires ViewableRange<R> && Constructible<V, all_view<R>>
    constexpr filter_view(R&& r, Pred pred);

    constexpr V base() const;

    constexpr iterator begin();
    constexpr auto end() {
      if constexpr (CommonRange<V>)
        return iterator{*this, ranges::end(base_)};
      else
        return sentinel{*this};
    }
  };

  template<class R, class Pred>
    filter_view(R&&, Pred) -> filter_view<all_view<R>, Pred>;
}

🔗

constexpr filter_view(V base, Pred pred);

Effects: Initializes base_ with std::move(base) and initializes pred_ with std::move(pred).

🔗

template<InputRange R>
  requires ViewableRange<R> && Constructible<V, all_view<R>>
constexpr filter_view(R&& r, Pred pred);

Effects: Initializes base_ with view::all(std::forward<R>(r)) and initializes pred_ with std::move(pred).

🔗

constexpr V base() const;

Effects: Equivalent to: return base_;

🔗

constexpr iterator begin();

Expects: 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, this function caches the result within the filter_view for use on subsequent calls.

23.7.4.3 Class filter_view::iterator [range.filter.iterator]

namespace std::ranges {
  template<class V, class 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        = iter_value_t<iterator_t<V>>;
    using difference_type   = iter_difference_t<iterator_t<V>>;

    iterator() = default;
    constexpr iterator(filter_view& parent, iterator_t<V> current);

    constexpr iterator_t<V> base() const;
    constexpr iter_reference_t<iterator_t<V>> operator*() const;
    constexpr iterator_t<V> operator->() const
      requires has-arrow<iterator_t<V>>;

    constexpr iterator& operator++();
    constexpr void operator++(int);
    constexpr iterator operator++(int) requires ForwardRange<V>;

    constexpr iterator& operator--() requires BidirectionalRange<V>;
    constexpr iterator operator--(int) requires BidirectionalRange<V>;

    friend constexpr bool operator==(const iterator& x, const iterator& y)
      requires EqualityComparable<iterator_t<V>>;
    friend constexpr bool operator!=(const iterator& x, const iterator& y)
      requires EqualityComparable<iterator_t<V>>;

    friend constexpr iter_rvalue_reference_t<iterator_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 IndirectlySwappable<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:

(2.1)
If V models BidirectionalRange, then iterator_concept denotes bidirectional_iterator_tag.
(2.2)
Otherwise, if V models ForwardRange, then iterator_concept denotes forward_iterator_tag.
(2.3)
Otherwise, iterator_concept denotes input_iterator_tag.

iterator::iterator_category is defined as follows:

(3.1)
Let C denote the type iterator_traits<iterator_t<V>>::iterator_category.
(3.2)
If C models DerivedFrom<bidirectional_iterator_tag>, then iterator_category denotes bidirectional_iterator_tag.
(3.3)
Otherwise, if C models DerivedFrom<forward_iterator_tag>, then iterator_category denotes forward_iterator_tag.
(3.4)
Otherwise, iterator_category denotes input_iterator_tag.

🔗

constexpr iterator(filter_view& parent, iterator_t<V> current);

Effects: Initializes current_ with current and parent_ with addressof(parent).

🔗

constexpr iterator_t<V> base() const;

Effects: Equivalent to: return current_;

🔗

constexpr iter_reference_t<iterator_t<V>> operator*() const;

Effects: Equivalent to: return *current_;

🔗

constexpr iterator_t<V> operator->() const
  requires has-arrow<iterator_t<V>>;

Effects: Equivalent to: return current_;

🔗

constexpr iterator& operator++();

Effects: Equivalent to:

current_ = ranges::find_if(++current_, ranges::end(parent_->base_), ref(*parent_->pred_));
return *this;

🔗

constexpr void operator++(int);

Effects: Equivalent to ++*this.

🔗

constexpr iterator operator++(int) requires ForwardRange<V>;

Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

🔗

constexpr iterator& operator--() requires BidirectionalRange<V>;

Effects: Equivalent to:

do
  --current_;
while (!invoke(*parent_->pred_, *current_));
return *this;

🔗

constexpr iterator operator--(int) requires BidirectionalRange<V>;

Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

🔗

friend constexpr bool operator==(const iterator& x, const iterator& y)
  requires EqualityComparable<iterator_t<V>>;

Effects: Equivalent to: return x.current_ == y.current_;

🔗

friend constexpr bool operator!=(const iterator& x, const iterator& y)
  requires EqualityComparable<iterator_t<V>>;

Effects: Equivalent to: return !(x == y);

🔗

friend constexpr iter_rvalue_reference_t<iterator_t<V>> iter_move(const iterator& i)
  noexcept(noexcept(ranges::iter_move(i.current_)));

Effects: Equivalent to: return 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 IndirectlySwappable<iterator_t<V>>;

Effects: Equivalent to ranges::iter_swap(x.current_, y.current_).

23.7.4.4 Class filter_view::sentinel [range.filter.sentinel]

namespace std::ranges {
  template<class V, class 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);
    friend constexpr bool operator==(const sentinel& x, const iterator& y);
    friend constexpr bool operator!=(const iterator& x, const sentinel& y);
    friend constexpr bool operator!=(const sentinel& x, const iterator& y);
  };
}

🔗

constexpr explicit sentinel(filter_view& parent);

Effects: Initializes end_ with ranges::end(parent).

🔗

constexpr sentinel_t<V> base() const;

Effects: Equivalent to: return end_;

🔗

friend constexpr bool operator==(const iterator& x, const sentinel& y);

Effects: Equivalent to: return x.current_ == y.end_;

🔗

friend constexpr bool operator==(const sentinel& x, const iterator& y);

Effects: Equivalent to: return y == x;

🔗

friend constexpr bool operator!=(const iterator& x, const sentinel& y);

Effects: Equivalent to: return !(x == y);

🔗

friend constexpr bool operator!=(const sentinel& x, const iterator& y);

Effects: Equivalent to: return !(y == x);

23.7.4.5 view::filter [range.filter.adaptor]

The name view::filter denotes a range adaptor object ([range.adaptor.object]).

For some subexpressions E and P, the expression view::filter(E, P) is expression-equivalent to filter_view{E, P}.

23.7.5 Transform view [range.transform]

23.7.5.1 Overview [range.transform.overview]

transform_view presents a View of an underlying sequence after applying a transformation function to each element.

[ Example

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

]

23.7.5.2 Class template transform_view [range.transform.view]

namespace std::ranges {
  template<InputRange V, CopyConstructible F>
    requires View<V> && is_object_v<F> &&
             RegularInvocable<F&, iter_reference_t<iterator_t<V>>>
  class transform_view : public view_interface<transform_view<V, F>> {
  private:
    template<bool> struct iterator;             // exposition only
    template<bool> struct sentinel;             // exposition only

    V base_ = V();                              // exposition only
    semiregular<F> fun_;                        // exposition only

  public:
    transform_view() = default;
    constexpr transform_view(V base, F fun);
    template<InputRange R>
      requires ViewableRange<R> && Constructible<V, all_view<R>>
    constexpr transform_view(R&& r, F fun);

    constexpr V base() const;

    constexpr iterator<false> begin();
    constexpr iterator<true> begin() const
      requires Range<const V> &&
               RegularInvocable<const F&, iter_reference_t<iterator_t<const V>>>;

    constexpr sentinel<false> end();
    constexpr iterator<false> end() requires CommonRange<V>;
    constexpr sentinel<true> end() const
      requires Range<const V> &&
               RegularInvocable<const F&, iter_reference_t<iterator_t<const V>>>;
    constexpr iterator<true> end() const
      requires CommonRange<const V> &&
               RegularInvocable<const F&, iter_reference_t<iterator_t<const V>>>;

    constexpr auto size() requires SizedRange<V> { return ranges::size(base_); }
    constexpr auto size() const requires SizedRange<const V>
    { return ranges::size(base_); }
  };

  template<class R, class F>
    transform_view(R&&, F) -> transform_view<all_view<R>, F>;
}

🔗

constexpr transform_view(V base, F fun);

Effects: Initializes base_ with std::move(base) and fun_ with std::move(fun).

🔗

template<InputRange R>
  requires ViewableRange<R> && Constructible<V, all_view<R>>
constexpr transform_view(R&& r, F fun);

Effects: Initializes base_ with view::all(std::forward<R>(r)) and fun_ with std::move(fun).

🔗

constexpr V base() const;

Effects: Equivalent to: return base_;

🔗

constexpr iterator<false> begin();

Effects: Equivalent to:

return iterator<false>{*this, ranges::begin(base_)};

🔗

constexpr iterator<true> begin() const
  requires Range<const V> &&
           RegularInvocable<const F&, iter_reference_t<iterator_t<const V>>>;

Effects: Equivalent to:

return iterator<true>{*this, ranges::begin(base_)};

🔗

constexpr sentinel<false> end();

Effects: Equivalent to:

return sentinel<false>{ranges::end(base_)};

🔗

constexpr iterator<false> end() requires CommonRange<V>;

Effects: Equivalent to:

return iterator<false>{*this, ranges::end(base_)};

🔗

constexpr sentinel<true> end() const
  requires Range<const V> &&
           RegularInvocable<const F&, iter_reference_t<iterator_t<const V>>>;

Effects: Equivalent to:

return sentinel<true>{ranges::end(base_)};

🔗

constexpr iterator<true> end() const
  requires CommonRange<const V> &&
           RegularInvocable<const F&, iter_reference_t<iterator_t<const V>>>;

Effects: Equivalent to:

return iterator<true>{*this, ranges::end(base_)};

23.7.5.3 Class template transform_view::iterator [range.transform.iterator]

namespace std::ranges {
  template<class V, class F>
  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&, iter_reference_t<iterator_t<Base>>>>;
    using difference_type   = iter_difference_t<iterator_t<Base>>;

    iterator() = default;
    constexpr iterator(Parent& parent, iterator_t<Base> current);
    constexpr iterator(iterator<!Const> i)
      requires Const && ConvertibleTo<iterator_t<V>, iterator_t<Base>>;

    constexpr iterator_t<Base> base() const;
    constexpr decltype(auto) operator*() const
    { return invoke(*parent_->fun_, *current_); }

    constexpr iterator& operator++();
    constexpr void operator++(int);
    constexpr iterator operator++(int) requires ForwardRange<Base>;

    constexpr iterator& operator--() requires BidirectionalRange<Base>;
    constexpr iterator operator--(int) requires BidirectionalRange<Base>;

    constexpr iterator& operator+=(difference_type n)
      requires RandomAccessRange<Base>;
    constexpr iterator& operator-=(difference_type n)
      requires RandomAccessRange<Base>;
    constexpr decltype(auto) operator[](difference_type n) const
      requires RandomAccessRange<Base>
    { return invoke(*parent_->fun_, current_[n]); }

    friend constexpr bool operator==(const iterator& x, const iterator& y)
      requires EqualityComparable<iterator_t<Base>>;
    friend constexpr bool operator!=(const iterator& x, const iterator& y)
      requires EqualityComparable<iterator_t<Base>>;

    friend constexpr bool operator<(const iterator& x, const iterator& y)
      requires RandomAccessRange<Base>;
    friend constexpr bool operator>(const iterator& x, const iterator& y)
      requires RandomAccessRange<Base>;
    friend constexpr bool operator<=(const iterator& x, const iterator& y)
      requires RandomAccessRange<Base>;
    friend constexpr bool operator>=(const iterator& x, const iterator& y)
      requires RandomAccessRange<Base>;

    friend constexpr iterator operator+(iterator i, difference_type n)
      requires RandomAccessRange<Base>;
    friend constexpr iterator operator+(difference_type n, iterator i)
      requires RandomAccessRange<Base>;

    friend constexpr iterator operator-(iterator i, difference_type n)
      requires RandomAccessRange<Base>;
    friend constexpr difference_type operator-(const iterator& x, const iterator& y)
      requires RandomAccessRange<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 IndirectlySwappable<iterator_t<Base>>;
  };
}

iterator::iterator_concept is defined as follows:

(1.1)
If V models RandomAccessRange, then iterator_concept denotes random_access_iterator_tag.
(1.2)
Otherwise, if V models BidirectionalRange, then iterator_concept denotes bidirectional_iterator_tag.
(1.3)
Otherwise, if V models ForwardRange, then iterator_concept denotes forward_iterator_tag.
(1.4)
Otherwise, iterator_concept denotes input_iterator_tag.

Let C denote the type iterator_traits<iterator_t<Base>>::iterator_category.

If C models DerivedFrom<contiguous_iterator_tag>, then iterator_category denotes random_access_iterator_tag; otherwise, iterator_category denotes C.

🔗

constexpr iterator(Parent& parent, iterator_t<Base> current);

Effects: Initializes current_ with current and parent_ with addressof(parent).

🔗

constexpr iterator(iterator<!Const> i)
  requires Const && ConvertibleTo<iterator_t<V>, iterator_t<Base>>;

Effects: Initializes current_ with std::move(i.current_) and parent_ with i.parent_.

🔗

constexpr iterator_t<Base> base() const;

Effects: Equivalent to: return current_;

🔗

constexpr iterator& operator++();

Effects: Equivalent to:

++current_;
return *this;

🔗

constexpr void operator++(int);

Effects: Equivalent to ++current_.

🔗

constexpr iterator operator++(int) requires ForwardRange<Base>;

Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

🔗

constexpr iterator& operator--() requires BidirectionalRange<Base>;

Effects: Equivalent to:

--current_;
return *this;

🔗

constexpr iterator operator--(int) requires BidirectionalRange<Base>;

Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

🔗

constexpr iterator& operator+=(difference_type n)
  requires RandomAccessRange<Base>;

Effects: Equivalent to:

current_ += n;
return *this;

🔗

constexpr iterator& operator-=(difference_type n)
  requires RandomAccessRange<Base>;

Effects: Equivalent to:

current_ -= n;
return *this;

🔗

friend constexpr bool operator==(const iterator& x, const iterator& y)
  requires EqualityComparable<iterator_t<Base>>;

Effects: Equivalent to: return x.current_ == y.current_;

🔗

friend constexpr bool operator!=(const iterator& x, const iterator& y)
  requires EqualityComparable<iterator_t<Base>>;

Effects: Equivalent to: return !(x == y);

🔗

friend constexpr bool operator<(const iterator& x, const iterator& y)
  requires RandomAccessRange<Base>;

Effects: Equivalent to: return x.current_ < y.current_;

🔗

friend constexpr bool operator>(const iterator& x, const iterator& y)
  requires RandomAccessRange<Base>;

Effects: Equivalent to: return y < x;

🔗

friend constexpr bool operator<=(const iterator& x, const iterator& y)
  requires RandomAccessRange<Base>;

Effects: Equivalent to: return !(y < x);

🔗

friend constexpr bool operator>=(const iterator& x, const iterator& y)
  requires RandomAccessRange<Base>;

Effects: Equivalent to: return !(x < y);

🔗

friend constexpr iterator operator+(iterator i, difference_type n)
  requires RandomAccessRange<Base>;
friend constexpr iterator operator+(difference_type n, iterator i)
  requires RandomAccessRange<Base>;

Effects: Equivalent to: return iterator{*i.parent_, i.current_ + n};

🔗

friend constexpr iterator operator-(iterator i, difference_type n)
  requires RandomAccessRange<Base>;

Effects: Equivalent to: return iterator{*i.parent_, i.current_ - n};

🔗

friend constexpr difference_type operator-(const iterator& x, const iterator& y)
  requires RandomAccessRange<Base>;

Effects: Equivalent to: return x.current_ - y.current_;

🔗

friend constexpr void iter_swap(const iterator& x, const iterator& y)
  noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
  requires IndirectlySwappable<iterator_t<Base>>;

Effects: Equivalent to ranges::iter_swap(x.current_, y.current_).

23.7.5.4 Class template transform_view::sentinel [range.transform.sentinel]

namespace std::ranges {
  template<class V, class F>
  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 && ConvertibleTo<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 bool operator==(const sentinel& x, const iterator<Const>& y);
    friend constexpr bool operator!=(const iterator<Const>& x, const sentinel& y);
    friend constexpr bool operator!=(const sentinel& x, const iterator<Const>& y);

    friend constexpr iter_difference_t<iterator_t<Base>>
      operator-(const iterator<Const>& x, const sentinel& y)
        requires SizedSentinel<sentinel_t<Base>, iterator_t<Base>>;
    friend constexpr iter_difference_t<iterator_t<Base>>
      operator-(const sentinel& y, const iterator<Const>& x)
        requires SizedSentinel<sentinel_t<Base>, iterator_t<Base>>;
  };
}

🔗

constexpr explicit sentinel(sentinel_t<Base> end);

Effects: Initializes end_ with end.

🔗

constexpr sentinel(sentinel<!Const> i)
  requires Const && ConvertibleTo<sentinel_t<V>, sentinel_t<Base>>;

Effects: Initializes end_ with std::move(i.end_).

🔗

constexpr sentinel_t<Base> base() const;

Effects: Equivalent to: return end_;

🔗

friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);

Effects: Equivalent to: return x.current_ == y.end_;

🔗

friend constexpr bool operator==(const sentinel& x, const iterator<Const>& y);

Effects: Equivalent to: return y == x;

🔗

friend constexpr bool operator!=(const iterator<Const>& x, const sentinel& y);

Effects: Equivalent to: return !(x == y);

🔗

friend constexpr bool operator!=(const sentinel& x, const iterator<Const>& y);

Effects: Equivalent to: return !(y == x);

🔗

friend constexpr iter_difference_t<iterator_t<Base>>
  operator-(const iterator<Const>& x, const sentinel& y)
    requires SizedSentinel<sentinel_t<Base>, iterator_t<Base>>;

Effects: Equivalent to: return x.current_ - y.end_;

🔗

friend constexpr iter_difference_t<iterator_t<Base>>
  operator-(const sentinel& y, const iterator<Const>& x)
    requires SizedSentinel<sentinel_t<Base>, iterator_t<Base>>;

Effects: Equivalent to: return x.end_ - y.current_;

23.7.5.5 view::transform [range.transform.adaptor]

The name view::transform denotes a range adaptor object ([range.adaptor.object]).

For some subexpressions E and F, the expression view::transform(E, F) is expression-equivalent to transform_view{E, F}.

23.7.6 Take view [range.take]

23.7.6.1 Overview [range.take.overview]

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.

[ Example

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

]

23.7.6.2 Class template take_view [range.take.view]

namespace std::ranges {
  template<View V>
  class take_view : public view_interface<take_view<V>> {
  private:
    V base_ = V();                                      // exposition only
    iter_difference_t<iterator_t<V>> count_ = 0;        // exposition only
    template<bool> struct sentinel;                     // exposition only
  public:
    take_view() = default;
    constexpr take_view(V base, iter_difference_t<iterator_t<V>> count);
    template<ViewableRange R>
      requires Constructible<V, all_view<R>>
    constexpr take_view(R&& r, iter_difference_t<iterator_t<V>> count);

    constexpr V base() const;

    constexpr auto begin() requires (!simple-view<V>) {
      if constexpr (SizedRange<V>) {
        if constexpr (RandomAccessRange<V>)
          return ranges::begin(base_);
        else
          return counted_iterator{ranges::begin(base_), size()};
      } else
        return counted_iterator{ranges::begin(base_), count_};
    }

    constexpr auto begin() const requires Range<const V> {
      if constexpr (SizedRange<const V>) {
        if constexpr (RandomAccessRange<const V>)
          return ranges::begin(base_);
        else
          return counted_iterator{ranges::begin(base_), size()};
      } else
        return counted_iterator{ranges::begin(base_), count_};
    }

    constexpr auto end() requires (!simple-view<V>) {
      if constexpr (SizedRange<V>) {
        if constexpr (RandomAccessRange<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 (SizedRange<const V>) {
        if constexpr (RandomAccessRange<const V>)
          return ranges::begin(base_) + size();
        else
          return default_sentinel;
      } else
        return sentinel<true>{ranges::end(base_)};
    }

    constexpr auto size() requires SizedRange<V> {
      auto n = ranges::size(base_);
      return ranges::min(n, static_cast<decltype(n)>(count_));
    }

    constexpr auto size() const requires SizedRange<const V> {
      auto n = ranges::size(base_);
      return ranges::min(n, static_cast<decltype(n)>(count_));
    }
  };

  template<Range R>
    take_view(R&&, iter_difference_t<iterator_t<R>>)
      -> take_view<all_view<R>>;
}

🔗

constexpr take_view(V base, iter_difference_t<iterator_t<V>> count);

Effects: Initializes base_ with std::move(base) and count_ with count.

🔗

template<ViewableRange R>
  requires Constructible<V, all_view<R>>
constexpr take_view(R&& r, iter_difference_t<iterator_t<V>> count);

Effects: Initializes base_ with view::all(std::forward<R>(r)) and count_ with count.

🔗

constexpr V base() const;

Effects: Equivalent to: return base_;

23.7.6.3 Class template take_view::sentinel [range.take.sentinel]

namespace std::ranges {
  template<class 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 && ConvertibleTo<sentinel_t<V>, sentinel_t<Base>>;

    constexpr sentinel_t<Base> base() const;

    friend constexpr bool operator==(const sentinel& x, const CI& y);
    friend constexpr bool operator==(const CI& y, const sentinel& x);
    friend constexpr bool operator!=(const sentinel& x, const CI& y);
    friend constexpr bool operator!=(const CI& y, const sentinel& x);
  };
}

🔗

constexpr explicit sentinel(sentinel_t<Base> end);

Effects: Initializes end_ with end.

🔗

constexpr sentinel(sentinel<!Const> s)
  requires Const && ConvertibleTo<sentinel_t<V>, sentinel_t<Base>>;

Effects: Initializes end_ with std::move(s.end_).

🔗

constexpr sentinel_t<Base> base() const;

Effects: Equivalent to: return end_;

🔗

friend constexpr bool operator==(const sentinel& x, const CI& y);
friend constexpr bool operator==(const CI& y, const sentinel& x);

Effects: Equivalent to: return y.count() == 0 || y.base() == x.end_;

🔗

friend constexpr bool operator!=(const sentinel& x, const CI& y);
friend constexpr bool operator!=(const CI& y, const sentinel& x);

Effects: Equivalent to: return !(x == y);

23.7.6.4 view::take [range.take.adaptor]

The name view::take denotes a range adaptor object .

For some subexpressions E and F, the expression view::take(E, F) is expression-equivalent to take_view{E, F}.

23.7.7 Join view [range.join]

23.7.7.1 Overview [range.join.overview]

join_view flattens a View of ranges into a View.

[ Example

vector<string> ss{"hello", " ", "world", "!"};
join_view greeting{ss};
for (char ch : greeting)
  cout << ch; // prints: hello world!

— end example

]

23.7.7.2 Class template join_view [range.join.view]

namespace std::ranges {
  template<InputRange V>
    requires View<V> && InputRange<iter_reference_t<iterator_t<V>>> &&
             (is_reference_v<iter_reference_t<iterator_t<V>>> ||
              View<iter_value_t<iterator_t<V>>>)
  class join_view : public view_interface<join_view<V>> {
  private:
    using InnerRng =                    // exposition only
      iter_reference_t<iterator_t<V>>;
    template<bool Const>
      struct iterator;                  // exposition only
    template<bool Const>
      struct sentinel;                  // exposition only

    V base_ = V();                      // exposition only
    all_view<InnerRng> inner_ =         // exposition only, present only when !is_reference_v<InnerRng>
      all_view<InnerRng>();
  public:
    join_view() = default;
    constexpr explicit join_view(V base);

    template<InputRange R>
      requires ViewableRange<R> && Constructible<V, all_view<R>>
    constexpr explicit join_view(R&& r);

    constexpr auto begin() {
      return iterator<simple-view<V>>{*this, ranges::begin(base_)};
    }

    constexpr auto begin() const
    requires InputRange<const V> &&
             is_reference_v<iter_reference_t<iterator_t<const V>>> {
      return iterator<true>{*this, ranges::begin(base_)};
    }

    constexpr auto end() {
      if constexpr (ForwardRange<V> &&
                    is_reference_v<InnerRng> && ForwardRange<InnerRng> &&
                    CommonRange<V> && CommonRange<InnerRng>)
        return iterator<simple-view<V>>{*this, ranges::end(base_)};
      else
        return sentinel<simple-view<V>>{*this};
    }

    constexpr auto end() const
    requires InputRange<const V> &&
             is_reference_v<iter_reference_t<iterator_t<const V>>> {
      if constexpr (ForwardRange<const V> &&
                    is_reference_v<iter_reference_t<iterator_t<const V>>> &&
                    ForwardRange<iter_reference_t<iterator_t<const V>>> &&
                    CommonRange<const V> &&
                    CommonRange<iter_reference_t<iterator_t<const V>>>)
        return iterator<true>{*this, ranges::end(base_)};
      else
        return sentinel<true>{*this};
    }
  };

  template<class R>
    explicit join_view(R&&) -> join_view<all_view<R>>;
}

🔗

constexpr explicit join_view(V base);

Effects: Initializes base_ with std::move(base).

🔗

template<InputRange R>
  requires ViewableRange<R> && Constructible<V, all_view<R>>
constexpr explicit join_view(R&& r);

Effects: Initializes base_ with view::all(std::forward<R>(r)).

23.7.7.3 Class template join_view::iterator [range.join.iterator]

namespace std::ranges {
template<class 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<iter_reference_t<iterator_t<Base>>>;

    iterator_t<Base> outer_ = iterator_t<Base>();               // exposition only
    iterator_t<iter_reference_t<iterator_t<Base>>> inner_ =     // exposition only
      iterator_t<iter_reference_t<iterator_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        =
      iter_value_t<iterator_t<iter_reference_t<iterator_t<Base>>>>;
    using difference_type   = see below;

    iterator() = default;
    constexpr iterator(Parent& parent, iterator_t<V> outer);
    constexpr iterator(iterator<!Const> i)
      requires Const &&
               ConvertibleTo<iterator_t<V>, iterator_t<Base>> &&
               ConvertibleTo<iterator_t<InnerRng>,
                             iterator_t<iter_reference_t<iterator_t<Base>>>>;

    constexpr decltype(auto) operator*() const { return *inner_; }

    constexpr iterator_t<Base> operator->() const
      requires has-arrow<iterator_t<Base>>;

    constexpr iterator& operator++();
    constexpr void operator++(int);
    constexpr iterator operator++(int)
      requires ref_is_glvalue && ForwardRange<Base> &&
               ForwardRange<iter_reference_t<iterator_t<Base>>>;

    constexpr iterator& operator--()
      requires ref_is_glvalue && BidirectionalRange<Base> &&
               BidirectionalRange<iter_reference_t<iterator_t<Base>>>;

    constexpr iterator operator--(int)
      requires ref_is_glvalue && BidirectionalRange<Base> &&
               BidirectionalRange<iter_reference_t<iterator_t<Base>>>;

    friend constexpr bool operator==(const iterator& x, const iterator& y)
      requires ref_is_glvalue && EqualityComparable<iterator_t<Base>> &&
               EqualityComparable<iterator_t<iter_reference_t<iterator_t<Base>>>>;

    friend constexpr bool operator!=(const iterator& x, const iterator& y)
      requires ref_is_glvalue && EqualityComparable<iterator_t<Base>> &&
               EqualityComparable<iterator_t<iter_reference_t<iterator_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:

(2.1)
If ref_is_glvalue is true,
- (2.1.1)
  If Base and iter_reference_t<iterator_t<Base>> each model BidirectionalRange, then iterator_concept denotes bidirectional_iterator_tag.
- (2.1.2)
  Otherwise, if Base and iter_reference_t<iterator_t<Base>> each model ForwardRange, then iterator_concept denotes forward_iterator_tag.
(2.2)
Otherwise, iterator_concept denotes input_iterator_tag.

iterator::iterator_category is defined as follows:

(3.1)
Let OUTERC denote iterator_traits<iterator_t<Base>>::iterator_category, and let INNERC denote iterator_traits<iterator_t<iter_reference_t<iterator_t<Base>>>>::iterator_category.
(3.2)
If ref_is_glvalue is true,
- (3.2.1)
  If OUTERC and INNERC each model DerivedFrom<bidirectional_iterator_tag>, iterator_category denotes bidirectional_iterator_tag.
- (3.2.2)
  Otherwise, if OUTERC and INNERC each model DerivedFrom<forward_iterator_tag>, iterator_category denotes forward_iterator_tag.
(3.3)
Otherwise, iterator_category denotes input_iterator_tag.

iterator::difference_type denotes the type:

common_type_t<
  iter_difference_t<iterator_t<Base>>,
  iter_difference_t<iterator_t<iter_reference_t<iterator_t<Base>>>>>

join_view iterators use the satisfy function to skip over empty inner ranges.

🔗

constexpr void satisfy();       // exposition only

Effects: Equivalent to:

auto update_inner = [this](iter_reference_t<iterator_t<Base>> x) -> decltype(auto) {
  if constexpr (ref_is_glvalue) // x is a reference
    return (x);                 // (x) is an lvalue
  else
    return (parent_->inner_ = view::all(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<iter_reference_t<iterator_t<Base>>>();

🔗

constexpr iterator(Parent& parent, iterator_t<V> outer)

Effects: Initializes outer_ with outer and parent_ with addressof(parent); then calls satisfy().

🔗

constexpr iterator(iterator<!Const> i)
  requires Const &&
           ConvertibleTo<iterator_t<V>, iterator_t<Base>> &&
           ConvertibleTo<iterator_t<InnerRng>,
                         iterator_t<iter_reference_t<iterator_t<Base>>>>;

Effects: Initializes outer_ with std::move(i.outer_), inner_ with std::move(i.inner_), and parent_ with i.parent_.

🔗

constexpr iterator_t<Base> operator->() const
  requires has-arrow<iterator_t<Base>>;

Effects: Equivalent to return inner_;

🔗

constexpr iterator& operator++();

Let inner-range be:

(10.1)
If ref_is_glvalue is true, *outer_.
(10.2)
Otherwise, parent_->inner_.

Effects: Equivalent to:

auto&& inner_rng = inner-range;
if (++inner_ == ranges::end(inner_rng)) {
  ++outer_;
  satisfy();
}
return *this;

🔗

constexpr void operator++(int);

Effects: Equivalent to: ++*this.

🔗

constexpr iterator operator++(int)
  requires ref_is_glvalue && ForwardRange<Base> &&
           ForwardRange<iter_reference_t<iterator_t<Base>>>;

Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

🔗

constexpr iterator& operator--()
  requires ref_is_glvalue && BidirectionalRange<Base> &&
           BidirectionalRange<iter_reference_t<iterator_t<Base>>>;

Effects: Equivalent to:

if (outer_ == ranges::end(parent_->base_))
  inner_ = ranges::end(*--outer_);
while (inner_ == ranges::begin(*outer_))
  inner_ = ranges::end(*--outer_);
--inner_;
return *this;

🔗

constexpr iterator operator--(int)
  requires ref_is_glvalue && BidirectionalRange<Base> &&
           BidirectionalRange<iter_reference_t<iterator_t<Base>>>;

Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

🔗

friend constexpr bool operator==(const iterator& x, const iterator& y)
  requires ref_is_glvalue && EqualityComparable<iterator_t<Base>> &&
           EqualityComparable<iterator_t<iter_reference_t<iterator_t<Base>>>>;

Effects: Equivalent to: return x.outer_ == y.outer_ && x.inner_ == y.inner_;

🔗

friend constexpr bool operator!=(const iterator& x, const iterator& y)
  requires ref_is_glvalue && EqualityComparable<iterator_t<Base>> &&
           EqualityComparable<iterator_t<iter_reference_t<iterator_t<Base>>>>;

Effects: Equivalent to: return !(x == y);

🔗

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_);

23.7.7.4 Class template join_view::sentinel [range.join.sentinel]

namespace std::ranges {
  template<class 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 && ConvertibleTo<sentinel_t<V>, sentinel_t<Base>>;

    friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);
    friend constexpr bool operator==(const sentinel& x, const iterator<Const>& y);
    friend constexpr bool operator!=(const iterator<Const>& x, const sentinel& y);
    friend constexpr bool operator!=(const sentinel& x, const iterator<Const>& y);
  };
}

🔗

constexpr explicit sentinel(Parent& parent);

Effects: Initializes end_ with ranges::end(parent.base_).

🔗

constexpr sentinel(sentinel<!Const> s)
  requires Const && ConvertibleTo<sentinel_t<V>, sentinel_t<Base>>;

Effects: Initializes end_ with std::move(s.end_).

🔗

friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);

Effects: Equivalent to: return x.outer_ == y.end_;

🔗

friend constexpr bool operator==(const sentinel& x, const iterator<Const>& y);

Effects: Equivalent to: return y == x;

🔗

friend constexpr bool operator!=(const iterator<Const>& x, const sentinel& y);

Effects: Equivalent to: return !(x == y);

🔗

friend constexpr bool operator!=(const sentinel& x, const iterator<Const>& y);

Effects: Equivalent to: return !(y == x);

23.7.7.5 view::join [range.join.adaptor]

The name view::join denotes a range adaptor object .

For some subexpression E, the expression view::join(E) is expression-equivalent to join_view{E}.

23.7.8 Split view [range.split]

23.7.8.1 Overview [range.split.overview]

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.

[ Example

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

]

23.7.8.2 Class template split_view [range.split.view]

namespace std::ranges {
  template<auto> struct require-constant;       // exposition only

  template<class R>
  concept tiny-range =                          // exposition only
    SizedRange<R> &&
    requires { typename require-constant<remove_reference_t<R>::size()>; } &&
    (remove_reference_t<R>::size() <= 1);

  template<InputRange V, ForwardRange Pattern>
    requires View<V> && View<Pattern> &&
             IndirectlyComparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to<>> &&
             (ForwardRange<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 !ForwardRange<V>
    template<bool> struct outer_iterator;       // exposition only
    template<bool> struct inner_iterator;       // exposition only
  public:
    split_view() = default;
    constexpr split_view(V base, Pattern pattern);

    template<InputRange R, ForwardRange P>
      requires Constructible<V, all_view<R>> &&
               Constructible<Pattern, all_view<P>>
    constexpr split_view(R&& r, P&& p);

    template<InputRange R>
      requires Constructible<V, all_view<R>> &&
               Constructible<Pattern, single_view<iter_value_t<iterator_t<R>>>>
    constexpr split_view(R&& r, iter_value_t<iterator_t<R>> e);

    constexpr auto begin() {
      if constexpr (ForwardRange<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 ForwardRange<V> && ForwardRange<const V> {
      return outer_iterator<true>{*this, ranges::begin(base_)};
    }

    constexpr auto end() requires ForwardRange<V> && CommonRange<V> {
      return outer_iterator<simple-view<V>>{*this, ranges::end(base_)};
    }

    constexpr auto end() const {
      if constexpr (ForwardRange<V> && ForwardRange<const V> && CommonRange<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<all_view<R>, all_view<P>>;

  template<InputRange R>
    split_view(R&&, iter_value_t<iterator_t<R>>)
      -> split_view<all_view<R>, single_view<iter_value_t<iterator_t<R>>>>;
}

🔗

constexpr split_view(V base, Pattern pattern);

Effects: Initializes base_ with std::move(base), and pattern_ with std::move(pattern).

🔗

template<InputRange R, ForwardRange P>
  requires Constructible<V, all_view<R>> &&
           Constructible<Pattern, all_view<P>>
constexpr split_view(R&& r, P&& p);

Effects: Initializes base_ with view::all(std::forward<R>(r)) and pattern_ with view::all(std::forward<P>(p)).

🔗

template<InputRange R>
  requires Constructible<V, all_view<R>> &&
           Constructible<Pattern, single_view<iter_value_t<iterator_t<R>>>>
constexpr split_view(R&& r, iter_value_t<iterator_t<R>> e);

Effects: Initializes base_ with view::all(std::forward<R>(r)) and pattern_ with single_view{std::move(e)}.

23.7.8.3 Class template split_view::outer_iterator [range.split.outer]

namespace std::ranges {
  template<class V, class 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 ForwardRange
      iterator_t<Base>();

  public:
    using iterator_concept  =
      conditional_t<ForwardRange<Base>, forward_iterator_tag, input_iterator_tag>;
    using iterator_category = input_iterator_tag;
    struct value_type;                                  // see [range.split.outer.value]
    using difference_type   = iter_difference_t<iterator_t<Base>>;

    outer_iterator() = default;
    constexpr explicit outer_iterator(Parent& parent)
      requires (!ForwardRange<Base>);
    constexpr outer_iterator(Parent& parent, iterator_t<Base> current)
      requires ForwardRange<Base>;
    constexpr outer_iterator(outer_iterator<!Const> i)
      requires Const && ConvertibleTo<iterator_t<V>, iterator_t<const V>>;

    constexpr value_type operator*() const;

    constexpr outer_iterator& operator++();
    constexpr decltype(auto) operator++(int) {
      if constexpr (ForwardRange<Base>) {
        auto tmp = *this;
        ++*this;
        return tmp;
      } else
        ++*this;
    }

    friend constexpr bool operator==(const outer_iterator& x, const outer_iterator& y)
      requires ForwardRange<Base>;
    friend constexpr bool operator!=(const outer_iterator& x, const outer_iterator& y)
      requires ForwardRange<Base>;

    friend constexpr bool operator==(const outer_iterator& x, default_sentinel_t);
    friend constexpr bool operator==(default_sentinel_t, const outer_iterator& x);
    friend constexpr bool operator!=(const outer_iterator& x, default_sentinel_t y);
    friend constexpr bool operator!=(default_sentinel_t y, const outer_iterator& x);
  };
}

Many of the following specifications refer to the notional member current of outer_iterator.

current is equivalent to current_ if V models ForwardRange, and parent_->current_ otherwise.

🔗

constexpr explicit outer_iterator(Parent& parent)
  requires (!ForwardRange<Base>);

Effects: Initializes parent_ with addressof(parent).

🔗

constexpr outer_iterator(Parent& parent, iterator_t<Base> current)
  requires ForwardRange<Base>;

Effects: Initializes parent_ with addressof(parent) and current_ with current.

🔗

constexpr outer_iterator(outer_iterator<!Const> i)
  requires Const && ConvertibleTo<iterator_t<V>, iterator_t<const V>>;

Effects: Initializes parent_ with i.parent_ and current_ with std::move(i.current_).

🔗

constexpr value_type operator*() const;

Effects: Equivalent to: return value_type{*this};

🔗

constexpr outer_iterator& operator++();

Effects: Equivalent to:

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 {
    const auto [b, p] = ranges::mismatch(current, end, pbegin, pend);
    if (p == pend) {
      current = b;  // The pattern matched; skip it
      break;
    }
  } while (++current != end);
}
return *this;

🔗

friend constexpr bool operator==(const outer_iterator& x, const outer_iterator& y)
  requires ForwardRange<Base>;

Effects: Equivalent to: return x.current_ == y.current_;

🔗

friend constexpr bool operator!=(const outer_iterator& x, const outer_iterator& y)
  requires ForwardRange<Base>;

Effects: Equivalent to: return !(x == y);

🔗

friend constexpr bool operator==(const outer_iterator& x, default_sentinel_t);
friend constexpr bool operator==(default_sentinel_t, const outer_iterator& x);

Effects: Equivalent to: return x.current == ranges::end(x.parent_->base_);

🔗

friend constexpr bool operator!=(const outer_iterator& x, default_sentinel_t y);
friend constexpr bool operator!=(default_sentinel_t y, const outer_iterator& x);

Effects: Equivalent to: return !(x == y);

23.7.8.4 Class split_view::outer_iterator::value_type [range.split.outer.value]

namespace std::ranges {
  template<class V, class Pattern>
  template<bool Const>
  struct split_view<V, Pattern>::outer_iterator<Const>::value_type {
  private:
    outer_iterator i_ = outer_iterator();               // exposition only
  public:
    value_type() = default;
    constexpr explicit value_type(outer_iterator i);

    constexpr inner_iterator<Const> begin() const;
    constexpr default_sentinel_t end() const;
  };
}

🔗

constexpr explicit value_type(outer_iterator i);

Effects: Initializes i_ with i.

🔗

constexpr inner_iterator<Const> begin() const;

Effects: Equivalent to: return inner_iterator<Const>{i_};

🔗

constexpr default_sentinel_t end() const;

Effects: Equivalent to: return default_sentinel;

23.7.8.5 Class template split_view::inner_iterator [range.split.inner]

namespace std::ranges {
  template<class V, class 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        = iter_value_t<iterator_t<Base>>;
    using difference_type   = iter_difference_t<iterator_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 (ForwardRange<V>) {
        auto tmp = *this;
        ++*this;
        return tmp;
      } else
        ++*this;
    }

    friend constexpr bool operator==(const inner_iterator& x, const inner_iterator& y)
      requires ForwardRange<Base>;
    friend constexpr bool operator!=(const inner_iterator& x, const inner_iterator& y)
      requires ForwardRange<Base>;

    friend constexpr bool operator==(const inner_iterator& x, default_sentinel_t);
    friend constexpr bool operator==(default_sentinel_t, const inner_iterator& x);
    friend constexpr bool operator!=(const inner_iterator& x, default_sentinel_t y);
    friend constexpr bool operator!=(default_sentinel_t y, const inner_iterator& x);

    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 IndirectlySwappable<iterator_t<Base>>;
  };
}

The typedef-name iterator_category denotes forward_iterator_tag if iterator_traits<iterator_t<Base>>::iterator_category models DerivedFrom<forward_iterator_tag>, and input_iterator_tag otherwise.

🔗

constexpr explicit inner_iterator(outer_iterator<Const> i);

Effects: Initializes i_ with i.

🔗

constexpr inner_iterator& operator++() const;

Effects: Equivalent to:

incremented_ = true;
if constexpr (!ForwardRange<Base>) {
  if constexpr (Pattern::size() == 0) {
    return *this;
  }
}
++i_.current;
return *this;

🔗

friend constexpr bool operator==(const inner_iterator& x, const inner_iterator& y)
  requires ForwardRange<Base>;

Effects: Equivalent to: return x.i_.current_ == y.i_.current_;

🔗

friend constexpr bool operator!=(const inner_iterator& x, const inner_iterator& y)
  requires ForwardRange<Base>;

Effects: Equivalent to: return !(x == y);

🔗

friend constexpr bool operator==(const inner_iterator& x, default_sentinel_t);
friend constexpr bool operator==(default_sentinel_t, const inner_iterator& x);

Effects: Equivalent to:

auto cur = x.i_.current;
auto end = ranges::end(x.i_.parent_->base_);
if (cur == end) return true;
auto [pcur, pend] = subrange{x.i_.parent_->pattern_};
if (pcur == pend) return x.incremented_;
do {
  if (*cur != *pcur) return false;
  if (++pcur == pend) return true;
} while (++cur != end);
return false;

🔗

friend constexpr bool operator!=(const inner_iterator& x, default_sentinel_t y);
friend constexpr bool operator!=(default_sentinel_t y, const inner_iterator& x);

Effects: Equivalent to: return !(x == y);

🔗

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 IndirectlySwappable<iterator_t<Base>>;

Effects: Equivalent to ranges::iter_swap(x.i_.current, y.i_.current).

23.7.8.6 view::split [range.split.adaptor]

The name view::split denotes a range adaptor object .

For some subexpressions E and F, the expression view::split(E, F) is expression-equivalent to split_view{E, F}.

23.7.9 Counted view [range.counted]

The name view::counted denotes a customization point object .

Let E and F be expressions, and let T be decay_t<decltype((E))>.

Then the expression view::counted(E, F) is expression-equivalent to:

(1.1)
If T models Iterator and decltype((F)) models ConvertibleTo<iter_difference_t<T>>,
- (1.1.1)
  subrange{E, E + static_cast<iter_difference_t<T>>(F)} if T models RandomAccessIterator.
- (1.1.2)
  Otherwise, subrange{counted_iterator{E, F}, default_sentinel}.
(1.2)
Otherwise, view::counted(E, F) is ill-formed.

[ Note
:
This case can result in substitution failure when view::counted(E, F) appears in the immediate context of a template instantiation.
— end note
]

23.7.10 Common view [range.common]

23.7.10.1 Overview [range.common.overview]

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

common_view is useful for calling legacy algorithms that expect a range's iterator and sentinel types to be the same.

— end note

]

[ Example

// Legacy algorithm:
template<class ForwardIterator>
size_t count(ForwardIterator first, ForwardIterator last);

template<ForwardRange R>
void my_algo(R&& r) {
  auto&& common = common_view{r};
  auto cnt = count(common.begin(), common.end());
  // ...
}

— end example

]

23.7.10.2 Class template common_view [range.common.view]

namespace std::ranges {
  template<View V>
    requires (!CommonRange<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<ViewableRange R>
      requires (!CommonRange<R> && Constructible<V, all_view<R>>)
    constexpr explicit common_view(R&& r);

    constexpr V base() const;

    constexpr auto size() requires SizedRange<V> {
      return ranges::size(base_);
    }
    constexpr auto size() const requires SizedRange<const V> {
      return ranges::size(base_);
    }

    constexpr auto begin() {
      if constexpr (RandomAccessRange<V> && SizedRange<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 (RandomAccessRange<const V> && SizedRange<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 (RandomAccessRange<V> && SizedRange<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 (RandomAccessRange<const V> && SizedRange<const V>)
        return ranges::begin(base_) + ranges::size(base_);
      else
        return common_iterator<iterator_t<const V>, sentinel_t<const V>>(ranges::end(base_));
    }
  };

  template<class R>
    common_view(R&&) -> common_view<all_view<R>>;
}

🔗

constexpr explicit common_view(V base);

Effects: Initializes base_ with std::move(base).

🔗

template<ViewableRange R>
  requires (!CommonRange<R> && Constructible<V, all_view<R>>)
constexpr explicit common_view(R&& r);

Effects: Initializes base_ with view::all(std::forward<R>(r)).

🔗

constexpr V base() const;

Effects: Equivalent to: return base_;

23.7.10.3 view::common [range.common.adaptor]

The name view::common denotes a range adaptor object .

For some subexpression E, the expression view::common(E) is expression-equivalent to:

(1.1)
view::all(E), if decltype((E)) models CommonRange and view::all(E) is a well-formed expression.
(1.2)
Otherwise, common_view{E}.

23.7.11 Reverse view [range.reverse]

23.7.11.1 Overview [range.reverse.overview]

reverse_view takes a bidirectional View and produces another View that iterates the same elements in reverse order.

[ Example

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

]

23.7.11.2 Class template reverse_view [range.reverse.view]

namespace std::ranges {
  template<View V>
    requires BidirectionalRange<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);

    template<ViewableRange R>
      requires BidirectionalRange<R> && Constructible<V, all_view<R>>
    constexpr explicit reverse_view(R&& r);

    constexpr V base() const;

    constexpr reverse_iterator<iterator_t<V>> begin();
    constexpr reverse_iterator<iterator_t<V>> begin() requires CommonRange<V>;
    constexpr reverse_iterator<iterator_t<const V>> begin() const
      requires CommonRange<const V>;

    constexpr reverse_iterator<iterator_t<V>> end();
    constexpr reverse_iterator<iterator_t<const V>> end() const
      requires CommonRange<const V>;

    constexpr auto size() requires SizedRange<V> {
      return ranges::size(base_);
    }
    constexpr auto size() const requires SizedRange<const V> {
      return ranges::size(base_);
    }
  };

  template<class R>
    reverse_view(R&&) -> reverse_view<all_view<R>>;
}

🔗

constexpr explicit reverse_view(V base);

Effects: Initializes base_ with std::move(base).

🔗

template<ViewableRange R>
  requires BidirectionalRange<R> && Constructible<V, all_view<R>>
constexpr explicit reverse_view(R&& r);

Effects: Initializes base_ with view::all(std::forward<R>(r)).

🔗

constexpr V base() const;

Effects: Equivalent to: return base_;

🔗

constexpr reverse_iterator<iterator_t<V>> begin();

Returns:

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.

🔗

constexpr reverse_iterator<iterator_t<V>> begin() requires CommonRange<V>;
constexpr reverse_iterator<iterator_t<const V>> begin() const
  requires CommonRange<const V>;

Effects: Equivalent to: return make_reverse_iterator(ranges::end(base_));

🔗

constexpr reverse_iterator<iterator_t<V>> end();
constexpr reverse_iterator<iterator_t<const V>> end() const
  requires CommonRange<const V>;

Effects: Equivalent to: return make_reverse_iterator(ranges::begin(base_));

23.7.11.3 view::reverse [range.reverse.adaptor]

The name view::reverse denotes a range adaptor object .

For some subexpression E, the expression view::reverse(E) is expression-equivalent to reverse_view{E}.

23 Ranges library [ranges]

23.7 Range adaptors [range.adaptors]

23.7.1 Range adaptor objects [range.adaptor.object]

23.7.2 Semiregular wrapper [range.semi.wrap]

23.7.3 All view [range.all]

23.7.3.1 ref-view [range.view.ref]

23.7.4 Filter view [range.filter]

23.7.4.1 Overview [range.filter.overview]

23.7.4.2 Class template filter_­view [range.filter.view]

23.7.4.3 Class filter_­view​::​iterator [range.filter.iterator]

23.7.4.4 Class filter_­view​::​sentinel [range.filter.sentinel]

23.7.4.5 view​::​filter [range.filter.adaptor]

23.7.5 Transform view [range.transform]

23.7.5.1 Overview [range.transform.overview]

23.7.5.2 Class template transform_­view [range.transform.view]

23.7.5.3 Class template transform_­view​::​iterator [range.transform.iterator]

23.7.5.4 Class template transform_­view​::​sentinel [range.transform.sentinel]

23.7.5.5 view​::​transform [range.transform.adaptor]

23.7.6 Take view [range.take]

23.7.6.1 Overview [range.take.overview]

23.7.6.2 Class template take_­view [range.take.view]

23.7.6.3 Class template take_­view​::​sentinel [range.take.sentinel]

23.7.6.4 view​::​take [range.take.adaptor]

23.7.7 Join view [range.join]

23.7.7.1 Overview [range.join.overview]

23.7.7.2 Class template join_­view [range.join.view]

23.7.7.3 Class template join_­view​::​iterator [range.join.iterator]

23.7.7.4 Class template join_­view​::​sentinel [range.join.sentinel]

23.7.7.5 view​::​join [range.join.adaptor]

23.7.8 Split view [range.split]

23.7.8.1 Overview [range.split.overview]

23.7.8.2 Class template split_­view [range.split.view]

23.7.8.3 Class template split_­view​::​outer_­iterator [range.split.outer]

23.7.8.4 Class split_­view​::​outer_­iterator​::​value_­type [range.split.outer.value]

23.7.8.5 Class template split_­view​::​inner_­iterator [range.split.inner]

23.7.8.6 view​::​split [range.split.adaptor]

23.7.9 Counted view [range.counted]

23.7.10 Common view [range.common]

23.7.10.1 Overview [range.common.overview]

23.7.10.2 Class template common_­view [range.common.view]

23.7.10.3 view​::​common [range.common.adaptor]

23.7.11 Reverse view [range.reverse]

23.7.11.1 Overview [range.reverse.overview]

23.7.11.2 Class template reverse_­view [range.reverse.view]

23.7.11.3 view​::​reverse [range.reverse.adaptor]

23.7.4.2 Class template filter_view [range.filter.view]

23.7.4.3 Class filter_view::iterator [range.filter.iterator]

23.7.4.4 Class filter_view::sentinel [range.filter.sentinel]

23.7.4.5 view::filter [range.filter.adaptor]

23.7.5.2 Class template transform_view [range.transform.view]

23.7.5.3 Class template transform_view::iterator [range.transform.iterator]

23.7.5.4 Class template transform_view::sentinel [range.transform.sentinel]

23.7.5.5 view::transform [range.transform.adaptor]

23.7.6.2 Class template take_view [range.take.view]

23.7.6.3 Class template take_view::sentinel [range.take.sentinel]

23.7.6.4 view::take [range.take.adaptor]

23.7.7.2 Class template join_view [range.join.view]

23.7.7.3 Class template join_view::iterator [range.join.iterator]

23.7.7.4 Class template join_view::sentinel [range.join.sentinel]

23.7.7.5 view::join [range.join.adaptor]

23.7.8.2 Class template split_view [range.split.view]

23.7.8.3 Class template split_view::outer_iterator [range.split.outer]

23.7.8.4 Class split_view::outer_iterator::value_type [range.split.outer.value]

23.7.8.5 Class template split_view::inner_iterator [range.split.inner]

23.7.8.6 view::split [range.split.adaptor]

23.7.10.2 Class template common_view [range.common.view]

23.7.10.3 view::common [range.common.adaptor]

23.7.11.2 Class template reverse_view [range.reverse.view]

23.7.11.3 view::reverse [range.reverse.adaptor]