%!TEX root = std.tex

\rSec0[ranges]{Ranges library}

\rSec1[ranges.general]{General}

\pnum

This Clause describes components for dealing with ranges of elements.

\pnum

The following subclauses describe

range and view requirements, and

components for

range primitives and range generators

as summarized in \tref{range.summary}.

\begin{libsumtab}{Ranges library summary}{range.summary}

\ref{range.access} & Range access & \tcode{<ranges>} \\

\ref{range.req} & Requirements & \\

\ref{range.utility} & Range utilities & \\

\ref{range.factories} & Range factories & \\

\ref{range.adaptors} & Range adaptors & \\ \rowsep

\ref{coro.generator} & Range generators & \libheader{generator} \\

\end{libsumtab}

\rSec1[ranges.syn]{Header \tcode{<ranges>} synopsis}

\indexheader{ranges}%

\indexlibraryglobal{all_t}%

\begin{codeblock}

// mostly freestanding

#include <compare> // see \ref{compare.syn}

#include <initializer_list> // see \ref{initializer.list.syn}

#include <iterator> // see \ref{iterator.synopsis}

namespace std::ranges {

inline namespace @\unspec@ {

// \ref{range.access}, range access

inline constexpr @\unspec@ begin = @\unspec@;

inline constexpr @\unspec@ end = @\unspec@;

inline constexpr @\unspec@ cbegin = @\unspec@;

inline constexpr @\unspec@ cend = @\unspec@;

inline constexpr @\unspec@ rbegin = @\unspec@;

inline constexpr @\unspec@ rend = @\unspec@;

inline constexpr @\unspec@ crbegin = @\unspec@;

inline constexpr @\unspec@ crend = @\unspec@;

inline constexpr @\unspec@ size = @\unspec@;

inline constexpr @\unspec@ reserve_hint = @\unspec@;

inline constexpr @\unspec@ ssize = @\unspec@;

inline constexpr @\unspec@ empty = @\unspec@;

inline constexpr @\unspec@ data = @\unspec@;

inline constexpr @\unspec@ cdata = @\unspec@;

}

// \ref{range.range}, ranges

template<class T>

concept range = @\seebelow@;

template<class T>

constexpr bool enable_borrowed_range = false;

template<class T>

concept borrowed_range = @\seebelow@;

template<class T>

using iterator_t = decltype(ranges::begin(declval<T&>()));

template<@\libconcept{range}@ R>

using sentinel_t = decltype(ranges::end(declval<R&>()));

template<@\libconcept{range}@ R>

using const_iterator_t = decltype(ranges::cbegin(declval<R&>()));

template<@\libconcept{range}@ R>

using const_sentinel_t = decltype(ranges::cend(declval<R&>()));

template<@\libconcept{range}@ R>

using range_difference_t = iter_difference_t<iterator_t<R>>;

template<@\libconcept{sized_range}@ R>

using range_size_t = decltype(ranges::size(declval<R&>()));

template<@\libconcept{range}@ R>

using range_value_t = iter_value_t<iterator_t<R>>;

template<@\libconcept{range}@ R>

using range_reference_t = iter_reference_t<iterator_t<R>>;

template<@\libconcept{range}@ R>

using range_const_reference_t = iter_const_reference_t<iterator_t<R>>;

template<@\libconcept{range}@ R>

using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R>>;

template<@\libconcept{range}@ R>

using range_common_reference_t = iter_common_reference_t<iterator_t<R>>;

// \ref{range.sized}, sized ranges

template<class>

constexpr bool disable_sized_range = false;

template<class T>

concept approximately_sized_range = @\seebelow@;

template<class T>

concept sized_range = @\seebelow@;

// \ref{range.view}, views

template<class T>

constexpr bool enable_view = @\seebelow@;

struct view_base {};

template<class T>

concept view = @\seebelow@;

// \ref{range.refinements}, other range refinements

template<class R, class T>

concept output_range = @\seebelow@;

template<class T>

concept input_range = @\seebelow@;

template<class T>

concept forward_range = @\seebelow@;

template<class T>

concept bidirectional_range = @\seebelow@;

template<class T>

concept random_access_range = @\seebelow@;

template<class T>

concept contiguous_range = @\seebelow@;

template<class T>

concept common_range = @\seebelow@;

template<class T>

concept viewable_range = @\seebelow@;

template<class T>

concept constant_range = @\seebelow@;

// \ref{view.interface}, class template \tcode{view_interface}

template<class D>

requires is_class_v<D> && @\libconcept{same_as}@<D, remove_cv_t<D>>

class view_interface;

// \ref{range.subrange}, sub-ranges

enum class @\libglobal{subrange_kind}@ : bool { @\libmember{unsized}{subrange_kind}@, @\libmember{sized}{subrange_kind}@ };

template<@\libconcept{input_or_output_iterator}@ I, @\libconcept{sentinel_for}@<I> S = I, subrange_kind K = @\seebelow@>

requires (K == subrange_kind::sized || !@\libconcept{sized_sentinel_for}@<S, I>)

class subrange;

template<class I, class S, subrange_kind K>

constexpr bool @\libspec{enable_borrowed_range}{subrange}@<subrange<I, S, K>> = true;

template<size_t N, class I, class S, subrange_kind K>

requires ((N == 0 && @\libconcept{copyable}@<I>) || N == 1)

constexpr auto get(const subrange<I, S, K>& r);

template<size_t N, class I, class S, subrange_kind K>

requires (N < 2)

constexpr auto get(subrange<I, S, K>&& r);

}

