ranges.tex

%!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
as summarized in \tref{range.summary}.

\begin{libsumtab}{Ranges library summary}{tab:range.summary}
  \ref{range.access}       & Range access      & \tcode{<ranges>} \\
  \ref{range.prim}         & Range primitives  & \\
  \ref{range.req}          & Requirements      & \\
  \ref{range.utility}      & Range utilities   & \\
  \ref{range.adaptors}     & Range adaptors    & \\
\end{libsumtab}

\pnum
Several places in this clause use the expression \tcode{\placeholdernc{DECAY_COPY}(x)}
with semantics as defined in \ref{thread.decaycopy}.


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

\indexlibrary{\idxhdr{ranges}}%
\begin{codeblock}
#include <initializer_list>
#include <iterator>

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@;

    // \ref{range.prim}, range primitives
    inline constexpr @\unspec@ size = @\unspec@;
    inline constexpr @\unspec@ empty = @\unspec@;
    inline constexpr @\unspec@ data = @\unspec@;
    inline constexpr @\unspec@ cdata = @\unspec@;
  }

  // \ref{range.range}, ranges
  template<class T>
    using iterator_t = decltype(ranges::begin(declval<T&>()));

  template<class T>
    using sentinel_t = decltype(ranges::end(declval<T&>()));

  template<@\placeholder{fowarding-range}@ R>
    using safe_iterator_t = iterator_t<R>;

  template<class T>
    concept Range = @\seebelow@;

  // \ref{range.sized}, sized ranges
  template<class>
    inline constexpr bool disable_sized_range = false;

  template<class T>
    concept SizedRange = @\seebelow@;

  // \ref{range.view}, views
  template<class T>
    inline constexpr bool enable_view = @\seebelow@;

  struct view_base { };

  template<class T>
    concept View = @\seebelow@;

  // \ref{range.refinements}, common range refinements
  template<class R, class T>
    concept OutputRange = @\seebelow@;

  template<class T>
    concept InputRange = @\seebelow@;

  template<class T>
    concept ForwardRange = @\seebelow@;

  template<class T>
    concept BidirectionalRange = @\seebelow@;

  template<class T>
    concept RandomAccessRange = @\seebelow@;

  template<class T>
    concept ContiguousRange = @\seebelow@;

  template<class T>
    concept CommonRange = @\seebelow@;

  template<class T>
    concept ViewableRange = @\seebelow@;

  // \ref{view.interface}, class template \tcode{view_interface}
  template<class D>
    requires is_class_v<D>
  class view_interface;

  // \ref{range.subrange}, sub-ranges
  enum class subrange_kind : bool { unsized, sized };

  template<Iterator I, Sentinel<I> S = I, subrange_kind K = @\seebelow@>
    requires (K == subrange_kind::sized || !SizedSentinel<S, I>)
  class subrange;

  template<@\placeholder{forwarding-range}@ R>
    using safe_subrange_t = subrange<iterator_t<R>>;

  // \ref{range.all}, all view
  namespace view { inline constexpr @\unspec@ all = @\unspec@; }

  template<ViewableRange R>
    using all_view = decltype(view::all(declval<R>()));

  // \ref{range.filter}, filter view
  template<InputRange V, IndirectUnaryPredicate<iterator_t<V>> Pred>
    requires View<V>
  class filter_view;

  namespace view { inline constexpr @\unspec@ filter = @\unspec@; }

  // \ref{range.transform}, transform view
  template<InputRange V, CopyConstructible F>
    requires View<V> && is_object_v<F> &&
             RegularInvocable<F&, iter_reference_t<iterator_t<V>>>
  class transform_view;

  namespace view { inline constexpr @\unspec@ transform = @\unspec@; }

  // \ref{range.iota}, iota view
  template<WeaklyIncrementable W, Semiregular Bound = unreachable_sentinel_t>
    requires @\placeholder{weakly-equality-comparable-with}@<W, Bound>
  class iota_view;

  namespace view { inline constexpr @\unspec@ iota = @\unspec@; }

  // \ref{range.take}, take view
  template<View> class take_view;

  namespace view { inline constexpr @\unspec@ take = @\unspec@; }

  // \ref{range.join}, join view
  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;

  namespace view { inline constexpr @\unspec@ join = @\unspec@; }

  // \ref{range.empty}, empty view
  template<class T>
    requires is_object_v<T>
  class empty_view;

  namespace view {
    template<class T>
      inline constexpr empty_view<T> empty {};
  }

  // \ref{range.single}, single view
  template<CopyConstructible T>
    requires is_object_v<T>
  class single_view;

  namespace view { inline constexpr @\unspec@ single = @\unspec@; }

  // \ref{range.split}, split view
  template<class R>
    concept @\placeholder{tiny-range}@ = @\seebelow@;   // \expos

  template<InputRange V, ForwardRange Pattern>
    requires View<V> && View<Pattern> &&
             IndirectlyComparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to<>> &&
             (ForwardRange<V> || @\placeholder{tiny-range}@<Pattern>)
  class split_view;

  namespace view { inline constexpr @\unspec@ split = @\unspec@; }

  // \ref{range.counted}, counted view
  namespace view { inline constexpr @\unspec@ counted = @\unspec@; }

  // \ref{range.common}, common view
  template<View V>
    requires (!CommonRange<V>)
  class common_view;

  namespace view { inline constexpr @\unspec@ common = @\unspec@; }

  // \ref{range.reverse}, reverse view
  template<View V>
    requires BidirectionalRange<V>
  class reverse_view;

  namespace view { inline constexpr @\unspec@ reverse = @\unspec@; }
}

namespace std {
  namespace view = ranges::view;

  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;
  };
}
\end{codeblock}

\rSec1[range.access]{Range access}

\pnum
In addition to being available via inclusion of the \tcode{<ranges>}
header, the customization point objects in \ref{range.access} are
available when \tcode{<iterator>} is included.

\rSec2[range.access.begin]{\tcode{ranges::begin}}
\pnum
The name \tcode{ranges::begin} denotes a customization point
object\iref{customization.point.object}. The expression
\tcode{ranges::\brk{}begin(E)} for some subexpression \tcode{E} is
expression-equivalent to:

\begin{itemize}
\item
  \tcode{E + 0} if \tcode{E} is an lvalue of array type\iref{basic.compound}.

\item
  Otherwise, if \tcode{E} is an lvalue,
  \tcode{\placeholdernc{DECAY_COPY}(E.begin())}
  if it is a valid expression and its type \tcode{I} models \tcode{Iterator}.

\item
  Otherwise, \tcode{\placeholdernc{DECAY_COPY}(begin(E))} if it is a
  valid expression and its type \tcode{I} models \tcode{Iterator} with overload
  resolution performed in a context that includes the declarations:
  \begin{codeblock}
  template<class T> void begin(T&&) = delete;
  template<class T> void begin(initializer_list<T>&&) = delete;
  \end{codeblock}

  and does not include a declaration of \tcode{ranges::begin}.

\item
  Otherwise, \tcode{ranges::begin(E)} is ill-formed.
  \begin{note}
  This case can result in substitution failure when \tcode{ranges::begin(E)}
  appears in the immediate context of a template instantiation.
  \end{note}
\end{itemize}

\pnum
\begin{note}
Whenever \tcode{ranges::begin(E)} is a valid expression, its type models
\tcode{Iterator}.
\end{note}

\rSec2[range.access.end]{\tcode{ranges::end}}
\pnum
The name \tcode{ranges::end} denotes a customization point
object\iref{customization.point.object}. The expression
\tcode{ranges::end(E)} for some subexpression \tcode{E} is
expression-equivalent to:

\begin{itemize}
\item
  \tcode{E + extent_v<T>} if \tcode{E} is an lvalue of array
  type\iref{basic.compound} \tcode{T}.

\item
  Otherwise, if \tcode{E} is an lvalue,
  \tcode{\placeholdernc{DECAY_COPY}(E.end())}
  if it is a valid expression and its type \tcode{S} models
  \tcode{Sentinel<decltype(\brk{}ranges::\brk{}begin(E))>}.

\item
  Otherwise, \tcode{\placeholdernc{DECAY_COPY}(end(E))} if it is a valid
  expression and its type \tcode{S} models
  \tcode{Sentinel<decltype(\brk{}ranges::\brk{}begin(E))>} with overload
  resolution performed in a context that includes the declarations:
  \begin{codeblock}
  template<class T> void end(T&&) = delete;
  template<class T> void end(initializer_list<T>&&) = delete;
  \end{codeblock}

  and does not include a declaration of \tcode{ranges::end}.

\item
  Otherwise, \tcode{ranges::end(E)} is ill-formed.
  \begin{note}
  This case can result in substitution failure when \tcode{ranges::end(E)}
  appears in the immediate context of a template instantiation.
  \end{note}
\end{itemize}

\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 \libconcept{Sentinel<S, I>}.
\end{note}

\rSec2[range.access.cbegin]{\tcode{ranges::cbegin}}
\pnum
The name \tcode{ranges::cbegin} denotes a customization point
object\iref{customization.point.object}. The expression
\tcode{ranges::\brk{}cbegin(E)} for some subexpression \tcode{E} of type \tcode{T}
is expression-equivalent to:
\begin{itemize}
\item \tcode{ranges::begin(static_cast<const T\&>(E))} if \tcode{E} is an lvalue.
\item Otherwise, \tcode{ranges::begin(static_cast<const T\&\&>(E))}.
\end{itemize}

\pnum
\begin{note}
Whenever \tcode{ranges::cbegin(E)} is a valid expression, its type models
\tcode{Iterator}.
\end{note}

\rSec2[range.access.cend]{\tcode{ranges::cend}}
\pnum
The name \tcode{ranges::cend} denotes a customization point
object\iref{customization.point.object}. The expression
\tcode{ranges::cend(E)} for some subexpression \tcode{E} of type \tcode{T}
is expression-equivalent to:

\begin{itemize}
\item \tcode{ranges::end(static_cast<const T\&>(E))} if \tcode{E} is an lvalue.
\item Otherwise, \tcode{ranges::end(static_cast<const T\&\&>(E))}.
\end{itemize}

\pnum
\begin{note}
Whenever \tcode{ranges::cend(E)} is a valid expression,
the types \tcode{S} and \tcode{I} of
\tcode{ranges::cend(E)} and \tcode{ranges::cbegin(E)}
model \libconcept{Sentinel<S, I>}.
\end{note}

\rSec2[range.access.rbegin]{\tcode{ranges::rbegin}}
\pnum
The name \tcode{ranges::rbegin} denotes a customization point
object\iref{customization.point.object}. The expression
\tcode{ranges::\brk{}rbegin(E)} for some subexpression \tcode{E} is
expression-equivalent to:

\begin{itemize}
\item
  If \tcode{E} is an lvalue, \tcode{\placeholdernc{DECAY_COPY}(E.rbegin())}
  if it is a valid expression and its type \tcode{I} models \tcode{Iterator}.

\item
  Otherwise, \tcode{\placeholdernc{DECAY_COPY}(rbegin(E))} if it is a valid
  expression and its type \tcode{I} models \tcode{Iterator} with overload
  resolution performed in a context that includes the declaration:
  \begin{codeblock}
  template<class T> void rbegin(T&&) = delete;
  \end{codeblock}

  and does not include a declaration of \tcode{ranges::rbegin}.

\item
  Otherwise, \tcode{make_reverse_iterator(ranges::end(E))} if both
  \tcode{ranges::begin(E)} and \tcode{ranges::end(\brk{}E)} are valid
  expressions of the same type \tcode{I} which models
  \libconcept{BidirectionalIterator}\iref{iterator.concept.bidir}.

\item
  Otherwise, \tcode{ranges::rbegin(E)} is ill-formed.
  \begin{note}
  This case can result in substitution failure when \tcode{ranges::rbegin(E)}
  appears in the immediate context of a template instantiation.
  \end{note}
\end{itemize}

\pnum
\begin{note}
Whenever \tcode{ranges::rbegin(E)} is a valid expression, its type models
\tcode{Iterator}.
\end{note}

\rSec2[range.access.rend]{\tcode{ranges::rend}}
\pnum
The name \tcode{ranges::rend} denotes a customization point
object\iref{customization.point.object}. The expression
\tcode{ranges::rend(E)} for some subexpression \tcode{E} is
expression-equivalent to:

\begin{itemize}
\item
  If \tcode{E} is an lvalue, \tcode{\placeholdernc{DECAY_COPY}(E.rend())}
  if it is a valid expression and its type \tcode{S} models
  \tcode{Sentinel<\brk{}decltype(ranges::rbegin(E))>}.

\item
  Otherwise, \tcode{\placeholdernc{DECAY_COPY}(rend(E))} if it is a valid
  expression and its type \tcode{S} models
  \tcode{Sentinel<decltype(\brk{}ranges::rbegin(E))>} with overload
  resolution performed in a context that includes the declaration:
  \begin{codeblock}
  template<class T> void rend(T&&) = delete;
  \end{codeblock}

  and does not include a declaration of \tcode{ranges::rend}.

\item
  Otherwise, \tcode{make_reverse_iterator(ranges::begin(E))} if both
  \tcode{ranges::begin(E)} and \tcode{ranges::\brk{}end(E)} are valid
  expressions of the same type \tcode{I} which models
  \tcode{BidirectionalIterator}\iref{iterator.concept.bidir}.

\item
  Otherwise, \tcode{ranges::rend(E)} is ill-formed.
  \begin{note}
  This case can result in substitution failure when \tcode{ranges::rend(E)}
  appears in the immediate context of a template instantiation.
  \end{note}
\end{itemize}

\pnum
\begin{note}
Whenever \tcode{ranges::rend(E)} is a valid expression,
the types \tcode{S} and \tcode{I} of
\tcode{ranges::rend(E)} and \tcode{ranges::rbegin(E)}
model \libconcept{Sentinel<S, I>}.
\end{note}

\rSec2[range.access.crbegin]{\tcode{ranges::crbegin}}
\pnum
The name \tcode{ranges::crbegin} denotes a customization point
object\iref{customization.point.object}. The expression
\tcode{ranges::\brk{}crbegin(E)} for some subexpression \tcode{E} of type
\tcode{T} is expression-equivalent to:
\begin{itemize}
\item \tcode{ranges::\brk{}rbegin(static_cast<const T\&>(E))} if \tcode{E} is
  an lvalue.
\item Otherwise, \tcode{ranges::rbegin(static_cast<const T\&\&>(E))}.
\end{itemize}

\pnum
\begin{note}
Whenever \tcode{ranges::crbegin(E)} is a valid expression, its
type models \tcode{Iterator}.
\end{note}

\rSec2[range.access.crend]{\tcode{ranges::crend}}
\pnum
The name \tcode{ranges::crend} denotes a customization point
object\iref{customization.point.object}. The expression
\tcode{ranges::\brk{}crend(E)} for some subexpression \tcode{E} of type \tcode{T}
is expression-equivalent to:
\begin{itemize}
\item \tcode{ranges::rend(static_cast<const T\&>(E))} if \tcode{E} is an lvalue.

\item Otherwise, \tcode{ranges::rend(static_cast<const T\&\&>(E))}.
\end{itemize}

\pnum
\begin{note}
Whenever \tcode{ranges::crend(E)} is a valid expression,
the types \tcode{S} and \tcode{I} of
\tcode{ranges::crend(E)} and \tcode{ranges::crbegin(E)}
model \libconcept{Sentinel<S, I>}.
\end{note}

\rSec1[range.prim]{Range primitives}

\pnum
In addition to being available via inclusion of the \tcode{<ranges>} header,
the customization point objects in \ref{range.prim} are available
when \tcode{<iterator>} is included.

\rSec2[range.prim.size]{\tcode{size}}
\pnum
The name \tcode{size} denotes a customization point
object\iref{customization.point.object}. The expression
\tcode{ranges::size(E)} for some subexpression \tcode{E} with type
\tcode{T} is expression-equivalent to:

\begin{itemize}
\item
  \tcode{\placeholdernc{DECAY_COPY}(extent_v<T>)} if \tcode{T} is an array
  type\iref{basic.compound}.