namespace std {

using ranges::get;

}

namespace std::ranges {

// \ref{range.dangling}, dangling iterator handling

struct dangling;

// \ref{range.elementsof}, class template \tcode{elements_of}

template<@\libconcept{range}@ R, class Allocator = allocator<byte>>

struct elements_of; // hosted

template<@\libconcept{range}@ R>

using borrowed_iterator_t = @\seebelow@;

template<@\libconcept{range}@ R>

using borrowed_subrange_t = @\seebelow@;

// \ref{range.utility.conv}, range conversions

template<class C, @\libconcept{input_range}@ R, class... Args> requires (!@\libconcept{view}@<C>)

constexpr C to(R&& r, Args&&... args);

template<template<class...> class C, @\libconcept{input_range}@ R, class... Args>

constexpr auto to(R&& r, Args&&... args);

template<class C, class... Args> requires (!@\libconcept{view}@<C>)

constexpr auto to(Args&&... args);

template<template<class...> class C, class... Args>

constexpr auto to(Args&&... args);

// \ref{range.empty}, empty view

template<class T>

requires is_object_v<T>

class empty_view;

template<class T>

constexpr bool @\libspec{enable_borrowed_range}{empty_view}@<empty_view<T>> = true;

namespace views {

template<class T>

constexpr empty_view<T> @\libmember{empty}{views}@{};

}

// \ref{range.single}, single view

template<@\libconcept{move_constructible}@ T>

requires is_object_v<T>

class single_view;

namespace views { inline constexpr @\unspecnc@ single = @\unspecnc@; }

template<bool Const, class T>

using @\exposidnc{maybe-const}@ = conditional_t<Const, const T, T>; // \expos

// \ref{range.iota}, iota view

template<@\libconcept{weakly_incrementable}@ W, @\libconcept{semiregular}@ Bound = unreachable_sentinel_t>

requires @\exposconcept{weakly-equality-comparable-with}@<W, Bound> && @\libconcept{copyable}@<W>

class iota_view;

template<class W, class Bound>

constexpr bool @\libspec{enable_borrowed_range}{iota_view}@<iota_view<W, Bound>> = true;

namespace views { inline constexpr @\unspecnc@ iota = @\unspecnc@; }

// \ref{range.repeat}, repeat view

template<@\libconcept{move_constructible}@ T, @\libconcept{semiregular}@ Bound = unreachable_sentinel_t>

requires @\seebelow@

class repeat_view;

namespace views { inline constexpr @\unspecnc@ repeat = @\unspecnc@; }

// \ref{range.istream}, istream view

template<@\libconcept{movable}@ Val, class CharT, class Traits = char_traits<CharT>>

requires @\seebelow@

class basic_istream_view; // hosted

template<class Val>

using istream_view = basic_istream_view<Val, char>; // hosted

template<class Val>

using wistream_view = basic_istream_view<Val, wchar_t>; // hosted

namespace views {

template<class T> constexpr @\unspecnc@ istream = @\unspecnc@; // hosted

}

// \ref{range.adaptor.object}, range adaptor objects

template<class D>

requires is_class_v<D> && @\libconcept{same_as}@<D, remove_cv_t<D>>

class range_adaptor_closure { };

// \ref{range.all}, all view

namespace views {

inline constexpr @\unspecnc@ all = @\unspecnc@;

template<@\libconcept{viewable_range}@ R>

using all_t = decltype(all(declval<R>()));

}

// \ref{range.ref.view}, ref view

template<@\libconcept{range}@ R>

requires is_object_v<R>

class ref_view;

template<class T>

constexpr bool @\libspec{enable_borrowed_range}{ref_view}@<ref_view<T>> = true;

// \ref{range.owning.view}, owning view

template<@\libconcept{range}@ R>

requires @\seebelow@

class owning_view;

template<class T>

constexpr bool @\libspec{enable_borrowed_range}{owning_view}@<owning_view<T>> =

enable_borrowed_range<T>;

// \ref{range.as.rvalue}, as rvalue view

template<@\libconcept{view}@ V>

requires @\libconcept{input_range}@<V>

class as_rvalue_view;

template<class T>

constexpr bool @\libspec{enable_borrowed_range}{as_rvalue_view}@<as_rvalue_view<T>> =

enable_borrowed_range<T>;

namespace views { inline constexpr @\unspecnc@ as_rvalue = @\unspecnc@; }

// \ref{range.filter}, filter view

template<@\libconcept{input_range}@ V, @\libconcept{indirect_unary_predicate}@<iterator_t<V>> Pred>

requires @\libconcept{view}@<V> && is_object_v<Pred>

class filter_view;

namespace views { inline constexpr @\unspecnc@ filter = @\unspecnc@; }

// \ref{range.transform}, transform view

template<@\libconcept{input_range}@ V, @\libconcept{move_constructible}@ F>

requires @\libconcept{view}@<V> && is_object_v<F> &&

@\libconcept{regular_invocable}@<F&, range_reference_t<V>> &&

@\exposconcept{can-reference}@<invoke_result_t<F&, range_reference_t<V>>>

class transform_view;

namespace views { inline constexpr @\unspecnc@ transform = @\unspecnc@; }

// \ref{range.take}, take view

template<@\libconcept{view}@> class take_view;

template<class T>

constexpr bool @\libspec{enable_borrowed_range}{take_view}@<take_view<T>> =

enable_borrowed_range<T>;

namespace views { inline constexpr @\unspecnc@ take = @\unspecnc@; }

// \ref{range.take.while}, take while view

template<@\libconcept{view}@ V, class Pred>

requires @\libconcept{input_range}@<V> && is_object_v<Pred> &&

@\libconcept{indirect_unary_predicate}@<const Pred, iterator_t<V>>

class take_while_view;

namespace views { inline constexpr @\unspecnc@ take_while = @\unspecnc@; }

// \ref{range.drop}, drop view

template<@\libconcept{view}@ V>

class drop_view;

template<class T>

constexpr bool @\libspec{enable_borrowed_range}{drop_view}@<drop_view<T>> =

enable_borrowed_range<T>;

namespace views { inline constexpr @\unspecnc@ drop = @\unspecnc@; }

// \ref{range.drop.while}, drop while view

template<@\libconcept{view}@ V, class Pred>

requires @\libconcept{input_range}@<V> && is_object_v<Pred> &&

@\libconcept{indirect_unary_predicate}@<const Pred, iterator_t<V>>

class drop_while_view;

template<class T, class Pred>

constexpr bool @\libspec{enable_borrowed_range}{drop_while_view}@<drop_while_view<T, Pred>> =

enable_borrowed_range<T>;

namespace views { inline constexpr @\unspecnc@ drop_while = @\unspecnc@; }

// \ref{range.join}, join view

template<@\libconcept{input_range}@ V>

requires @\libconcept{view}@<V> && @\libconcept{input_range}@<range_reference_t<V>>

class join_view;

namespace views { inline constexpr @\unspecnc@ join = @\unspecnc@; }

// \ref{range.join.with}, join with view

template<@\libconcept{input_range}@ V, @\libconcept{forward_range}@ Pattern>

requires @\seebelow@

class join_with_view;

namespace views { inline constexpr @\unspecnc@ join_with = @\unspecnc@; }

// \ref{range.lazy.split}, lazy split view

template<class R>

concept @\exposconcept{tiny-range}@ = @\seebelow@; // \expos

template<@\libconcept{input_range}@ V, @\libconcept{forward_range}@ Pattern>

requires @\libconcept{view}@<V> && @\libconcept{view}@<Pattern> &&

@\libconcept{indirectly_comparable}@<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&

(@\libconcept{forward_range}@<V> || @\exposconcept{tiny-range}@<Pattern>)

class lazy_split_view;

// \ref{range.split}, split view

template<@\libconcept{forward_range}@ V, @\libconcept{forward_range}@ Pattern>

requires @\libconcept{view}@<V> && @\libconcept{view}@<Pattern> &&

@\libconcept{indirectly_comparable}@<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>

class split_view;

namespace views {

inline constexpr @\unspecnc@ lazy_split = @\unspecnc@;

inline constexpr @\unspecnc@ split = @\unspecnc@;

}

// \ref{range.concat}, concat view

template<@\libconcept{input_range}@... Views>

requires @\seebelow@

class concat_view;

namespace views { inline constexpr @\unspecnc@ concat = @\unspecnc@; }

// \ref{range.counted}, counted view

namespace views { inline constexpr @\unspecnc@ counted = @\unspecnc@; }

// \ref{range.common}, common view

template<@\libconcept{view}@ V>

requires (!@\libconcept{common_range}@<V> && @\libconcept{copyable}@<iterator_t<V>>)

class common_view;

template<class T>

constexpr bool @\libspec{enable_borrowed_range}{common_view}@<common_view<T>> =

enable_borrowed_range<T>;

namespace views { inline constexpr @\unspecnc@ common = @\unspecnc@; }

// \ref{range.reverse}, reverse view

template<@\libconcept{view}@ V>

requires @\libconcept{bidirectional_range}@<V>

class reverse_view;

template<class T>

constexpr bool @\libspec{enable_borrowed_range}{reverse_view}@<reverse_view<T>> =

enable_borrowed_range<T>;

namespace views { inline constexpr @\unspecnc@ reverse = @\unspecnc@; }

// \ref{range.as.const}, as const view

template<@\libconcept{input_range}@ R>

constexpr auto& @\exposid{possibly-const-range}@(R& r) noexcept { // \expos

if constexpr (@\libconcept{input_range}@<const R>) {

return const_cast<const R&>(r);

} else {

return r;

}

}

template<@\libconcept{view}@ V>

requires @\libconcept{input_range}@<V>

class as_const_view;

template<class T>

constexpr bool @\libspec{enable_borrowed_range}{as_const_view}@<as_const_view<T>> =

enable_borrowed_range<T>;

namespace views { inline constexpr @\unspecnc@ as_const = @\unspecnc@; }

// \ref{range.elements}, elements view

template<@\libconcept{input_range}@ V, size_t N>

requires @\seebelow@

class elements_view;

template<class T, size_t N>

constexpr bool @\libspec{enable_borrowed_range}{elements_view}@<elements_view<T, N>> =

enable_borrowed_range<T>;

template<class R>

using @\libglobal{keys_view}@ = elements_view<R, 0>;

template<class R>

using @\libglobal{values_view}@ = elements_view<R, 1>;

namespace views {

template<size_t N>

constexpr @\unspecnc@ elements = @\unspecnc@;

inline constexpr auto @\libmember{keys}{views}@ = elements<0>;

inline constexpr auto @\libmember{values}{views}@ = elements<1>;

}

// \ref{range.enumerate}, enumerate view

template<@\libconcept{view}@ V>

requires @\seebelow@

class enumerate_view;

template<class View>

constexpr bool @\libspec{enable_borrowed_range}{enumerate_view}@<enumerate_view<View>> =

enable_borrowed_range<View>;

namespace views { inline constexpr @\unspecnc@ enumerate = @\unspecnc@; }

// \ref{range.zip}, zip view

template<@\libconcept{input_range}@... Views>

requires (@\libconcept{view}@<Views> && ...) && (sizeof...(Views) > 0)

class zip_view;

template<class... Views>

constexpr bool @\libspec{enable_borrowed_range}{zip_view}@<zip_view<Views...>> =

(enable_borrowed_range<Views> && ...);

namespace views { inline constexpr @\unspecnc@ zip = @\unspecnc@; }

// \ref{range.zip.transform}, zip transform view

template<@\libconcept{move_constructible}@ F, @\libconcept{input_range}@... Views>

requires (@\libconcept{view}@<Views> && ...) && (sizeof...(Views) > 0) && is_object_v<F> &&

@\libconcept{regular_invocable}@<F&, range_reference_t<Views>...> &&

@\exposconcept{can-reference}@<invoke_result_t<F&, range_reference_t<Views>...>>

class zip_transform_view;

namespace views { inline constexpr @\unspecnc@ zip_transform = @\unspecnc@; }

// \ref{range.adjacent}, adjacent view

template<@\libconcept{forward_range}@ V, size_t N>

requires @\libconcept{view}@<V> && (N > 0)

class adjacent_view;

template<class V, size_t N>

constexpr bool @\libspec{enable_borrowed_range}{adjacent_view}@<adjacent_view<V, N>> =

enable_borrowed_range<V>;

namespace views {

template<size_t N>

constexpr @\unspecnc@ adjacent = @\unspecnc@;

inline constexpr auto @\libmember{pairwise}{views}@ = adjacent<2>;

}

// \ref{range.adjacent.transform}, adjacent transform view

template<@\libconcept{forward_range}@ V, @\libconcept{move_constructible}@ F, size_t N>

requires @\seebelow@

class adjacent_transform_view;

namespace views {

template<size_t N>

constexpr @\unspecnc@ adjacent_transform = @\unspecnc@;

inline constexpr auto @\libmember{pairwise_transform}{views}@ = adjacent_transform<2>;

}

// \ref{range.chunk}, chunk view

template<@\libconcept{view}@ V>

requires @\libconcept{input_range}@<V>

class chunk_view;

template<@\libconcept{view}@ V>

requires @\libconcept{forward_range}@<V>

class chunk_view<V>;

template<class V>

constexpr bool @\libspec{enable_borrowed_range}{chunk_view}@<chunk_view<V>> =

@\libconcept{forward_range}@<V> && enable_borrowed_range<V>;

namespace views { inline constexpr @\unspecnc@ chunk = @\unspecnc@; }

// \ref{range.slide}, slide view

template<@\libconcept{forward_range}@ V>

requires @\libconcept{view}@<V>

class slide_view;

template<class V>

constexpr bool @\libspec{enable_borrowed_range}{slide_view}@<slide_view<V>> =

enable_borrowed_range<V>;

namespace views { inline constexpr @\unspecnc@ slide = @\unspecnc@; }

// \ref{range.chunk.by}, chunk by view

template<@\libconcept{forward_range}@ V, @\libconcept{indirect_binary_predicate}@<iterator_t<V>, iterator_t<V>> Pred>

requires @\libconcept{view}@<V> && is_object_v<Pred>

class chunk_by_view;

namespace views { inline constexpr @\unspecnc@ chunk_by = @\unspecnc@; }

// \ref{range.stride}, stride view

template<@\libconcept{input_range}@ V>

requires @\libconcept{view}@<V>

class stride_view;

template<class V>

constexpr bool @\libspec{enable_borrowed_range}{stride_view}@<stride_view<V>> =

enable_borrowed_range<V>;

namespace views { inline constexpr @\unspecnc@ stride = @\unspecnc@; }

// \ref{range.cartesian}, cartesian product view

template<@\libconcept{input_range}@ First, @\libconcept{forward_range}@... Vs>

requires (@\libconcept{view}@<First> && ... && @\libconcept{view}@<Vs>)

class cartesian_product_view;

namespace views { inline constexpr @\unspecnc@ cartesian_product = @\unspecnc@; }

// \ref{range.cache.latest}, cache latest view

template<@\libconcept{input_range}@ V>

requires @\libconcept{view}@<V>

class cache_latest_view;

namespace views { inline constexpr @\unspec@ cache_latest = @\unspec@; }

// \ref{range.to.input}, to input view

template<@\libconcept{input_range}@ V>

requires @\libconcept{view}@<V>

class to_input_view;

template<class V>

constexpr bool enable_borrowed_range<to_input_view<V>> =

enable_borrowed_range<V>;

namespace views { inline constexpr @\unspec@ to_input = @\unspec@; }

}