\item
  Otherwise, if
  \tcode{disable_sized_range<remove_cv_t<T>>}\iref{range.sized}
  is \tcode{false}:
  \begin{itemize}
  \item
    \tcode{\placeholdernc{DECAY_COPY}(E.size())}
    if it is a valid expression and its type \tcode{I}
    models \libconcept{Integral}.

  \item
    Otherwise, \tcode{\placeholdernc{DECAY_COPY}(size(E))}
    if it is a valid expression and its type \tcode{I}
    models \libconcept{Integral}
    with overload resolution performed in a context that includes
    the declaration:
    \begin{codeblock}
    template<class T> void size(T&&) = delete;
    \end{codeblock}

    and does not include a declaration of \tcode{ranges::size}.
  \end{itemize}

\item
  Otherwise, \tcode{(ranges::end(E) - ranges::begin(E))}
  if it is a valid expression and
  the types \tcode{I} and \tcode{S} of \tcode{ranges::begin(E)} and
  \tcode{ranges::end(E)} model
  \tcode{SizedSentinel<S, I>}\iref{iterator.concept.sizedsentinel} and
  \tcode{Forward\-Iterator<I>}.
  However, \tcode{E} is evaluated only once.

\item
  Otherwise, \tcode{ranges::size(E)} is ill-formed.
  \begin{note}
  This case can result in substitution failure when \tcode{ranges::size(E)}
  appears in the immediate context of a template instantiation.
  \end{note}
\end{itemize}

\pnum
\begin{note}
Whenever \tcode{ranges::size(E)} is a valid expression, its
type models \libconcept{Integral}.
\end{note}

\rSec2[range.prim.empty]{\tcode{empty}}
\pnum
The name \tcode{empty} denotes a customization point
object\iref{customization.point.object}. The expression
\tcode{ranges::empty(E)} for some subexpression \tcode{E} is
expression-equivalent to:

\begin{itemize}
\item
  \tcode{bool((E).empty())} if it is a valid expression.

\item
  Otherwise, \tcode{(ranges::size(E) == 0)} if it is a valid expression.

\item
  Otherwise, \tcode{EQ}, where \tcode{EQ} is
  \tcode{bool(ranges::begin(E) == ranges::end(E))}
  except that \tcode{E} is only evaluated once,
  if \tcode{EQ} is a valid expression and
  the type of \tcode{ranges::begin(E)} models \libconcept{ForwardIterator}.

\item
  Otherwise, \tcode{ranges::empty(E)} is ill-formed.
  \begin{note}
  This case can result in substitution failure when \tcode{ranges::empty(E)}
  appears in the immediate context of a template instantiation.
  \end{note}
\end{itemize}

\pnum
\begin{note}
Whenever \tcode{ranges::empty(E)} is a valid expression,
it has type \tcode{bool}.
\end{note}

\rSec2[range.prim.data]{\tcode{data}}
\pnum
The name \tcode{data} denotes a customization point
object\iref{customization.point.object}. The expression
\tcode{ranges::data(E)} for some subexpression \tcode{E} is
expression-equivalent to:

\begin{itemize}
\item
  If \tcode{E} is an lvalue, \tcode{\placeholdernc{DECAY_COPY}(E.data())}
  if it is a valid expression of pointer to object type.

\item
  Otherwise, if \tcode{ranges::begin(E)} is a valid expression whose type models
  \tcode{ContiguousIterator},
  \begin{codeblock}
  ranges::begin(E) == ranges::end(E) ? nullptr : addressof(*ranges::begin(E))
  \end{codeblock}

  except that \tcode{E} is evaluated only once.

\item
  Otherwise, \tcode{ranges::data(E)} is ill-formed.
  \begin{note}
  This case can result in substitution failure when \tcode{ranges::data(E)}
  appears in the immediate context of a template instantiation.
  \end{note}
\end{itemize}

\pnum
\begin{note}
Whenever \tcode{ranges::data(E)} is a valid expression, it
has pointer to object type.
\end{note}

\rSec2[range.prim.cdata]{\tcode{cdata}}
\pnum
The name \tcode{cdata} denotes a customization point
object\iref{customization.point.object}. The expression
\tcode{ranges::cdata(E)} for some subexpression \tcode{E} of type \tcode{T}
is expression-equivalent to:
\begin{itemize}
\item \tcode{ranges::data(static_cast<const T\&>(E))} if \tcode{E} is an lvalue.

\item Otherwise, \tcode{ranges::data(static_cast<const T\&\&>(E))}.
\end{itemize}

\pnum
\begin{note}
Whenever \tcode{ranges::cdata(E)} is a valid expression, it
has pointer to object type.
\end{note}

\rSec1[range.req]{Range requirements}

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

\pnum
Ranges are an abstraction that allow a \Cpp{} program
to operate on elements of data structures uniformly.
Calling \tcode{ranges::begin} on a range returns an object
whose type models \libconcept{Iterator}\iref{iterator.concept.iterator}.
Calling \tcode{ranges::end} on a range returns an object whose type \tcode{S},
together with the type \tcode{I} of the object returned by \tcode{ranges::begin},
models \libconcept{Sentinel<S, I>}.
The library formalizes the interfaces, semantics, and complexity of ranges
to enable algorithms and range adaptors that work efficiently
on different types of sequences.

\pnum
The \libconcept{Range} concept requires that
\tcode{ranges::begin} and \tcode{ranges::end}
return an iterator and a sentinel, respectively.
The \libconcept{SizedRange} concept refines \libconcept{Range} with
the requirement that the number of elements in the range can be determined
in constant time using the \tcode{ranges::size} function.
The \tcode{View} concept specifies requirements on a \libconcept{Range} type
with constant-time copy and assign operations.

\pnum
Several refinements of \libconcept{Range} group requirements
that arise frequently in concepts and algorithms.
Common ranges are ranges for which
\tcode{ranges::begin} and \tcode{ranges::end}
return objects of the same type.
Random access ranges are ranges for which \tcode{ranges::begin}
returns a type that models
\libconcept{RandomAccessIterator}\iref{iterator.concept.random.access}.
(Contiguous, bidirectional, forward, input, and output ranges
are defined similarly.)
Viewable ranges can be converted to views.

\rSec2[range.range]{Ranges}

\pnum
The \libconcept{Range} concept defines the requirements of a type that allows
iteration over its elements by providing an iterator and sentinel
that denote the elements of the range.

\indexlibrary{\idxcode{Range}}%
\begin{itemdecl}
template<class T>
  concept @\placeholder{range-impl}@ =          // \expos
    requires(T&& t) {
      ranges::begin(std::forward<T>(t));        // sometimes equality-preserving (see below)
      ranges::end(std::forward<T>(t));
    };

template<class T>
  concept Range = @\placeholdernc{range-impl}@<T&>;

template<class T>
  concept @\placeholder{forwarding-range}@ =    // \expos
    Range<T> && @\placeholder{range-impl}@<T>;
\end{itemdecl}

\begin{itemdescr}
\pnum
The required expressions
\tcode{ranges::begin(std::forward<T>(t))}
and
\tcode{ranges::end(std::forward<\brk{}T>(t))}
of the \tcode{\placeholder{range-impl}} concept
do not require implicit expression variations\iref{concepts.equality}.

\pnum
Given an expression \tcode{E} such that \tcode{decltype((E))} is \tcode{T},
\tcode{T} models \tcode{\placeholder{range-impl}} only if

\begin{itemize}
\item \range{ranges::begin(E)}{ranges::end(E)}
  denotes a range\iref{iterator.requirements.general},

\item both
\tcode{ranges::begin(E)}
and
\tcode{ranges::end(E)}
are amortized constant time and non-modifying, and

\item if the type of \tcode{ranges::begin(E)} models
\libconcept{ForwardIterator}, \tcode{ranges::begin(E)} is equality-preserving.
\end{itemize}

\pnum
\begin{note}
Equality preservation of both \tcode{ranges::begin} and
\tcode{ranges::end} enables passing a \libconcept{Range} whose iterator
type models \libconcept{ForwardIterator} to multiple
algorithms and making multiple passes over the range by repeated calls to
\tcode{ranges::begin} and \tcode{ranges::end}.
Since \tcode{ranges::begin} is not required to be equality-preserving
when the return type does not model \libconcept{ForwardIterator}, repeated calls
might not return equal values or might not be well-defined;
\tcode{ranges::begin} should be called at most once for such a range.
\end{note}

\pnum
Given an expression \tcode{E} such that \tcode{decltype((E))} is \tcode{T}
and an lvalue \tcode{t} that denotes the same object as \tcode{E},
\tcode{T} models \tcode{\placeholdernc{forwarding-range}} only if
\begin{itemize}
\item \tcode{ranges::begin(E)} and \tcode{ranges::begin(t)}
  are expression-equivalent,
\item \tcode{ranges::end(E)} and \tcode{ranges::end(t)}
  are expression-equivalent, and
\item the validity of iterators obtained from the object denoted
  by \tcode{E} is not tied to the lifetime of that object.
\end{itemize}

\pnum
\begin{note}
Since the validity of iterators is not tied to the lifetime of
an object whose type models \tcode{\placeholdernc{forwarding-range}},
a function can accept arguments of such a type by value and
return iterators obtained from it without danger of dangling.
\end{note}

\pnum
\begin{example}
Specializations of class template \tcode{subrange}\iref{range.subrange}
model \tcode{\placeholdernc{forwarding-range}}. \tcode{subrange} provides
non-member rvalue overloads of \tcode{begin} and \tcode{end} with the same
semantics as its member lvalue overloads, and \tcode{subrange}'s iterators
- since they are ``borrowed'' from some other range -
do not have validity tied to the lifetime of a \tcode{subrange} object.
\end{example}
\end{itemdescr}

\rSec2[range.sized]{Sized ranges}

\pnum
The \libconcept{SizedRange} concept specifies the requirements
of a \libconcept{Range} type that knows its size in constant time with the
\tcode{size} function.

\indexlibrary{\idxcode{SizedRange}}%
\begin{itemdecl}
template<class T>
  concept SizedRange =
    Range<T> &&
    !disable_sized_range<remove_cvref_t<T>> &&
    requires(T& t) { ranges::size(t); };
\end{itemdecl}

\begin{itemdescr}
\pnum
Given an lvalue \tcode{t} of type \tcode{remove_reference_t<T>}, \tcode{T}
models \libconcept{SizedRange} only if

\begin{itemize}
\item \tcode{ranges::size(t)} is \bigoh{1}, does not modify \tcode{t},
and is equal to \tcode{ranges::distance(t)}, and

\item if \tcode{iterator_t<T>} models \libconcept{ForwardIterator},
\tcode{ranges::size(t)} is well-defined regardless of the evaluation of
\tcode{ranges::begin(t)}.
\begin{note}
\tcode{ranges::size(t)} is otherwise not required to be
well-defined after evaluating \tcode{ranges::begin(t)}.
For example, \tcode{ranges::size(t)} might be well-defined
for a \libconcept{SizedRange} whose iterator type
does not model \libconcept{ForwardIterator}
only if evaluated before the first call to \tcode{ranges::begin(t)}.
\end{note}
\end{itemize}

\pnum
\begin{note}
The complexity requirement for the evaluation of \tcode{ranges::size}
is non-amortized, unlike the case for the complexity of the evaluations of
\tcode{ranges::begin} and \tcode{ranges::end} in the \tcode{Range} concept.
\end{note}

\pnum
\begin{note}
\tcode{disable_sized_range} allows use of range types with the library
that satisfy but do not in fact model \libconcept{SizedRange}.
\end{note}
\end{itemdescr}

\rSec2[range.view]{Views}

\pnum
The \tcode{View} concept specifies the requirements of a \libconcept{Range} type
that has constant time copy, move, and assignment operators; that is, the cost of
these operations is not proportional to the number of elements in the
\tcode{View}.

\pnum
\begin{example}
Examples of \tcode{View}s are:

\begin{itemize}
\item A \libconcept{Range} type that wraps a pair of iterators.

\item A \libconcept{Range} type that holds its elements by \tcode{shared_ptr}
and shares ownership with all its copies.

\item A \libconcept{Range} type that generates its elements on demand.
\end{itemize}

Most containers\iref{containers} are not views since
copying the container copies the elements,
which cannot be done in constant time.
\end{example}

\indexlibrary{\idxcode{enable_view}}%
\indexlibrary{\idxcode{View}}%
\begin{itemdecl}
template<class T>
  inline constexpr bool enable_view = @\seebelow@;

template<class T>
  concept View =
    Range<T> && Semiregular<T> && enable_view<T>;
\end{itemdecl}

\begin{itemdescr}
\pnum
Since the difference between \libconcept{Range} and \libconcept{View} is largely
semantic, the two are differentiated with the help of \tcode{enable_view}.

\pnum
For a type \tcode{T}, the default value of \tcode{enable_view<T>} is:
\begin{itemize}

\item If \tcode{DerivedFrom<T, view_base>} is \tcode{true}, \tcode{true}.
\item Otherwise, if \tcode{T} is a specialization of class template
  \tcode{initializer_list}\iref{support.initlist},
  \tcode{set}\iref{set},
  \tcode{multiset}\iref{multiset},
  \tcode{unordered_set}\iref{unord.set},
  \tcode{unordered_multiset}\iref{unord.multiset}, or
  \tcode{match_results}\iref{re.results}, \tcode{false}.
\item Otherwise, if both \tcode{T} and \tcode{const T} model \libconcept{Range}
  and \tcode{iter_reference_t<iterator_t<T>{>}} is not the same type as
  \tcode{iter_reference_t<iterator_t<const T>{>}},
  \tcode{false}.
  \begin{note}
  Deep \tcode{const}-ness implies element ownership,
  whereas shallow \tcode{const}-ness implies reference semantics.
  \end{note}
\item Otherwise, \tcode{true}.
\end{itemize}

\pnum
Pursuant to \ref{namespace.std}, users may specialize \tcode{enable_view}
to \tcode{true} for types which model \libconcept{View},
and \tcode{false} for types which do not.
\end{itemdescr}

\rSec2[range.refinements]{Common range refinements}

\pnum
The \tcode{OutputRange} concept specifies requirements of a
\libconcept{Range} type for which \tcode{ranges::begin} returns
a model of \tcode{OutputIterator}\iref{iterator.concept.output}.
\tcode{InputRange}, \tcode{ForwardRange}, \tcode{BidirectionalRange},
and \tcode{RandomAccessRange} are defined similarly.

\indexlibrary{\idxcode{OutputRange}}%
\indexlibrary{\idxcode{InputRange}}%
\indexlibrary{\idxcode{ForwardRange}}%
\indexlibrary{\idxcode{BidirectionalRange}}%
\indexlibrary{\idxcode{RandomAccessRange}}%
\begin{itemdecl}
template<class R, class T>
  concept OutputRange =
    Range<R> && OutputIterator<iterator_t<R>, T>;

template<class T>
  concept InputRange =
    Range<T> && InputIterator<iterator_t<T>>;

template<class T>
  concept ForwardRange =
    InputRange<T> && ForwardIterator<iterator_t<T>>;

template<class T>
  concept BidirectionalRange =
    ForwardRange<T> && BidirectionalIterator<iterator_t<T>>;

template<class T>
  concept RandomAccessRange =
    BidirectionalRange<T> && RandomAccessIterator<iterator_t<T>>;
\end{itemdecl}

\pnum
\tcode{ContiguousRange} additionally requires that
the \tcode{ranges::data} customization point\iref{range.prim.data}
is usable with the range.

\indexlibrary{\idxcode{ContiguousRange}}%
\begin{itemdecl}
template<class T>
  concept ContiguousRange =
    RandomAccessRange<T> && ContiguousIterator<iterator_t<T>> &&
    requires(T& t) {
      { ranges::data(t) } -> Same<add_pointer_t<iter_reference_t<iterator_t<T>>>>;
    };
\end{itemdecl}