namespace std {

namespace views = ranges::views;

template<class T> struct tuple_size;

template<size_t I, class T> struct tuple_element;

template<class I, class S, ranges::subrange_kind K>

struct tuple_size<ranges::subrange<I, S, K>>

: integral_constant<size_t, 2> {};

template<class I, class S, ranges::subrange_kind K>

struct tuple_element<0, ranges::subrange<I, S, K>> {

using type = I;

};

template<class I, class S, ranges::subrange_kind K>

struct tuple_element<1, ranges::subrange<I, S, K>> {

using type = S;

};

template<class I, class S, ranges::subrange_kind K>

struct tuple_element<0, const ranges::subrange<I, S, K>> {

using type = I;

};

template<class I, class S, ranges::subrange_kind K>

struct tuple_element<1, const ranges::subrange<I, S, K>> {

using type = S;

};

struct from_range_t { explicit from_range_t() = default; };

inline constexpr from_range_t from_range{};

}

\end{codeblock}

\pnum

\indextext{to-unsigned-like@\exposid{to-unsigned-like}}%

\indextext{make-unsigned-like-t@\exposid{make-unsigned-like-t}}%

Within this Clause,

for an integer-like type \tcode{X}\iref{iterator.concept.winc},

\tcode{\placeholdernc{make-unsigned-like-t}<X>} denotes

\tcode{make_unsigned_t<X>} if \tcode{X} is an integer type;

otherwise, it denotes a corresponding unspecified unsigned-integer-like type

of the same width as \tcode{X}.

For an expression \tcode{x} of type \tcode{X},

\tcode{\placeholdernc{to-unsigned-like}(x)} is

\tcode{x} explicitly converted to

\tcode{\placeholdernc{make-unsigned-like-t}<X>}.

\pnum

Also within this Clause,

\tcode{\exposid{make-signed-like-t}<X>} for an integer-like type \tcode{X}

denotes \tcode{make_signed_t<X>} if \tcode{X} is an integer type;

otherwise, it denotes a corresponding unspecified signed-integer-like type

of the same width as \tcode{X}.

\rSec1[range.access]{Range access}

\rSec2[range.access.general]{General}

\pnum

In addition to being available via inclusion of the \libheader{ranges}

header, the customization point objects in \ref{range.access} are

available when the header \libheaderrefx{iterator}{iterator.synopsis} is included.

\pnum

Within \ref{range.access},

the \defnadj{reified}{object} of a subexpression \tcode{E} denotes

\begin{itemize}

\item

the same object as \tcode{E} if \tcode{E} is a glvalue, or

\item

the result of applying

the temporary materialization conversion\iref{conv.rval} to \tcode{E} otherwise.