\pnum
The \tcode{CommonRange} concept specifies requirements of
a \libconcept{Range} type for which \tcode{ranges::begin} and
\tcode{ranges::end} return objects of the same type.
\begin{example}
The standard containers\iref{containers} model \tcode{CommonRange}.
\end{example}

\indexlibrary{\idxcode{CommonRange}}%
\begin{itemdecl}
template<class T>
  concept CommonRange =
    Range<T> && Same<iterator_t<T>, sentinel_t<T>>;
\end{itemdecl}

\pnum
The \libconcept{ViewableRange} concept specifies the requirements of a
\libconcept{Range} type that can be converted to a \libconcept{View} safely.

\indexlibrary{\idxcode{ViewableRange}}%
\begin{itemdecl}
template<class T>
  concept ViewableRange =
    Range<T> && (@\placeholder{forwarding-range}@<T> || View<decay_t<T>>);
\end{itemdecl}

\rSec1[range.utility]{Range utilities}

\pnum
The components in this subclause are general utilities for representing and
manipulating ranges.

\rSec2[range.utility.helpers]{Helper concepts}

\pnum
Many of the types in this subclause are specified in terms of
the following exposition-only concepts:

\begin{codeblock}
template<class R>
  concept @\placeholder{simple-view}@ =
    View<R> && Range<const R> &&
    Same<iterator_t<R>, iterator_t<const R>> &&
    Same<sentinel_t<R>, sentinel_t<const R>>;

template<InputIterator I>
  concept @\placeholder{has-arrow}@ =
    is_pointer_v<I> || requires(I i) { i.operator->(); };

template<class T, class U>
  concept @\placeholder{not-same-as}@ =
    !Same<remove_cvref_t<T>, remove_cvref_t<U>>;
\end{codeblock}

\rSec2[view.interface]{View interface}

\pnum
The class template \tcode{view_interface} is a helper for defining
\tcode{View}-like types that offer a container-like interface. It is
parameterized with the type that is derived from it.

\indexlibrary{\idxcode{view_interface}}%
\begin{codeblock}
namespace std::ranges {
  template<Range R>
  struct @\placeholdernc{range-common-iterator-impl}@ {                   // \expos
    using type = common_iterator<iterator_t<R>, sentinel_t<R>>;
  };
  template<CommonRange R>
  struct @\placeholdernc{range-common-iterator-impl}@<R> {                // \expos
    using type = iterator_t<R>;
  };
  template<Range R>
    using @\placeholdernc{range-common-iterator}@ =                       // \expos
      typename @\placeholdernc{range-common-iterator-impl}@<R>::type;

  template<class D>
    requires is_class_v<D> && Same<D, remove_cv_t<D>>
  class view_interface : public view_base {
  private:
    constexpr D& derived() noexcept {                   // \expos
      return static_cast<D&>(*this);
    }
    constexpr const D& derived() const noexcept {       // \expos
      return static_cast<const D&>(*this);
    }
  public:
    constexpr bool empty() requires ForwardRange<D> {
      return ranges::begin(derived()) == ranges::end(derived());
    }
    constexpr bool empty() const requires ForwardRange<const D> {
      return ranges::begin(derived()) == ranges::end(derived());
    }

    constexpr explicit operator bool()
      requires requires { ranges::empty(derived()); } {
        return !ranges::empty(derived());
      }
    constexpr explicit operator bool() const
      requires requires { ranges::empty(derived()); } {
        return !ranges::empty(derived());
      }

    constexpr auto data() requires ContiguousIterator<iterator_t<D>> {
      return ranges::empty(derived()) ? nullptr : addressof(*ranges::begin(derived()));
    }
    constexpr auto data() const
      requires Range<const D> && ContiguousIterator<iterator_t<const D>> {
        return ranges::empty(derived()) ? nullptr : addressof(*ranges::begin(derived()));
      }

    constexpr auto size() requires ForwardRange<D> &&
      SizedSentinel<sentinel_t<D>, iterator_t<D>> {
        return ranges::end(derived()) - ranges::begin(derived());
      }
    constexpr auto size() const requires ForwardRange<const D> &&
      SizedSentinel<sentinel_t<const D>, iterator_t<const D>> {
        return ranges::end(derived()) - ranges::begin(derived());
      }

    constexpr decltype(auto) front() requires ForwardRange<D>;
    constexpr decltype(auto) front() const requires ForwardRange<const D>;

    constexpr decltype(auto) back() requires BidirectionalRange<D> && CommonRange<D>;
    constexpr decltype(auto) back() const
      requires BidirectionalRange<const D> && CommonRange<const D>;

    template<RandomAccessRange R = D>
      constexpr decltype(auto) operator[](iter_difference_t<iterator_t<R>> n) {
        return ranges::begin(derived())[n];
      }
    template<RandomAccessRange R = const D>
      constexpr decltype(auto) operator[](iter_difference_t<iterator_t<R>> n) const {
        return ranges::begin(derived())[n];
      }
  };
}
\end{codeblock}

\pnum
The template parameter \tcode{D} for \tcode{view_interface} may be an
incomplete type. Before any member of the resulting specialization of
\tcode{view_interface} other than special member functions
is referenced, \tcode{D} shall be complete, and
model both \libconcept{DerivedFrom<view_interface<D>>} and \libconcept{View}.

\rSec3[view.interface.members]{Members}

\indexlibrary{\idxcode{view_interface}!\idxcode{front}}%
\begin{itemdecl}
constexpr decltype(auto) front() requires ForwardRange<D>;
constexpr decltype(auto) front() const requires ForwardRange<const D>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\expects \tcode{!empty()}.

\pnum
\effects Equivalent to: \tcode{return *ranges::begin(derived());}
\end{itemdescr}

\indexlibrary{\idxcode{view_interface}!\idxcode{back}}%
\begin{itemdecl}
constexpr decltype(auto) back() requires BidirectionalRange<D> && CommonRange<D>;
constexpr decltype(auto) back() const
  requires BidirectionalRange<const D> && CommonRange<const D>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\expects \tcode{!empty()}.

\pnum
\effects Equivalent to: \tcode{return *ranges::prev(ranges::end(derived()));}
\end{itemdescr}

\rSec2[range.subrange]{Sub-ranges}

\pnum
The \tcode{subrange} class template combines together an
iterator and a sentinel into a single object that models the
\libconcept{View} concept. Additionally, it models the
\libconcept{SizedRange} concept when the final template parameter is
\tcode{subrange_kind::sized}.

\indexlibrary{\idxcode{subrange}}%
\begin{codeblock}
namespace std::ranges {
  template<class T>
    concept @\placeholdernc{pair-like}@ =                                 // \expos
      !is_reference_v<T> && requires(T t) {
        typename tuple_size<T>::type; // ensures tuple_size<T> is complete
        requires DerivedFrom<tuple_size<T>, integral_constant<size_t, 2>>;
        typename tuple_element_t<0, remove_const_t<T>>;
        typename tuple_element_t<1, remove_const_t<T>>;
        { get<0>(t) } -> const tuple_element_t<0, T>&;
        { get<1>(t) } -> const tuple_element_t<1, T>&;
      };

  template<class T, class U, class V>
    concept @\placeholdernc{pair-like-convertible-to}@ =                  // \expos
      !Range<T> && @\placeholder{pair-like}@<remove_reference_t<T>> &&
      requires(T&& t) {
        { get<0>(std::forward<T>(t)) } -> ConvertibleTo<U>;
        { get<1>(std::forward<T>(t)) } -> ConvertibleTo<V>;
      };

  template<class T, class U, class V>
    concept @\placeholdernc{pair-like-convertible-from}@ =                // \expos
      !Range<T> && @\placeholdernc{pair-like}@<T> && Constructible<T, U, V>;

  template<class T>
    concept @\placeholdernc{iterator-sentinel-pair}@ =                    // \expos
      !Range<T> && @\placeholdernc{pair-like}@<T> &&
      Sentinel<tuple_element_t<1, T>, tuple_element_t<0, T>>;

  template<Iterator I, Sentinel<I> S = I, subrange_kind K =
      SizedSentinel<S, I> ? subrange_kind::sized : subrange_kind::unsized>
    requires (K == subrange_kind::sized || !SizedSentinel<S, I>)
  class subrange : public view_interface<subrange<I, S, K>> {
  private:
    static constexpr bool StoreSize =                   // \expos
      K == subrange_kind::sized && !SizedSentinel<S, I>;
    I begin_ = I();                                     // \expos
    S end_ = S();                                       // \expos
    iter_difference_t<I> size_ = 0;                     // \expos; present only
                                                        // when \tcode{StoreSize} is \tcode{true}
  public:
    subrange() = default;

    constexpr subrange(I i, S s) requires (!StoreSize);

    constexpr subrange(I i, S s, iter_difference_t<I> n)
      requires (K == subrange_kind::sized);

    template<@\placeholdernc{not-same-as}@<subrange> R>
      requires @\placeholdernc{forwarding-range}@<R> &&
        ConvertibleTo<iterator_t<R>, I> && ConvertibleTo<sentinel_t<R>, S>
    constexpr subrange(R&& r) requires (!StoreSize || SizedRange<R>);

    template<@\placeholdernc{forwarding-range}@ R>
      requires ConvertibleTo<iterator_t<R>, I> && ConvertibleTo<sentinel_t<R>, S>
    constexpr subrange(R&& r, iter_difference_t<I> n)
      requires (K == subrange_kind::sized)
        : subrange{ranges::begin(r), ranges::end(r), n}
    {}

    template<@\placeholdernc{not-same-as}@<subrange> PairLike>
      requires @\placeholdernc{pair-like-convertible-to}@<PairLike, I, S>
    constexpr subrange(PairLike&& r) requires (!StoreSize)
      : subrange{std::get<0>(std::forward<PairLike>(r)),
                 std::get<1>(std::forward<PairLike>(r))}
    {}

    template<@\placeholdernc{pair-like-convertible-to}@<I, S> PairLike>
    constexpr subrange(PairLike&& r, iter_difference_t<I> n)
      requires (K == subrange_kind::sized)
      : subrange{std::get<0>(std::forward<PairLike>(r)),
                 std::get<1>(std::forward<PairLike>(r)), n}
    {}

    template<@\placeholdernc{not-same-as}@<subrange> PairLike>
      requires @\placeholdernc{pair-like-convertible-from}@<PairLike, const I&, const S&>
    constexpr operator PairLike() const;

    constexpr I begin() const;
    constexpr S end() const;

    constexpr bool empty() const;
    constexpr iter_difference_t<I> size() const
      requires (K == subrange_kind::sized);

    [[nodiscard]] constexpr subrange next(iter_difference_t<I> n = 1) const;
    [[nodiscard]] constexpr subrange prev(iter_difference_t<I> n = 1) const
      requires BidirectionalIterator<I>;
    constexpr subrange& advance(iter_difference_t<I> n);

    friend constexpr I begin(subrange&& r) { return r.begin(); }
    friend constexpr S end(subrange&& r) { return r.end(); }
  };

  template<Iterator I, Sentinel<I> S>
    subrange(I, S, iter_difference_t<I>) -> subrange<I, S, subrange_kind::sized>;

  template<@\placeholder{iterator-sentinel-pair}@ P>
    subrange(P) -> subrange<tuple_element_t<0, P>, tuple_element_t<1, P>>;

  template<@\placeholder{iterator-sentinel-pair}@ P>
    subrange(P, iter_difference_t<tuple_element_t<0, P>>) ->
      subrange<tuple_element_t<0, P>, tuple_element_t<1, P>, subrange_kind::sized>;

  template<@\placeholder{forwarding-range}@ R>
    subrange(R&&) ->
      subrange<iterator_t<R>, sentinel_t<R>,
               (SizedRange<R> || SizedSentinel<sentinel_t<R>, iterator_t<R>>)
                 ? subrange_kind::sized : subrange_kind::unsized>;

  template<@\placeholder{forwarding-range}@ R>
    subrange(R&&, iter_difference_t<iterator_t<R>>) ->
      subrange<iterator_t<R>, sentinel_t<R>, subrange_kind::sized>;

  template<size_t N, class I, class S, subrange_kind K>
    requires (N < 2)
  constexpr auto get(const subrange<I, S, K>& r);
}

namespace std {
  using ranges::get;
}
\end{codeblock}

\rSec3[range.subrange.ctor]{Constructors and conversions}

\indexlibrary{\idxcode{subrange}!\idxcode{subrange}}%
\begin{itemdecl}
constexpr subrange(I i, S s) requires (!StoreSize);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{begin_} with \tcode{i} and \tcode{end_} with
\tcode{s}.
\end{itemdescr}

\indexlibrary{\idxcode{subrange}!\idxcode{subrange}}%
\begin{itemdecl}
constexpr subrange(I i, S s, iter_difference_t<I> n)
  requires (K == subrange_kind::sized);
\end{itemdecl}

\begin{itemdescr}
\pnum
\expects \tcode{n == ranges::distance(i, s)}.

\pnum
\effects Initializes \tcode{begin_} with \tcode{i} and \tcode{end_} with
\tcode{s}. If \tcode{StoreSize} is \tcode{true}, initializes \tcode{size_} with
\tcode{n}.

\pnum
\begin{note}
Accepting the length of the range and storing it to later return  from
\tcode{size()} enables \tcode{subrange} to model \libconcept{SizedRange} even
when it stores an iterator and sentinel that do not model
\libconcept{SizedSentinel}.
\end{note}
\end{itemdescr}

\indexlibrary{\idxcode{subrange}!\idxcode{subrange}}%
\begin{itemdecl}
template<@\placeholdernc{not-same-as}@<subrange> R>
  requires @\placeholdernc{forwarding-range}@<R> &&
           ConvertibleTo<iterator_t<R>, I> && ConvertibleTo<sentinel_t<R>, S>
constexpr subrange(R&& r) requires (!StoreSize || SizedRange<R>);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{itemize}
\item If \tcode{StoreSize} is \tcode{true},
\tcode{subrange\{ranges::begin(r), ranges::end(r), ranges::size(r)\}}.
\item Otherwise, \tcode{subrange\{ranges::begin(r), ranges::end(r)\}}.
\end{itemize}
\end{itemdescr}

\indexlibrary{\idxcode{operator \placeholder{PairLike}}!\idxcode{subrange}}%
\begin{itemdecl}
template<@\placeholdernc{not-same-as}@<subrange> PairLike>
  requires @\placeholdernc{pair-like-convertible-from}@<PairLike, const I&, const S&>
constexpr operator PairLike() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return PairLike(begin_, end_);}
\end{itemdescr}

\rSec3[range.subrange.access]{Accessors}

\indexlibrary{\idxcode{begin}!\idxcode{subrange}}%
\begin{itemdecl}
constexpr I begin() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return begin_;}
\end{itemdescr}

\indexlibrary{\idxcode{end}!\idxcode{subrange}}%
\begin{itemdecl}
constexpr S end() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return end_;}
\end{itemdescr}

\indexlibrary{\idxcode{empty}!\idxcode{subrange}}%
\begin{itemdecl}
constexpr bool empty() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return begin_ == end_;}
\end{itemdescr}

\indexlibrary{\idxcode{size}!\idxcode{subrange}}%
\begin{itemdecl}
constexpr iter_difference_t<I> size() const
  requires (K == subrange_kind::sized);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
\begin{itemize}
\item If \tcode{StoreSize} is \tcode{true}, equivalent to: \tcode{return size_;}
\item Otherwise, equivalent to: \tcode{return end_ - begin_;}
\end{itemize}
\end{itemdescr}

\indexlibrary{\idxcode{next}!\idxcode{subrange}}%
\begin{itemdecl}
[[nodiscard]] constexpr subrange next(iter_difference_t<I> n = 1) const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
auto tmp = *this;
tmp.advance(n);
return tmp;
\end{codeblock}

\pnum
\begin{note}
If \tcode{I} does not model \libconcept{ForwardIterator}, \tcode{next}
can invalidate \tcode{*this}.
\end{note}
\end{itemdescr}