\end{itemize}

\rSec2[range.access.begin]{\tcode{ranges::begin}}

\indexlibraryglobal{begin}%

\pnum

The name \tcode{ranges::begin} denotes a customization point

object\iref{customization.point.object}.

\pnum

Given a subexpression \tcode{E} with type \tcode{T},

let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.

Then:

\begin{itemize}

\item

If \tcode{E} is an rvalue and

\tcode{enable_borrowed_range<remove_cv_t<T>>} is \tcode{false},

\tcode{ranges::begin(E)} is ill-formed.

\item

Otherwise, if \tcode{T} is an array type\iref{term.array.type} and

\tcode{remove_all_extents_t<T>} is an incomplete type,

\tcode{ranges::begin(E)} is ill-formed with no diagnostic required.

\item

Otherwise, if \tcode{T} is an array type,

\tcode{ranges::begin(E)} is expression-equivalent to \tcode{t + 0}.

\item

Otherwise, if \tcode{auto(t.begin())}

is a valid expression whose type models

\libconcept{input_or_output_iterator},

\tcode{ranges::begin(E)} is expression-equivalent to

\tcode{auto(t.begin())}.

\item

Otherwise, if \tcode{T} is a class or enumeration type and

\tcode{auto(begin(t))}

is a valid expression whose type models