\indexlibrary{\idxcode{prev}!\idxcode{subrange}}%
\begin{itemdecl}
[[nodiscard]] constexpr subrange prev(iter_difference_t<I> n = 1) const
  requires BidirectionalIterator<I>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
auto tmp = *this;
tmp.advance(-n);
return tmp;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{advance}!\idxcode{subrange}}%
\begin{itemdecl}
constexpr subrange& advance(iter_difference_t<I> n);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{itemize}
\item If \tcode{StoreSize} is \tcode{true},
\begin{codeblock}
size_ -= n - ranges::advance(begin_, n, end_);
return *this;
\end{codeblock}
\item Otherwise,
\begin{codeblock}
ranges::advance(begin_, n, end_);
return *this;
\end{codeblock}
\end{itemize}
\end{itemdescr}

\indexlibrary{\idxcode{get}!\idxcode{subrange}}%
\begin{itemdecl}
template<size_t N, class I, class S, subrange_kind K>
  requires (N < 2)
constexpr auto get(const subrange<I, S, K>& r);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
if constexpr (N == 0)
  return r.begin();
else
  return r.end();
\end{codeblock}
\end{itemdescr}


\rSec1[range.adaptors]{Range adaptors}

\pnum
This subclause defines \term{range adaptors}, which are utilities that transform a
\libconcept{Range} into a \libconcept{View} with custom behaviors. These
adaptors can be chained to create pipelines of range transformations that
evaluate lazily as the resulting view is iterated.

\pnum
Range adaptors are declared in namespace \tcode{std::ranges::view}.

\pnum
The bitwise \logop{OR} operator is overloaded for the purpose of creating adaptor chain
pipelines. The adaptors also support function call syntax with equivalent
semantics.

\pnum
\begin{example}
\begin{codeblock}
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{codeblock}
\end{example}

\rSec2[range.adaptor.object]{Range adaptor objects}

\pnum
A \term{range adaptor closure object} is a unary function object that accepts
a \libconcept{ViewableRange} argument and returns a \libconcept{View}. For
a range adaptor closure object \tcode{C} and an expression \tcode{R} such that
\tcode{decltype((R))} models \libconcept{ViewableRange}, the following
expressions are equivalent and yield a \libconcept{View}:

\begin{codeblock}
C(R)
R | C
\end{codeblock}

Given an additional range adaptor closure object \tcode{D},
the expression \tcode{C | D} is well-formed and produces another range adaptor
closure object such that the following two expressions are equivalent:

\begin{codeblock}
R | C | D
R | (C | D)
\end{codeblock}

\pnum
A \term{range adaptor object} is a
customization point object\iref{customization.point.object}
that accepts a \libconcept{ViewableRange} as its first argument and returns a
\libconcept{View}.

\pnum
If a range adaptor object accepts only one argument,
then it is a range adaptor closure object.

\pnum
If a range adaptor object accepts more than one argument,
then the following expressions are equivalent:

\begin{codeblock}
@\placeholdernc{adaptor}@(range, args...)
@\placeholdernc{adaptor}@(args...)(range)
range | @\placeholdernc{adaptor}@(args...)
\end{codeblock}

In this case, \tcode{\placeholdernc{adaptor}(args...)} is a range adaptor
closure object.

\rSec2[range.semi.wrap]{Semiregular wrapper}

\pnum
Many of the types in this subclause are specified in terms of
an exposition-only class template \tcode{\placeholder{semiregular}}.
\tcode{\placeholder{semiregular}<T>} behaves exactly like \tcode{optional<T>}
with the following differences:

\begin{itemize}
\item \tcode{\placeholder{semiregular}<T>} constrains
its type parameter \tcode{T} with
\tcode{\libconcept{CopyConstructible}<T> \&\& is_object_v<T>}.

\item If \tcode{T} models \libconcept{DefaultConstructible}, the default
constructor of \tcode{\placeholder{semiregular}<T>} is equivalent to:
\begin{codeblock}
constexpr @\placeholder{semiregular}@() noexcept(is_nothrow_default_constructible_v<T>)
  : @\placeholder{semiregular}@{in_place}
{ }
\end{codeblock}

\item If \tcode{\libconcept{Assignable}<T\&, const T\&>} is not
satisfied, the copy assignment operator is equivalent to:
\begin{codeblock}
@\placeholder{semiregular}@& operator=(const @\placeholder{semiregular}@& that)
  noexcept(is_nothrow_copy_constructible_v<T>)
{
  if (that) emplace(*that);
  else reset();
  return *this;
}
\end{codeblock}

\item If \tcode{\libconcept{Assignable}<T\&, T>} is not satisfied,
the move assignment operator is equivalent to:
\begin{codeblock}
@\placeholder{semiregular}@& operator=(@\placeholder{semiregular}@&& that)
  noexcept(is_nothrow_move_constructible_v<T>)
{
  if (that) emplace(std::move(*that));
  else reset();
  return *this;
}
\end{codeblock}
\end{itemize}

\rSec2[range.all]{All view}

\pnum
\tcode{view::all} returns a \libconcept{View} that includes all elements of
its \libconcept{Range} argument.

\pnum
The name \tcode{view::all} denotes a
range adaptor object\iref{range.adaptor.object}.
For some subexpression \tcode{E}, the expression
\tcode{view::all(E)} is expression-equivalent to:

\begin{itemize}
\item \tcode{\placeholdernc{DECAY_COPY}(E)} if the decayed type of \tcode{E}
models \libconcept{View}.

\item Otherwise, \tcode{\placeholder{ref-view}\{E\}} if that
expression is well-formed, where \tcode{\placeholder{ref-view}}
is the exposition-only \libconcept{View} specified below.

\item Otherwise, \tcode{subrange\{E\}}.
\end{itemize}

\rSec3[range.view.ref]{\placeholder{ref-view}}

\begin{codeblock}
namespace std::ranges {
  template<Range R>
    requires is_object_v<R>
  class @\placeholder{ref-view}@ : public view_interface<@\placeholder{ref-view}@<R>> {
  private:
    R* r_ = nullptr;            // \expos
  public:
    constexpr @\placeholdernc{ref-view}@() noexcept = default;

    template<@\placeholder{not-same-as}@<@\placeholder{ref-view}@> T>
      requires @\seebelow@
    constexpr @\placeholder{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(@\placeholder{ref-view}@ r)
    { return r.begin(); }

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

\indexlibrary{\idxcode{\placeholder{ref-view}}!\idxcode{\placeholder{ref-view}}}%
\begin{itemdecl}
template<@\placeholder{not-same-as}@<@\placeholder{ref-view}@> T>
  requires @\seebelow@
constexpr @\placeholder{ref-view}@(T&& t);
\end{itemdecl}

\begin{itemdescr}
\pnum
\remarks Let \tcode{\placeholder{FUN}} denote the exposition-only functions
\begin{codeblock}
void @\placeholder{FUN}@(R&);
void @\placeholder{FUN}@(R&&) = delete;
\end{codeblock}
The expression in the \grammarterm{requires-clause} is equivalent to
\begin{codeblock}
ConvertibleTo<T, R&> && requires { @\placeholder{FUN}@(declval<T>()); }
\end{codeblock}

\pnum
\effects
Initializes \tcode{r_} with
\tcode{addressof(static_cast<R\&>(std::forward<T>(t)))}.
\end{itemdescr}


\rSec2[range.filter]{Filter view}

\rSec3[range.filter.overview]{Overview}

\pnum
\tcode{filter_view} presents a \libconcept{View} of an underlying sequence
without the elements that fail to satisfy a predicate.

\pnum
\begin{example}
\begin{codeblock}
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{codeblock}
\end{example}

\rSec3[range.filter.view]{Class template \tcode{filter_view}}

\begin{codeblock}
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();              // \expos
    @\placeholdernc{semiregular}@<Pred> pred_;    // \expos

    class iterator;             // \expos
    class sentinel;             // \expos

  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>;
}
\end{codeblock}

\indexlibrary{\idxcode{filter_view}!\idxcode{filter_view}}%
\begin{itemdecl}
constexpr filter_view(V base, Pred pred);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{base_} with \tcode{std::move(base)} and initializes
\tcode{pred_} with \tcode{std::move(pred)}.
\end{itemdescr}

\indexlibrary{\idxcode{filter_view}!\idxcode{filter_view}}%
\begin{itemdecl}
template<InputRange R>
  requires ViewableRange<R> && Constructible<V, all_view<R>>
constexpr filter_view(R&& r, Pred pred);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{base_} with \tcode{view::all(std::forward<R>(r))}
and initializes \tcode{pred_} with \tcode{std::\brk{}move(pred)}.
\end{itemdescr}

\indexlibrary{\idxcode{base}!\idxcode{filter_view}}%
\begin{itemdecl}
constexpr V base() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return base_;}
\end{itemdescr}

\indexlibrary{\idxcode{begin}!\idxcode{filter_view}}%
\begin{itemdecl}
constexpr iterator begin();
\end{itemdecl}

\begin{itemdescr}
\pnum
\expects
\tcode{pred_.has_value()}.

\pnum
\returns
\tcode{\{*this, ranges::find_if(base_, ref(*pred_))\}}.

\pnum
\remarks In order to provide the amortized constant time complexity required by
the \libconcept{Range} concept, this function caches the result within the
\tcode{filter_view} for use on subsequent calls.
\end{itemdescr}

\rSec3[range.filter.iterator]{Class \tcode{filter_view::iterator}}

\indexlibrary{\idxcode{iterator}!\idxcode{filter_view}}%
\begin{codeblock}
namespace std::ranges {
  template<class V, class Pred>
  class filter_view<V, Pred>::iterator {
  private:
    iterator_t<V> current_ = iterator_t<V>();   // \expos
    filter_view* parent_ = nullptr;             // \expos
  public:
    using iterator_concept  = @\seebelow@;
    using iterator_category = @\seebelow@;
    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 @\placeholder{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>>;
  };
}
\end{codeblock}

\pnum
Modification of the element a \tcode{filter_view::iterator} denotes is
permitted, but results in undefined behavior if the resulting value does not
satisfy the filter predicate.

\pnum
\tcode{iterator::iterator_concept} is defined as follows:
\begin{itemize}
\item If \tcode{V} models \libconcept{BidirectionalRange}, then
\tcode{iterator_concept} denotes \tcode{bidirectional_iterator_tag}.

\item Otherwise, if \tcode{V} models \libconcept{ForwardRange}, then
\tcode{iterator_concept} denotes \tcode{forward_iterator_tag}.

\item Otherwise, \tcode{iterator_concept} denotes \tcode{input_iterator_tag}.
\end{itemize}

\pnum
\tcode{iterator::iterator_category} is defined as follows:
\begin{itemize}
\item Let \tcode{C} denote the type
\tcode{iterator_traits<iterator_t<V>>::iterator_category}.

\item If \tcode{C} models \tcode{DerivedFrom<bidirectional_iterator_tag>},
then \tcode{iterator_category} denotes \tcode{bi\-directional_iterator_tag}.

\item Otherwise, if  \tcode{C} models \tcode{DerivedFrom<forward_iterator_tag>},
then \tcode{iterator_category} denotes \tcode{forward_iterator_tag}.

\item Otherwise, \tcode{iterator_category} denotes \tcode{input_iterator_tag}.
\end{itemize}

\indexlibrary{\idxcode{iterator}!\idxcode{filter_view::iterator}}%
\begin{itemdecl}
constexpr iterator(filter_view& parent, iterator_t<V> current);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{current_} with \tcode{current} and
\tcode{parent_} with \tcode{addressof(parent)}.
\end{itemdescr}

\indexlibrary{\idxcode{base}!\idxcode{filter_view::iterator}}%
\begin{itemdecl}
constexpr iterator_t<V> base() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return current_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator*}!\idxcode{filter_view::iterator}}%
\begin{itemdecl}
constexpr iter_reference_t<iterator_t<V>> operator*() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return *current_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator->}!\idxcode{filter_view::iterator}}%
\begin{itemdecl}
constexpr iterator_t<V> operator->() const
  requires @\placeholder{has-arrow}@<iterator_t<V>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
Equivalent to: \tcode{return current_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator++}!\idxcode{filter_view::iterator}}%
\begin{itemdecl}
constexpr iterator& operator++();
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
current_ = ranges::find_if(++current_, ranges::end(parent_->base_), ref(*parent_->pred_));
return *this;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator++}!\idxcode{filter_view::iterator}}%
\begin{itemdecl}
constexpr void operator++(int);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to \tcode{++*this}.
\end{itemdescr}

\indexlibrary{\idxcode{operator++}!\idxcode{filter_view::iterator}}%
\begin{itemdecl}
constexpr iterator operator++(int) requires ForwardRange<V>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
auto tmp = *this;
++*this;
return tmp;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator\dcr}!\idxcode{filter_view::iterator}}%
\begin{itemdecl}
constexpr iterator& operator--() requires BidirectionalRange<V>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
do
  --current_;
while (!invoke(*parent_->pred_, *current_));
return *this;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator\dcr}!\idxcode{filter_view::iterator}}%
\begin{itemdecl}
constexpr iterator operator--(int) requires BidirectionalRange<V>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
auto tmp = *this;
--*this;
return tmp;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator==}!\idxcode{filter_view::iterator}}%
\begin{itemdecl}
friend constexpr bool operator==(const iterator& x, const iterator& y)
  requires EqualityComparable<iterator_t<V>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return x.current_ == y.current_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator!=}!\idxcode{filter_view::iterator}}%
\begin{itemdecl}
friend constexpr bool operator!=(const iterator& x, const iterator& y)
  requires EqualityComparable<iterator_t<V>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(x == y);}
\end{itemdescr}

\indexlibrary{\idxcode{iter_move}!\idxcode{filter_view::iterator}}%
\begin{itemdecl}
friend constexpr iter_rvalue_reference_t<iterator_t<V>> iter_move(const iterator& i)
  noexcept(noexcept(ranges::iter_move(i.current_)));
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return ranges::iter_move(i.current_);}
\end{itemdescr}

\indexlibrary{\idxcode{iter_swap}!\idxcode{filter_view::iterator}}%
\begin{itemdecl}
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>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to \tcode{ranges::iter_swap(x.current_, y.current_)}.
\end{itemdescr}

\rSec3[range.filter.sentinel]{Class \tcode{filter_view::sentinel}}

\indexlibrary{\idxcode{sentinel}!\idxcode{filter_view}}%
\begin{codeblock}
namespace std::ranges {
  template<class V, class Pred>
  class filter_view<V, Pred>::sentinel {
  private:
    sentinel_t<V> end_ = sentinel_t<V>();       // \expos
  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);
  };
}
\end{codeblock}

\indexlibrary{\idxcode{sentinel}!\idxcode{filter_view::sentinel}}%
\begin{itemdecl}
constexpr explicit sentinel(filter_view& parent);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{end_} with \tcode{ranges::end(parent)}.
\end{itemdescr}

\indexlibrary{\idxcode{base}!\idxcode{filter_view::sentinel}}%
\begin{itemdecl}
constexpr sentinel_t<V> base() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return end_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator==}!\idxcode{filter_view::sentinel}}%
\begin{itemdecl}
friend constexpr bool operator==(const iterator& x, const sentinel& y);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return x.current_ == y.end_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator==}!\idxcode{filter_view::sentinel}}%
\begin{itemdecl}
friend constexpr bool operator==(const sentinel& x, const iterator& y);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return y == x;}
\end{itemdescr}

\indexlibrary{\idxcode{operator!=}!\idxcode{filter_view::sentinel}}%
\begin{itemdecl}
friend constexpr bool operator!=(const iterator& x, const sentinel& y);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(x == y);}
\end{itemdescr}

\indexlibrary{\idxcode{operator!=}!\idxcode{filter_view::sentinel}}%
\begin{itemdecl}
friend constexpr bool operator!=(const sentinel& x, const iterator& y);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(y == x);}
\end{itemdescr}

\rSec3[range.filter.adaptor]{\tcode{view::filter}}

\pnum
The name \tcode{view::filter} denotes a
range adaptor object\iref{range.adaptor.object}.
For some subexpressions \tcode{E} and \tcode{P},
the expression \tcode{view::filter(E, P)} is expression-equivalent to
\tcode{filter_view\{E, P\}}.