\libconcept{input_or_output_iterator}

where the meaning of \tcode{begin} is established as-if by performing

argument-dependent lookup only\iref{basic.lookup.argdep},

then \tcode{ranges::begin(E)} is expression-equivalent to

that expression.

\item

Otherwise, \tcode{ranges::begin(E)} is ill-formed.

\end{itemize}

\pnum

\begin{note}

Diagnosable ill-formed cases above

result in substitution failure when \tcode{ranges::begin(E)}

appears in the immediate context of a template instantiation.

\end{note}

\pnum

\begin{note}

Whenever \tcode{ranges::begin(E)} is a valid expression, its type models

\libconcept{input_or_output_iterator}.

\end{note}

\rSec2[range.access.end]{\tcode{ranges::end}}

\indexlibraryglobal{end}%

\pnum

The name \tcode{ranges::end} denotes a customization point

object\iref{customization.point.object}.

\pnum

Given a subexpression \tcode{E} with type \tcode{T},

let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.

Then:

\begin{itemize}

\item

If \tcode{E} is an rvalue and

\tcode{enable_borrowed_range<remove_cv_t<T>>} is \tcode{false},

\tcode{ranges::end(E)} is ill-formed.

\item

Otherwise, if \tcode{T} is an array type\iref{term.array.type} and

\tcode{remove_all_extents_t<T>} is an incomplete type,

\tcode{ranges::end(E)} is ill-formed with no diagnostic required.

\item

Otherwise, if \tcode{T} is an array of unknown bound,

\tcode{ranges::end(E)} is ill-formed.

\item

Otherwise, if \tcode{T} is an array,

\tcode{ranges::end(E)} is expression-equivalent to

\tcode{t + extent_v<T>}.

\item

Otherwise, if \tcode{auto(t.end())}

is a valid expression whose type models

\tcode{\libconcept{sentinel_for}<iterator_t<T>>}

then \tcode{ranges::end(E)} is expression-equivalent to

\tcode{auto(t.end())}.

\item

Otherwise, if \tcode{T} is a class or enumeration type and

\tcode{auto(end(t))}

is a valid expression whose type models

\tcode{\libconcept{sentinel_for}<iterator_t<T>>}

where the meaning of \tcode{end} is established as-if by performing