\rSec2[range.transform]{Transform view}

\rSec3[range.transform.overview]{Overview}

\pnum
\tcode{transform_view} presents
a \libconcept{View} of an underlying sequence after
applying a transformation function to each element.

\pnum
\begin{example}
\begin{codeblock}
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{codeblock}
\end{example}

\rSec3[range.transform.view]{Class template \tcode{transform_view}}

\begin{codeblock}
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;             // \expos
    template<bool> struct sentinel;             // \expos

    V base_ = V();                              // \expos
    @\placeholdernc{semiregular}@<F> fun_;                        // \expos

  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>;
}
\end{codeblock}

\indexlibrary{\idxcode{transform_view}!\idxcode{transform_view}}%
\begin{itemdecl}
constexpr transform_view(V base, F fun);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{base_} with \tcode{std::move(base)} and
\tcode{fun_} with \tcode{std::move(fun)}.
\end{itemdescr}

\indexlibrary{\idxcode{transform_view}!\idxcode{transform_view}}%
\begin{itemdecl}
template<InputRange R>
  requires ViewableRange<R> && Constructible<V, all_view<R>>
constexpr transform_view(R&& r, F fun);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{base_} with \tcode{view::all(std::forward<R>(r))}
and \tcode{fun_} with \tcode{std::move(fun)}.
\end{itemdescr}

\indexlibrary{\idxcode{base}!\idxcode{transform_view}}%
\begin{itemdecl}
constexpr V base() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return base_;}
\end{itemdescr}

\indexlibrary{\idxcode{begin}!\idxcode{transform_view}}%
\begin{itemdecl}
constexpr iterator<false> begin();
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
return iterator<false>{*this, ranges::begin(base_)};
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{begin}!\idxcode{transform_view}}%
\begin{itemdecl}
constexpr iterator<true> begin() const
  requires Range<const V> &&
           RegularInvocable<const F&, iter_reference_t<iterator_t<const V>>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
return iterator<true>{*this, ranges::begin(base_)};
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{end}!\idxcode{transform_view}}%
\begin{itemdecl}
constexpr sentinel<false> end();
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
return sentinel<false>{ranges::end(base_)};
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{end}!\idxcode{transform_view}}%
\begin{itemdecl}
constexpr iterator<false> end() requires CommonRange<V>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
return iterator<false>{*this, ranges::end(base_)};
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{end}!\idxcode{transform_view}}%
\begin{itemdecl}
constexpr sentinel<true> end() const
  requires Range<const V> &&
           RegularInvocable<const F&, iter_reference_t<iterator_t<const V>>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
return sentinel<true>{ranges::end(base_)};
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{end}!\idxcode{transform_view}}%
\begin{itemdecl}
constexpr iterator<true> end() const
  requires CommonRange<const V> &&
           RegularInvocable<const F&, iter_reference_t<iterator_t<const V>>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
return iterator<true>{*this, ranges::end(base_)};
\end{codeblock}
\end{itemdescr}

\rSec3[range.transform.iterator]{Class template \tcode{transform_view::iterator}}

\begin{codeblock}
namespace std::ranges {
  template<class V, class F>
  template<bool Const>
  class transform_view<V, F>::iterator {
  private:
    using Parent =                              // \expos
      conditional_t<Const, const transform_view, transform_view>;
    using Base   =                              // \expos
      conditional_t<Const, const V, V>;
    iterator_t<Base> current_ =                 // \expos
      iterator_t<Base>();
    Parent* parent_ = nullptr;                  // \expos
  public:
    using iterator_concept  = @\seebelow@;
    using iterator_category = @\seebelow@;
    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>>;
  };
}
\end{codeblock}

\pnum
\tcode{iterator::iterator_concept} is defined as follows:
\begin{itemize}
\item If \tcode{V} models \libconcept{RandomAccessRange}, then
\tcode{iterator_concept} denotes \tcode{random_access_iterator_tag}.

\item Otherwise, if \tcode{V} models \libconcept{BidirectionalRange}, then
\tcode{iterator_concept} denotes \tcode{bidirectional_iterator_tag}.

\item Otherwise, if \tcode{V} models \libconcept{ForwardRange}, then
\tcode{iterator_concept} denotes \tcode{forward_iterator_tag}.

\item Otherwise, \tcode{iterator_concept} denotes \tcode{input_iterator_tag}.
\end{itemize}

\pnum
Let \tcode{C} denote the type
\tcode{iterator_traits<iterator_t<Base>>::iterator_category}.
If \tcode{C} models \tcode{\libconcept{Derived\-From}<contiguous_iterator_tag>},
then \tcode{iterator_category} denotes
\tcode{random_access_iterator_tag}; otherwise,
\tcode{iterator_category} denotes \tcode{C}.

\indexlibrary{\idxcode{iterator}!\idxcode{transform_view::iterator}}
\begin{itemdecl}
constexpr iterator(Parent& parent, iterator_t<Base> current);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{current_} with \tcode{current} and
\tcode{parent_} with \tcode{addressof(parent)}.
\end{itemdescr}

\indexlibrary{\idxcode{iterator}!\idxcode{transform_view::iterator}}%
\begin{itemdecl}
constexpr iterator(iterator<!Const> i)
  requires Const && ConvertibleTo<iterator_t<V>, iterator_t<Base>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{current_} with \tcode{std::move(i.current_)} and
\tcode{parent_} with \tcode{i.parent_}.
\end{itemdescr}

\indexlibrary{\idxcode{base}!\idxcode{transform_view::iterator}}
\begin{itemdecl}
constexpr iterator_t<Base> base() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return current_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator++}!\idxcode{transform_view::iterator}}
\begin{itemdecl}
constexpr iterator& operator++();
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
++current_;
return *this;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator++}!\idxcode{transform_view::iterator}}
\begin{itemdecl}
constexpr void operator++(int);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to \tcode{++current_}.
\end{itemdescr}

\indexlibrary{\idxcode{operator++}!\idxcode{transform_view::iterator}}
\begin{itemdecl}
constexpr iterator operator++(int) requires ForwardRange<Base>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
auto tmp = *this;
++*this;
return tmp;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator\dcr}!\idxcode{transform_view::iterator}}
\begin{itemdecl}
constexpr iterator& operator--() requires BidirectionalRange<Base>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
--current_;
return *this;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator\dcr}!\idxcode{transform_view::iterator}}
\begin{itemdecl}
constexpr iterator operator--(int) requires BidirectionalRange<Base>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
auto tmp = *this;
--*this;
return tmp;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator+=}!\idxcode{transform_view::iterator}}
\begin{itemdecl}
constexpr iterator& operator+=(difference_type n)
  requires RandomAccessRange<Base>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
current_ += n;
return *this;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator-=}!\idxcode{transform_view::iterator}}%
\begin{itemdecl}
constexpr iterator& operator-=(difference_type n)
  requires RandomAccessRange<Base>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
current_ -= n;
return *this;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator==}!\idxcode{transform_view::iterator}}
\begin{itemdecl}
friend constexpr bool operator==(const iterator& x, const iterator& y)
  requires EqualityComparable<iterator_t<Base>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return x.current_ == y.current_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator!=}!\idxcode{transform_view::iterator}}%
\begin{itemdecl}
friend constexpr bool operator!=(const iterator& x, const iterator& y)
  requires EqualityComparable<iterator_t<Base>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(x == y);}
\end{itemdescr}

\indexlibrary{\idxcode{operator<}!\idxcode{transform_view::iterator}}%
\begin{itemdecl}
friend constexpr bool operator<(const iterator& x, const iterator& y)
  requires RandomAccessRange<Base>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return x.current_ < y.current_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator>}!\idxcode{transform_view::iterator}}%
\begin{itemdecl}
friend constexpr bool operator>(const iterator& x, const iterator& y)
  requires RandomAccessRange<Base>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return y < x;}
\end{itemdescr}

\indexlibrary{\idxcode{operator<=}!\idxcode{transform_view::iterator}}%
\begin{itemdecl}
friend constexpr bool operator<=(const iterator& x, const iterator& y)
  requires RandomAccessRange<Base>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(y < x);}
\end{itemdescr}

\indexlibrary{\idxcode{operator>=}!\idxcode{transform_view::iterator}}%
\begin{itemdecl}
friend constexpr bool operator>=(const iterator& x, const iterator& y)
  requires RandomAccessRange<Base>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(x < y);}
\end{itemdescr}

\indexlibrary{\idxcode{operator+}!\idxcode{transform_view::iterator}}
\begin{itemdecl}
friend constexpr iterator operator+(iterator i, difference_type n)
  requires RandomAccessRange<Base>;
friend constexpr iterator operator+(difference_type n, iterator i)
  requires RandomAccessRange<Base>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return iterator\{*i.parent_, i.current_ + n\};}
\end{itemdescr}

\indexlibrary{\idxcode{operator-}!\idxcode{transform_view::iterator}}%
\begin{itemdecl}
friend constexpr iterator operator-(iterator i, difference_type n)
  requires RandomAccessRange<Base>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return iterator\{*i.parent_, i.current_ - n\};}
\end{itemdescr}

\indexlibrary{\idxcode{operator-}!\idxcode{transform_view::iterator}}%
\begin{itemdecl}
friend constexpr difference_type operator-(const iterator& x, const iterator& y)
  requires RandomAccessRange<Base>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return x.current_ - y.current_;}
\end{itemdescr}

\indexlibrary{\idxcode{iter_swap}!\idxcode{transform_view::iterator}}
\begin{itemdecl}
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>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to \tcode{ranges::iter_swap(x.current_, y.current_)}.
\end{itemdescr}


\rSec3[range.transform.sentinel]{Class template \tcode{transform_view::sentinel}}

\begin{codeblock}
namespace std::ranges {
  template<class V, class F>
  template<bool Const>
  class transform_view<V, F>::sentinel {
  private:
    using Parent =                                      // \expos
      conditional_t<Const, const transform_view, transform_view>;
    using Base = conditional_t<Const, const V, V>;      // \expos
    sentinel_t<Base> end_ = sentinel_t<Base>();         // \expos
  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>>;
  };
}
\end{codeblock}

\indexlibrary{\idxcode{sentinel}!\idxcode{transform_view::sentinel}}
\begin{itemdecl}
constexpr explicit sentinel(sentinel_t<Base> end);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{end_} with \tcode{end}.
\end{itemdescr}

\indexlibrary{\idxcode{sentinel}!\idxcode{transform_view::sentinel}}
\begin{itemdecl}
constexpr sentinel(sentinel<!Const> i)
  requires Const && ConvertibleTo<sentinel_t<V>, sentinel_t<Base>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{end_} with \tcode{std::move(i.end_)}.
\end{itemdescr}

\indexlibrary{\idxcode{base}!\idxcode{transform_view::sentinel}}
\begin{itemdecl}
constexpr sentinel_t<Base> base() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return end_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator==}!\idxcode{transform_view::sentinel}}
\begin{itemdecl}
friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return x.current_ == y.end_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator==}!\idxcode{transform_view::sentinel}}
\begin{itemdecl}
friend constexpr bool operator==(const sentinel& x, const iterator<Const>& y);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return y == x;}
\end{itemdescr}

\indexlibrary{\idxcode{operator!=}!\idxcode{transform_view::sentinel}}%
\begin{itemdecl}
friend constexpr bool operator!=(const iterator<Const>& x, const sentinel& y);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(x == y);}
\end{itemdescr}

\indexlibrary{\idxcode{operator!=}!\idxcode{transform_view::sentinel}}%
\begin{itemdecl}
friend constexpr bool operator!=(const sentinel& x, const iterator<Const>& y);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(y == x);}
\end{itemdescr}

\indexlibrary{\idxcode{operator!=}!\idxcode{transform_view::sentinel}}%
\begin{itemdecl}
friend constexpr iter_difference_t<iterator_t<Base>>
  operator-(const iterator<Const>& x, const sentinel& y)
    requires SizedSentinel<sentinel_t<Base>, iterator_t<Base>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return x.current_ - y.end_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator!=}!\idxcode{transform_view::sentinel}}%
\begin{itemdecl}
friend constexpr iter_difference_t<iterator_t<Base>>
  operator-(const sentinel& y, const iterator<Const>& x)
    requires SizedSentinel<sentinel_t<Base>, iterator_t<Base>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return x.end_ - y.current_;}
\end{itemdescr}

\rSec3[range.transform.adaptor]{\tcode{view::transform}}

\pnum
The name \tcode{view::transform} denotes a
range adaptor object\iref{range.adaptor.object}.
For some subexpressions \tcode{E} and \tcode{F}, the expression
\tcode{view::transform(E, F)} is expression-equivalent to
\tcode{transform_view\{E, F\}}.


\rSec2[range.iota]{Iota view}

\rSec3[range.iota.overview]{Overview}

\pnum
\tcode{iota_view} generates a
sequence of elements by repeatedly incrementing an initial value.

\pnum
\begin{example}
\begin{codeblock}
for (int i : iota_view{1, 10})
  cout << i << ' '; // prints: 1 2 3 4 5 6 7 8 9
\end{codeblock}
\end{example}

\rSec3[range.iota.view]{Class template \tcode{iota_view}}

\begin{codeblock}
namespace std::ranges {
  template<class I>
    concept @\placeholdernc{Decrementable}@ =     // \expos
      @\seebelow@;
  template<class I>
    concept @\placeholdernc{Advanceable}@ =       // \expos
      @\seebelow@;

  template<WeaklyIncrementable W, Semiregular Bound = unreachable_sentinel_t>
    requires @\placeholdernc{weakly-equality-comparable-with}@<W, Bound>
  class iota_view : public view_interface<iota_view<W, Bound>> {
  private:
    struct iterator;            // \expos
    struct sentinel;            // \expos
    W value_ = W();             // \expos
    Bound bound_ = Bound();     // \expos
  public:
    iota_view() = default;
    constexpr explicit iota_view(W value);
    constexpr iota_view(type_identity_t<W> value,
                        type_identity_t<Bound> bound);

    constexpr iterator begin() const;
    constexpr sentinel end() const;
    constexpr iterator end() const requires Same<W, Bound>;

    constexpr auto size() const
      requires (Same<W, Bound> && @\placeholdernc{Advanceable}@<W>) ||
               (Integral<W> && Integral<Bound>) ||
               SizedSentinel<Bound, W>
    { return bound_ - value_; }
  };

  template<class W, class Bound>
    requires (!Integral<W> || !Integral<Bound> || is_signed_v<W> == is_signed_v<Bound>)
  iota_view(W, Bound) -> iota_view<W, Bound>;
}
\end{codeblock}

\pnum
The exposition-only \tcode{\placeholder{Decrementable}} concept is equivalent to:
\begin{itemdecl}
template<class I>
  concept @\placeholder{Decrementable}@ =
    Incrementable<I> && requires(I i) {
      { --i } -> Same<I&>;
      { i-- } -> Same<I>;
    };
\end{itemdecl}

\begin{itemdescr}
\pnum
When an object is in the domain of both pre- and post-decrement,
the object is said to be \term{decrementable}.

\pnum
Let \tcode{a} and \tcode{b} be equal objects of type \tcode{I}.
\tcode{I} models \tcode{\placeholdernc{Decrementable}} only if
\begin{itemize}
\item If \tcode{a} and \tcode{b} are decrementable,
  then the following are all true:
  \begin{itemize}
  \item \tcode{addressof(--a) == addressof(a)}
  \item \tcode{bool(a-- == b)}
  \item \tcode{bool(((void)a--, a) == --b)}
  \item \tcode{bool(++(--a) == b)}.
  \end{itemize}
\item If \tcode{a} and \tcode{b} are incrementable,
  then \tcode{bool(--(++a) == b)}.
\end{itemize}
\end{itemdescr}