argument-dependent lookup only\iref{basic.lookup.argdep},

then \tcode{ranges::end(E)} is expression-equivalent to

that expression.

\item

Otherwise, \tcode{ranges::end(E)} is ill-formed.

\end{itemize}

\pnum

\begin{note}

Diagnosable ill-formed cases above

result in substitution failure when \tcode{ranges::end(E)}

appears in the immediate context of a template instantiation.

\end{note}

\pnum

\begin{note}

Whenever \tcode{ranges::end(E)} is a valid expression,

the types \tcode{S} and \tcode{I} of

\tcode{ranges::end(E)} and \tcode{ranges::begin(E)}

model \tcode{\libconcept{sentinel_for}<S, I>}.

\end{note}

\rSec2[range.access.cbegin]{\tcode{ranges::cbegin}}

\indexlibraryglobal{cbegin}%

\pnum

The name \tcode{ranges::cbegin} denotes a customization point

object\iref{customization.point.object}.

Given a subexpression \tcode{E} with type \tcode{T},

let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.

Then:

\begin{itemize}

\item

If \tcode{E} is an rvalue and

\tcode{enable_borrowed_range<remove_cv_t<T>>} is \tcode{false},

\tcode{ranges::cbegin(E)} is ill-formed.

\item

Otherwise,

let \tcode{U} be \tcode{ranges::begin(\exposid{possibly-const-range}(t))}.

\tcode{ranges::cbegin(E)} is expression-equivalent to

\tcode{const_iterator<decltype(U)>(U)}.

\end{itemize}

\pnum

\begin{note}

Whenever \tcode{ranges::cbegin(E)} is a valid expression, its type models

\libconcept{input_or_output_iterator} and \exposconcept{constant-iterator}.

\end{note}

\rSec2[range.access.cend]{\tcode{ranges::cend}}

\indexlibraryglobal{cend}%

\pnum

The name \tcode{ranges::cend} denotes a customization point

object\iref{customization.point.object}.

Given a subexpression \tcode{E} with type \tcode{T},

let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.

Then:

\begin{itemize}

\item

If \tcode{E} is an rvalue and

\tcode{enable_borrowed_range<remove_cv_t<T>>} is \tcode{false},

\tcode{ranges::cend(E)} is ill-formed.

\item

Otherwise,

let \tcode{U} be \tcode{ranges::end(\exposid{possibly-const-range}(t))}.

\tcode{ranges::cend(E)} is expression-equivalent to

\tcode{const_sentinel<decltype(U)>(U)}.

\end{itemize}

\pnum

\begin{note}

Whenever \tcode{ranges::cend(E)} is a valid expression,

the types \tcode{S} and \tcode{I} of the expressions

\tcode{ranges::cend(E)} and \tcode{ranges::cbegin(E)}

model \tcode{\libconcept{sentinel_for}<S, I>}.

If \tcode{S} models \libconcept{input_iterator},

then \tcode{S} also models \exposconceptx{constant-itera\-tor}{constant-iterator}.

\end{note}

\rSec2[range.access.rbegin]{\tcode{ranges::rbegin}}

\indexlibraryglobal{rbegin}%

\pnum

The name \tcode{ranges::rbegin} denotes a customization point

object\iref{customization.point.object}.

\pnum

Given a subexpression \tcode{E} with type \tcode{T},

let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.

Then:

\begin{itemize}

\item

If \tcode{E} is an rvalue and

\tcode{enable_borrowed_range<remove_cv_t<T>>} is \tcode{false},

\tcode{ranges::rbegin(E)} is ill-formed.

\item

Otherwise, if \tcode{T} is an array type\iref{term.array.type} and

\tcode{remove_all_extents_t<T>} is an incomplete type,

\tcode{ranges::rbegin(E)} is ill-formed with no diagnostic required.

\item

Otherwise, if \tcode{auto(t.rbegin())}

is a valid expression whose type models

\libconcept{input_or_output_iterator},

\tcode{ranges::rbegin(E)} is expression-equivalent to

\tcode{auto(t.rbegin())}.

\item

Otherwise, if \tcode{T} is a class or enumeration type and

\tcode{auto(rbegin(t))}

is a valid expression whose type models

\libconcept{input_or_output_iterator}

where the meaning of \tcode{rbegin} is established as-if by performing

argument-dependent lookup only\iref{basic.lookup.argdep},

then \tcode{ranges::rbegin(E)} is expression-equivalent to

that expression.

\item

Otherwise, if both \tcode{ranges::begin(t)} and \tcode{ranges::end(t)}

are valid expressions of the same type which models

\libconcept{bidirectional_iterator}\iref{iterator.concept.bidir},

\tcode{ranges::rbegin(E)} is expression-equivalent to

\tcode{make_reverse_iterator(ranges::end(t))}.

\item

Otherwise, \tcode{ranges::rbegin(E)} is ill-formed.

\end{itemize}

\pnum

\begin{note}

Diagnosable ill-formed cases above result in substitution failure

when \tcode{ranges::rbegin(E)}

appears in the immediate context of a template instantiation.

\end{note}

\pnum

\begin{note}

Whenever \tcode{ranges::rbegin(E)} is a valid expression, its type models

\libconcept{input_or_output_iterator}.

\end{note}

\rSec2[range.access.rend]{\tcode{ranges::rend}}

\indexlibraryglobal{rend}%

\pnum

The name \tcode{ranges::rend} denotes a customization point

object\iref{customization.point.object}.

\pnum

Given a subexpression \tcode{E} with type \tcode{T},

let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.

Then:

\begin{itemize}

\item

If \tcode{E} is an rvalue and

\tcode{enable_borrowed_range<remove_cv_t<T>>} is \tcode{false},

\tcode{ranges::rend(E)} is ill-formed.

\item

Otherwise, if \tcode{T} is an array type\iref{term.array.type} and

\tcode{remove_all_extents_t<T>} is an incomplete type,

\tcode{ranges::rend(E)} is ill-formed with no diagnostic required.

\item

Otherwise, if \tcode{auto(t.rend())}

is a valid expression whose type models

\tcode{\libconcept{sentinel_for}<decltype(\brk{}ranges::rbegin(E))>}

then \tcode{ranges::rend(E)} is expression-equivalent to

\tcode{auto(t.rend())}.

\item

Otherwise, if \tcode{T} is a class or enumeration type and

\tcode{auto(rend(t))}

is a valid expression whose type models

\tcode{\libconcept{sentinel_for}<decltype(ranges::rbegin(E))>}

where the meaning of \tcode{rend} is established as-if by performing

argument-dependent lookup only\iref{basic.lookup.argdep},

then \tcode{ranges::rend(E)} is expression-equivalent to

that expression.

\item

Otherwise, if both \tcode{ranges::begin(t)} and \tcode{ranges::end(t)}

are valid expressions of the same type which models

\libconcept{bidirectional_iterator}\iref{iterator.concept.bidir},

then \tcode{ranges::rend(E)} is expression-equivalent to

\tcode{make_reverse_iterator(ranges::begin(t))}.

\item

Otherwise, \tcode{ranges::rend(E)} is ill-formed.

\end{itemize}

\pnum

\begin{note}

Diagnosable ill-formed cases above

result in substitution failure when \tcode{ranges::rend(E)}

appears in the immediate context of a template instantiation.

\end{note}

\pnum

\begin{note}

Whenever \tcode{ranges::rend(E)} is a valid expression,

the types \tcode{S} and \tcode{I} of the expressions

\tcode{ranges::rend(E)} and \tcode{ranges::rbegin(E)}

model \tcode{\libconcept{sentinel_for}<S, I>}.

\end{note}

\rSec2[range.access.crbegin]{\tcode{ranges::crbegin}}

\indexlibraryglobal{crbegin}%

\pnum

The name \tcode{ranges::crbegin} denotes a customization point

object\iref{customization.point.object}.

Given a subexpression \tcode{E} with type \tcode{T},

let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.

Then:

\begin{itemize}

\item

If \tcode{E} is an rvalue and

\tcode{enable_borrowed_range<remove_cv_t<T>>} is \tcode{false},

\tcode{ranges::crbegin(E)} is ill-formed.

\item

Otherwise,

let \tcode{U} be \tcode{ranges::rbegin(\exposid{possibly-const-range}(t))}.

\tcode{ranges::crbegin(E)} is expres\-sion-equivalent to

\tcode{const_iterator<decltype(U)>(U)}.

\end{itemize}

\pnum

\begin{note}

Whenever \tcode{ranges::crbegin(E)} is a valid expression, its

type models \libconcept{input_or_output_iterator} and

\exposconcept{constant-iterator}.

\end{note}

\rSec2[range.access.crend]{\tcode{ranges::crend}}

\indexlibraryglobal{crend}%

\pnum

The name \tcode{ranges::crend} denotes a customization point

object\iref{customization.point.object}.

Given a subexpression \tcode{E} with type \tcode{T},

let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.

Then:

\begin{itemize}

\item

If \tcode{E} is an rvalue and

\tcode{enable_borrowed_range<remove_cv_t<T>>} is \tcode{false},