\pnum
The exposition-only \tcode{\placeholder{Advanceable}} concept is equivalent to:
\begin{itemdecl}
template<class I>
  concept @\placeholder{Advanceable}@ =
    @\placeholdernc{Decrementable}@<I> && StrictTotallyOrdered<I> &&
    requires(I i, const I j, const iter_difference_t<I> n) {
      { i += n } -> Same<I&>;
      { i -= n } -> Same<I&>;
      { j +  n } -> Same<I>;
      { n +  j } -> Same<I>;
      { j -  n } -> Same<I>;
      { j -  j } -> Same<iter_difference_t<I>>;
    };
\end{itemdecl}

Let \tcode{a} and \tcode{b} be objects of type \tcode{I} such that
\tcode{b} is reachable from \tcode{a}
after \tcode{n} applications of \tcode{++a},
for some value \tcode{n} of type \tcode{iter_difference_t<I>},
and let \tcode{D} be \tcode{iter_difference_t<I>}.
\tcode{I} models \tcode{\placeholdernc{Advanceable}} only if
\begin{itemize}
\item \tcode{(a += n)} is equal to \tcode{b}.
\item \tcode{addressof(a += n)} is equal to \tcode{addressof(a)}.
\item \tcode{(a + n)} is equal to \tcode{(a += n)}.
\item For any two positive values
  \tcode{x} and \tcode{y} of type \tcode{D},
  if \tcode{(a + D(x + y))} is well-defined, then
  \tcode{(a + D(x + y))} is equal to \tcode{((a + x) + y)}.
\item \tcode{(a + D(0))} is equal to \tcode{a}.
\item If \tcode{(a + D(n - 1))} is well-defined, then
  \tcode{(a + n)} is equal to \tcode{++(a + D(n - 1))}.
\item \tcode{(b += -n)} is equal to \tcode{a}.
\item \tcode{(b -= n)} is equal to \tcode{a}.
\item \tcode{addressof(b -= n)} is equal to \tcode{addressof(b)}.
\item \tcode{(b - n)} is equal to \tcode{(b -= n)}.
\item \tcode{(b - a)} is equal to \tcode{n}.
\item \tcode{(a - b)} is equal to \tcode{-n}.
\item \tcode{bool(a <= b)} is \tcode{true}.
\end{itemize}

\indexlibrary{\idxcode{iota_view}!\idxcode{iota_view}}%
\begin{itemdecl}
constexpr explicit iota_view(W value);
\end{itemdecl}

\begin{itemdescr}
\pnum
\expects
\tcode{Bound} denotes \tcode{unreachable_sentinel_t} or
\tcode{Bound()} is reachable from \tcode{value}.

\pnum
\effects Initializes \tcode{value_} with \tcode{value}.
\end{itemdescr}

\indexlibrary{\idxcode{iota_view}!\idxcode{iota_view}}%
\begin{itemdecl}
constexpr iota_view(type_identity_t<W> value, type_identity_t<Bound> bound);
\end{itemdecl}

\begin{itemdescr}
\pnum
\expects
\tcode{Bound} denotes \tcode{unreachable_sentinel_t} or
\tcode{bound} is reachable from \tcode{value}.

\pnum
\effects Initializes \tcode{value_} with \tcode{value} and
\tcode{bound_} with \tcode{bound}.
\end{itemdescr}

\indexlibrary{\idxcode{begin}!\idxcode{iota_view}}%
\begin{itemdecl}
constexpr iterator begin() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return iterator\{value_\};}
\end{itemdescr}

\indexlibrary{\idxcode{end}!\idxcode{iota_view}}%
\begin{itemdecl}
constexpr sentinel end() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return sentinel\{bound_\};}
\end{itemdescr}

\indexlibrary{\idxcode{end}!\idxcode{iota_view}}%
\begin{itemdecl}
constexpr iterator end() const requires Same<W, Bound>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return iterator\{bound_\};}
\end{itemdescr}

\rSec3[range.iota.iterator]{Class \tcode{iota_view::iterator}}

\begin{codeblock}
namespace std::ranges {
  template<class W, class Bound>
  struct iota_view<W, Bound>::iterator {
  private:
    W value_ = W();             // \expos
  public:
    using iterator_category = @\seebelow@;
    using value_type = W;
    using difference_type = iter_difference_t<W>;

    iterator() = default;
    constexpr explicit iterator(W value);

    constexpr W operator*() const noexcept(is_nothrow_copy_constructible_v<W>);

    constexpr iterator& operator++();
    constexpr void operator++(int);
    constexpr iterator operator++(int) requires Incrementable<W>;

    constexpr iterator& operator--() requires @\placeholdernc{Decrementable}@<W>;
    constexpr iterator operator--(int) requires @\placeholdernc{Decrementable}@<W>;

    constexpr iterator& operator+=(difference_type n)
      requires @\placeholdernc{Advanceable}@<W>;
    constexpr iterator& operator-=(difference_type n)
      requires @\placeholdernc{Advanceable}@<W>;
    constexpr W operator[](difference_type n) const
      requires @\placeholdernc{Advanceable}@<W>;

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

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

    friend constexpr iterator operator+(iterator i, difference_type n)
      requires @\placeholdernc{Advanceable}@<W>;
    friend constexpr iterator operator+(difference_type n, iterator i)
      requires @\placeholdernc{Advanceable}@<W>;

    friend constexpr iterator operator-(iterator i, difference_type n)
      requires @\placeholdernc{Advanceable}@<W>;
    friend constexpr difference_type operator-(const iterator& x, const iterator& y)
      requires @\placeholdernc{Advanceable}@<W>;
  };
}
\end{codeblock}

\pnum
\tcode{iterator::iterator_category} is defined as follows:
\begin{itemize}
\item If \tcode{W} models \tcode{\placeholder{Advanceable}}, then
\tcode{iterator_category} is \tcode{random_access_iterator_tag}.
\item Otherwise, if \tcode{W} models \tcode{\placeholder{Decrementable}}, then
\tcode{iterator_category} is \tcode{bidirectional_iterator_tag}.
\item Otherwise, if \tcode{W} models \libconcept{Incrementable}, then
\tcode{iterator_category} is \tcode{forward_iterator_tag}.
\item Otherwise, \tcode{iterator_category} is \tcode{input_iterator_tag}.
\end{itemize}

\pnum
\begin{note}
Overloads for \tcode{iter_move} and \tcode{iter_swap} are omitted intentionally.
\end{note}

\indexlibrary{\idxcode{iterator}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
constexpr explicit iterator(W value);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{value_} with \tcode{value}.
\end{itemdescr}

\indexlibrary{\idxcode{operator*}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
constexpr W operator*() const noexcept(is_nothrow_copy_constructible_v<W>);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return value_;}

\pnum
\begin{note}
The \tcode{noexcept} clause is needed by the default \tcode{iter_move}
implementation.
\end{note}
\end{itemdescr}

\indexlibrary{\idxcode{operator++}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
constexpr iterator& operator++();
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
++value_;
return *this;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator++}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
constexpr void operator++(int);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to \tcode{++*this}.
\end{itemdescr}

\indexlibrary{\idxcode{operator++}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
constexpr iterator operator++(int) requires Incrementable<W>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
auto tmp = *this;
++*this;
return tmp;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator\dcr}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
constexpr iterator& operator--() requires @\placeholdernc{Decrementable}@<W>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
--value_;
return *this;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator\dcr}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
constexpr iterator operator--(int) requires @\placeholdernc{Decrementable}@<W>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
auto tmp = *this;
--*this;
return tmp;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator+=}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
constexpr iterator& operator+=(difference_type n)
  requires @\placeholdernc{Advanceable}@<W>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
value_ += n;
return *this;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator-=}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
constexpr iterator& operator-=(difference_type n)
  requires @\placeholdernc{Advanceable}@<W>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
value_ -= n;
return *this;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator[]}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
constexpr W operator[](difference_type n) const
  requires @\placeholdernc{Advanceable}@<W>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return value_ + n;}
\end{itemdescr}

\indexlibrary{\idxcode{operator==}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
friend constexpr bool operator==(const iterator& x, const iterator& y)
  requires EqualityComparable<W>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return x.value_ == y.value_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator!=}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
friend constexpr bool operator!=(const iterator& x, const iterator& y)
  requires EqualityComparable<W>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(x == y);}
\end{itemdescr}

\indexlibrary{\idxcode{operator<}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
friend constexpr bool operator<(const iterator& x, const iterator& y)
  requires StrictTotallyOrdered<W>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return x.value_ < y.value_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator>}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
friend constexpr bool operator>(const iterator& x, const iterator& y)
  requires StrictTotallyOrdered<W>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return y < x;}
\end{itemdescr}

\indexlibrary{\idxcode{operator<=}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
friend constexpr bool operator<=(const iterator& x, const iterator& y)
  requires StrictTotallyOrdered<W>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(y < x);}
\end{itemdescr}

\indexlibrary{\idxcode{operator>=}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
friend constexpr bool operator>=(const iterator& x, const iterator& y)
  requires StrictTotallyOrdered<W>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(x < y);}
\end{itemdescr}

\indexlibrary{\idxcode{operator+}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
friend constexpr iterator operator+(iterator i, difference_type n)
  requires @\placeholdernc{Advanceable}@<W>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return iterator\{i.value_ + n\};}
\end{itemdescr}

\indexlibrary{\idxcode{operator+}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
friend constexpr iterator operator+(difference_type n, iterator i)
  requires @\placeholdernc{Advanceable}@<W>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return i + n;}
\end{itemdescr}

\indexlibrary{\idxcode{operator-}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
friend constexpr iterator operator-(iterator i, difference_type n)
  requires @\placeholdernc{Advanceable}@<W>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return i + -n;}
\end{itemdescr}

\indexlibrary{\idxcode{operator-}!\idxcode{iota_view::iterator}}
\begin{itemdecl}
friend constexpr difference_type operator-(const iterator& x, const iterator& y)
  requires @\placeholdernc{Advanceable}@<W>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return x.value_ - y.value_;}
\end{itemdescr}

\rSec3[range.iota.sentinel]{Class \tcode{iota_view::sentinel}}

\begin{codeblock}
namespace std::ranges {
  template<class W, class Bound>
  struct iota_view<W, Bound>::sentinel {
  private:
    Bound bound_ = Bound();     // \expos
  public:
    sentinel() = default;
    constexpr explicit sentinel(Bound bound);

    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);
  };
}
\end{codeblock}

\indexlibrary{\idxcode{sentinel}!\idxcode{iota_view::sentinel}}
\begin{itemdecl}
constexpr explicit sentinel(Bound bound);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{bound_} with \tcode{bound}.
\end{itemdescr}

\indexlibrary{\idxcode{operator==}!\idxcode{iota_view::sentinel}}
\begin{itemdecl}
friend constexpr bool operator==(const iterator& x, const sentinel& y);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return x.value_ == y.bound_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator==}!\idxcode{iota_view::sentinel}}
\begin{itemdecl}
friend constexpr bool operator==(const sentinel& x, const iterator& y);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return y == x;}
\end{itemdescr}

\indexlibrary{\idxcode{operator!=}!\idxcode{iota_view::sentinel}}
\begin{itemdecl}
friend constexpr bool operator!=(const iterator& x, const sentinel& y);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(x == y);}
\end{itemdescr}

\indexlibrary{\idxcode{operator!=}!\idxcode{iota_view::sentinel}}
\begin{itemdecl}
friend constexpr bool operator!=(const sentinel& x, const iterator& y);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(y == x);}
\end{itemdescr}

\rSec3[range.iota.adaptor]{\tcode{view::iota}}

\pnum
The name \tcode{view::iota} denotes a
customization point object\iref{customization.point.object}.
For some subexpressions \tcode{E} and \tcode{F}, the expressions
\tcode{view::iota(E)} and \tcode{view::iota(E, F)}
are expression-equivalent to
\tcode{iota_view\{E\}} and \tcode{iota_view\{E, F\}}, respectively.


\rSec2[range.take]{Take view}

\rSec3[range.take.overview]{Overview}

\pnum
\tcode{take_view} produces a \libconcept{View} of the first $N$ elements
from another \libconcept{View}, or all the elements if the adapted
\libconcept{View} contains fewer than $N$.

\pnum
\begin{example}
\begin{codeblock}
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{codeblock}
\end{example}

\rSec3[range.take.view]{Class template \tcode{take_view}}

\begin{codeblock}
namespace std::ranges {
  template<View V>
  class take_view : public view_interface<take_view<V>> {
  private:
    V base_ = V();                                      // \expos
    iter_difference_t<iterator_t<V>> count_ = 0;        // \expos
    template<bool> struct sentinel;                     // \expos
  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 (!@\placeholder{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 (!@\placeholder{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>>;
}
\end{codeblock}

\indexlibrary{\idxcode{take_view}!\idxcode{take_view}}%
\begin{itemdecl}
constexpr take_view(V base, iter_difference_t<iterator_t<V>> count);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{base_} with \tcode{std::move(base)} and
\tcode{count_} with \tcode{count}.
\end{itemdescr}

\indexlibrary{\idxcode{take_view}!\idxcode{take_view}}%
\begin{itemdecl}
template<ViewableRange R>
  requires Constructible<V, all_view<R>>
constexpr take_view(R&& r, iter_difference_t<iterator_t<V>> count);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{base_} with \tcode{view::all(std::forward<R>(r))}
and \tcode{count_} with \tcode{count}.
\end{itemdescr}

\indexlibrary{\idxcode{base}!\idxcode{take_view}}%
\begin{itemdecl}
constexpr V base() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return base_;}
\end{itemdescr}

\rSec3[range.take.sentinel]{Class template \tcode{take_view::sentinel}}

\begin{codeblock}
namespace std::ranges {
  template<class V>
  template<bool Const>
  class take_view<V>::sentinel {
  private:
    using Base = conditional_t<Const, const V, V>;      // \expos
    using CI = counted_iterator<iterator_t<Base>>;      // \expos
    sentinel_t<Base> end_ = sentinel_t<Base>();         // \expos
  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);
  };
}
\end{codeblock}

\indexlibrary{\idxcode{sentinel}!\idxcode{take_view::sentinel}}
\begin{itemdecl}
constexpr explicit sentinel(sentinel_t<Base> end);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{end_} with \tcode{end}.
\end{itemdescr}

\indexlibrary{\idxcode{sentinel}!\idxcode{take_view::sentinel}}%
\begin{itemdecl}
constexpr sentinel(sentinel<!Const> s)
  requires Const && ConvertibleTo<sentinel_t<V>, sentinel_t<Base>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{end_} with \tcode{std::move(s.end_)}.
\end{itemdescr}

\indexlibrary{\idxcode{base}!\idxcode{take_view::sentinel}}
\begin{itemdecl}
constexpr sentinel_t<Base> base() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return end_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator==}!\idxcode{take_view::sentinel}}
\begin{itemdecl}
friend constexpr bool operator==(const sentinel& x, const CI& y);
friend constexpr bool operator==(const CI& y, const sentinel& x);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\tcode{return y.count() == 0 || y.base() == x.end_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator!=}!\idxcode{take_view::sentinel}}%
\begin{itemdecl}
friend constexpr bool operator!=(const sentinel& x, const CI& y);
friend constexpr bool operator!=(const CI& y, const sentinel& x);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(x == y);}
\end{itemdescr}

\rSec3[range.take.adaptor]{\tcode{view::take}}

\pnum
The name \tcode{view::take} denotes a
range adaptor object\iref{range.adaptor.object}.
For some subexpressions \tcode{E} and \tcode{F}, the expression
\tcode{view::take(E, F)} is expression-equivalent to
\tcode{take_view\{E, F\}}.


\rSec2[range.join]{Join view}

\rSec3[range.join.overview]{Overview}

\pnum
\tcode{join_view} flattens a \libconcept{View} of ranges into a
\libconcept{View}.

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

\rSec3[range.join.view]{Class template \tcode{join_view}}

\begin{codeblock}
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 =                    // \expos
      iter_reference_t<iterator_t<V>>;
    template<bool Const>
      struct iterator;                  // \expos
    template<bool Const>
      struct sentinel;                  // \expos

    V base_ = V();                      // \expos
    all_view<InnerRng> inner_ =         // \expos, present only when \tcode{!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<@\placeholder{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<@\placeholder{simple-view}@<V>>{*this, ranges::end(base_)};
      else
        return sentinel<@\placeholder{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>>;
}
\end{codeblock}

\indexlibrary{\idxcode{join_view}!\idxcode{join_view}}%
\begin{itemdecl}
constexpr explicit join_view(V base);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{base_} with \tcode{std::move(base)}.
\end{itemdescr}

\indexlibrary{\idxcode{join_view}!\idxcode{join_view}}%
\begin{itemdecl}
template<InputRange R>
  requires ViewableRange<R> && Constructible<V, all_view<R>>
constexpr explicit join_view(R&& r);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{base_} with \tcode{view::all(std::forward<R>(r))}.
\end{itemdescr}

\rSec3[range.join.iterator]{Class template \tcode{join_view::iterator}}

\pnum
\begin{codeblock}
namespace std::ranges {
template<class V>
  template<bool Const>
  struct join_view<V>::iterator {
  private:
    using Parent =                                              // \expos
      conditional_t<Const, const join_view, join_view>;
    using Base   = conditional_t<Const, const V, V>;            // \expos

    static constexpr bool ref_is_glvalue =                      // \expos
      is_reference_v<iter_reference_t<iterator_t<Base>>>;

    iterator_t<Base> outer_ = iterator_t<Base>();               // \expos
    iterator_t<iter_reference_t<iterator_t<Base>>> inner_ =     // \expos
      iterator_t<iter_reference_t<iterator_t<Base>>>();
    Parent* parent_ = nullptr;                                  // \expos

    constexpr void satisfy();                                   // \expos
  public:
    using iterator_concept  = @\seebelow@;
    using iterator_category = @\seebelow@;
    using value_type        =
      iter_value_t<iterator_t<iter_reference_t<iterator_t<Base>>>>;
    using difference_type   = @\seebelow@;

    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 @\placeholder{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_)));
  };
}
\end{codeblock}

\pnum
\tcode{iterator::iterator_concept} is defined as follows:
\begin{itemize}
\item If \tcode{ref_is_glvalue} is \tcode{true},
  \begin{itemize}
  \item If \tcode{Base} and \tcode{iter_reference_t<iterator_t<Base>>} each model
    \libconcept{BidirectionalRange}, then \tcode{iterator_concept} denotes
    \tcode{bidirectional_iterator_tag}.
  \item Otherwise, if \tcode{Base} and \tcode{iter_reference_t<iterator_t<Base>>}
    each model \libconcept{ForwardRange}, then \tcode{iterator_concept} denotes
    \tcode{forward_iterator_tag}.
  \end{itemize}
\item Otherwise, \tcode{iterator_concept} denotes \tcode{input_iterator_tag}.
\end{itemize}

\pnum
\tcode{iterator::iterator_category} is defined as follows:
\begin{itemize}
\item Let \placeholder{OUTERC} denote
  \tcode{iterator_traits<iterator_t<Base>>::iterator_category}, and
  let \placeholder{INNERC} denote
  \tcode{iterator_traits<iterator_t<iter_reference_t<iterator_t<Base>>>>::iterator_cate\-gory}.
\item If \tcode{ref_is_glvalue} is \tcode{true},
  \begin{itemize}
  \item If \placeholder{OUTERC} and \placeholder{INNERC} each model
    \tcode{DerivedFrom<bidirectional_iterator_tag>}, \tcode{itera\-tor_category}
    denotes \tcode{bidirectional_iterator_tag}.
  \item Otherwise, if \placeholder{OUTERC} and \placeholder{INNERC} each model
    \tcode{DerivedFrom<forward_iterator_tag>}, \tcode{itera\-tor_category}
    denotes \tcode{forward_iterator_tag}.
  \end{itemize}
\item Otherwise, \tcode{iterator_category} denotes \tcode{input_iterator_tag}.
\end{itemize}

\pnum
\tcode{iterator::difference_type} denotes the type:
\begin{codeblock}
common_type_t<
  iter_difference_t<iterator_t<Base>>,
  iter_difference_t<iterator_t<iter_reference_t<iterator_t<Base>>>>>
\end{codeblock}

\pnum
\tcode{join_view} iterators use the \tcode{satisfy} function to skip over
empty inner ranges.

\begin{itemdecl}
constexpr void satisfy();       // \expos
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
auto update_inner = [this](iter_reference_t<iterator_t<Base>> x) -> decltype(auto) {
  if constexpr (ref_is_glvalue) // \tcode{x} is a reference
    return (x);                 // \tcode{(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>>>();
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{iterator}!\idxcode{join_view::iterator}}
\begin{itemdecl}
constexpr iterator(Parent& parent, iterator_t<V> outer)
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{outer_} with \tcode{outer} and
\tcode{parent_} with \tcode{addressof(parent)}; then calls \tcode{satisfy()}.
\end{itemdescr}

\indexlibrary{\idxcode{iterator}!\idxcode{join_view::iterator}}
\begin{itemdecl}
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>>>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{outer_} with \tcode{std::move(i.outer_)},
\tcode{inner_} with \tcode{std::move(i.inner_)}, and
\tcode{parent_} with \tcode{i.parent_}.
\end{itemdescr}

\indexlibrary{\idxcode{operator->}!\idxcode{join_view::iterator}}
\begin{itemdecl}
constexpr iterator_t<Base> operator->() const
  requires @\placeholder{has-arrow}@<iterator_t<Base>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to \tcode{return inner_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator++}!\idxcode{join_view::iterator}}
\begin{itemdecl}
constexpr iterator& operator++();
\end{itemdecl}

\begin{itemdescr}
\pnum
Let \tcode{\placeholder{inner-range}} be:
\begin{itemize}
\item If \tcode{ref_is_glvalue} is \tcode{true}, \tcode{*outer_}.
\item Otherwise, \tcode{parent_->inner_}.
\end{itemize}

\pnum
\effects Equivalent to:
\begin{codeblock}
auto&& inner_rng = @\placeholder{inner-range}@;
if (++inner_ == ranges::end(inner_rng)) {
  ++outer_;
  satisfy();
}
return *this;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator++}!\idxcode{join_view::iterator}}
\begin{itemdecl}
constexpr void operator++(int);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{++*this}.
\end{itemdescr}

\indexlibrary{\idxcode{operator++}!\idxcode{join_view::iterator}}
\begin{itemdecl}
constexpr iterator operator++(int)
  requires ref_is_glvalue && ForwardRange<Base> &&
           ForwardRange<iter_reference_t<iterator_t<Base>>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
auto tmp = *this;
++*this;
return tmp;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator\dcr}!\idxcode{join_view::iterator}}
\begin{itemdecl}
constexpr iterator& operator--()
  requires ref_is_glvalue && BidirectionalRange<Base> &&
           BidirectionalRange<iter_reference_t<iterator_t<Base>>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
if (outer_ == ranges::end(parent_->base_))
  inner_ = ranges::end(*--outer_);
while (inner_ == ranges::begin(*outer_))
  inner_ = ranges::end(*--outer_);
--inner_;
return *this;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator\dcr}!\idxcode{join_view::iterator}}
\begin{itemdecl}
constexpr iterator operator--(int)
  requires ref_is_glvalue && BidirectionalRange<Base> &&
           BidirectionalRange<iter_reference_t<iterator_t<Base>>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
auto tmp = *this;
--*this;
return tmp;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator==}!\idxcode{join_view::iterator}}
\begin{itemdecl}
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>>>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\tcode{return x.outer_ == y.outer_ \&\& x.inner_ == y.inner_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator!=}!\idxcode{join_view::iterator}}
\begin{itemdecl}
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>>>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(x == y);}
\end{itemdescr}

\indexlibrary{\idxcode{iter_swap}!\idxcode{join_view::iterator}}
\begin{itemdecl}
friend constexpr void iter_swap(const iterator& x, const iterator& y)
  noexcept(noexcept(ranges::iter_swap(x.inner_, y.inner_)));
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return ranges::iter_swap(x.inner_, y.inner_);}
\end{itemdescr}

\rSec3[range.join.sentinel]{Class template \tcode{join_view::sentinel}}

\begin{codeblock}
namespace std::ranges {
  template<class V>
  template<bool Const>
  struct join_view<V>::sentinel {
  private:
    using Parent =                                      // \expos
      conditional_t<Const, const join_view, join_view>;
    using Base   = conditional_t<Const, const V, V>;    // \expos
    sentinel_t<Base> end_ = sentinel_t<Base>();         // \expos
  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);
  };
}
\end{codeblock}

\indexlibrary{\idxcode{sentinel}!\idxcode{join_view::sentinel}}
\begin{itemdecl}
constexpr explicit sentinel(Parent& parent);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{end_} with \tcode{ranges::end(parent.base_)}.
\end{itemdescr}

\indexlibrary{\idxcode{sentinel}!\idxcode{join_view::sentinel}}
\begin{itemdecl}
constexpr sentinel(sentinel<!Const> s)
  requires Const && ConvertibleTo<sentinel_t<V>, sentinel_t<Base>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{end_} with \tcode{std::move(s.end_)}.
\end{itemdescr}

\indexlibrary{\idxcode{operator==}!\idxcode{join_view::sentinel}}
\begin{itemdecl}
friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return x.outer_ == y.end_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator==}!\idxcode{join_view::sentinel}}
\begin{itemdecl}
friend constexpr bool operator==(const sentinel& x, const iterator<Const>& y);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return y == x;}
\end{itemdescr}

\indexlibrary{\idxcode{operator!=}!\idxcode{join_view::sentinel}}
\begin{itemdecl}
friend constexpr bool operator!=(const iterator<Const>& x, const sentinel& y);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(x == y);}
\end{itemdescr}

\indexlibrary{\idxcode{operator!=}!\idxcode{join_view::sentinel}}
\begin{itemdecl}
friend constexpr bool operator!=(const sentinel& x, const iterator<Const>& y);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(y == x);}
\end{itemdescr}

\rSec3[range.join.adaptor]{\tcode{view::join}}

\pnum
The name \tcode{view::join} denotes a
range adaptor object\iref{range.adaptor.object}.
For some subexpression \tcode{E}, the expression
\tcode{view::join(E)} is expression-equivalent to
\tcode{join_view\{E\}}.


\rSec2[range.empty]{Empty view}

\rSec3[range.empty.overview]{Overview}

\pnum
\tcode{empty_view} produces a \libconcept{View} of no elements of
a particular type.

\pnum
\begin{example}
\begin{codeblock}
empty_view<int> e;
static_assert(ranges::empty(e));
static_assert(0 == e.size());
\end{codeblock}
\end{example}

\rSec3[range.empty.view]{Class template \tcode{empty_view}}

\begin{codeblock}
namespace std::ranges {
  template<class T>
    requires is_object_v<T>
  class empty_view : public view_interface<empty_view<T>> {
  public:
    static constexpr T* begin() noexcept { return nullptr; }
    static constexpr T* end() noexcept { return nullptr; }
    static constexpr T* data() noexcept { return nullptr; }
    static constexpr ptrdiff_t size() noexcept { return 0; }
    static constexpr bool empty() noexcept { return true; }

    friend constexpr T* begin(empty_view) noexcept { return nullptr; }
    friend constexpr T* end(empty_view) noexcept { return nullptr; }
  };
}
\end{codeblock}


\rSec2[range.single]{Single view}

\rSec3[range.single.overview]{Overview}

\pnum
\tcode{single_view} produces a \libconcept{View} that contains
exactly one element of a specified value.

\pnum
\begin{example}
\begin{codeblock}
single_view s{4};
for (int i : s)
  cout << i; // prints 4
\end{codeblock}
\end{example}

\rSec3[range.single.view]{Class template \tcode{single_view}}

\begin{codeblock}
namespace std::ranges {
  template<CopyConstructible T>
    requires is_object_v<T>
  class single_view : public view_interface<single_view<T>> {
  private:
    @\placeholdernc{semiregular}@<T> value_;      // \expos
  public:
    single_view() = default;
    constexpr explicit single_view(const T& t);
    constexpr explicit single_view(T&& t);
    template<class... Args>
      requires Constructible<T, Args...>
    constexpr single_view(in_place_t, Args&&... args);

    constexpr T* begin() noexcept;
    constexpr const T* begin() const noexcept;
    constexpr T* end() noexcept;
    constexpr const T* end() const noexcept;
    static constexpr ptrdiff_t size() noexcept;
    constexpr T* data() noexcept;
    constexpr const T* data() const noexcept;
  };
}
\end{codeblock}

\indexlibrary{\idxcode{single_view}!\idxcode{single_view}}%
\begin{itemdecl}
constexpr explicit single_view(const T& t);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{value_} with \tcode{t}.
\end{itemdescr}

\indexlibrary{\idxcode{single_view}!\idxcode{single_view}}%
\begin{itemdecl}
constexpr explicit single_view(T&& t);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{value_} with \tcode{std::move(t)}.
\end{itemdescr}

\indexlibrary{\idxcode{single_view}!\idxcode{single_view}}%
\begin{itemdecl}
template<class... Args>
constexpr single_view(in_place_t, Args&&... args);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{value_} as if by
\tcode{value_\{in_place, std::forward<Args>(args)...\}}.
\end{itemdescr}

\indexlibrary{\idxcode{begin}!\idxcode{single_view}}%
\begin{itemdecl}
constexpr T* begin() noexcept;
constexpr const T* begin() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return data();}
\end{itemdescr}

\indexlibrary{\idxcode{end}!\idxcode{single_view}}%
\begin{itemdecl}
constexpr T* end() noexcept;
constexpr const T* end() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return data() + 1;}
\end{itemdescr}

\indexlibrary{\idxcode{size}!\idxcode{single_view}}%
\begin{itemdecl}
static constexpr ptrdiff_t size() noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return 1;}
\end{itemdescr}

\indexlibrary{\idxcode{data}!\idxcode{single_view}}%
\begin{itemdecl}
constexpr T* data() noexcept;
constexpr const T* data() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return value_.operator->();}
\end{itemdescr}

\rSec3[range.single.adaptor]{\tcode{view::single}}

\pnum
The name \tcode{view::single} denotes a
customization point object\iref{customization.point.object}.
For some subexpression \tcode{E}, the expression
\tcode{view::single(E)} is expression-equivalent to
\tcode{single_view\{E\}}.


\rSec2[range.split]{Split view}

\rSec3[range.split.overview]{Overview}

\pnum
\tcode{split_view} takes a \libconcept{View} and a delimiter, and splits
the \libconcept{View} into subranges on the delimiter. The delimiter can be
a single element or a \libconcept{View} of elements.

\pnum
\begin{example}
\begin{codeblock}
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{codeblock}
\end{example}

\rSec3[range.split.view]{Class template \tcode{split_view}}

\begin{codeblock}
namespace std::ranges {
  template<auto> struct @\placeholdernc{require-constant}@;       // \expos

  template<class R>
  concept @\placeholdernc{tiny-range}@ =                          // \expos
    SizedRange<R> &&
    requires { typename @\placeholdernc{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> || @\placeholdernc{tiny-range}@<Pattern>)
  class split_view : public view_interface<split_view<V, Pattern>> {
  private:
    V base_ = V();                              // \expos
    Pattern pattern_ = Pattern();               // \expos
    iterator_t<V> current_ = iterator_t<V>();   // \expos, present only if \tcode{!ForwardRange<V>}
    template<bool> struct outer_iterator;       // \expos
    template<bool> struct inner_iterator;       // \expos
  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<@\placeholder{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<@\placeholder{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>>>>;
}
\end{codeblock}

\indexlibrary{\idxcode{split_view}!\idxcode{split_view}}%
\begin{itemdecl}
constexpr split_view(V base, Pattern pattern);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{base_} with \tcode{std::move(base)}, and
\tcode{pattern_} with \tcode{std::move(pattern)}.
\end{itemdescr}

\indexlibrary{\idxcode{split_view}!\idxcode{split_view}}%
\begin{itemdecl}
template<InputRange R, ForwardRange P>
  requires Constructible<V, all_view<R>> &&
           Constructible<Pattern, all_view<P>>
constexpr split_view(R&& r, P&& p);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
Initializes \tcode{base_} with \tcode{view::all(std::forward<R>(r))} and
\tcode{pattern_} with \tcode{view::all(std\brk{}::forward<P>(p))}.
\end{itemdescr}

\indexlibrary{\idxcode{split_view}!\idxcode{split_view}}%
\begin{itemdecl}
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);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
Initializes \tcode{base_} with \tcode{view::all(std::forward<R>(r))} and
\tcode{pattern_} with \tcode{single_view\{\brk{}std::move(e)\}}.
\end{itemdescr}

\rSec3[range.split.outer]{Class template \tcode{split_view::outer_iterator}}

\begin{codeblock}
namespace std::ranges {
  template<class V, class Pattern>
  template<bool Const>
  struct split_view<V, Pattern>::outer_iterator {
  private:
    using Parent =                              // \expos
      conditional_t<Const, const split_view, split_view>;
    using Base   =                              // \expos
      conditional_t<Const, const V, V>;
    Parent* parent_ = nullptr;                  // \expos
    iterator_t<Base> current_ =                 // \expos, present only if \tcode{V} models \libconcept{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 \ref{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);
  };
}
\end{codeblock}

\pnum
Many of the following specifications refer to the notional member
\tcode{\placeholder{current}} of \tcode{outer_iterator}.
\tcode{\placeholder{current}} is equivalent to \tcode{current_} if \tcode{V}
models \libconcept{ForwardRange}, and \tcode{parent_->current_} otherwise.

\indexlibrary{\idxcode{outer_iterator}!\idxcode{split_view::outer_iterator}}%
\begin{itemdecl}
constexpr explicit outer_iterator(Parent& parent)
  requires (!ForwardRange<Base>);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{parent_} with \tcode{addressof(parent)}.
\end{itemdescr}

\indexlibrary{\idxcode{outer_iterator}!\idxcode{split_view::outer_iterator}}%
\begin{itemdecl}
constexpr outer_iterator(Parent& parent, iterator_t<Base> current)
  requires ForwardRange<Base>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{parent_} with \tcode{addressof(parent)}
and \tcode{current_} with \tcode{current}.
\end{itemdescr}

\indexlibrary{\idxcode{outer_iterator}!\idxcode{split_view::outer_iterator}}%
\begin{itemdecl}
constexpr outer_iterator(outer_iterator<!Const> i)
  requires Const && ConvertibleTo<iterator_t<V>, iterator_t<const V>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{parent_} with \tcode{i.parent_} and
\tcode{current_} with \tcode{std::move(i.current_)}.
\end{itemdescr}

\indexlibrary{\idxcode{operator*}!\idxcode{split_view::outer_iterator}}%
\begin{itemdecl}
constexpr value_type operator*() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return value_type\{*this\};}
\end{itemdescr}

\indexlibrary{\idxcode{operator++}!\idxcode{split_view::outer_iterator}}%
\begin{itemdecl}
constexpr outer_iterator& operator++();
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
const auto end = ranges::end(parent_->base_);
if (@\placeholder{current}@ == end) return *this;
const auto [pbegin, pend] = subrange{parent_->pattern_};
if (pbegin == pend) ++@\placeholder{current}@;
else {
  do {
    const auto [b, p] = ranges::mismatch(@\placeholdernc{current}@, end, pbegin, pend);
    if (p == pend) {
      @\placeholder{current}@ = b;  // The pattern matched; skip it
      break;
    }
  } while (++@\placeholder{current}@ != end);
}
return *this;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator==}!\idxcode{split_view::outer_iterator}}%
\begin{itemdecl}
friend constexpr bool operator==(const outer_iterator& x, const outer_iterator& y)
  requires ForwardRange<Base>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return x.current_ == y.current_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator!=}!\idxcode{split_view::outer_iterator}}%
\begin{itemdecl}
friend constexpr bool operator!=(const outer_iterator& x, const outer_iterator& y)
  requires ForwardRange<Base>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(x == y);}
\end{itemdescr}

\indexlibrary{\idxcode{operator==}!\idxcode{split_view::outer_iterator}}%
\begin{itemdecl}
friend constexpr bool operator==(const outer_iterator& x, default_sentinel_t);
friend constexpr bool operator==(default_sentinel_t, const outer_iterator& x);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
Equivalent to: \tcode{return x.\placeholder{current} == ranges::end(x.parent_->base_);}
\end{itemdescr}

\indexlibrary{\idxcode{operator!=}!\idxcode{split_view::outer_iterator}}%
\begin{itemdecl}
friend constexpr bool operator!=(const outer_iterator& x, default_sentinel_t y);
friend constexpr bool operator!=(default_sentinel_t y, const outer_iterator& x);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(x == y);}
\end{itemdescr}

\rSec3[range.split.outer.value]{Class \tcode{split_view::outer_iterator::value_type}}

\begin{codeblock}
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();               // \expos
  public:
    value_type() = default;
    constexpr explicit value_type(outer_iterator i);

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

\indexlibrary{\idxcode{value_type}!\idxcode{split_view::outer_iterator::value_type}}%
\begin{itemdecl}
constexpr explicit value_type(outer_iterator i);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{i_} with \tcode{i}.
\end{itemdescr}

\indexlibrary{\idxcode{begin}!\idxcode{split_view::outer_iterator::value_type}}%
\begin{itemdecl}
constexpr inner_iterator<Const> begin() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return inner_iterator<Const>\{i_\};}
\end{itemdescr}

\indexlibrary{\idxcode{end}!\idxcode{split_view::outer_iterator::value_type}}%
\begin{itemdecl}
constexpr default_sentinel_t end() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return default_sentinel;}
\end{itemdescr}

\rSec3[range.split.inner]{Class template \tcode{split_view::inner_iterator}}

\begin{codeblock}
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>;                 // \expos
    outer_iterator<Const> i_ = outer_iterator<Const>(); // \expos
    bool incremented_ = false;                          // \expos
  public:
    using iterator_concept  = typename outer_iterator<Const>::iterator_concept;
    using iterator_category = @\seebelow@;
    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_.@\placeholder{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_.@\placeholdernc{current}@))) {
      return ranges::iter_move(i.i_.@\placeholdernc{current}@);
    }

    friend constexpr void iter_swap(const inner_iterator& x, const inner_iterator& y)
      noexcept(noexcept(ranges::iter_swap(x.i_.@\placeholdernc{current}, y.i_.\placeholdernc{current}@)))
      requires IndirectlySwappable<iterator_t<Base>>;
  };
}
\end{codeblock}

\pnum
The \grammarterm{typedef-name} \tcode{iterator_category} denotes
\tcode{forward_iterator_tag} if
\tcode{iterator_traits<iterator_t<Base>>::iterator_category} models
\tcode{DerivedFrom<forward_iterator_tag>}, and \tcode{input_iterator_tag}
otherwise.

\indexlibrary{\idxcode{inner_iterator}!\idxcode{split_view::inner_iterator}}%
\begin{itemdecl}
constexpr explicit inner_iterator(outer_iterator<Const> i);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{i_} with \tcode{i}.
\end{itemdescr}

\indexlibrary{\idxcode{operator++}!\idxcode{split_view::inner_iterator}}%
\begin{itemdecl}
constexpr inner_iterator& operator++() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
incremented_ = true;
if constexpr (!ForwardRange<Base>) {
  if constexpr (Pattern::size() == 0) {
    return *this;
  }
}
++i_.@\placeholder{current}@;
return *this;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator==}!\idxcode{split_view::inner_iterator}}%
\begin{itemdecl}
friend constexpr bool operator==(const inner_iterator& x, const inner_iterator& y)
  requires ForwardRange<Base>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return x.i_.current_ == y.i_.current_;}
\end{itemdescr}

\indexlibrary{\idxcode{operator!=}!\idxcode{split_view::inner_iterator}}%
\begin{itemdecl}
friend constexpr bool operator!=(const inner_iterator& x, const inner_iterator& y)
  requires ForwardRange<Base>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(x == y);}
\end{itemdescr}

\indexlibrary{\idxcode{operator==}!\idxcode{split_view::inner_iterator}}%
\begin{itemdecl}
friend constexpr bool operator==(const inner_iterator& x, default_sentinel_t);
friend constexpr bool operator==(default_sentinel_t, const inner_iterator& x);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to:
\begin{codeblock}
auto cur = x.i_.@\placeholder{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;
\end{codeblock}
\end{itemdescr}

\indexlibrary{\idxcode{operator!=}!\idxcode{split_view::inner_iterator}}%
\begin{itemdecl}
friend constexpr bool operator!=(const inner_iterator& x, default_sentinel_t y);
friend constexpr bool operator!=(default_sentinel_t y, const inner_iterator& x);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return !(x == y);}
\end{itemdescr}

\indexlibrary{\idxcode{iter_swap}!\idxcode{split_view::inner_iterator}}%
\begin{itemdecl}
friend constexpr void iter_swap(const inner_iterator& x, const inner_iterator& y)
  noexcept(noexcept(ranges::iter_swap(x.i_.@\placeholdernc{current}, y.i_.\placeholdernc{current}@)))
  requires IndirectlySwappable<iterator_t<Base>>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to
\tcode{ranges::iter_swap(x.i_.\placeholdernc{current}, y.i_.\placeholdernc{current})}.
\end{itemdescr}

\rSec3[range.split.adaptor]{\tcode{view::split}}

\pnum
The name \tcode{view::split} denotes a
range adaptor object\iref{range.adaptor.object}.
For some subexpressions \tcode{E} and \tcode{F},
the expression \tcode{view::split(E, F)} is expression-equivalent to
\tcode{split_view\{E, F\}}.


\rSec2[range.counted]{Counted view}

\pnum
The name \tcode{view::counted} denotes a
customization point object\iref{customization.point.object}.
Let \tcode{E} and \tcode{F} be expressions,
and let \tcode{T} be \tcode{decay_t<decltype((E))>}.
Then the expression \tcode{view::counted(E, F)} is expression-equivalent to:

\begin{itemize}
\item If \tcode{T} models \libconcept{Iterator} and
  \tcode{decltype((F))} models \libconcept{ConvertibleTo<iter_difference_t<T>>},
  \begin{itemize}
  \item \tcode{subrange\{E, E + static_cast<iter_difference_t<T>>(F)\}}
    if \tcode{T} models \libconcept{RandomAccessItera\-tor}.
  \item Otherwise,
    \tcode{subrange\{counted_iterator\{E, F\}, default_sentinel\}}.
\end{itemize}

\item Otherwise, \tcode{view::counted(E, F)} is ill-formed.
  \begin{note}
  This case can result in substitution failure when \tcode{view::counted(E, F)}
  appears in the immediate context of a template instantiation.
  \end{note}
\end{itemize}


\rSec2[range.common]{Common view}

\rSec3[range.common.overview]{Overview}

\pnum
\tcode{common_view} takes a \libconcept{View} which has different types for
its iterator and sentinel and turns it into a \libconcept{View} of the same
elements with an iterator and sentinel of the same type.

\pnum
\begin{note}
\tcode{common_view} is useful for calling legacy algorithms that expect
a range's iterator and sentinel types to be the same.
\end{note}

\pnum
\begin{example}
\begin{codeblock}
// 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{codeblock}
\end{example}

\rSec3[range.common.view]{Class template \tcode{common_view}}

\begin{codeblock}
namespace std::ranges {
  template<View V>
    requires (!CommonRange<V>)
  class common_view : public view_interface<common_view<V>> {
  private:
    V base_ = V();  // \expos
  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>>;
}
\end{codeblock}

\indexlibrary{\idxcode{common_view}!\idxcode{common_view}}%
\begin{itemdecl}
constexpr explicit common_view(V base);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{base_} with \tcode{std::move(base)}.
\end{itemdescr}

\indexlibrary{\idxcode{common_view}!\idxcode{common_view}}%
\begin{itemdecl}
template<ViewableRange R>
  requires (!CommonRange<R> && Constructible<V, all_view<R>>)
constexpr explicit common_view(R&& r);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{base_} with \tcode{view::all(std::forward<R>(r))}.
\end{itemdescr}

\indexlibrary{\idxcode{base}!\idxcode{common_view}}%
\begin{itemdecl}
constexpr V base() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return base_;}
\end{itemdescr}

\rSec3[range.common.adaptor]{\tcode{view::common}}

\pnum
The name \tcode{view::common} denotes a
range adaptor object\iref{range.adaptor.object}.
For some subexpression \tcode{E},
the expression \tcode{view::common(E)} is expression-equivalent to:

\begin{itemize}
\item \tcode{view::all(E)},
  if \tcode{decltype((E))} models \libconcept{CommonRange}
  and \tcode{view::all(E)} is a well-formed expression.

\item Otherwise, \tcode{common_view\{E\}}.
\end{itemize}


\rSec2[range.reverse]{Reverse view}

\rSec3[range.reverse.overview]{Overview}

\pnum
\tcode{reverse_view} takes a bidirectional \libconcept{View} and produces
another \libconcept{View} that iterates the same elements in reverse order.

\pnum
\begin{example}
\begin{codeblock}
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{codeblock}
\end{example}

\rSec3[range.reverse.view]{Class template \tcode{reverse_view}}

\indexlibrary{\idxcode{weiv_esrever}}%
\begin{codeblock}
namespace std::ranges {
  template<View V>
    requires BidirectionalRange<V>
  class reverse_view : public view_interface<reverse_view<V>> {
  private:
    V base_ = V();  // \expos
  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>>;
}
\end{codeblock}

\indexlibrary{\idxcode{reverse_view}!\idxcode{reverse_view}}%
\begin{itemdecl}
constexpr explicit reverse_view(V base);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{base_} with \tcode{std::move(base)}.
\end{itemdescr}

\indexlibrary{\idxcode{reverse_view}!\idxcode{reverse_view}}%
\begin{itemdecl}
template<ViewableRange R>
  requires BidirectionalRange<R> && Constructible<V, all_view<R>>
constexpr explicit reverse_view(R&& r);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Initializes \tcode{base_} with \tcode{view::all(std::forward<R>(r))}.
\end{itemdescr}

\indexlibrary{\idxcode{base}!\idxcode{reverse_view}}%
\begin{itemdecl}
constexpr V base() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return base_;}
\end{itemdescr}

\indexlibrary{\idxcode{begin}!\idxcode{reverse_view}}%
\begin{itemdecl}
constexpr reverse_iterator<iterator_t<V>> begin();
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\begin{codeblock}
make_reverse_iterator(ranges::next(ranges::begin(base_), ranges::end(base_)))
\end{codeblock}

\pnum
\remarks In order to provide the amortized constant time complexity required by
the \libconcept{Range} concept, this function caches the result within the
\tcode{reverse_view} for use on subsequent calls.
\end{itemdescr}

\indexlibrary{\idxcode{begin}!\idxcode{reverse_view}}%
\begin{itemdecl}
constexpr reverse_iterator<iterator_t<V>> begin() requires CommonRange<V>;
constexpr reverse_iterator<iterator_t<const V>> begin() const
  requires CommonRange<const V>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return make_reverse_iterator(ranges::end(base_));}
\end{itemdescr}

\indexlibrary{\idxcode{end}!\idxcode{reverse_view}}%
\begin{itemdecl}
constexpr reverse_iterator<iterator_t<V>> end();
constexpr reverse_iterator<iterator_t<const V>> end() const
  requires CommonRange<const V>;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Equivalent to: \tcode{return make_reverse_iterator(ranges::begin(base_));}
\end{itemdescr}

\rSec3[range.reverse.adaptor]{\tcode{view::reverse}}

\pnum
The name \tcode{view::reverse} denotes a
range adaptor object\iref{range.adaptor.object}.
For some subexpression \tcode{E}, the expression
\tcode{view::reverse(E)} is expression-equivalent to
\tcode{reverse_view\{E\}}.