Namespaces
Variants
    Actions

      Standard library header <ranges> (C++20)

      From cppreference.com
      < cpp‎ | header
       
      C++
       
      Standard library headers
       

      This header is part of the ranges library.

      Contents

      [edit]Namespace aliases

      namespace std {

          namespace views = ranges::views;

      }

      The namespace alias std::views is provided as a shorthand for std::ranges::views.

      Includes

      (C++20)
      		Three-way comparison operator support[edit]
      (C++11)
      		std::initializer_list class template[edit]
      		Range iterators[edit]

      Concepts

      Range concepts
      Defined in namespace std::ranges
      (C++20)
      		 specifies that a type is a range, that is, it provides a begin iterator and an end sentinel
      (concept)[edit]
      (C++20)
      		 specifies that a type is a range and iterators obtained from an expression of it can be safely returned without danger of dangling
      (concept)[edit]
      (C++26)
      		 specifies that a range can estimate its size in constant time
      (concept)[edit]
      (C++20)
      		 specifies that a range knows its size in constant time
      (concept)[edit]
      (C++20)
      		 specifies that a range is a view, that is, it has constant time copy/move/assignment
      (concept)[edit]
      (C++20)
      		 specifies a range whose iterator type satisfies input_iterator
      (concept)[edit]
      (C++20)
      		 specifies a range whose iterator type satisfies output_iterator
      (concept)[edit]
      (C++20)
      		 specifies a range whose iterator type satisfies forward_iterator
      (concept)[edit]
      (C++20)
      		 specifies a range whose iterator type satisfies bidirectional_iterator
      (concept)[edit]
      (C++20)
      		 specifies a range whose iterator type satisfies random_access_iterator
      (concept)[edit]
      (C++20)
      		 specifies a range whose iterator type satisfies contiguous_iterator
      (concept)[edit]
      (C++20)
      		 specifies that a range has identical iterator and sentinel types
      (concept)[edit]
      (C++20)
      		 specifies the requirements for a range to be safely convertible to a view
      (concept)[edit]
      (C++23)
      		 specifies that a range has read-only elements
      (concept)[edit]

      Functions

      Range conversions
      Defined in namespace std::ranges
      (C++23)
      		 constructs a new non-view object from an input range
      (function template)[edit]

      Classes

      Range primitives
      Defined in namespace std::ranges
      (C++20)(C++23)(C++20)(C++23)
      		 obtains iterator and sentinel types of a range
      (alias template)[edit]
      (C++20)(C++20)(C++20)
      		 obtains size, difference, and value types of a range
      (alias template)[edit]
      (C++20)(C++23)(C++20)(C++20)
      		 obtains reference types of a range
      (alias template)[edit]
      Views
      Defined in namespace std::ranges
      (C++20)
      		 helper class template for defining a view, using the curiously recurring template pattern
      (class template)[edit]
      (C++20)
      		 combines an iterator-sentinel pair into a view
      (class template)[edit]
      Dangling iterator handling
      Defined in namespace std::ranges
      (C++20)
      		 a placeholder type indicating that an iterator or a subrange should not be returned since it would be dangling
      (class)[edit]
      (C++20)
      		 obtains iterator type or subrange type of a borrowed_range
      (alias template)[edit]
      Other utilities
      Defined in namespace std::ranges
      (C++23)
      		 tags a range to be treated as a sequence rather than a single value
      (class template)[edit]
      Factories
      Defined in namespace std::ranges
      (C++20)
      		 an empty view with no elements
      (class template)(variable template)[edit]
      (C++20)
      		 a view that contains a single element of a specified value
      (class template)(customization point object)[edit]
      (C++20)
      		 a view consisting of a sequence generated by repeatedly incrementing an initial value
      (class template)(customization point object)[edit]
      (C++23)
      		 a view consisting of a generated sequence by repeatedly producing the same value
      (class template)(customization point object)[edit]
      (C++20)
      		 a view consisting of the elements obtained by successive application of operator>> on the associated input stream
      (class template)(customization point object)[edit]
      Adaptors
      Defined in namespace std::ranges
      (C++23)
      		 helper base class template for defining a range adaptor closure object
      (class template)[edit]
      (C++20)
      		 a view that includes all elements of a range
      (alias template)(range adaptor object)[edit]
      (C++20)
      		 a view of the elements of some other range
      (class template)[edit]
      (C++20)
      		 a view with unique ownership of some range
      (class template)[edit]
      (C++23)
      		 a view of a sequence that casts each element to an rvalue
      (class template)(range adaptor object)[edit]
      (C++20)
      		 a view that consists of the elements of a range that satisfies a predicate
      (class template)(range adaptor object)[edit]
      (C++20)
      		 a view of a sequence that applies a transformation function to each element
      (class template)(range adaptor object)[edit]
      (C++20)
      		 a view consisting of the first N elements of another view
      (class template)(range adaptor object)[edit]
      (C++20)
      		 a view consisting of the initial elements of another view, until the first element on which a predicate returns false
      (class template)(range adaptor object)[edit]
      (C++20)
      		 a view consisting of elements of another view, skipping the first N elements
      (class template)(range adaptor object)[edit]
      (C++20)
      		 a view consisting of the elements of another view, skipping the initial subsequence of elements until the first element where the predicate returns false
      (class template)(range adaptor object)[edit]
      (C++20)
      		 a view consisting of the sequence obtained from flattening a view of ranges
      (class template)(range adaptor object)[edit]
      (C++23)
      		 a view consisting of the sequence obtained from flattening a view of ranges, with the delimiter in between elements
      (class template)(range adaptor object)[edit]
      (C++20)
      		 a view over the subranges obtained from splitting another view using a delimiter
      (class template)(range adaptor object)[edit]
      (C++20)
      		 a view over the subranges obtained from splitting another view using a delimiter
      (class template)(range adaptor object)[edit]
      (C++26)
      		 a view consisting of concatenation of the adapted views
      (class template)(customization point object)[edit]
      (C++20)
      		 creates a subrange from an iterator and a count
      (customization point object)[edit]
      (C++20)
      		 converts a view into a common_range
      (class template)(range adaptor object)[edit]
      (C++20)
      		 a view that iterates over the elements of another bidirectional view in reverse order
      (class template)(range adaptor object)[edit]
      (C++23)
      		 converts a view into a constant_range
      (class template)(range adaptor object)[edit]
      (C++20)
      		 takes a view consisting of tuple-like values and a number N and produces a view of Nth element of each tuple
      (class template)(range adaptor object)[edit]
      (C++20)
      		 takes a view consisting of pair-like values and produces a view of the first elements of each pair
      (class template)(range adaptor object)[edit]
      (C++20)
      		 takes a view consisting of pair-like values and produces a view of the second elements of each pair
      (class template)(range adaptor object)[edit]
      (C++23)
      		 a view that maps each element of adapted sequence to a tuple of both the element's position and its value
      (class template)(range adaptor object)[edit]
      (C++23)
      		 a view consisting of tuples of references to corresponding elements of the adapted views
      (class template)(customization point object)[edit]
      (C++23)
      		 a view consisting of results of application of a transformation function to corresponding elements of the adapted views
      (class template)(customization point object)[edit]
      (C++23)
      		 a view consisting of tuples of references to adjacent elements of the adapted view
      (class template)(range adaptor object)[edit]
      (C++23)
      		 a view consisting of results of application of a transformation function to adjacent elements of the adapted view
      (class template)(range adaptor object)[edit]
      (C++23)
      		 a range of views that are N-sized non-overlapping successive chunks of the elements of another view
      (class template)(range adaptor object)[edit]
      (C++23)
      		 a view whose Mth element is a view over the Mth through (M + N - 1)th elements of another view
      (class template)(range adaptor object)[edit]
      (C++23)
      		 splits the view into subranges between each pair of adjacent elements for which the given predicate returns false
      (class template)(range adaptor object)[edit]
      (C++23)
      		 a view consisting of elements of another view, advancing over N elements at a time
      (class template)(range adaptor object)[edit]
      (C++23)
      		 a view consisting of tuples of results calculated by the n-ary cartesian product of the adapted views
      (class template)(customization point object)[edit]
      (C++26)
      		 a view that caches the last-accessed element of its underlying sequence
      (class template)(range adaptor object)[edit]
      (C++26)
      		 converts a view into a range that is input_range-only and non-common_range
      (class template)(range adaptor object)[edit]

      Customization point objects

      Range access
      Defined in namespace std::ranges
      (C++20)
      		 returns an iterator to the beginning of a range
      (customization point object)[edit]
      (C++20)
      		 returns a sentinel indicating the end of a range
      (customization point object)[edit]
      (C++20)
      		 returns an iterator to the beginning of a read-only range
      (customization point object)[edit]
      (C++20)
      		 returns a sentinel indicating the end of a read-only range
      (customization point object)[edit]
      (C++20)
      		 returns a reverse iterator to a range
      (customization point object)[edit]
      (C++20)
      		 returns a reverse end iterator to a range
      (customization point object)[edit]
      (C++20)
      		 returns a reverse iterator to a read-only range
      (customization point object)[edit]
      (C++20)
      		 returns a reverse end iterator to a read-only range
      (customization point object)[edit]
      (C++26)
      		 returns an integer equal to the reserve hint given by a range
      (customization point object)[edit]
      (C++20)
      		 returns an integer equal to the size of a range
      (customization point object)[edit]
      (C++20)
      		 returns a signed integer equal to the size of a range
      (customization point object)[edit]
      (C++20)
      		 checks whether a range is empty
      (customization point object)[edit]
      (C++20)
      		 obtains a pointer to the beginning of a contiguous range
      (customization point object)[edit]
      (C++20)
      		 obtains a pointer to the beginning of a read-only contiguous range
      (customization point object)[edit]

      Enumerations

      Defined in namespace std::ranges
      (C++20)
      		 specifies whether a std::ranges::subrange models std::ranges::sized_range
      (enum)[edit]

      Helpers

      (C++20)
      		 obtains the size of a std::ranges::subrange
      (class template specialization)[edit]
      (C++20)
      		 obtains the type of the iterator or the sentinel of a std::ranges::subrange
      (class template specialization)[edit]
      (C++20)
      		 obtains iterator or sentinel from a std::ranges::subrange
      (function template)[edit]
      (C++23)
      		 from-range construction tag
      (tag)[edit]

      [edit]Synopsis

      // mostly freestanding#include <compare>#include <initializer_list>#include <iterator>   namespace std::ranges{inlinenamespace/* unspecified */{// range accessinlineconstexpr/* unspecified */ begin =/* unspecified */;inlineconstexpr/* unspecified */ end =/* unspecified */;inlineconstexpr/* unspecified */ cbegin =/* unspecified */;inlineconstexpr/* unspecified */ cend =/* unspecified */;inlineconstexpr/* unspecified */ rbegin =/* unspecified */;inlineconstexpr/* unspecified */ rend =/* unspecified */;inlineconstexpr/* unspecified */ crbegin =/* unspecified */;inlineconstexpr/* unspecified */ crend =/* unspecified */;   inlineconstexpr/* unspecified */ size =/* unspecified */;inlineconstexpr/* unspecified */ reserve_hint =/* unspecified */;inlineconstexpr/* unspecified */ ssize =/* unspecified */;inlineconstexpr/* unspecified */ empty =/* unspecified */;inlineconstexpr/* unspecified */ data =/* unspecified */;inlineconstexpr/* unspecified */ cdata =/* unspecified */;}   // rangestemplate<class T> concept range =/* see description */;   template<class T>constexprbool enable_borrowed_range =false;   template<class T> concept borrowed_range =/* see description */;   template<class T>using iterator_t = decltype(ranges::begin(declval<T&>()));template<range R>using sentinel_t = decltype(ranges::end(declval<R&>()));template<range R>using const_iterator_t = decltype(ranges::cbegin(declval<R&>()));template<range R>using const_sentinel_t = decltype(ranges::cend(declval<R&>()));template<range R>using range_difference_t = iter_difference_t<iterator_t<R>>;template<sized_range R>using range_size_t = decltype(ranges::size(declval<R&>()));template<range R>using range_value_t = iter_value_t<iterator_t<R>>;template<range R>using range_reference_t = iter_reference_t<iterator_t<R>>;template<range R>using range_const_reference_t = iter_const_reference_t<iterator_t<R>>;template<range R>using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R>>;template<range R>using range_common_reference_t = iter_common_reference_t<iterator_t<R>>;   // sized rangestemplate<class>constexprbool disable_sized_range =false;   template<class T> concept approximately_sized_range =/* see description */;   template<class T> concept sized_range =/* see description */;   // viewstemplate<class T>constexprbool enable_view =/* see description */;   struct view_base {};   template<class T> concept view =/* see description */;   // other range refinementstemplate<class R, class T> concept output_range =/* see description */;   template<class T> concept input_range =/* see description */;   template<class T> concept forward_range =/* see description */;   template<class T> concept bidirectional_range =/* see description */;   template<class T> concept random_access_range =/* see description */;   template<class T> concept contiguous_range =/* see description */;   template<class T> concept common_range =/* see description */;   template<class T> concept viewable_range =/* see description */;   template<class T> concept constant_range =/* see description */;   // class template view_interfacetemplate<class D> requires is_class_v<D>&& same_as<D, remove_cv_t<D>>class view_interface;   // sub-rangesenumclass subrange_kind :bool{ unsized, sized };   template<input_or_output_iterator I, sentinel_for<I> S = I, subrange_kind K =/* see description */> requires(K == subrange_kind::sized||!sized_sentinel_for<S, I>)class subrange;   template<class I, class S, subrange_kind K>constexprbool enable_borrowed_range<subrange<I, S, K>>=true;   template<size_t N, class I, class S, subrange_kind K> requires((N ==0&& copyable<I>)|| N ==1)constexprauto get(const subrange<I, S, K>& r);   template<size_t N, class I, class S, subrange_kind K> requires(N <2)constexprauto get(subrange<I, S, K>&& r);}   namespace std {usingranges::get;}   namespace std::ranges{// dangling iterator handlingstruct dangling;   // class template elements_oftemplate<range R, class Allocator = allocator<byte>>struct elements_of;// hosted   template<range R>using borrowed_iterator_t =/* see description */;   template<range R>using borrowed_subrange_t =/* see description */;   // range conversionstemplate<class C, input_range R, class... Args> requires(!view<C>)constexpr C to(R&& r, Args&&... args);template<template<class...>class C, input_range R, class... Args>constexprauto to(R&& r, Args&&... args);template<class C, class... Args> requires(!view<C>)constexprauto to(Args&&... args);template<template<class...>class C, class... Args>constexprauto to(Args&&... args);   // empty viewtemplate<class T> requires is_object_v<T>class empty_view;   template<class T>constexprbool enable_borrowed_range<empty_view<T>>=true;   namespace views {template<class T>constexpr empty_view<T> empty{};}   // single viewtemplate<move_constructible T> requires is_object_v<T>class single_view;   namespace views {inlineconstexpr/* unspecified */ single =/* unspecified */;}   template<bool Const, class T>using/*maybe-const*/= conditional_t<Const, const T, T>;// exposition-only   // iota viewtemplate<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t> requires /*weakly-equality-comparable-with*/<W, Bound>&& copyable<W>class iota_view;   template<class W, class Bound>constexprbool enable_borrowed_range<iota_view<W, Bound>>=true;   namespace views {inlineconstexpr/* unspecified */ iota =/* unspecified */;}   // repeat viewtemplate<move_constructible T, semiregular Bound = unreachable_sentinel_t> requires /* see description */class repeat_view;   namespace views {inlineconstexpr/* unspecified */ repeat =/* unspecified */;}   // istream viewtemplate<movable Val, class CharT, class Traits = char_traits<CharT>> requires /* see description */class basic_istream_view;// hostedtemplate<class Val>using istream_view = basic_istream_view<Val, char>;// hostedtemplate<class Val>using wistream_view = basic_istream_view<Val, wchar_t>;// hosted   namespace views {template<class T>constexpr/* unspecified */ istream =/* unspecified */;// hosted}   // range adaptor objectstemplate<class D> requires is_class_v<D>&& same_as<D, remove_cv_t<D>>class range_adaptor_closure {};   // all viewnamespace views {inlineconstexpr/* unspecified */ all =/* unspecified */;   template<viewable_range R>using all_t = decltype(all(declval<R>()));}   // ref viewtemplate<range R> requires is_object_v<R>class ref_view;   template<class T>constexprbool enable_borrowed_range<ref_view<T>>=true;   // owning viewtemplate<range R> requires /* see description */class owning_view;   template<class T>constexprbool enable_borrowed_range<owning_view<T>>= enable_borrowed_range<T>;   // as rvalue viewtemplate<view V> requires input_range<V>class as_rvalue_view;   template<class T>constexprbool enable_borrowed_range<as_rvalue_view<T>>= enable_borrowed_range<T>;   namespace views {inlineconstexpr/* unspecified */ as_rvalue =/* unspecified */;}   // filter viewtemplate<input_range V, indirect_unary_predicate<iterator_t<V>> Pred> requires view<V>&& is_object_v<Pred>class filter_view;   namespace views {inlineconstexpr/* unspecified */ filter =/* unspecified */;}   // transform viewtemplate<input_range V, move_constructible F> requires view<V>&& is_object_v<F>&& regular_invocable<F&, range_reference_t<V>>&&/*can-reference*/<invoke_result_t<F&, range_reference_t<V>>>class transform_view;   namespace views {inlineconstexpr/* unspecified */ transform =/* unspecified */;}   // take viewtemplate<view>class take_view;   template<class T>constexprbool enable_borrowed_range<take_view<T>>= enable_borrowed_range<T>;   namespace views {inlineconstexpr/* unspecified */ take =/* unspecified */;}   // take while viewtemplate<view V, class Pred> requires input_range<V>&& is_object_v<Pred>&& indirect_unary_predicate<const Pred, iterator_t<V>>class take_while_view;   namespace views {inlineconstexpr/* unspecified */ take_while =/* unspecified */;}   // drop viewtemplate<view V>class drop_view;   template<class T>constexprbool enable_borrowed_range<drop_view<T>>= enable_borrowed_range<T>;   namespace views {inlineconstexpr/* unspecified */ drop =/* unspecified */;}   // drop while viewtemplate<view V, class Pred> requires input_range<V>&& is_object_v<Pred>&& indirect_unary_predicate<const Pred, iterator_t<V>>class drop_while_view;   template<class T, class Pred>constexprbool enable_borrowed_range<drop_while_view<T, Pred>>= enable_borrowed_range<T>;   namespace views {inlineconstexpr/* unspecified */ drop_while =/* unspecified */;}   // join viewtemplate<input_range V> requires view<V>&& input_range<range_reference_t<V>>class join_view;   namespace views {inlineconstexpr/* unspecified */ join =/* unspecified */;}   // join with viewtemplate<input_range V, forward_range Pattern> requires /* see description */class join_with_view;   namespace views {inlineconstexpr/* unspecified */ join_with =/* unspecified */;}   // lazy split viewtemplate<class R> concept /*tiny-range*/=/* see description */;// exposition-only   template<input_range V, forward_range Pattern> requires view<V>&& view<Pattern>&& indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>&&(forward_range<V>||/*tiny-range*/<Pattern>)class lazy_split_view;   // split viewtemplate<forward_range V, forward_range Pattern> requires view<V>&& view<Pattern>&& indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>class split_view;   namespace views {inlineconstexpr/* unspecified */ lazy_split =/* unspecified */;inlineconstexpr/* unspecified */ split =/* unspecified */;}   // concat viewtemplate<input_range... Views> requires /* see description */class concat_view;   namespace views {inlineconstexpr/* unspecified */ concat =/* unspecified */;}   // counted viewnamespace views {inlineconstexpr/* unspecified */ counted =/* unspecified */;}   // common viewtemplate<view V> requires(!common_range<V>&& copyable<iterator_t<V>>)class common_view;   template<class T>constexprbool enable_borrowed_range<common_view<T>>= enable_borrowed_range<T>;   namespace views {inlineconstexpr/* unspecified */ common =/* unspecified */;}   // reverse viewtemplate<view V> requires bidirectional_range<V>class reverse_view;   template<class T>constexprbool enable_borrowed_range<reverse_view<T>>= enable_borrowed_range<T>;   namespace views {inlineconstexpr/* unspecified */ reverse =/* unspecified */;}   // as const viewtemplate<input_range R>constexprauto&/*possibly-const-range*/(R& r)noexcept{// exposition-onlyifconstexpr(input_range<const R>){returnconst_cast<const R&>(r);}else{return r;}}   template<view V> requires input_range<V>class as_const_view;   template<class T>constexprbool enable_borrowed_range<as_const_view<T>>= enable_borrowed_range<T>;   namespace views {inlineconstexpr/* unspecified */ as_const =/* unspecified */;}   // elements viewtemplate<input_range V, size_t N> requires /* see description */class elements_view;   template<class T, size_t N>constexprbool enable_borrowed_range<elements_view<T, N>>= enable_borrowed_range<T>;   template<class R>using keys_view = elements_view<R, 0>;template<class R>using values_view = elements_view<R, 1>;   namespace views {template<size_t N>constexpr/* unspecified */ elements =/* unspecified */;inlineconstexprauto keys = elements<0>;inlineconstexprauto values = elements<1>;}   // enumerate viewtemplate<view V> requires /* see description */class enumerate_view;   template<class View>constexprbool enable_borrowed_range<enumerate_view<View>>= enable_borrowed_range<View>;   namespace views {inlineconstexpr/* unspecified */ enumerate =/* unspecified */;}   // zip viewtemplate<input_range... Views> requires(view<Views>&& ...)&&(sizeof...(Views)>0)class zip_view;   template<class... Views>constexprbool enable_borrowed_range<zip_view<Views...>>=(enable_borrowed_range<Views>&& ...);   namespace views {inlineconstexpr/* unspecified */ zip =/* unspecified */;}   // zip transform viewtemplate<move_constructible F, input_range... Views> requires(view<Views>&& ...)&&(sizeof...(Views)>0)&& is_object_v<F>&& regular_invocable<F&, range_reference_t<Views>...>&&/*can-reference*/<invoke_result_t<F&, range_reference_t<Views>...>>class zip_transform_view;   namespace views {inlineconstexpr/* unspecified */ zip_transform =/* unspecified */;}   // adjacent viewtemplate<forward_range V, size_t N> requires view<V>&&(N >0)class adjacent_view;   template<class V, size_t N>constexprbool enable_borrowed_range<adjacent_view<V, N>>= enable_borrowed_range<V>;   namespace views {template<size_t N>constexpr/* unspecified */ adjacent =/* unspecified */;inlineconstexprauto pairwise = adjacent<2>;}   // adjacent transform viewtemplate<forward_range V, move_constructible F, size_t N> requires /* see description */class adjacent_transform_view;   namespace views {template<size_t N>constexpr/* unspecified */ adjacent_transform =/* unspecified */;inlineconstexprauto pairwise_transform = adjacent_transform<2>;}   // chunk viewtemplate<view V> requires input_range<V>class chunk_view;   template<view V> requires forward_range<V>class chunk_view<V>;   template<class V>constexprbool enable_borrowed_range<chunk_view<V>>= forward_range<V>&& enable_borrowed_range<V>;   namespace views {inlineconstexpr/* unspecified */ chunk =/* unspecified */;}   // slide viewtemplate<forward_range V> requires view<V>class slide_view;   template<class V>constexprbool enable_borrowed_range<slide_view<V>>= enable_borrowed_range<V>;   namespace views {inlineconstexpr/* unspecified */ slide =/* unspecified */;}   // chunk by viewtemplate<forward_range V, indirect_binary_predicate<iterator_t<V>, iterator_t<V>> Pred> requires view<V>&& is_object_v<Pred>class chunk_by_view;   namespace views {inlineconstexpr/* unspecified */ chunk_by =/* unspecified */;}   // stride viewtemplate<input_range V> requires view<V>class stride_view;   template<class V>constexprbool enable_borrowed_range<stride_view<V>>= enable_borrowed_range<V>;   namespace views {inlineconstexpr/* unspecified */ stride =/* unspecified */;}   // cartesian product viewtemplate<input_range First, forward_range... Vs> requires(view<First>&& ... && view<Vs>)class cartesian_product_view;   namespace views {inlineconstexpr/* unspecified */ cartesian_product =/* unspecified */;}   // cache latest viewtemplate<input_range V> requires view<V>class cache_latest_view;   namespace views {inlineconstexpr/* unspecified */ cache_latest =/* unspecified */;}   // to input viewtemplate<input_range V> requires view<V>class to_input_view;   template<class V>constexprbool enable_borrowed_range<to_input_view<V>>= enable_borrowed_range<V>;   namespace views {inlineconstexpr/* unspecified */ to_input =/* unspecified */;}}   namespace std {namespace views = ranges::views;   template<class T>struct tuple_size;template<size_t I, class T>struct tuple_element;   template<class I, class S, ranges::subrange_kind K>struct tuple_size<ranges::subrange<I, S, K>>: integral_constant<size_t, 2>{};template<class I, class S, ranges::subrange_kind K>struct tuple_element<0, ranges::subrange<I, S, K>>{using type = I;};template<class I, class S, ranges::subrange_kind K>struct tuple_element<1, ranges::subrange<I, S, K>>{using type = S;};template<class I, class S, ranges::subrange_kind K>struct tuple_element<0, constranges::subrange<I, S, K>>{using type = I;};template<class I, class S, ranges::subrange_kind K>struct tuple_element<1, constranges::subrange<I, S, K>>{using type = S;};   struct from_range_t {explicit from_range_t()=default;};inlineconstexpr from_range_t from_range{};}

      [edit]Concept range

      namespace std::ranges{template<class T> concept range = requires(T& t){ranges::begin(t);// sometimes equality-preserving (see description)ranges::end(t);};}

      [edit]Concept borrowed_range

      namespace std::ranges{template<class T> concept borrowed_range = range<T>&&(is_lvalue_reference_v<T>|| enable_borrowed_range<remove_cvref_t<T>>);}

      [edit]Concept approximately_sized_range

      namespace std::ranges{template<class T> concept approximately_sized_range = range<T>&& requires(T& t){ ranges::reserve_hint(t);};}

      [edit]Concept sized_range

      namespace std::ranges{template<class T> concept sized_range = approximately_sized_range<T>&& requires(T& t){ranges::size(t);};}

      [edit]Concept view

      namespace std::ranges{template<class T>constexprbool/*is-derived-from-view-interface*/=/* see description */;// exposition-onlytemplate<class T>constexprbool enable_view = derived_from<T, view_base>||/*is-derived-from-view-interface*/<T>;   template<class T> concept view = range<T>&& movable<T>&& enable_view<T>;}

      [edit]Concept output_range

      namespace std::ranges{template<class R, class T> concept output_range = range<R>&& output_iterator<iterator_t<R>, T>;}

      [edit]Concept input_range

      namespace std::ranges{template<class T> concept input_range = range<T>&& input_iterator<iterator_t<T>>;}

      [edit]Concept forward_range

      namespace std::ranges{template<class T> concept forward_range = input_range<T>&& forward_iterator<iterator_t<T>>;}

      [edit]Concept bidirectional_range

      namespace std::ranges{template<class T> concept bidirectional_range = forward_range<T>&& bidirectional_iterator<iterator_t<T>>;}

      [edit]Concept random_access_range

      namespace std::ranges{template<class T> concept random_access_range = bidirectional_range<T>&& random_access_iterator<iterator_t<T>>;}

      [edit]Concept contiguous_range

      namespace std::ranges{template<class T> concept contiguous_range = random_access_range<T>&& contiguous_iterator<iterator_t<T>>&& requires(T& t){{ranges::data(t)}-> same_as<add_pointer_t<range_reference_t<T>>>;};}

      [edit]Concept common_range

      namespace std::ranges{template<class T> concept common_range = range<T>&& same_as<iterator_t<T>, sentinel_t<T>>;}

      [edit]Concept viewable_range

      namespace std::ranges{template<class T> concept viewable_range = range<T>&&((view<remove_cvref_t<T>>&& constructible_from<remove_cvref_t<T>, T>)||(!view<remove_cvref_t<T>>&&(is_lvalue_reference_v<T>||(movable<remove_reference_t<T>>&&!/*is-initializer-list*/<T>))));}

      [edit]Concept constant_range

      namespace std::ranges{template<class T> concept constant_range = input_range<T>&&/*constant-iterator*/<iterator_t<T>>;}

      [edit]Helper concepts

      Note: The concepts in this section are only for exposition and are not part of the interface. 

      namespace std::ranges{// unspecified, for name lookup onlytemplate<class R> concept /*simple-view*/=// exposition-only view<R>&& range<const R>&& same_as<iterator_t<R>, iterator_t<const R>>&& same_as<sentinel_t<R>, sentinel_t<const R>>;   template<class I> concept /*has-arrow*/=// exposition-only input_iterator<I>&&(is_pointer_v<I>|| requires(const I i){ i.operator->();});   template<class T, class U> concept /*different-from*/=// exposition-only!same_as<remove_cvref_t<T>, remove_cvref_t<U>>;   template<class R> concept /*range-with-movable-references*/=// exposition-only input_range<R>&& move_constructible<range_reference_t<R>>&& move_constructible<range_rvalue_reference_t<R>>;   template<class R>constexprbool/*is-initializer-list*/=/* see description */;// exposition-only   template<class T>constexprauto/*as-const-pointer*/(const T* p)noexcept{return p;}// exposition-only}

      [edit]Class template std::ranges::view_interface

      namespace std::ranges{template<class D> requires is_class_v<D>&& same_as<D, remove_cv_t<D>>class view_interface {private:constexpr D&/*derived*/()noexcept{// exposition-onlyreturnstatic_cast<D&>(*this);}constexprconst D&/*derived*/()constnoexcept{// exposition-onlyreturnstatic_cast<const D&>(*this);}   public:constexprbool empty() requires sized_range<D>|| forward_range<D>{ifconstexpr(sized_range<D>)returnranges::size(/*derived*/())==0;elsereturnranges::begin(/*derived*/())==ranges::end(/*derived*/());}constexprbool empty()const requires sized_range<const D>|| forward_range<const D>{ifconstexpr(sized_range<const D>)returnranges::size(/*derived*/())==0;elsereturnranges::begin(/*derived*/())==ranges::end(/*derived*/());}   constexprauto cbegin() requires input_range<D>{returnranges::cbegin(/*derived*/());}constexprauto cbegin()const requires input_range<const D>{returnranges::cbegin(/*derived*/());}constexprauto cend() requires input_range<D>{returnranges::cend(/*derived*/());}constexprauto cend()const requires input_range<const D>{returnranges::cend(/*derived*/());}   constexprexplicit operator bool() requires requires {ranges::empty(/*derived*/());}{return!ranges::empty(/*derived*/());}constexprexplicit operator bool()const requires requires {ranges::empty(/*derived*/());}{return!ranges::empty(/*derived*/());}   constexprauto data() requires contiguous_iterator<iterator_t<D>>{return to_address(ranges::begin(/*derived*/()));}constexprauto data()const requires range<const D>&& contiguous_iterator<iterator_t<const D>>{return to_address(ranges::begin(/*derived*/()));}   constexprauto size() requires forward_range<D>&& sized_sentinel_for<sentinel_t<D>, iterator_t<D>>{return/*to-unsigned-like*/(ranges::end(/*derived*/())-ranges::begin(/*derived*/()));}constexprauto size()const requires forward_range<const D>&& sized_sentinel_for<sentinel_t<const D>, iterator_t<const D>>{return/*to-unsigned-like*/(ranges::end(/*derived*/())-ranges::begin(/*derived*/()));}   constexpr decltype(auto) front() requires forward_range<D>;constexpr decltype(auto) front()const requires forward_range<const D>;   constexpr decltype(auto) back() requires bidirectional_range<D>&& common_range<D>;constexpr decltype(auto) back()const requires bidirectional_range<const D>&& common_range<const D>;   template<random_access_range R = D>constexpr decltype(auto) operator[](range_difference_t<R> n){returnranges::begin(/*derived*/())[n];}template<random_access_range R =const D>constexpr decltype(auto) operator[](range_difference_t<R> n)const{returnranges::begin(/*derived*/())[n];}};}

      [edit]Class template std::ranges::subrange

      namespace std::ranges{template<class From, class To> concept /*uses-nonqualification-pointer-conversion*/=// exposition-only is_pointer_v<From>&& is_pointer_v<To>&&!convertible_to<remove_pointer_t<From>(*)[], remove_pointer_t<To>(*)[]>;   template<class From, class To> concept /*convertible-to-non-slicing*/=// exposition-only convertible_to<From, To>&&!/*uses-nonqualification-pointer-conversion*/<decay_t<From>, decay_t<To>>;   template<class T, class U, class V> concept /*pair-like-convertible-from*/=// exposition-only!range<T>&&!is_reference_v<T>&&/*pair-like*/<T>&& constructible_from<T, U, V>&&/*convertible-to-non-slicing*/<U, tuple_element_t<0, T>>&& convertible_to<V, tuple_element_t<1, T>>;   template<input_or_output_iterator I, sentinel_for<I> S = I, subrange_kind K = sized_sentinel_for<S, I>? subrange_kind::sized: subrange_kind::unsized> requires(K == subrange_kind::sized||!sized_sentinel_for<S, I>)class subrange :public view_interface<subrange<I, S, K>>{private:staticconstexprbool/*StoreSize*/=// exposition-only K == subrange_kind::sized&&!sized_sentinel_for<S, I>; I /*begin_*/= I();// exposition-only S /*end_*/= S();// exposition-only/*make-unsigned-like-t*/<iter_difference_t<I>>/*size_*/=0;// exposition-only present only// if StoreSize is truepublic: subrange() requires default_initializable<I>=default;   constexpr subrange(/*convertible-to-non-slicing*/<I>auto i, S s) requires(!/*StoreSize*/);   constexpr subrange(/*convertible-to-non-slicing*/<I>auto i, S s, /*make-unsigned-like-t*/<iter_difference_t<I>> n) requires(K == subrange_kind::sized);   template</*different-from*/<subrange> R> requires borrowed_range<R>&&/*convertible-to-non-slicing*/<iterator_t<R>, I>&& convertible_to<sentinel_t<R>, S>constexpr subrange(R&& r) requires(!/*StoreSize*/|| sized_range<R>);   template<borrowed_range R> requires /*convertible-to-non-slicing*/<iterator_t<R>, I>&& convertible_to<sentinel_t<R>, S>constexpr subrange(R&& r, /*make-unsigned-like-t*/<iter_difference_t<I>> n) requires(K == subrange_kind::sized): subrange{ranges::begin(r), ranges::end(r), n }{}   template</*different-from*/<subrange> PairLike> requires /*pair-like-convertible-from*/<PairLike, const I&, const S&>constexpr operator PairLike()const;   constexpr I begin()const requires copyable<I>;constexpr I begin() requires(!copyable<I>);constexpr S end()const;   constexprbool empty()const;constexpr/*make-unsigned-like-t*/<iter_difference_t<I>> size()const requires(K == subrange_kind::sized);   constexpr subrange next(iter_difference_t<I> n =1)const& requires forward_iterator<I>;constexpr subrange next(iter_difference_t<I> n =1)&&;constexpr subrange prev(iter_difference_t<I> n =1)const requires bidirectional_iterator<I>;constexpr subrange& advance(iter_difference_t<I> n);};   template<input_or_output_iterator I, sentinel_for<I> S> subrange(I, S)-> subrange<I, S>;   template<input_or_output_iterator I, sentinel_for<I> S> subrange(I, S, /*make-unsigned-like-t*/<iter_difference_t<I>>)-> subrange<I, S, subrange_kind::sized>;   template<borrowed_range R> subrange(R&&)-> subrange<iterator_t<R>, sentinel_t<R>, (sized_range<R>|| sized_sentinel_for<sentinel_t<R>, iterator_t<R>>)? subrange_kind::sized: subrange_kind::unsized>;   template<borrowed_range R> subrange(R&&, /*make-unsigned-like-t*/<range_difference_t<R>>)-> subrange<iterator_t<R>, sentinel_t<R>, subrange_kind::sized>;}

      [edit]Class std::ranges::dangling

      namespace std::ranges{struct dangling {constexpr dangling()noexcept=default;constexpr dangling(auto&&...)noexcept{}};}

      [edit]Class std::ranges::elements_of

      namespace std::ranges{template<range R, class Allocator = allocator<byte>>struct elements_of {[[no_unique_address]] R range;[[no_unique_address]] Allocator allocator = Allocator();};   template<class R, class Allocator = allocator<byte>> elements_of(R&&, Allocator = Allocator())-> elements_of<R&&, Allocator>;}

      [edit]Class template std::ranges::empty_view

      namespace std::ranges{template<class T> requires is_object_v<T>class empty_view :public view_interface<empty_view<T>>{public:staticconstexpr T* begin()noexcept{return nullptr;}staticconstexpr T* end()noexcept{return nullptr;}staticconstexpr T* data()noexcept{return nullptr;}staticconstexpr size_t size()noexcept{return0;}staticconstexprbool empty()noexcept{returntrue;}};}

      [edit]Class template std::ranges::single_view

      namespace std::ranges{template<move_constructible T> requires is_object_v<T>class single_view :public view_interface<single_view<T>>{private:/*movable-box*/<T>/*value_*/;// exposition-only   public: single_view() requires default_initializable<T>=default;constexprexplicit single_view(const T& t) requires copy_constructible<T>;constexprexplicit single_view(T&& t);template<class... Args> requires constructible_from<T, Args...>constexprexplicit single_view(in_place_t, Args&&... args);   constexpr T* begin()noexcept;constexprconst T* begin()constnoexcept;constexpr T* end()noexcept;constexprconst T* end()constnoexcept;staticconstexprbool empty()noexcept;staticconstexpr size_t size()noexcept;constexpr T* data()noexcept;constexprconst T* data()constnoexcept;};   template<class T> single_view(T)-> single_view<T>;}

      [edit]Class template std::ranges::iota_view

      namespace std::ranges{template<class I> concept /*decrementable*/=/* see description */;// exposition-only   template<class I> concept /*advanceable*/=/* see description */;// exposition-only   template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t> requires /*weakly-equality-comparable-with*/<W, Bound>&& copyable<W>class iota_view :public view_interface<iota_view<W, Bound>>{private:// class iota_view::iteratorstruct/*iterator*/;// exposition-only   // class iota_view::sentinelstruct/*sentinel*/;// exposition-only   W /*value_*/= W();// exposition-only Bound /*bound_*/= Bound();// exposition-only   public: iota_view() requires default_initializable<W>=default;constexprexplicit iota_view(W value);constexprexplicit iota_view(type_identity_t<W> value, type_identity_t<Bound> bound);constexprexplicit iota_view(/*iterator*/ first, /* see description */ last);   constexpr/*iterator*/ begin()const;constexprauto end()const;constexpr/*iterator*/ end()const requires same_as<W, Bound>;   constexprbool empty()const;constexprauto size()const requires /* see description */;};   template<class W, class Bound> requires(!/*is-integer-like*/<W>||!/*is-integer-like*/<Bound>||(/*is-signed-integer-like*/<W>==/*is-signed-integer-like*/<Bound>)) iota_view(W, Bound)-> iota_view<W, Bound>;}

      [edit]Class template std::ranges::iota_view::iterator

      namespace std::ranges{template<weakly_incrementable W, semiregular Bound> requires /*weakly-equality-comparable-with*/<W, Bound>&& copyable<W>struct iota_view<W, Bound>::/*iterator*/{private: W /*value_*/= W();// exposition-only   public:using iterator_concept =/* see description */;using iterator_category = input_iterator_tag;// present only if W models incrementable and// IOTA-DIFF-T(W) is an integral typeusing value_type = W;using difference_type =/*IOTA-DIFF-T*/(W);   /*iterator*/() requires default_initializable<W>=default;constexprexplicit/*iterator*/(W value);   constexpr W operator*()constnoexcept(is_nothrow_copy_constructible_v<W>);   constexpr/*iterator*/& operator++();constexprvoid operator++(int);constexpr/*iterator*/ operator++(int) requires incrementable<W>;   constexpr/*iterator*/& operator--() requires /*decrementable*/<W>;constexpr/*iterator*/ operator--(int) requires /*decrementable*/<W>;   constexpr/*iterator*/& operator+=(difference_type n) requires /*advanceable*/<W>;constexpr/*iterator*/& operator-=(difference_type n) requires /*advanceable*/<W>;constexpr W operator[](difference_type n)const requires /*advanceable*/<W>;   friendconstexprbool operator==(const/*iterator*/& x, const/*iterator*/& y) requires equality_comparable<W>;   friendconstexprbool operator<(const/*iterator*/& x, const/*iterator*/& y) requires totally_ordered<W>;friendconstexprbool operator>(const/*iterator*/& x, const/*iterator*/& y) requires totally_ordered<W>;friendconstexprbool operator<=(const/*iterator*/& x, const/*iterator*/& y) requires totally_ordered<W>;friendconstexprbool operator>=(const/*iterator*/& x, const/*iterator*/& y) requires totally_ordered<W>;friendconstexprauto operator<=>(const/*iterator*/& x, const/*iterator*/& y) requires totally_ordered<W>&& three_way_comparable<W>;   friendconstexpr/*iterator*/ operator+(/*iterator*/ i, difference_type n) requires /*advanceable*/<W>;friendconstexpr/*iterator*/ operator+(difference_type n, /*iterator*/ i) requires /*advanceable*/<W>;   friendconstexpr/*iterator*/ operator-(/*iterator*/ i, difference_type n) requires /*advanceable*/<W>;friendconstexpr difference_type operator-(const/*iterator*/& x, const/*iterator*/& y) requires /*advanceable*/<W>;};}

      [edit]Class template std::ranges::iota_view::sentinel

      namespace std::ranges{template<weakly_incrementable W, semiregular Bound> requires /*weakly-equality-comparable-with*/<W, Bound>&& copyable<W>struct iota_view<W, Bound>::/*sentinel*/{private: Bound /*bound_*/= Bound();// exposition-only   public:/*sentinel*/()=default;constexprexplicit/*sentinel*/(Bound bound);   friendconstexprbool operator==(const/*iterator*/& x, const/*sentinel*/& y);   friendconstexpr iter_difference_t<W> operator-(const/*iterator*/& x, const/*sentinel*/& y) requires sized_sentinel_for<Bound, W>;friendconstexpr iter_difference_t<W> operator-(const/*sentinel*/& x, const/*iterator*/& y) requires sized_sentinel_for<Bound, W>;};}

      [edit]Class template std::ranges::repeat_view

      namespace std::ranges{template<class T> concept /*integer-like-with-usable-difference-type*/=// exposition-only/*is-signed-integer-like*/<T>||(/*is-integer-like*/<T>&& weakly_incrementable<T>);   template<move_constructible T, semiregular Bound = unreachable_sentinel_t> requires(is_object_v<T>&& same_as<T, remove_cv_t<T>>&&(/*integer-like-with-usable-difference-type*/<Bound>|| same_as<Bound, unreachable_sentinel_t>))class repeat_view :public view_interface<repeat_view<T, Bound>>{private:// class repeat_view::iteratorstruct/*iterator*/;// exposition-only   /*movable-box*/<T>/*value_*/;// exposition-only Bound /*bound_*/= Bound();// exposition-only   public: repeat_view() requires default_initializable<T>=default;   constexprexplicit repeat_view(const T& value, Bound bound = Bound()) requires copy_constructible<T>;constexprexplicit repeat_view(T&& value, Bound bound = Bound());template<class... TArgs, class... BoundArgs> requires constructible_from<T, TArgs...>&& constructible_from<Bound, BoundArgs...>constexprexplicit repeat_view(piecewise_construct_t, tuple<TArgs...> value_args, tuple<BoundArgs...> bound_args = tuple<>{});   constexpr/*iterator*/ begin()const;constexpr/*iterator*/ end()const requires(!same_as<Bound, unreachable_sentinel_t>);constexpr unreachable_sentinel_t end()constnoexcept;   constexprauto size()const requires(!same_as<Bound, unreachable_sentinel_t>);};   template<class T, class Bound = unreachable_sentinel_t> repeat_view(T, Bound = Bound())-> repeat_view<T, Bound>;}

      [edit]Class template std::ranges::repeat_view::iterator

      namespace std::ranges{template<move_constructible T, semiregular Bound> requires(is_object_v<T>&& same_as<T, remove_cv_t<T>>&&(/*integer-like-with-usable-difference-type*/<Bound>|| same_as<Bound, unreachable_sentinel_t>))class repeat_view<T, Bound>::/*iterator*/{private:using/*index-type*/=// exposition-only conditional_t<same_as<Bound, unreachable_sentinel_t>, ptrdiff_t, Bound>;const T*/*value_*/= nullptr;// exposition-only/*index-type*//*current_*/=/*index-type*/();// exposition-only   constexprexplicit/*iterator*/(const T* value, /*index-type*/ b =/*index-type*/());// exposition-only   public:using iterator_concept = random_access_iterator_tag;using iterator_category = random_access_iterator_tag;using value_type = T;using difference_type =/* see description */;   /*iterator*/()=default;   constexprconst T& operator*()constnoexcept;   constexpr/*iterator*/& operator++();constexpr/*iterator*/ operator++(int);   constexpr/*iterator*/& operator--();constexpr/*iterator*/ operator--(int);   constexpr/*iterator*/& operator+=(difference_type n);constexpr/*iterator*/& operator-=(difference_type n);constexprconst T& operator[](difference_type n)constnoexcept;   friendconstexprbool operator==(const/*iterator*/& x, const/*iterator*/& y);friendconstexprauto operator<=>(const/*iterator*/& x, const/*iterator*/& y);   friendconstexpr/*iterator*/ operator+(/*iterator*/ i, difference_type n);friendconstexpr/*iterator*/ operator+(difference_type n, /*iterator*/ i);   friendconstexpr/*iterator*/ operator-(/*iterator*/ i, difference_type n);friendconstexpr difference_type operator-(const/*iterator*/& x, const/*iterator*/& y);};}

      [edit]Class template std::ranges::basic_istream_view

      namespace std::ranges{template<class Val, class CharT, class Traits> concept /*stream-extractable*/=// exposition-only requires(basic_istream<CharT, Traits>& is, Val& t){ is >> t;};   template<movable Val, class CharT, class Traits = char_traits<CharT>> requires default_initializable<Val>&&/*stream-extractable*/<Val, CharT, Traits>class basic_istream_view :public view_interface<basic_istream_view<Val, CharT, Traits>>{public:constexprexplicit basic_istream_view(basic_istream<CharT, Traits>& stream);   constexprauto begin(){*/*stream_*/>>/*value_*/;return/*iterator*/{*this };}   constexpr default_sentinel_t end()constnoexcept;   private:// class basic_istream_view::iteratorstruct/*iterator*/;// exposition-only basic_istream<CharT, Traits>*/*stream_*/;// exposition-only Val /*value_*/= Val();// exposition-only};}

      [edit]Class template std::ranges::basic_istream_view::iterator

      namespace std::ranges{template<movable Val, class CharT, class Traits> requires default_initializable<Val>&&/*stream-extractable*/<Val, CharT, Traits>class basic_istream_view<Val, CharT, Traits>::/*iterator*/{public:using iterator_concept = input_iterator_tag;using difference_type = ptrdiff_t;using value_type = Val;   constexprexplicit/*iterator*/(basic_istream_view& parent)noexcept;   /*iterator*/(const/*iterator*/&)= delete;/*iterator*/(/*iterator*/&&)=default;   /*iterator*/& operator=(const/*iterator*/&)= delete;/*iterator*/& operator=(/*iterator*/&&)=default;   /*iterator*/& operator++();void operator++(int);   Val& operator*()const;   friendbool operator==(const/*iterator*/& x, default_sentinel_t);   private: basic_istream_view*/*parent_*/;// exposition-only};}

      [edit]Class template std::ranges::ref_view

      namespace std::ranges{template<range R> requires is_object_v<R>class ref_view :public view_interface<ref_view<R>>{private: R*/*r_*/;// exposition-only   public:template</*different-from*/<ref_view> T> requires /* see description */constexpr ref_view(T&& t);   constexpr R& base()const{return*/*r_*/;}   constexpr iterator_t<R> begin()const{returnranges::begin(*/*r_*/);}constexpr sentinel_t<R> end()const{returnranges::end(*/*r_*/);}   constexprbool empty()const requires requires {ranges::empty(*/*r_*/);}{returnranges::empty(*/*r_*/);}   constexprauto size()const requires sized_range<R>{returnranges::size(*/*r_*/);}   constexprauto reserve_hint()const requires approximately_sized_range<R>{return ranges::reserve_hint(*/*r_*/);}   constexprauto data()const requires contiguous_range<R>{returnranges::data(*/*r_*/);}};   template<class R> ref_view(R&)-> ref_view<R>;}

      [edit]Class template std::ranges::owning_view

      namespace std::ranges{template<range R> requires movable<R>&&(!/*is-initializer-list*/<R>)class owning_view :public view_interface<owning_view<R>>{private: R /*r_*/= R();// exposition-only   public: owning_view() requires default_initializable<R>=default;constexpr owning_view(R&& t);   owning_view(owning_view&&)=default; owning_view& operator=(owning_view&&)=default;   constexpr R& base()&noexcept{return/*r_*/;}constexprconst R& base()const&noexcept{return/*r_*/;}constexpr R&& base()&&noexcept{return std::move(/*r_*/);}constexprconst R&& base()const&&noexcept{return std::move(/*r_*/);}   constexpr iterator_t<R> begin(){returnranges::begin(/*r_*/);}constexpr sentinel_t<R> end(){returnranges::end(/*r_*/);}   constexprauto begin()const requires range<const R>{returnranges::begin(/*r_*/);}constexprauto end()const requires range<const R>{returnranges::end(/*r_*/);}   constexprbool empty() requires requires {ranges::empty(/*r_*/);}{returnranges::empty(/*r_*/);}constexprbool empty()const requires requires {ranges::empty(/*r_*/);}{returnranges::empty(/*r_*/);}   constexprauto size() requires sized_range<R>{returnranges::size(/*r_*/);}constexprauto size()const requires sized_range<const R>{returnranges::size(/*r_*/);}   constexprauto reserve_hint() requires approximately_sized_range<R>{return ranges::reserve_hint(/*r_*/);}constexprauto reserve_hint()const requires approximately_sized_range<const R>{return ranges::reserve_hint(/*r_*/);}   constexprauto data() requires contiguous_range<R>{returnranges::data(/*r_*/);}constexprauto data()const requires contiguous_range<const R>{returnranges::data(/*r_*/);}};}

      [edit]Class template std::ranges::as_rvalue_view

      namespace std::ranges{template<view V> requires input_range<V>class as_rvalue_view :public view_interface<as_rvalue_view<V>>{ V /*base_*/= V();// exposition-only   public: as_rvalue_view() requires default_initializable<V>=default;constexprexplicit as_rvalue_view(V base);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexprauto begin() requires(!/*simple-view*/<V>){return move_iterator(ranges::begin(/*base_*/));}constexprauto begin()const requires range<const V>{return move_iterator(ranges::begin(/*base_*/));}   constexprauto end() requires(!/*simple-view*/<V>){ifconstexpr(common_range<V>){return move_iterator(ranges::end(/*base_*/));}else{return move_sentinel(ranges::end(/*base_*/));}}constexprauto end()const requires range<const V>{ifconstexpr(common_range<const V>){return move_iterator(ranges::end(/*base_*/));}else{return move_sentinel(ranges::end(/*base_*/));}}   constexprauto size() requires sized_range<V>{returnranges::size(/*base_*/);}constexprauto size()const requires sized_range<const V>{returnranges::size(/*base_*/);}   constexprauto reserve_hint() requires approximately_sized_range<V>{return ranges::reserve_hint(/*base_*/);}constexprauto reserve_hint()const requires approximately_sized_range<const V>{return ranges::reserve_hint(/*base_*/);}};   template<class R> as_rvalue_view(R&&)-> as_rvalue_view<views::all_t<R>>;}

      [edit]Class template std::ranges::filter_view

      namespace std::ranges{template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred> requires view<V>&& is_object_v<Pred>class filter_view :public view_interface<filter_view<V, Pred>>{private: V /*base_*/= V();// exposition-only/*movable-box*/<Pred>/*pred_*/;// exposition-only   // class filter_view::iteratorclass/*iterator*/;// exposition-only   // class filter_view::sentinelclass/*sentinel*/;// exposition-only   public: filter_view() requires default_initializable<V>&& default_initializable<Pred>=default;constexprexplicit filter_view(V base, Pred pred);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexprconst Pred& pred()const;   constexpr/*iterator*/ begin();constexprauto end(){ifconstexpr(common_range<V>)return/*iterator*/{*this, ranges::end(/*base_*/)};elsereturn/*sentinel*/{*this };}};   template<class R, class Pred> filter_view(R&&, Pred)-> filter_view<views::all_t<R>, Pred>;}

      [edit]Class template std::ranges::filter_view::iterator

      namespace std::ranges{template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred> requires view<V>&& is_object_v<Pred>class filter_view<V, Pred>::/*iterator*/{private: iterator_t<V>/*current_*/= iterator_t<V>();// exposition-only filter_view*/*parent_*/= nullptr;// exposition-only   public:using iterator_concept =/* see description */;using iterator_category =/* see description */;// not always presentusing value_type = range_value_t<V>;using difference_type = range_difference_t<V>;   /*iterator*/() requires default_initializable<iterator_t<V>>=default;constexpr/*iterator*/(filter_view& parent, iterator_t<V> current);   constexprconst iterator_t<V>& base()const&noexcept;constexpr iterator_t<V> base()&&;constexpr range_reference_t<V> operator*()const;constexpr iterator_t<V> operator->()const requires /*has-arrow*/<iterator_t<V>>&& copyable<iterator_t<V>>;   constexpr/*iterator*/& operator++();constexprvoid operator++(int);constexpr/*iterator*/ operator++(int) requires forward_range<V>;   constexpr/*iterator*/& operator--() requires bidirectional_range<V>;constexpr/*iterator*/ operator--(int) requires bidirectional_range<V>;   friendconstexprbool operator==(const/*iterator*/& x, const/*iterator*/& y) requires equality_comparable<iterator_t<V>>;   friendconstexpr range_rvalue_reference_t<V> iter_move(const/*iterator*/& i)noexcept(noexcept(ranges::iter_move(i./*current_*/)));   friendconstexprvoid iter_swap(const/*iterator*/& x, const/*iterator*/& y)noexcept(noexcept(ranges::iter_swap(x./*current_*/, y./*current_*/))) requires indirectly_swappable<iterator_t<V>>;};}

      [edit]Class template std::ranges::filter_view::sentinel

      namespace std::ranges{template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred> requires view<V>&& is_object_v<Pred>class filter_view<V, Pred>::/*sentinel*/{private: sentinel_t<V>/*end_*/= sentinel_t<V>();// exposition-only   public:/*sentinel*/()=default;constexprexplicit/*sentinel*/(filter_view& parent);   constexpr sentinel_t<V> base()const;   friendconstexprbool operator==(const/*iterator*/& x, const/*sentinel*/& y);};}

      [edit]Class template std::ranges::transform_view

      namespace std::ranges{template<input_range V, move_constructible F> requires view<V>&& is_object_v<F>&& regular_invocable<F&, range_reference_t<V>>&&/*can-reference*/<invoke_result_t<F&, range_reference_t<V>>>class transform_view :public view_interface<transform_view<V, F>>{private:// class template transform_view::iteratortemplate<bool>struct/*iterator*/;// exposition-only   // class template transform_view::sentineltemplate<bool>struct/*sentinel*/;// exposition-only   V /*base_*/= V();// exposition-only/*movable-box*/<F>/*fun_*/;// exposition-only   public: transform_view() requires default_initializable<V>&& default_initializable<F>=default;constexprexplicit transform_view(V base, F fun);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexpr/*iterator*/<false> begin();constexpr/*iterator*/<true> begin()const requires range<const V>&& regular_invocable<const F&, range_reference_t<const V>>;   constexpr/*sentinel*/<false> end();constexpr/*iterator*/<false> end() requires common_range<V>;constexpr/*sentinel*/<true> end()const requires range<const V>&& regular_invocable<const F&, range_reference_t<const V>>;constexpr/*iterator*/<true> end()const requires common_range<const V>&& regular_invocable<const F&, range_reference_t<const V>>;   constexprauto size() requires sized_range<V>{returnranges::size(/*base_*/);}constexprauto size()const requires sized_range<const V>{returnranges::size(/*base_*/);}   constexprauto reserve_hint() requires approximately_sized_range<V>{return ranges::reserve_hint(/*base_*/);}constexprauto reserve_hint()const requires approximately_sized_range<const V>{return ranges::reserve_hint(/*base_*/);}};   template<class R, class F> transform_view(R&&, F)-> transform_view<views::all_t<R>, F>;}

      [edit]Class template std::ranges::transform_view::iterator

      namespace std::ranges{template<input_range V, move_constructible F> requires view<V>&& is_object_v<F>&& regular_invocable<F&, range_reference_t<V>>&&/*can-reference*/<invoke_result_t<F&, range_reference_t<V>>>template<bool Const>class transform_view<V, F>::/*iterator*/{private:using/*Parent*/=/*maybe-const*/<Const, transform_view>;// exposition-onlyusing/*Base*/=/*maybe-const*/<Const, V>;// exposition-only iterator_t</*Base*/>/*current_*/= iterator_t</*Base*/>();// exposition-only/*Parent*/*/*parent_*/= nullptr;// exposition-only   public:using iterator_concept =/* see description */;using iterator_category =/* see description */;// not always presentusing value_type = remove_cvref_t< invoke_result_t</*maybe-const*/<Const, F>&, range_reference_t</*Base*/>>>;using difference_type = range_difference_t</*Base*/>;   /*iterator*/() requires default_initializable<iterator_t</*Base*/>>=default;constexpr/*iterator*/(/*Parent*/& parent, iterator_t</*Base*/> current);constexpr/*iterator*/(/*iterator*/<!Const> i) requires Const && convertible_to<iterator_t<V>, iterator_t</*Base*/>>;   constexprconst iterator_t</*Base*/>& base()const&noexcept;constexpr iterator_t</*Base*/> base()&&;   constexpr decltype(auto) operator*()constnoexcept(noexcept(invoke(*/*parent_*/->/*fun_*/, */*current_*/))){return invoke(*/*parent_*/->/*fun_*/, */*current_*/);}   constexpr/*iterator*/& operator++();constexprvoid operator++(int);constexpr/*iterator*/ operator++(int) requires forward_range</*Base*/>;   constexpr/*iterator*/& operator--() requires bidirectional_range</*Base*/>;constexpr/*iterator*/ operator--(int) requires bidirectional_range</*Base*/>;   constexpr/*iterator*/& operator+=(difference_type n) requires random_access_range</*Base*/>;constexpr/*iterator*/& operator-=(difference_type n) requires random_access_range</*Base*/>;   constexpr decltype(auto) operator[](difference_type n)const requires random_access_range</*Base*/>{return invoke(*/*parent_*/->/*fun_*/, /*current_*/[n]);}   friendconstexprbool operator==(const/*iterator*/& x, const/*iterator*/& y) requires equality_comparable<iterator_t</*Base*/>>;   friendconstexprbool operator<(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprbool operator>(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprbool operator<=(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprbool operator>=(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprauto operator<=>(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>&& three_way_comparable<iterator_t</*Base*/>>;   friendconstexpr/*iterator*/ operator+(/*iterator*/ i, difference_type n) requires random_access_range</*Base*/>;friendconstexpr/*iterator*/ operator+(difference_type n, /*iterator*/ i) requires random_access_range</*Base*/>;   friendconstexpr/*iterator*/ operator-(/*iterator*/ i, difference_type n) requires random_access_range</*Base*/>;friendconstexpr difference_type operator-(const/*iterator*/& x, const/*iterator*/& y) requires sized_sentinel_for<iterator_t</*Base*/>, iterator_t</*Base*/>>;};}

      [edit]Class template std::ranges::transform_view::sentinel

      namespace std::ranges{template<input_range V, move_constructible F> requires view<V>&& is_object_v<F>&& regular_invocable<F&, range_reference_t<V>>&&/*can-reference*/<invoke_result_t<F&, range_reference_t<V>>>template<bool Const>class transform_view<V, F>::/*sentinel*/{private:using/*Parent*/=/*maybe-const*/<Const, transform_view>;// exposition-onlyusing/*Base*/=/*maybe-const*/<Const, V>;// exposition-only sentinel_t</*Base*/>/*end_*/= sentinel_t</*Base*/>();// exposition-only   public:/*sentinel*/()=default;constexprexplicit/*sentinel*/(sentinel_t</*Base*/> end);constexpr/*sentinel*/(/*sentinel*/<!Const> i) requires Const && convertible_to<sentinel_t<V>, sentinel_t</*Base*/>>;   constexpr sentinel_t</*Base*/> base()const;   template<bool OtherConst> requires sentinel_for<sentinel_t</*Base*/>, iterator_t</*maybe-const*/<OtherConst, V>>>friendconstexprbool operator==(const/*iterator*/<OtherConst>& x, const/*sentinel*/& y);   template<bool OtherConst> requires sized_sentinel_for<sentinel_t</*Base*/>, iterator_t</*maybe-const*/<OtherConst, V>>>friendconstexpr range_difference_t</*maybe-const*/<OtherConst, V>> operator-(const/*iterator*/<OtherConst>& x, const/*sentinel*/& y);   template<bool OtherConst> requires sized_sentinel_for<sentinel_t</*Base*/>, iterator_t</*maybe-const*/<OtherConst, V>>>friendconstexpr range_difference_t</*maybe-const*/<OtherConst, V>> operator-(const/*sentinel*/& y, const/*iterator*/<OtherConst>& x);};}

      [edit]Class template std::ranges::take_view

      namespace std::ranges{template<view V>class take_view :public view_interface<take_view<V>>{private: V /*base_*/= V();// exposition-only range_difference_t<V>/*count_*/=0;// exposition-only   // class template take_view::sentineltemplate<bool>class/*sentinel*/;// exposition-only   public: take_view() requires default_initializable<V>=default;constexprexplicit take_view(V base, range_difference_t<V> count);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexprauto begin() requires(!/*simple-view*/<V>){ifconstexpr(sized_range<V>){ifconstexpr(random_access_range<V>){returnranges::begin(/*base_*/);}else{auto sz = range_difference_t<V>(size());return counted_iterator(ranges::begin(/*base_*/), sz);}}elseifconstexpr(sized_sentinel_for<sentinel_t<V>, iterator_t<V>>){auto it =ranges::begin(/*base_*/);auto sz =std::min(/*count_*/, ranges::end(/*base_*/)- it);return counted_iterator(std::move(it), sz);}else{return counted_iterator(ranges::begin(/*base_*/), /*count_*/);}}   constexprauto begin()const requires range<const V>{ifconstexpr(sized_range<const V>){ifconstexpr(random_access_range<const V>){returnranges::begin(/*base_*/);}else{auto sz = range_difference_t<const V>(size());return counted_iterator(ranges::begin(/*base_*/), sz);}}elseifconstexpr(sized_sentinel_for<sentinel_t<const V>, iterator_t<const V>>){auto it =ranges::begin(/*base_*/);auto sz =std::min(/*count_*/, ranges::end(/*base_*/)- it);return counted_iterator(std::move(it), sz);}else{return counted_iterator(ranges::begin(/*base_*/), /*count_*/);}}   constexprauto end() requires(!/*simple-view*/<V>){ifconstexpr(sized_range<V>){ifconstexpr(random_access_range<V>)returnranges::begin(/*base_*/)+ range_difference_t<V>(size());elsereturn default_sentinel;}elseifconstexpr(sized_sentinel_for<sentinel_t<V>, iterator_t<V>>){return default_sentinel;}else{return/*sentinel*/<false>{ranges::end(/*base_*/)};}}   constexprauto end()const requires range<const V>{ifconstexpr(sized_range<const V>){ifconstexpr(random_access_range<const V>)returnranges::begin(/*base_*/)+ range_difference_t<const V>(size());elsereturn default_sentinel;}elseifconstexpr(sized_sentinel_for<sentinel_t<const V>, iterator_t<const V>>){return default_sentinel;}else{return/*sentinel*/<true>{ranges::end(/*base_*/)};}}   constexprauto size() requires sized_range<V>{auto n =ranges::size(/*base_*/);returnranges::min(n, static_cast<decltype(n)>(/*count_*/));}   constexprauto size()const requires sized_range<const V>{auto n =ranges::size(/*base_*/);returnranges::min(n, static_cast<decltype(n)>(/*count_*/));}   constexprauto reserve_hint(){ifconstexpr(approximately_sized_range<V>){auto n =static_cast<range_difference_t<V>>(ranges::reserve_hint(/*base_*/));return/*to-unsigned-like*/(ranges::min(n, /*count_*/));}return/*to-unsigned-like*/(/*count_*/);}   constexprauto reserve_hint()const{ifconstexpr(approximately_sized_range<const V>){auto n =static_cast<range_difference_t<const V>>(ranges::reserve_hint(/*base_*/));return/*to-unsigned-like*/(ranges::min(n, /*count_*/));}return/*to-unsigned-like*/(/*count_*/);}};   template<class R> take_view(R&&, range_difference_t<R>)-> take_view<views::all_t<R>>;}

      [edit]Class template std::ranges::take_view::sentinel

      namespace std::ranges{template<view V>template<bool Const>class take_view<V>::/*sentinel*/{private:using/*Base*/=/*maybe-const*/<Const, V>;// exposition-onlytemplate<bool OtherConst>using/*CI*/= counted_iterator<iterator_t</*maybe-const*/<OtherConst, V>>>;// exposition-only sentinel_t</*Base*/>/*end_*/= sentinel_t</*Base*/>();// exposition-only   public:/*sentinel*/()=default;constexprexplicit/*sentinel*/(sentinel_t</*Base*/> end);constexpr/*sentinel*/(/*sentinel*/<!Const> s) requires Const && convertible_to<sentinel_t<V>, sentinel_t</*Base*/>>;   constexpr sentinel_t</*Base*/> base()const;   friendconstexprbool operator==(const/*CI*/<Const>& y, const/*sentinel*/& x);   template<bool OtherConst =!Const> requires sentinel_for<sentinel_t</*Base*/>, iterator_t</*maybe-const*/<OtherConst, V>>>friendconstexprbool operator==(const/*CI*/<OtherConst>& y, const/*sentinel*/& x);};}

      [edit]Class template std::ranges::take_while_view

      namespace std::ranges{template<view V, class Pred> requires input_range<V>&& is_object_v<Pred>&& indirect_unary_predicate<const Pred, iterator_t<V>>class take_while_view :public view_interface<take_while_view<V, Pred>>{// class template take_while_view::sentineltemplate<bool>class/*sentinel*/;// exposition-only   V /*base_*/= V();// exposition-only/*movable-box*/<Pred>/*pred_*/;// exposition-only   public: take_while_view() requires default_initializable<V>&& default_initializable<Pred>=default;constexprexplicit take_while_view(V base, Pred pred);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexprconst Pred& pred()const;   constexprauto begin() requires(!/*simple-view*/<V>){returnranges::begin(/*base_*/);}   constexprauto begin()const requires range<const V>&& indirect_unary_predicate<const Pred, iterator_t<const V>>{returnranges::begin(/*base_*/);}   constexprauto end() requires(!/*simple-view*/<V>){return/*sentinel*/<false>(ranges::end(/*base_*/), addressof(*/*pred_*/));}   constexprauto end()const requires range<const V>&& indirect_unary_predicate<const Pred, iterator_t<const V>>{return/*sentinel*/<true>(ranges::end(/*base_*/), addressof(*/*pred_*/));}};   template<class R, class Pred> take_while_view(R&&, Pred)-> take_while_view<views::all_t<R>, Pred>;}

      [edit]Class template std::ranges::take_while_view::sentinel

      namespace std::ranges{template<view V, class Pred> requires input_range<V>&& is_object_v<Pred>&& indirect_unary_predicate<const Pred, iterator_t<V>>template<bool Const>class take_while_view<V, Pred>::/*sentinel*/{using/*Base*/=/*maybe-const*/<Const, V>;// exposition-only   sentinel_t</*Base*/>/*end_*/= sentinel_t</*Base*/>();// exposition-onlyconst Pred*/*pred_*/= nullptr;// exposition-only   public:/*sentinel*/()=default;constexprexplicit/*sentinel*/(sentinel_t</*Base*/> end, const Pred* pred);constexpr/*sentinel*/(/*sentinel*/<!Const> s) requires Const && convertible_to<sentinel_t<V>, sentinel_t</*Base*/>>;   constexpr sentinel_t</*Base*/> base()const{return/*end_*/;}   friendconstexprbool operator==(const iterator_t</*Base*/>& x, const/*sentinel*/& y);   template<bool OtherConst =!Const> requires sentinel_for<sentinel_t</*Base*/>, iterator_t</*maybe-const*/<OtherConst, V>>>friendconstexprbool operator==(const iterator_t</*maybe-const*/<OtherConst, V>>& x, const/*sentinel*/& y);};}

      [edit]Class template std::ranges::drop_view

      namespace std::ranges{template<view V>class drop_view :public view_interface<drop_view<V>>{public: drop_view() requires default_initializable<V>=default;constexprexplicit drop_view(V base, range_difference_t<V> count);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexprauto begin() requires(!(/*simple-view*/<V>&& random_access_range<const V>&& sized_range<const V>));constexprauto begin()const requires random_access_range<const V>&& sized_range<const V>;   constexprauto end() requires(!/*simple-view*/<V>){returnranges::end(/*base_*/);}   constexprauto end()const requires range<const V>{returnranges::end(/*base_*/);}   constexprauto size() requires sized_range<V>{constauto s =ranges::size(/*base_*/);constauto c =static_cast<decltype(s)>(/*count_*/);return s < c ?0: s - c;}   constexprauto size()const requires sized_range<const V>{constauto s =ranges::size(/*base_*/);constauto c =static_cast<decltype(s)>(/*count_*/);return s < c ?0: s - c;}   constexprauto reserve_hint() requires approximately_sized_range<V>{constauto s =static_cast<range_difference_t<V>>(ranges::reserve_hint(/*base_*/));return/*to-unsigned-like*/(s </*count_*/?0: s -/*count_*/);}   constexprauto reserve_hint()const requires approximately_sized_range<const V>{constauto s =static_cast<range_difference_t<const V>>(ranges::reserve_hint(/*base_*/));return/*to-unsigned-like*/(s </*count_*/?0: s -/*count_*/);}   private: V /*base_*/= V();// exposition-only range_difference_t<V>/*count_*/=0;// exposition-only};   template<class R> drop_view(R&&, range_difference_t<R>)-> drop_view<views::all_t<R>>;}

      [edit]Class template std::ranges::drop_while_view

      namespace std::ranges{template<view V, class Pred> requires input_range<V>&& is_object_v<Pred>&& indirect_unary_predicate<const Pred, iterator_t<V>>class drop_while_view :public view_interface<drop_while_view<V, Pred>>{public: drop_while_view() requires default_initializable<V>&& default_initializable<Pred>=default;constexprexplicit drop_while_view(V base, Pred pred);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexprconst Pred& pred()const;   constexprauto begin();   constexprauto end(){returnranges::end(/*base_*/);}   private: V /*base_*/= V();// exposition-only/*movable-box*/<Pred>/*pred_*/;// exposition-only};   template<class R, class Pred> drop_while_view(R&&, Pred)-> drop_while_view<views::all_t<R>, Pred>;}

      [edit]Class template std::ranges::join_view

      namespace std::ranges{template<input_range V> requires view<V>&& input_range<range_reference_t<V>>class join_view :public view_interface<join_view<V>>{private:using/*InnerRng*/= range_reference_t<V>;// exposition-only   // class template join_view::iteratortemplate<bool Const>struct/*iterator*/;// exposition-only   // class template join_view::sentineltemplate<bool Const>struct/*sentinel*/;// exposition-only   V /*base_*/= V();// exposition-only   /*non-propagating-cache*/<iterator_t<V>>/*outer_*/;// exposition-only present only// when !forward_range<V>/*non-propagating-cache*/<remove_cv_t</*InnerRng*/>>/*inner_*/;// exposition-only present only// if is_reference_v<InnerRng> is false   public: join_view() requires default_initializable<V>=default;constexprexplicit join_view(V base);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexprauto begin(){ifconstexpr(forward_range<V>){constexprbool use_const =/*simple-view*/<V>&& is_reference_v</*InnerRng*/>;return/*iterator*/<use_const>{*this, ranges::begin(/*base_*/)};}else{/*outer_*/=ranges::begin(/*base_*/);return/*iterator*/<false>{*this };}}   constexprauto begin()const requires forward_range<const V>&& is_reference_v<range_reference_t<const V>>&& input_range<range_reference_t<const V>>{return/*iterator*/<true>{*this, ranges::begin(/*base_*/)};}   constexprauto end(){ifconstexpr(forward_range<V>&& is_reference_v</*InnerRng*/>&& forward_range</*InnerRng*/>&& common_range<V>&& common_range</*InnerRng*/>)return/*iterator*/</*simple-view*/<V>>{*this, ranges::end(/*base_*/)};elsereturn/*sentinel*/</*simple-view*/<V>>{*this };}   constexprauto end()const requires forward_range<const V>&& is_reference_v<range_reference_t<const V>>&& input_range<range_reference_t<const V>>{ifconstexpr(forward_range<range_reference_t<const V>>&& common_range<const V>&& common_range<range_reference_t<const V>>)return/*iterator*/<true>{*this, ranges::end(/*base_*/)};elsereturn/*sentinel*/<true>{*this };}};   template<class R>explicit join_view(R&&)-> join_view<views::all_t<R>>;}

      [edit]Class template std::ranges::join_view::iterator

      namespace std::ranges{template<input_range V> requires view<V>&& input_range<range_reference_t<V>>template<bool Const>struct join_view<V>::/*iterator*/{private:using/*Parent*/=/*maybe-const*/<Const, join_view>;// exposition-onlyusing/*Base*/=/*maybe-const*/<Const, V>;// exposition-onlyusing/*OuterIter*/= iterator_t</*Base*/>;// exposition-onlyusing/*InnerIter*/= iterator_t<range_reference_t</*Base*/>>;// exposition-only   staticconstexprbool/*ref-is-glvalue*/=// exposition-only is_reference_v<range_reference_t</*Base*/>>;   /*OuterIter*//*outer_*/=/*OuterIter*/();// exposition-only present only// if Base models forward_range optional</*InnerIter*/>/*inner_*/;// exposition-only/*Parent*/*/*parent_*/= nullptr;// exposition-only   constexprvoid/*satisfy*/();// exposition-only   constexpr/*OuterIter*/&/*outer*/();// exposition-onlyconstexprconst/*OuterIter*/&/*outer*/()const;// exposition-only   constexpr/*iterator*/(/*Parent*/& parent, /*OuterIter*/ outer) requires forward_range</*Base*/>;// exposition-onlyconstexprexplicit/*iterator*/(/*Parent*/& parent) requires(!forward_range</*Base*/>);// exposition-only   public:using iterator_concept =/* see description */;using iterator_category =/* see description */;// not always presentusing value_type = range_value_t<range_reference_t</*Base*/>>;using difference_type =/* see description */;   /*iterator*/()=default;constexpr/*iterator*/(/*iterator*/<!Const> i) requires Const && convertible_to<iterator_t<V>, /*OuterIter*/>&& convertible_to<iterator_t</*InnerRng*/>, /*InnerIter*/>;   constexpr decltype(auto) operator*()const{return**/*inner_*/;}   constexpr/*InnerIter*/ operator->()const requires /*has-arrow*/</*InnerIter*/>&& copyable</*InnerIter*/>;   constexpr/*iterator*/& operator++();constexprvoid operator++(int);constexpr/*iterator*/ operator++(int) requires /*ref-is-glvalue*/&& forward_range</*Base*/>&& forward_range<range_reference_t</*Base*/>>;   constexpr/*iterator*/& operator--() requires /*ref-is-glvalue*/&& bidirectional_range</*Base*/>&& bidirectional_range<range_reference_t</*Base*/>>&& common_range<range_reference_t</*Base*/>>;   constexpr/*iterator*/ operator--(int) requires /*ref-is-glvalue*/&& bidirectional_range</*Base*/>&& bidirectional_range<range_reference_t</*Base*/>>&& common_range<range_reference_t</*Base*/>>;   friendconstexprbool operator==(const/*iterator*/& x, const/*iterator*/& y) requires /*ref-is-glvalue*/&& forward_range</*Base*/>&& equality_comparable<iterator_t<range_reference_t</*Base*/>>>;   friendconstexpr decltype(auto) iter_move(const/*iterator*/& i)noexcept(noexcept(ranges::iter_move(*i./*inner_*/))){returnranges::iter_move(*i./*inner_*/);}   friendconstexprvoid iter_swap(const/*iterator*/& x, const/*iterator*/& y)noexcept(noexcept(ranges::iter_swap(*x./*inner_*/, *y./*inner_*/))) requires indirectly_swappable</*InnerIter*/>;};}

      [edit]Class template std::ranges::join_view::sentinel

      namespace std::ranges{template<input_range V> requires view<V>&& input_range<range_reference_t<V>>template<bool Const>struct join_view<V>::/*sentinel*/{private:using/*Parent*/=/*maybe-const*/<Const, join_view>;// exposition-onlyusing/*Base*/=/*maybe-const*/<Const, V>;// exposition-only sentinel_t</*Base*/>/*end_*/= sentinel_t</*Base*/>();// exposition-only   public:/*sentinel*/()=default;   constexprexplicit/*sentinel*/(/*Parent*/& parent);constexpr/*sentinel*/(/*sentinel*/<!Const> s) requires Const && convertible_to<sentinel_t<V>, sentinel_t</*Base*/>>;   template<bool OtherConst> requires sentinel_for<sentinel_t</*Base*/>, iterator_t</*maybe-const*/<OtherConst, V>>>friendconstexprbool operator==(const/*iterator*/<OtherConst>& x, const/*sentinel*/& y);};}

      [edit]Class template std::ranges::join_with_view

      namespace std::ranges{template<class R> concept /*bidirectional-common*/= bidirectional_range<R>&& common_range<R>;// exposition-only   template<input_range V, forward_range Pattern> requires view<V>&& input_range<range_reference_t<V>>&& view<Pattern>&&/*concatable*/<range_reference_t<V>, Pattern>class join_with_view :public view_interface<join_with_view<V, Pattern>>{using/*InnerRng*/= range_reference_t<V>;// exposition-only   V /*base_*/= V();// exposition-only/*non-propagating-cache*/<iterator_t<V>>/*outer-it_*/;// exposition-only present// only when !forward_range<V>/*non-propagating-cache*/<remove_cv_t</*InnerRng*/>>/*inner_*/;// exposition-only present only// if is_reference_v<InnerRng> is false Pattern /*pattern_*/= Pattern();// exposition-only   // class template join_with_view::iteratortemplate<bool Const>struct/*iterator*/;// exposition-only   // class template join_with_view::sentineltemplate<bool Const>struct/*sentinel*/;// exposition-only   public: join_with_view() requires default_initializable<V>&& default_initializable<Pattern>=default;   constexprexplicit join_with_view(V base, Pattern pattern);   template<input_range R> requires constructible_from<V, views::all_t<R>>&& constructible_from<Pattern, single_view<range_value_t</*InnerRng*/>>>constexprexplicit join_with_view(R&& r, range_value_t</*InnerRng*/> e);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexprauto begin(){ifconstexpr(forward_range<V>){constexprbool use_const =/*simple-view*/<V>&& is_reference_v</*InnerRng*/>&&/*simple-view*/<Pattern>;return/*iterator*/<use_const>{*this, ranges::begin(/*base_*/)};}else{/*outer-it_*/=ranges::begin(/*base_*/);return/*iterator*/<false>{*this };}}constexprauto begin()const requires forward_range<const V>&& forward_range<const Pattern>&& is_reference_v<range_reference_t<const V>>&& input_range<range_reference_t<const V>>&&/*concatable*/<range_reference_t<const V>, const Pattern>{return/*iterator*/<true>{*this, ranges::begin(/*base_*/)};}   constexprauto end(){ifconstexpr(forward_range<V>&& is_reference_v</*InnerRng*/>&& forward_range</*InnerRng*/>&& common_range<V>&& common_range</*InnerRng*/>)return/*iterator*/</*simple-view*/<V>&&/*simple-view*/< Pattern >>{*this, ranges::end(/*base_*/)};elsereturn/*sentinel*/</*simple-view*/<V>&&/*simple-view*/< Pattern >>{*this };}constexprauto end()const requires forward_range<const V>&& forward_range<const Pattern>&& is_reference_v<range_reference_t<const V>>&& input_range<range_reference_t<const V>>&&/*concatable*/<range_reference_t<const V>, const Pattern>{using InnerConstRng = range_reference_t<const V>;ifconstexpr(forward_range<InnerConstRng>&& common_range<const V>&& common_range<InnerConstRng>)return/*iterator*/<true>{*this, ranges::end(/*base_*/)};elsereturn/*sentinel*/<true>{*this };}};   template<class R, class P> join_with_view(R&&, P&&)-> join_with_view<views::all_t<R>, views::all_t<P>>;   template<input_range R> join_with_view(R&&, range_value_t<range_reference_t<R>>)-> join_with_view<views::all_t<R>, single_view<range_value_t<range_reference_t<R>>>>;}

      [edit]Class template std::ranges::join_with_view::iterator

      namespace std::ranges{template<input_range V, forward_range Pattern> requires view<V>&& input_range<range_reference_t<V>>&& view<Pattern>&&/*concatable*/<range_reference_t<V>, Pattern>template<bool Const>class join_with_view<V, Pattern>::/*iterator*/{using/*Parent*/=/*maybe-const*/<Const, join_with_view>;// exposition-onlyusing/*Base*/=/*maybe-const*/<Const, V>;// exposition-onlyusing/*InnerBase*/= range_reference_t</*Base*/>;// exposition-onlyusing/*PatternBase*/=/*maybe-const*/<Const, Pattern>;// exposition-only   using/*OuterIter*/= iterator_t</*Base*/>;// exposition-onlyusing/*InnerIter*/= iterator_t</*InnerBase*/>;// exposition-onlyusing/*PatternIter*/= iterator_t</*PatternBase*/>;// exposition-only   staticconstexprbool/*ref-is-glvalue*/= is_reference_v</*InnerBase*/>;// exposition-only   /*Parent*/*/*parent_*/= nullptr;// exposition-only/*OuterIter*//*outer-it_*/=/*OuterIter*/();// exposition-only present only// if Base models forward_range variant</*PatternIter*/, /*InnerIter*/>/*inner-it_*/;// exposition-only   constexpr/*iterator*/(/*Parent*/& parent, /*OuterIter*/ outer) requires forward_range</*Base*/>;// exposition-onlyconstexprexplicit/*iterator*/(/*Parent*/& parent) requires(!forward_range</*Base*/>);// exposition-onlyconstexpr/*OuterIter*/&/*outer*/();// exposition-onlyconstexprconst/*OuterIter*/&/*outer*/()const;// exposition-onlyconstexprauto&/*update-inner*/();// exposition-onlyconstexprauto&/*get-inner*/();// exposition-onlyconstexprvoid/*satisfy*/();// exposition-only   public:using iterator_concept =/* see description */;using iterator_category =/* see description */;// not always presentusing value_type =/* see description */;using difference_type =/* see description */;   /*iterator*/()=default;constexpr/*iterator*/(/*iterator*/<!Const> i) requires Const && convertible_to<iterator_t<V>, /*OuterIter*/>&& convertible_to<iterator_t</*InnerRng*/>, /*InnerIter*/>&& convertible_to<iterator_t<Pattern>, /*PatternIter*/>;   constexpr decltype(auto) operator*()const;   constexpr/*iterator*/& operator++();constexprvoid operator++(int);constexpr/*iterator*/ operator++(int) requires /*ref-is-glvalue*/&& forward_iterator</*OuterIter*/>&& forward_iterator</*InnerIter*/>;   constexpr/*iterator*/& operator--() requires /*ref-is-glvalue*/&& bidirectional_range</*Base*/>&&/*bidirectional-common*/</*InnerBase*/>&&/*bidirectional-common*/</*PatternBase*/>;constexpr/*iterator*/ operator--(int) requires /*ref-is-glvalue*/&& bidirectional_range</*Base*/>&&/*bidirectional-common*/</*InnerBase*/>&&/*bidirectional-common*/</*PatternBase*/>;   friendconstexprbool operator==(const/*iterator*/& x, const/*iterator*/& y) requires /*ref-is-glvalue*/&& forward_range</*Base*/>&& equality_comparable</*InnerIter*/>;   friendconstexpr decltype(auto) iter_move(const/*iterator*/& x){using rvalue_reference = common_reference_t<iter_rvalue_reference_t</*InnerIter*/>, iter_rvalue_reference_t</*PatternIter*/>>;return visit<rvalue_reference>(ranges::iter_move, x./*inner-it_*/);}   friendconstexprvoid iter_swap(const/*iterator*/& x, const/*iterator*/& y) requires indirectly_swappable</*InnerIter*/, /*PatternIter*/>{ visit(ranges::iter_swap, x./*inner-it_*/, y./*inner-it_*/);}};}

      [edit]Class template std::ranges::join_with_view::sentinel

      namespace std::ranges{template<input_range V, forward_range Pattern> requires view<V>&& input_range<range_reference_t<V>>&& view<Pattern>&&/*concatable*/<range_reference_t<V>, Pattern>template<bool Const>class join_with_view<V, Pattern>::/*sentinel*/{using/*Parent*/=/*maybe-const*/<Const, join_with_view>;// exposition-onlyusing/*Base*/=/*maybe-const*/<Const, V>;// exposition-only sentinel_t</*Base*/>/*end_*/= sentinel_t</*Base*/>();// exposition-only   constexprexplicit/*sentinel*/(/*Parent*/& parent);// exposition-only   public:/*sentinel*/()=default;constexpr/*sentinel*/(/*sentinel*/<!Const> s) requires Const && convertible_to<sentinel_t<V>, sentinel_t</*Base*/>>;   template<bool OtherConst> requires sentinel_for<sentinel_t</*Base*/>, iterator_t</*maybe-const*/<OtherConst, V>>>friendconstexprbool operator==(const/*iterator*/<OtherConst>& x, const/*sentinel*/& y);};}

      [edit]Class template std::ranges::lazy_split_view

      namespace std::ranges{template<auto>struct/*require-constant*/;// exposition-only   template<class R> concept /*tiny-range*/=// exposition-only sized_range<R>&& requires {typename/*require-constant*/<remove_reference_t<R>::size()>;}&&(remove_reference_t<R>::size()<=1);   template<input_range V, forward_range Pattern> requires view<V>&& view<Pattern>&& indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>&&(forward_range<V>||/*tiny-range*/<Pattern>)class lazy_split_view :public view_interface<lazy_split_view<V, Pattern>>{private: V /*base_*/= V();// exposition-only Pattern /*pattern_*/= Pattern();// exposition-only   /*non-propagating-cache*/<iterator_t<V>>/*current_*/;// exposition-only present only// if forward_range<V> is false   // class template lazy_split_view::outer-iteratortemplate<bool>struct/*outer-iterator*/;// exposition-only   // class template lazy_split_view::inner-iteratortemplate<bool>struct/*inner-iterator*/;// exposition-only   public: lazy_split_view() requires default_initializable<V>&& default_initializable<Pattern>=default;constexprexplicit lazy_split_view(V base, Pattern pattern);   template<input_range R> requires constructible_from<V, views::all_t<R>>&& constructible_from<Pattern, single_view<range_value_t<R>>>constexprexplicit lazy_split_view(R&& r, range_value_t<R> e);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexprauto begin(){ifconstexpr(forward_range<V>){return/*outer-iterator*/</*simple-view*/<V>&&/*simple-view*/< Pattern >>{*this, ranges::begin(/*base_*/)};}else{/*current_*/=ranges::begin(/*base_*/);return/*outer-iterator*/<false>{*this };}}   constexprauto begin()const requires forward_range<V>&& forward_range<const V>{return/*outer-iterator*/<true>{*this, ranges::begin(/*base_*/)};}   constexprauto end() requires forward_range<V>&& common_range<V>{return/*outer-iterator*/</*simple-view*/<V>&&/*simple-view*/< Pattern >>{*this, ranges::end(/*base_*/)};}   constexprauto end()const{ifconstexpr(forward_range<V>&& forward_range<const V>&& common_range<const V>)return/*outer-iterator*/<true>{*this, ranges::end(/*base_*/)};elsereturn default_sentinel;}};   template<class R, class P> lazy_split_view(R&&, P&&)-> lazy_split_view<views::all_t<R>, views::all_t<P>>;   template<input_range R> lazy_split_view(R&&, range_value_t<R>)-> lazy_split_view<views::all_t<R>, single_view<range_value_t<R>>>;}

      [edit]Class template std::ranges::lazy_split_view::outer_iterator

      namespace std::ranges{template<input_range V, forward_range Pattern> requires view<V>&& view<Pattern>&& indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>&&(forward_range<V>||/*tiny-range*/<Pattern>)template<bool Const>struct lazy_split_view<V, Pattern>::/*outer-iterator*/{private:using/*Parent*/=/*maybe-const*/<Const, lazy_split_view>;// exposition-onlyusing/*Base*/=/*maybe-const*/<Const, V>;// exposition-only/*Parent*/*/*parent_*/= nullptr;// exposition-only   iterator_t</*Base*/>/*current_*/= iterator_t</*Base*/>();// exposition-only present only// if V models forward_range   bool/*trailing-empty_*/=false;// exposition-only   public:using iterator_concept = conditional_t<forward_range</*Base*/>, forward_iterator_tag, input_iterator_tag>;   using iterator_category = input_iterator_tag;// present only if Base// models forward_range   // class lazy_split_view::outer-iterator::value_typestruct value_type;using difference_type = range_difference_t</*Base*/>;   /*outer-iterator*/()=default;constexprexplicit/*outer-iterator*/(/*Parent*/& parent) requires(!forward_range</*Base*/>);constexpr/*outer-iterator*/(/*Parent*/& parent, iterator_t</*Base*/> current) requires forward_range</*Base*/>;constexpr/*outer-iterator*/(/*outer-iterator*/<!Const> i) requires Const && convertible_to<iterator_t<V>, iterator_t</*Base*/>>;   constexpr value_type operator*()const;   constexpr/*outer-iterator*/& operator++();constexpr decltype(auto) operator++(int){ifconstexpr(forward_range</*Base*/>){auto tmp =*this;++*this;return tmp;}else++*this;}   friendconstexprbool operator==(const/*outer-iterator*/& x, const/*outer-iterator*/& y) requires forward_range</*Base*/>;   friendconstexprbool operator==(const/*outer-iterator*/& x, default_sentinel_t);};}

      [edit]Class template std::ranges::lazy_split_view::outer_iterator::value_type

      namespace std::ranges{template<input_range V, forward_range Pattern> requires view<V>&& view<Pattern>&& indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>&&(forward_range<V>||/*tiny-range*/<Pattern>)template<bool Const>struct lazy_split_view<V, Pattern>::/*outer-iterator*/<Const>::value_type: view_interface<value_type>{private:/*outer-iterator*//*i_*/=/*outer-iterator*/();// exposition-only   constexprexplicit value_type(/*outer-iterator*/ i);// exposition-only   public:constexpr/*inner-iterator*/<Const> begin()const;constexpr default_sentinel_t end()constnoexcept;};}

      [edit]Class template std::ranges::lazy_split_view::inner_iterator

      namespace std::ranges{template<input_range V, forward_range Pattern> requires view<V>&& view<Pattern>&& indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>&&(forward_range<V>||/*tiny-range*/<Pattern>)template<bool Const>struct lazy_split_view<V, Pattern>::/*inner-iterator*/{private:using/*Base*/=/*maybe-const*/<Const, V>;// exposition-only/*outer-iterator*/<Const>/*i_*/=/*outer-iterator*/<Const>();// exposition-onlybool/*incremented_*/=false;// exposition-only   public:using iterator_concept =typename/*outer-iterator*/<Const>::iterator_concept;   using iterator_category =/* see description */;// present only if Base// models forward_rangeusing value_type = range_value_t</*Base*/>;using difference_type = range_difference_t</*Base*/>;   /*inner-iterator*/()=default;constexprexplicit/*inner-iterator*/(/*outer-iterator*/<Const> i);   constexprconst iterator_t</*Base*/>& base()const&noexcept;constexpr iterator_t</*Base*/> base()&& requires forward_range<V>;   constexpr decltype(auto) operator*()const{return*/*i_*/./*current*/;}   constexpr/*inner-iterator*/& operator++();constexpr decltype(auto) operator++(int){ifconstexpr(forward_range</*Base*/>){auto tmp =*this;++*this;return tmp;}else++*this;}   friendconstexprbool operator==(const/*inner-iterator*/& x, const/*inner-iterator*/& y) requires forward_range</*Base*/>;   friendconstexprbool operator==(const/*inner-iterator*/& x, default_sentinel_t);   friendconstexpr decltype(auto) iter_move(const/*inner-iterator*/& i)noexcept(noexcept(ranges::iter_move(i./*i_*/./*current*/))){returnranges::iter_move(i./*i_*/./*current*/);}   friendconstexprvoid iter_swap(const/*inner-iterator*/& x, const/*inner-iterator*/& y)noexcept(noexcept(ranges::iter_swap(x./*i_*/./*current*/, y./*i_*/./*current*/))) requires indirectly_swappable<iterator_t</*Base*/>>;};}

      [edit]Class template std::ranges::split_view

      namespace std::ranges{template<forward_range V, forward_range Pattern> requires view<V>&& view<Pattern>&& indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>class split_view :public view_interface<split_view<V, Pattern>>{private: V /*base_*/= V();// exposition-only Pattern /*pattern_*/= Pattern();// exposition-only   // class split_view::iteratorstruct/*iterator*/;// exposition-only   // class split_view::sentinelstruct/*sentinel*/;// exposition-only   public: split_view() requires default_initializable<V>&& default_initializable<Pattern>=default;constexprexplicit split_view(V base, Pattern pattern);   template<forward_range R> requires constructible_from<V, views::all_t<R>>&& constructible_from<Pattern, single_view<range_value_t<R>>>constexprexplicit split_view(R&& r, range_value_t<R> e);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexpr/*iterator*/ begin();   constexprauto end(){ifconstexpr(common_range<V>){return/*iterator*/{*this, ranges::end(/*base_*/), {}};}else{return/*sentinel*/{*this };}}   constexpr subrange<iterator_t<V>>/*find-next*/(iterator_t<V>);// exposition-only};   template<class R, class P> split_view(R&&, P&&)-> split_view<views::all_t<R>, views::all_t<P>>;   template<forward_range R> split_view(R&&, range_value_t<R>)-> split_view<views::all_t<R>, single_view<range_value_t<R>>>;}

      [edit]Class template std::ranges::split_view::iterator

      namespace std::ranges{template<forward_range V, forward_range Pattern> requires view<V>&& view<Pattern>&& indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>class split_view<V, Pattern>::/*iterator*/{private: split_view*/*parent_*/= nullptr;// exposition-only iterator_t<V>/*cur_*/= iterator_t<V>();// exposition-only subrange<iterator_t<V>>/*next_*/= subrange<iterator_t<V>>();// exposition-onlybool/*trailing-empty_*/=false;// exposition-only   public:using iterator_concept = forward_iterator_tag;using iterator_category = input_iterator_tag;using value_type = subrange<iterator_t<V>>;using difference_type = range_difference_t<V>;   /*iterator*/()=default;constexpr/*iterator*/(split_view& parent, iterator_t<V> current, subrange<iterator_t<V>> next);   constexpr iterator_t<V> base()const;constexpr value_type operator*()const;   constexpr/*iterator*/& operator++();constexpr/*iterator*/ operator++(int);   friendconstexprbool operator==(const/*iterator*/& x, const/*iterator*/& y);};}

      [edit]Class template std::ranges::split_view::sentinel

      namespace std::ranges{template<forward_range V, forward_range Pattern> requires view<V>&& view<Pattern>&& indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>struct split_view<V, Pattern>::/*sentinel*/{private: sentinel_t<V>/*end_*/= sentinel_t<V>();// exposition-only   public:/*sentinel*/()=default;constexprexplicit/*sentinel*/(split_view& parent);   friendconstexprbool operator==(const/*iterator*/& x, const/*sentinel*/& y);};}

      [edit]Class template std::ranges::concat

      namespace std::ranges{template<class... Rs>using/*concat-reference-t*/= common_reference_t<range_reference_t<Rs>...>;// exposition-onlytemplate<class... Rs>using/*concat-value-t*/= common_type_t<range_value_t<Rs>...>;// exposition-onlytemplate<class... Rs>using/*concat-rvalue-reference-t*/=// exposition-only common_reference_t<range_rvalue_reference_t<Rs>...>;   template<class... Rs> concept /*concat-indirectly-readable*/=/* see description */;// exposition-onlytemplate<class... Rs> concept /*concatable*/=/* see description */;// exposition-onlytemplate<bool Const, class... Rs> concept /*concat-is-random-access*/=/* see description */;// exposition-onlytemplate<bool Const, class... Rs> concept /*concat-is-bidirectional*/=/* see description */;// exposition-only   template<input_range... Views> requires(view<Views>&& ...)&&(sizeof...(Views)>0)&&/*concatable*/<Views...>class concat_view :public view_interface<concat_view<Views...>>{   tuple<Views...>/*views_*/;// exposition-only   // class template concat_view::iteratortemplate<bool>class/*iterator*/;// exposition-only   public:constexpr concat_view()=default;constexprexplicit concat_view(Views... views);   constexpr/*iterator*/<false> begin() requires(!(/*simple-view*/<Views>&& ...));constexpr/*iterator*/<true> begin()const requires(range<const Views>&& ...)&&/*concatable*/<const Views...>;   constexprauto end() requires(!(/*simple-view*/<Views>&& ...));constexprauto end()const requires(range<const Views>&& ...)&&/*concatable*/<const Views...>;   constexprauto size() requires(sized_range<Views>&& ...);constexprauto size()const requires(sized_range<const Views>&& ...);};   template<class... R> concat_view(R&&...)-> concat_view<views::all_t<R>...>;}

      [edit]Class template std::ranges::concat::iterator

      namespace std::ranges{template<input_range... Views> requires(view<Views>&& ...)&&(sizeof...(Views)>0)&&/*concatable*/<Views...>template<bool Const>class concat_view<Views...>::/*iterator*/{   public:using iterator_category =/* see description */;// not always presentusing iterator_concept =/* see description */;using value_type =/*concat-value-t*/</*maybe-const*/<Const, Views>...>;using difference_type = common_type_t<range_difference_t</*maybe-const*/<Const, Views>>...>;   private:using/*base-iter*/=// exposition-only variant<iterator_t</*maybe-const*/<Const, Views>>...>;   /*maybe-const*/<Const, concat_view>*/*parent_*/= nullptr;// exposition-only/*base-iter*//*it_*/;// exposition-only   template<size_t N>constexprvoid/*satisfy*/();// exposition-onlytemplate<size_t N>constexprvoid/*prev*/();// exposition-only   template<size_t N>constexprvoid/*advance-fwd*/(difference_type offset, // exposition-only difference_type steps);template<size_t N>constexprvoid/*advance-bwd*/(difference_type offset, // exposition-only difference_type steps);   template<class... Args>constexprexplicit/*iterator*/(/*maybe-const*/<Const, concat_view>* parent, // exposition-only Args&&... args) requires constructible_from</*base-iter*/, Args&&...>;   public:/*iterator*/()=default;   constexpr/*iterator*/(/*iterator*/<!Const> i) requires Const &&(convertible_to<iterator_t<Views>, iterator_t<const Views>>&& ...);   constexpr decltype(auto) operator*()const;constexpr/*iterator*/& operator++();constexprvoid operator++(int);constexpr/*iterator*/ operator++(int) requires /*all-forward*/<Const, Views...>;constexpr/*iterator*/& operator--() requires /*concat-is-bidirectional*/<Const, Views...>;constexpr/*iterator*/ operator--(int) requires /*concat-is-bidirectional*/<Const, Views...>;constexpr/*iterator*/& operator+=(difference_type n) requires /*concat-is-random-access*/<Const, Views...>;constexpr/*iterator*/& operator-=(difference_type n) requires /*concat-is-random-access*/<Const, Views...>;constexpr decltype(auto) operator[](difference_type n)const requires /*concat-is-random-access*/<Const, Views...>;   friendconstexprbool operator==(const/*iterator*/& x, const/*iterator*/& y) requires(equality_comparable<iterator_t</*maybe-const*/<Const, Views>>>&& ...);friendconstexprbool operator==(const/*iterator*/& it, default_sentinel_t);friendconstexprbool operator<(const/*iterator*/& x, const/*iterator*/& y) requires /*all-random-access*/<Const, Views...>;friendconstexprbool operator>(const/*iterator*/& x, const/*iterator*/& y) requires /*all-random-access*/<Const, Views...>;friendconstexprbool operator<=(const/*iterator*/& x, const/*iterator*/& y) requires /*all-random-access*/<Const, Views...>;friendconstexprbool operator>=(const/*iterator*/& x, const/*iterator*/& y) requires /*all-random-access*/<Const, Views...>;friendconstexprauto operator<=>(const/*iterator*/& x, const/*iterator*/& y) requires(/*all-random-access*/<Const, Views...>&&(three_way_comparable<iterator_t</*maybe-const*/<Const, Views>>>&& ...));friendconstexpr/*iterator*/ operator+(const/*iterator*/& it, difference_type n) requires /*concat-is-random-access*/<Const, Views...>;friendconstexpr/*iterator*/ operator+(difference_type n, const/*iterator*/& it) requires /*concat-is-random-access*/<Const, Views...>;friendconstexpr/*iterator*/ operator-(const/*iterator*/& it, difference_type n) requires /*concat-is-random-access*/<Const, Views...>;friendconstexpr difference_type operator-(const/*iterator*/& x, const/*iterator*/& y) requires /*concat-is-random-access*/<Const, Views...>;friendconstexpr difference_type operator-(const/*iterator*/& x, default_sentinel_t) requires /* see description */;friendconstexpr difference_type operator-(default_sentinel_t, const/*iterator*/& x) requires /* see description */;friendconstexpr decltype(auto) iter_move(const/*iterator*/& it)noexcept(/* see description */);friendconstexprvoid iter_swap(const/*iterator*/& x, const/*iterator*/& y)noexcept(/* see description */) requires /* see description */;};}

      [edit]Class template std::ranges::common_view

      namespace std::ranges{template<view V> requires(!common_range<V>&& copyable<iterator_t<V>>)class common_view :public view_interface<common_view<V>>{private: V /*base_*/= V();// exposition-only   public: common_view() requires default_initializable<V>=default;   constexprexplicit common_view(V r);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexprauto begin() requires(!/*simple-view*/<V>){ifconstexpr(random_access_range<V>&& sized_range<V>)returnranges::begin(/*base_*/);elsereturn common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::begin(/*base_*/));}   constexprauto begin()const requires range<const V>{ifconstexpr(random_access_range<const V>&& sized_range<const V>)returnranges::begin(/*base_*/);elsereturn common_iterator<iterator_t<const V>, sentinel_t<const V>>(ranges::begin(/*base_*/));}   constexprauto end() requires(!/*simple-view*/<V>){ifconstexpr(random_access_range<V>&& sized_range<V>)returnranges::begin(/*base_*/)+ranges::distance(/*base_*/);elsereturn common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::end(/*base_*/));}   constexprauto end()const requires range<const V>{ifconstexpr(random_access_range<const V>&& sized_range<const V>)returnranges::begin(/*base_*/)+ranges::distance(/*base_*/);elsereturn common_iterator<iterator_t<const V>, sentinel_t<const V>>(ranges::end(/*base_*/));}   constexprauto size() requires sized_range<V>{returnranges::size(/*base_*/);}constexprauto size()const requires sized_range<const V>{returnranges::size(/*base_*/);}   constexprauto reserve_hint() requires approximately_sized_range<V>{return ranges::reserve_hint(/*base_*/);}constexprauto reserve_hint()const requires approximately_sized_range<const V>{return ranges::reserve_hint(/*base_*/);}};   template<class R> common_view(R&&)-> common_view<views::all_t<R>>;}

      [edit]Class template std::ranges::reverse_view

      namespace std::ranges{template<view V> requires bidirectional_range<V>class reverse_view :public view_interface<reverse_view<V>>{private: V /*base_*/= V();// exposition-only   public: reverse_view() requires default_initializable<V>=default;   constexprexplicit reverse_view(V r);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexpr reverse_iterator<iterator_t<V>> begin();constexpr reverse_iterator<iterator_t<V>> begin() requires common_range<V>;constexprauto begin()const requires common_range<const V>;   constexpr reverse_iterator<iterator_t<V>> end();constexprauto end()const requires common_range<const V>;   constexprauto size() requires sized_range<V>{returnranges::size(/*base_*/);}   constexprauto size()const requires sized_range<const V>{returnranges::size(/*base_*/);}   constexprauto reserve_hint() requires approximately_sized_range<V>{return ranges::reserve_hint(/*base_*/);}constexprauto reserve_hint()const requires approximately_sized_range<const V>{return ranges::reserve_hint(/*base_*/);}};   template<class R> reverse_view(R&&)-> reverse_view<views::all_t<R>>;}

      [edit]Class template std::ranges::as_const_view

      namespace std::ranges{template<view V> requires input_range<V>class as_const_view :public view_interface<as_const_view<V>>{ V /*base_*/= V();// exposition-only   public: as_const_view() requires default_initializable<V>=default;constexprexplicit as_const_view(V base);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexprauto begin() requires(!/*simple-view*/<V>){returnranges::cbegin(/*base_*/);}constexprauto begin()const requires range<const V>{returnranges::cbegin(/*base_*/);}   constexprauto end() requires(!/*simple-view*/<V>){returnranges::cend(/*base_*/);}constexprauto end()const requires range<const V>{returnranges::cend(/*base_*/);}   constexprauto size() requires sized_range<V>{returnranges::size(/*base_*/);}constexprauto size()const requires sized_range<const V>{returnranges::size(/*base_*/);}   constexprauto reserve_hint() requires approximately_sized_range<V>{return ranges::reserve_hint(/*base_*/);}constexprauto reserve_hint()const requires approximately_sized_range<const V>{return ranges::reserve_hint(/*base_*/);}};   template<class R> as_const_view(R&&)-> as_const_view<views::all_t<R>>;}

      [edit]Class template std::ranges::elements_view

      namespace std::ranges{template<class T, size_t N> concept /*has-tuple-element*/=// exposition-only/*tuple-like*/<T>&& N < tuple_size_v<T>;   template<class T, size_t N> concept /*returnable-element*/=// exposition-only is_reference_v<T>|| move_constructible<tuple_element_t<N, T>>;   template<input_range V, size_t N> requires view<V>&&/*has-tuple-element*/<range_value_t<V>, N>&&/*has-tuple-element*/<remove_reference_t<range_reference_t<V>>, N>&&/*returnable-element*/<range_reference_t<V>, N>class elements_view :public view_interface<elements_view<V, N>>{public: elements_view() requires default_initializable<V>=default;constexprexplicit elements_view(V base);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexprauto begin() requires(!/*simple-view*/<V>){return/*iterator*/<false>(ranges::begin(/*base_*/));}   constexprauto begin()const requires range<const V>{return/*iterator*/<true>(ranges::begin(/*base_*/));}   constexprauto end() requires(!/*simple-view*/<V>&&!common_range<V>){return/*sentinel*/<false>{ranges::end(/*base_*/)};}   constexprauto end() requires(!/*simple-view*/<V>&& common_range<V>){return/*iterator*/<false>{ranges::end(/*base_*/)};}   constexprauto end()const requires range<const V>{return/*sentinel*/<true>{ranges::end(/*base_*/)};}   constexprauto end()const requires common_range<const V>{return/*iterator*/<true>{ranges::end(/*base_*/)};}   constexprauto size() requires sized_range<V>{returnranges::size(/*base_*/);}   constexprauto size()const requires sized_range<const V>{returnranges::size(/*base_*/);}   constexprauto reserve_hint() requires approximately_sized_range<V>{return ranges::reserve_hint(/*base_*/);}   constexprauto reserve_hint()const requires approximately_sized_range<const V>{return ranges::reserve_hint(/*base_*/);}   private:// class template elements_view::iteratortemplate<bool>class/*iterator*/;// exposition-only   // class template elements_view::sentineltemplate<bool>class/*sentinel*/;// exposition-only   V /*base_*/= V();// exposition-only};}

      [edit]Class template std::ranges::elements_view::iterator

      namespace std::ranges{template<input_range V, size_t N> requires view<V>&&/*has-tuple-element*/<range_value_t<V>, N>&&/*has-tuple-element*/<remove_reference_t<range_reference_t<V>>, N>&&/*returnable-element*/<range_reference_t<V>, N>template<bool Const>class elements_view<V, N>::/*iterator*/{using/*Base*/=/*maybe-const*/<Const, V>;// exposition-only   iterator_t</*Base*/>/*current_*/= iterator_t</*Base*/>();// exposition-only   staticconstexpr decltype(auto)/*get-element*/(const iterator_t</*Base*/>& i);// exposition-only   public:using iterator_concept =/* see description */;using iterator_category =/* see description */;// not always presentusing value_type = remove_cvref_t<tuple_element_t<N, range_value_t</*Base*/>>>;using difference_type = range_difference_t</*Base*/>;   /*iterator*/() requires default_initializable<iterator_t</*Base*/>>=default;constexprexplicit/*iterator*/(iterator_t</*Base*/> current);constexpr/*iterator*/(/*iterator*/<!Const> i) requires Const && convertible_to<iterator_t<V>, iterator_t</*Base*/>>;   constexprconst iterator_t</*Base*/>& base()const&noexcept;constexpr iterator_t</*Base*/> base()&&;   constexpr decltype(auto) operator*()const{return/*get-element*/(/*current_*/);}   constexpr/*iterator*/& operator++();constexprvoid operator++(int);constexpr/*iterator*/ operator++(int) requires forward_range</*Base*/>;   constexpr/*iterator*/& operator--() requires bidirectional_range</*Base*/>;constexpr/*iterator*/ operator--(int) requires bidirectional_range</*Base*/>;   constexpr/*iterator*/& operator+=(difference_type x) requires random_access_range</*Base*/>;constexpr/*iterator*/& operator-=(difference_type x) requires random_access_range</*Base*/>;   constexpr decltype(auto) operator[](difference_type n)const requires random_access_range</*Base*/>{return/*get-element*/(/*current_*/+ n);}   friendconstexprbool operator==(const/*iterator*/& x, const/*iterator*/& y) requires equality_comparable<iterator_t</*Base*/>>;   friendconstexprbool operator<(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprbool operator>(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprbool operator<=(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprbool operator>=(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprauto operator<=>(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>&& three_way_comparable<iterator_t</*Base*/>>;   friendconstexpr/*iterator*/ operator+(const/*iterator*/& x, difference_type y) requires random_access_range</*Base*/>;friendconstexpr/*iterator*/ operator+(difference_type x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexpr/*iterator*/ operator-(const/*iterator*/& x, difference_type y) requires random_access_range</*Base*/>;friendconstexpr difference_type operator-(const/*iterator*/& x, const/*iterator*/& y) requires sized_sentinel_for<iterator_t</*Base*/>, iterator_t</*Base*/>>;};}

      [edit]Class template std::ranges::elements_view::sentinel

      namespace std::ranges{template<input_range V, size_t N> requires view<V>&&/*has-tuple-element*/<range_value_t<V>, N>&&/*has-tuple-element*/<remove_reference_t<range_reference_t<V>>, N>&&/*returnable-element*/<range_reference_t<V>, N>template<bool Const>class elements_view<V, N>::/*sentinel*/{private:using/*Base*/=/*maybe-const*/<Const, V>;// exposition-only sentinel_t</*Base*/>/*end_*/= sentinel_t</*Base*/>();// exposition-only   public:/*sentinel*/()=default;constexprexplicit/*sentinel*/(sentinel_t</*Base*/> end);constexpr/*sentinel*/(/*sentinel*/<!Const> other) requires Const && convertible_to<sentinel_t<V>, sentinel_t</*Base*/>>;   constexpr sentinel_t</*Base*/> base()const;   template<bool OtherConst> requires sentinel_for<sentinel_t</*Base*/>, iterator_t</*maybe-const*/<OtherConst, V>>>friendconstexprbool operator==(const/*iterator*/<OtherConst>& x, const/*sentinel*/& y);   template<bool OtherConst> requires sized_sentinel_for<sentinel_t</*Base*/>, iterator_t</*maybe-const*/<OtherConst, V>>>friendconstexpr range_difference_t</*maybe-const*/<OtherConst, V>> operator-(const/*iterator*/<OtherConst>& x, const/*sentinel*/& y);   template<bool OtherConst> requires sized_sentinel_for<sentinel_t</*Base*/>, iterator_t</*maybe-const*/<OtherConst, V>>>friendconstexpr range_difference_t</*maybe-const*/<OtherConst, V>> operator-(const/*sentinel*/& x, const/*iterator*/<OtherConst>& y);};}

      [edit]Class template std::ranges::enumerate_view

      namespace std::ranges{template<view V> requires /*range-with-movable-references*/<V>class enumerate_view :public view_interface<enumerate_view<V>>{ V /*base_*/= V();// exposition-only   // class template enumerate_view::iteratortemplate<bool Const>class/*iterator*/;// exposition-only   // class template enumerate_view::sentineltemplate<bool Const>class/*sentinel*/;// exposition-only   public:constexpr enumerate_view() requires default_initializable<V>=default;constexprexplicit enumerate_view(V base);   constexprauto begin() requires(!/*simple-view*/<V>){return/*iterator*/<false>(ranges::begin(/*base_*/), 0);}constexprauto begin()const requires /*range-with-movable-references*/<const V>{return/*iterator*/<true>(ranges::begin(/*base_*/), 0);}   constexprauto end() requires(!/*simple-view*/<V>){ifconstexpr(forward_range<V>&& common_range<V>&& sized_range<V>)return/*iterator*/<false>(ranges::end(/*base_*/), ranges::distance(/*base_*/));elsereturn/*sentinel*/<false>(ranges::end(/*base_*/));}constexprauto end()const requires /*range-with-movable-references*/<const V>{ifconstexpr(forward_range<const V>&& common_range<const V>&& sized_range<const V>)return/*iterator*/<true>(ranges::end(/*base_*/), ranges::distance(/*base_*/));elsereturn/*sentinel*/<true>(ranges::end(/*base_*/));}   constexprauto size() requires sized_range<V>{returnranges::size(/*base_*/);}constexprauto size()const requires sized_range<const V>{returnranges::size(/*base_*/);}   constexprauto reserve_hint() requires approximately_sized_range<V>{return ranges::reserve_hint(/*base_*/);}constexprauto reserve_hint()const requires approximately_sized_range<const V>{return ranges::reserve_hint(/*base_*/);}   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}};   template<class R> enumerate_view(R&&)-> enumerate_view<views::all_t<R>>;}

      [edit]Class template std::ranges::enumerate_view::iterator

      namespace std::ranges{template<view V> requires /*range-with-movable-references*/<V>template<bool Const>class enumerate_view<V>::/*iterator*/{using/*Base*/=/*maybe-const*/<Const, V>;// exposition-only   public:using iterator_category = input_iterator_tag;using iterator_concept =/* see description */;using difference_type = range_difference_t</*Base*/>;using value_type = tuple<difference_type, range_value_t</*Base*/>>;   private:using/*reference-type*/=// exposition-only tuple<difference_type, range_reference_t</*Base*/>>; iterator_t</*Base*/>/*current_*/= iterator_t</*Base*/>();// exposition-only difference_type /*pos_*/=0;// exposition-only   constexprexplicit/*iterator*/(iterator_t</*Base*/> current, difference_type pos);// exposition-only   public:/*iterator*/() requires default_initializable<iterator_t</*Base*/>>=default;constexpr/*iterator*/(/*iterator*/<!Const> i) requires Const && convertible_to<iterator_t<V>, iterator_t</*Base*/>>;   constexprconst iterator_t</*Base*/>& base()const&noexcept;constexpr iterator_t</*Base*/> base()&&;   constexpr difference_type index()constnoexcept;   constexprauto operator*()const{return/*reference-type*/(/*pos_*/, */*current_*/);}   constexpr/*iterator*/& operator++();constexprvoid operator++(int);constexpr/*iterator*/ operator++(int) requires forward_range</*Base*/>;   constexpr/*iterator*/& operator--() requires bidirectional_range</*Base*/>;constexpr/*iterator*/ operator--(int) requires bidirectional_range</*Base*/>;   constexpr/*iterator*/& operator+=(difference_type x) requires random_access_range</*Base*/>;constexpr/*iterator*/& operator-=(difference_type x) requires random_access_range</*Base*/>;   constexprauto operator[](difference_type n)const requires random_access_range</*Base*/>{return/*reference-type*/(/*pos_*/+ n, /*current_*/[n]);}   friendconstexprbool operator==(const/*iterator*/& x, const/*iterator*/& y)noexcept;friendconstexpr strong_ordering operator<=>(const/*iterator*/& x, const/*iterator*/& y)noexcept;   friendconstexpr/*iterator*/ operator+(const/*iterator*/& x, difference_type y) requires random_access_range</*Base*/>;friendconstexpr/*iterator*/ operator+(difference_type x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexpr/*iterator*/ operator-(const/*iterator*/& x, difference_type y) requires random_access_range</*Base*/>;friendconstexpr difference_type operator-(const/*iterator*/& x, const/*iterator*/& y)noexcept;   friendconstexprauto iter_move(const/*iterator*/& i)noexcept(noexcept(ranges::iter_move(i./*current_*/))&& is_nothrow_move_constructible_v<range_rvalue_reference_t</*Base*/>>){return tuple<difference_type, range_rvalue_reference_t</*Base*/>>( i./*pos_*/, ranges::iter_move(i./*current_*/));}};}

      [edit]Class template std::ranges::enumerate_view::sentinel

      namespace std::ranges{template<view V> requires /*range-with-movable-references*/<V>template<bool Const>class enumerate_view<V>::/*sentinel*/{using/*Base*/=/*maybe-const*/<Const, V>;// exposition-only sentinel_t</*Base*/>/*end_*/= sentinel_t</*Base*/>();// exposition-onlyconstexprexplicit/*sentinel*/(sentinel_t</*Base*/> end);// exposition-only   public:/*sentinel*/()=default;constexpr/*sentinel*/(/*sentinel*/<!Const> other) requires Const && convertible_to<sentinel_t<V>, sentinel_t</*Base*/>>;   constexpr sentinel_t</*Base*/> base()const;   template<bool OtherConst> requires sentinel_for<sentinel_t</*Base*/>, iterator_t</*maybe-const*/<OtherConst, V>>>friendconstexprbool operator==(const/*iterator*/<OtherConst>& x, const/*sentinel*/& y);   template<bool OtherConst> requires sized_sentinel_for<sentinel_t</*Base*/>, iterator_t</*maybe-const*/<OtherConst, V>>>friendconstexpr range_difference_t</*maybe-const*/<OtherConst, V>> operator-(const/*iterator*/<OtherConst>& x, const/*sentinel*/& y);   template<bool OtherConst> requires sized_sentinel_for<sentinel_t</*Base*/>, iterator_t</*maybe-const*/<OtherConst, V>>>friendconstexpr range_difference_t</*maybe-const*/<OtherConst, V>> operator-(const/*sentinel*/& x, const/*iterator*/<OtherConst>& y);};}

      [edit]Class template std::ranges::zip_view

      namespace std::ranges{template<class... Rs> concept /*zip-is-common*/=// exposition-only(sizeof...(Rs)==1&&(common_range<Rs>&& ...))||(!(bidirectional_range<Rs>&& ...)&&(common_range<Rs>&& ...))||((random_access_range<Rs>&& ...)&&(sized_range<Rs>&& ...));   template<input_range... Views> requires(view<Views>&& ...)&&(sizeof...(Views)>0)class zip_view :public view_interface<zip_view<Views...>>{ tuple<Views...>/*views_*/;// exposition-only   // class template zip_view::iteratortemplate<bool>class/*iterator*/;// exposition-only   // class template zip_view::sentineltemplate<bool>class/*sentinel*/;// exposition-only   public: zip_view()=default;constexprexplicit zip_view(Views... views);   constexprauto begin() requires(!(/*simple-view*/<Views>&& ...)){return/*iterator*/<false>(/*tuple-transform*/(ranges::begin, /*views_*/));}constexprauto begin()const requires(range<const Views>&& ...){return/*iterator*/<true>(/*tuple-transform*/(ranges::begin, /*views_*/));}   constexprauto end() requires(!(/*simple-view*/<Views>&& ...)){ifconstexpr(!/*zip-is-common*/<Views...>){return/*sentinel*/<false>(/*tuple-transform*/(ranges::end, /*views_*/));}elseifconstexpr((random_access_range<Views>&& ...)){return begin()+ iter_difference_t</*iterator*/<false>>(size());}else{return/*iterator*/<false>(/*tuple-transform*/(ranges::end, /*views_*/));}}   constexprauto end()const requires(range<const Views>&& ...){ifconstexpr(!/*zip-is-common*/<const Views...>){return/*sentinel*/<true>(/*tuple-transform*/(ranges::end, /*views_*/));}elseifconstexpr((random_access_range<const Views>&& ...)){return begin()+ iter_difference_t</*iterator*/<true>>(size());}else{return/*iterator*/<true>(/*tuple-transform*/(ranges::end, /*views_*/));}}   constexprauto size() requires(sized_range<Views>&& ...);constexprauto size()const requires(sized_range<const Views>&& ...);};   template<class... Rs> zip_view(Rs&&...)-> zip_view<views::all_t<Rs>...>;}

      [edit]Class template std::ranges::zip_view::iterator

      namespace std::ranges{template<input_range... Views> requires(view<Views>&& ...)&&(sizeof...(Views)>0)template<bool Const>class zip_view<Views...>::/*iterator*/{ tuple<iterator_t</*maybe-const*/<Const, Views>>...>/*current_*/;// exposition-onlyconstexprexplicit/*iterator*/(tuple<iterator_t</*maybe-const*/<Const, Views>>...>);// exposition-onlypublic:using iterator_category = input_iterator_tag;// not always presentusing iterator_concept =/* see description */;using value_type = tuple<range_value_t</*maybe-const*/<Const, Views>>...>;using difference_type = common_type_t<range_difference_t</*maybe-const*/<Const, Views>>...>;   /*iterator*/()=default;constexpr/*iterator*/(/*iterator*/<!Const> i) requires Const &&(convertible_to<iterator_t<Views>, iterator_t<const Views>>&& ...);   constexprauto operator*()const;constexpr/*iterator*/& operator++();constexprvoid operator++(int);constexpr/*iterator*/ operator++(int) requires /*all-forward*/<Const, Views...>;   constexpr/*iterator*/& operator--() requires /*all-bidirectional*/<Const, Views...>;constexpr/*iterator*/ operator--(int) requires /*all-bidirectional*/<Const, Views...>;   constexpr/*iterator*/& operator+=(difference_type x) requires /*all-random-access*/<Const, Views...>;constexpr/*iterator*/& operator-=(difference_type x) requires /*all-random-access*/<Const, Views...>;   constexprauto operator[](difference_type n)const requires /*all-random-access*/<Const, Views...>;   friendconstexprbool operator==(const/*iterator*/& x, const/*iterator*/& y) requires(equality_comparable<iterator_t</*maybe-const*/<Const, Views>>>&& ...);   friendconstexprauto operator<=>(const/*iterator*/& x, const/*iterator*/& y) requires /*all-random-access*/<Const, Views...>;   friendconstexpr/*iterator*/ operator+(const/*iterator*/& i, difference_type n) requires /*all-random-access*/<Const, Views...>;friendconstexpr/*iterator*/ operator+(difference_type n, const/*iterator*/& i) requires /*all-random-access*/<Const, Views...>;friendconstexpr/*iterator*/ operator-(const/*iterator*/& i, difference_type n) requires /*all-random-access*/<Const, Views...>;friendconstexpr difference_type operator-(const/*iterator*/& x, const/*iterator*/& y) requires(sized_sentinel_for<iterator_t</*maybe-const*/<Const, Views>>, iterator_t</*maybe-const*/<Const, Views>>>&& ...);   friendconstexprauto iter_move(const/*iterator*/& i)noexcept(/* see description */);   friendconstexprvoid iter_swap(const/*iterator*/& l, const/*iterator*/& r)noexcept(/* see description */) requires(indirectly_swappable<iterator_t</*maybe-const*/<Const, Views>>>&& ...);};}

      [edit]Class template std::ranges::zip_view::sentinel

      namespace std::ranges{template<input_range... Views> requires(view<Views>&& ...)&&(sizeof...(Views)>0)template<bool Const>class zip_view<Views...>::/*sentinel*/{ tuple<sentinel_t</*maybe-const*/<Const, Views>>...>/*end_*/;// exposition-onlyconstexprexplicit/*sentinel*/( tuple<sentinel_t</*maybe-const*/<Const, Views>>...> end);// exposition-onlypublic:/*sentinel*/()=default;constexpr/*sentinel*/(/*sentinel*/<!Const> i) requires Const &&(convertible_to<sentinel_t<Views>, sentinel_t<const Views>>&& ...);   template<bool OtherConst> requires(sentinel_for<sentinel_t</*maybe-const*/<Const, Views>>, iterator_t</*maybe-const*/<OtherConst, Views>>>&& ...)friendconstexprbool operator==(const/*iterator*/<OtherConst>& x, const/*sentinel*/& y);   template<bool OtherConst> requires(sized_sentinel_for<sentinel_t</*maybe-const*/<Const, Views>>, iterator_t</*maybe-const*/<OtherConst, Views>>>&& ...)friendconstexpr common_type_t< range_difference_t</*maybe-const*/<OtherConst, Views>>...> operator-(const/*iterator*/<OtherConst>& x, const/*sentinel*/& y);   template<bool OtherConst> requires(sized_sentinel_for<sentinel_t</*maybe-const*/<Const, Views>>, iterator_t</*maybe-const*/<OtherConst, Views>>>&& ...)friendconstexpr common_type_t< range_difference_t</*maybe-const*/<OtherConst, Views>>...> operator-(const/*sentinel*/& y, const/*iterator*/<OtherConst>& x);};}

      [edit]Class template std::ranges::zip_transform_view

      namespace std::ranges{template<move_constructible F, input_range... Views> requires(view<Views>&& ...)&&(sizeof...(Views)>0)&& is_object_v<F>&& regular_invocable<F&, range_reference_t<Views>...>&&/*can-reference*/<invoke_result_t<F&, range_reference_t<Views>...>>class zip_transform_view :public view_interface<zip_transform_view<F, Views...>>{/*movable-box*/<F>/*fun_*/;// exposition-only zip_view<Views...>/*zip_*/;// exposition-only   using/*InnerView*/= zip_view<Views...>;// exposition-onlytemplate<bool Const>using/*ziperator*/= iterator_t</*maybe-const*/<Const, /*InnerView*/>>;// exposition-onlytemplate<bool Const>using/*zentinel*/= sentinel_t</*maybe-const*/<Const, /*InnerView*/>>;// exposition-only   // class template zip_transform_view::iteratortemplate<bool>class/*iterator*/;// exposition-only   // class template zip_transform_view::sentineltemplate<bool>class/*sentinel*/;// exposition-only   public: zip_transform_view()=default;   constexprexplicit zip_transform_view(F fun, Views... views);   constexprauto begin(){return/*iterator*/<false>(*this, /*zip_*/.begin());}   constexprauto begin()const requires range<const/*InnerView*/>&& regular_invocable<const F&, range_reference_t<const Views>...>{return/*iterator*/<true>(*this, /*zip_*/.begin());}   constexprauto end(){ifconstexpr(common_range</*InnerView*/>){return/*iterator*/<false>(*this, /*zip_*/.end());}else{return/*sentinel*/<false>(/*zip_*/.end());}}   constexprauto end()const requires range<const/*InnerView*/>&& regular_invocable<const F&, range_reference_t<const Views>...>{ifconstexpr(common_range<const/*InnerView*/>){return/*iterator*/<true>(*this, /*zip_*/.end());}else{return/*sentinel*/<true>(/*zip_*/.end());}}   constexprauto size() requires sized_range</*InnerView*/>{return/*zip_*/.size();}   constexprauto size()const requires sized_range<const/*InnerView*/>{return/*zip_*/.size();}};   template<class F, class... Rs> zip_transform_view(F, Rs&&...)-> zip_transform_view<F, views::all_t<Rs>...>;}

      [edit]Class template std::ranges::zip_transform_view::iterator

      namespace std::ranges{template<move_constructible F, input_range... Views> requires(view<Views>&& ...)&&(sizeof...(Views)>0)&& is_object_v<F>&& regular_invocable<F&, range_reference_t<Views>...>&&/*can-reference*/<invoke_result_t<F&, range_reference_t<Views>...>>template<bool Const>class zip_transform_view<F, Views...>::/*iterator*/{using/*Parent*/=/*maybe-const*/<Const, zip_transform_view>;// exposition-onlyusing/*Base*/=/*maybe-const*/<Const, /*InnerView*/>;// exposition-only/*Parent*/*/*parent_*/= nullptr;// exposition-only/*ziperator*/<Const>/*inner_*/;// exposition-only   constexpr/*iterator*/(/*Parent*/& parent, /*ziperator*/<Const> inner);// exposition-only   public:using iterator_category =/* see description */;// not always presentusing iterator_concept =typename/*ziperator*/<Const>::iterator_concept;using value_type = remove_cvref_t< invoke_result_t</*maybe-const*/<Const, F>&, range_reference_t</*maybe-const*/<Const, Views>>...>>;using difference_type = range_difference_t</*Base*/>;   /*iterator*/()=default;constexpr/*iterator*/(/*iterator*/<!Const> i) requires Const && convertible_to</*ziperator*/<false>, /*ziperator*/<Const>>;   constexpr decltype(auto) operator*()constnoexcept(/* see description */);constexpr/*iterator*/& operator++();constexprvoid operator++(int);constexpr/*iterator*/ operator++(int) requires forward_range</*Base*/>;   constexpr/*iterator*/& operator--() requires bidirectional_range</*Base*/>;constexpr/*iterator*/ operator--(int) requires bidirectional_range</*Base*/>;   constexpr/*iterator*/& operator+=(difference_type x) requires random_access_range</*Base*/>;constexpr/*iterator*/& operator-=(difference_type x) requires random_access_range</*Base*/>;   constexpr decltype(auto) operator[](difference_type n)const requires random_access_range</*Base*/>;   friendconstexprbool operator==(const/*iterator*/& x, const/*iterator*/& y) requires equality_comparable</*ziperator*/<Const>>;   friendconstexprauto operator<=>(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;   friendconstexpr/*iterator*/ operator+(const/*iterator*/& i, difference_type n) requires random_access_range</*Base*/>;friendconstexpr/*iterator*/ operator+(difference_type n, const/*iterator*/& i) requires random_access_range</*Base*/>;friendconstexpr/*iterator*/ operator-(const/*iterator*/& i, difference_type n) requires random_access_range</*Base*/>;friendconstexpr difference_type operator-(const/*iterator*/& x, const/*iterator*/& y) requires sized_sentinel_for</*ziperator*/<Const>, /*ziperator*/<Const>>;};}

      [edit]Class template std::ranges::zip_transform_view::sentinel

      namespace std::ranges{template<move_constructible F, input_range... Views> requires(view<Views>&& ...)&&(sizeof...(Views)>0)&& is_object_v<F>&& regular_invocable<F&, range_reference_t<Views>...>&&/*can-reference*/<invoke_result_t<F&, range_reference_t<Views>...>>template<bool Const>class zip_transform_view<F, Views...>::/*sentinel*/{/*zentinel*/<Const>/*inner_*/;// exposition-onlyconstexprexplicit/*sentinel*/(/*zentinel*/<Const> inner);// exposition-only   public:/*sentinel*/()=default;constexpr/*sentinel*/(/*sentinel*/<!Const> i) requires Const && convertible_to</*zentinel*/<false>, /*zentinel*/<Const>>;   template<bool OtherConst> requires sentinel_for</*zentinel*/<Const>, /*ziperator*/<OtherConst>>friendconstexprbool operator==(const/*iterator*/<OtherConst>& x, const/*sentinel*/& y);   template<bool OtherConst> requires sized_sentinel_for</*zentinel*/<Const>, /*ziperator*/<OtherConst>>friendconstexpr range_difference_t</*maybe-const*/<OtherConst, /*InnerView*/>> operator-(const/*iterator*/<OtherConst>& x, const/*sentinel*/& y);   template<bool OtherConst> requires sized_sentinel_for</*zentinel*/<Const>, /*ziperator*/<OtherConst>>friendconstexpr range_difference_t</*maybe-const*/<OtherConst, /*InnerView*/>> operator-(const/*sentinel*/& x, const/*iterator*/<OtherConst>& y);};}

      [edit]Class template std::ranges::adjacent_view

      namespace std::ranges{template<forward_range V, size_t N> requires view<V>&&(N >0)class adjacent_view :public view_interface<adjacent_view<V, N>>{ V /*base_*/= V();// exposition-only   // class template adjacent_view::iteratortemplate<bool>class/*iterator*/;// exposition-only   // class template adjacent_view::sentineltemplate<bool>class/*sentinel*/;// exposition-only   struct/*as-sentinel*/{};// exposition-only   public: adjacent_view() requires default_initializable<V>=default;constexprexplicit adjacent_view(V base);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexprauto begin() requires(!/*simple-view*/<V>){return/*iterator*/<false>(ranges::begin(/*base_*/), ranges::end(/*base_*/));}   constexprauto begin()const requires range<const V>{return/*iterator*/<true>(ranges::begin(/*base_*/), ranges::end(/*base_*/));}   constexprauto end() requires(!/*simple-view*/<V>){ifconstexpr(common_range<V>){return/*iterator*/<false>(/*as-sentinel*/{}, ranges::begin(/*base_*/), ranges::end(/*base_*/));}else{return/*sentinel*/<false>(ranges::end(/*base_*/));}}   constexprauto end()const requires range<const V>{ifconstexpr(common_range<const V>){return/*iterator*/<true>(/*as-sentinel*/{}, ranges::begin(/*base_*/), ranges::end(/*base_*/));}else{return/*sentinel*/<true>(ranges::end(/*base_*/));}}   constexprauto size() requires sized_range<V>;constexprauto size()const requires sized_range<const V>;   constexprauto reserve_hint() requires approximately_sized_range<V>;constexprauto reserve_hint()const requires approximately_sized_range<const V>;};}

      [edit]Class template std::ranges::adjacent_view::iterator

      namespace std::ranges{template<forward_range V, size_t N> requires view<V>&&(N >0)template<bool Const>class adjacent_view<V, N>::/*iterator*/{using/*Base*/=/*maybe-const*/<Const, V>;// exposition-only array<iterator_t</*Base*/>, N>/*current_*/= array<iterator_t</*Base*/>, N>();// exposition-onlyconstexpr/*iterator*/(iterator_t</*Base*/> first, sentinel_t</*Base*/> last);// exposition-onlyconstexpr/*iterator*/(/*as-sentinel*/, iterator_t</*Base*/> first, iterator_t</*Base*/> last);// exposition-onlypublic:using iterator_category = input_iterator_tag;using iterator_concept =/* see description */;using value_type = tuple</*REPEAT*/(range_value_t</*Base*/>, N)...>;using difference_type = range_difference_t</*Base*/>;   /*iterator*/()=default;constexpr/*iterator*/(/*iterator*/<!Const> i) requires Const && convertible_to<iterator_t<V>, iterator_t</*Base*/>>;   constexprauto operator*()const;constexpr/*iterator*/& operator++();constexpr/*iterator*/ operator++(int);   constexpr/*iterator*/& operator--() requires bidirectional_range</*Base*/>;constexpr/*iterator*/ operator--(int) requires bidirectional_range</*Base*/>;   constexpr/*iterator*/& operator+=(difference_type x) requires random_access_range</*Base*/>;constexpr/*iterator*/& operator-=(difference_type x) requires random_access_range</*Base*/>;   constexprauto operator[](difference_type n)const requires random_access_range</*Base*/>;   friendconstexprbool operator==(const/*iterator*/& x, const/*iterator*/& y);friendconstexprbool operator<(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprbool operator>(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprbool operator<=(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprbool operator>=(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprauto operator<=>(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>&& three_way_comparable<iterator_t</*Base*/>>;   friendconstexpr/*iterator*/ operator+(const/*iterator*/& i, difference_type n) requires random_access_range</*Base*/>;friendconstexpr/*iterator*/ operator+(difference_type n, const/*iterator*/& i) requires random_access_range</*Base*/>;friendconstexpr/*iterator*/ operator-(const/*iterator*/& i, difference_type n) requires random_access_range</*Base*/>;friendconstexpr difference_type operator-(const/*iterator*/& x, const/*iterator*/& y) requires sized_sentinel_for<iterator_t</*Base*/>, iterator_t</*Base*/>>;   friendconstexprauto iter_move(const/*iterator*/& i)noexcept(/* see description */);friendconstexprvoid iter_swap(const/*iterator*/& l, const/*iterator*/& r)noexcept(/* see description */) requires indirectly_swappable<iterator_t</*Base*/>>;};}

      [edit]Class template std::ranges::adjacent_view::sentinel

      namespace std::ranges{template<forward_range V, size_t N> requires view<V>&&(N >0)template<bool Const>class adjacent_view<V, N>::/*sentinel*/{using/*Base*/=/*maybe-const*/<Const, V>;// exposition-only sentinel_t</*Base*/>/*end_*/= sentinel_t</*Base*/>();// exposition-onlyconstexprexplicit/*sentinel*/(sentinel_t</*Base*/> end);// exposition-only   public:/*sentinel*/()=default;constexpr/*sentinel*/(/*sentinel*/<!Const> i) requires Const && convertible_to<sentinel_t<V>, sentinel_t</*Base*/>>;   template<bool OtherConst> requires sentinel_for<sentinel_t</*Base*/>, iterator_t</*maybe-const*/<OtherConst, V>>>friendconstexprbool operator==(const/*iterator*/<OtherConst>& x, const/*sentinel*/& y);   template<bool OtherConst> requires sized_sentinel_for<sentinel_t</*Base*/>, iterator_t</*maybe-const*/<OtherConst, V>>>friendconstexpr range_difference_t</*maybe-const*/<OtherConst, V>> operator-(const/*iterator*/<OtherConst>& x, const/*sentinel*/& y);   template<bool OtherConst> requires sized_sentinel_for<sentinel_t</*Base*/>, iterator_t</*maybe-const*/<OtherConst, V>>>friendconstexpr range_difference_t</*maybe-const*/<OtherConst, V>> operator-(const/*sentinel*/& y, const/*iterator*/<OtherConst>& x);};}

      [edit]Class template std::ranges::adjacent_transform_view

      namespace std::ranges{template<forward_range V, move_constructible F, size_t N> requires view<V>&&(N >0)&& is_object_v<F>&& regular_invocable<F&, /*REPEAT*/(range_reference_t<V>, N)...>&&/*can-reference*/< invoke_result_t<F&, /*REPEAT*/(range_reference_t<V>, N)...>>class adjacent_transform_view :public view_interface<adjacent_transform_view<V, F, N>>{/*movable-box*/<F>/*fun_*/;// exposition-only adjacent_view<V, N>/*inner_*/;// exposition-only   using/*InnerView*/= adjacent_view<V, N>;// exposition-onlytemplate<bool Const>using/*inner-iterator*/= iterator_t</*maybe-const*/<Const, /*InnerView*/>>;// exposition-onlytemplate<bool Const>using/*inner-sentinel*/= sentinel_t</*maybe-const*/<Const, /*InnerView*/>>;// exposition-only   // class template adjacent_transform_view::iteratortemplate<bool>class/*iterator*/;// exposition-only   // class template adjacent_transform_view::sentineltemplate<bool>class/*sentinel*/;// exposition-only   public: adjacent_transform_view()=default;constexprexplicit adjacent_transform_view(V base, F fun);   constexpr V base()const& requires copy_constructible<V>{return/*inner_*/.base();}constexpr V base()&&{return std::move(/*inner_*/).base();}   constexprauto begin(){return/*iterator*/<false>(*this, /*inner_*/.begin());}   constexprauto begin()const requires range<const/*InnerView*/>&& regular_invocable<const F&, /*REPEAT*/(range_reference_t<const V>, N)...>{return/*iterator*/<true>(*this, /*inner_*/.begin());}   constexprauto end(){ifconstexpr(common_range</*InnerView*/>){return/*iterator*/<false>(*this, /*inner_*/.end());}else{return/*sentinel*/<false>(/*inner_*/.end());}}   constexprauto end()const requires range<const/*InnerView*/>&& regular_invocable<const F&, /*REPEAT*/(range_reference_t<const V>, N)...>{ifconstexpr(common_range<const/*InnerView*/>){return/*iterator*/<true>(*this, /*inner_*/.end());}else{return/*sentinel*/<true>(/*inner_*/.end());}}   constexprauto size() requires sized_range</*InnerView*/>{return/*inner_*/.size();}   constexprauto size()const requires sized_range<const/*InnerView*/>{return/*inner_*/.size();}   constexprauto reserve_hint() requires approximately_sized_range</*InnerView*/>{return/*inner_*/.reserve_hint();}   constexprauto reserve_hint()const requires approximately_sized_range<const/*InnerView*/>{return/*inner_*/.reserve_hint();}};}

      [edit]Class template std::ranges::adjacent_transform_view::iterator

      namespace std::ranges{template<forward_range V, move_constructible F, size_t N> requires view<V>&&(N >0)&& is_object_v<F>&& regular_invocable<F&, /*REPEAT*/(range_reference_t<V>, N)...>&&/*can-reference*/< invoke_result_t<F&, /*REPEAT*/(range_reference_t<V>, N)...>>template<bool Const>class adjacent_transform_view<V, F, N>::/*iterator*/{using/*Parent*/=/*maybe-const*/<Const, adjacent_transform_view>;// exposition-onlyusing/*Base*/=/*maybe-const*/<Const, V>;// exposition-only/*Parent*/*/*parent_*/= nullptr;// exposition-only/*inner-iterator*/<Const>/*inner_*/;// exposition-only   constexpr/*iterator*/(/*Parent*/& parent, /*inner-iterator*/<Const> inner);// exposition-only   public:using iterator_category =/* see description */;using iterator_concept =typename/*inner-iterator*/<Const>::iterator_concept;using value_type = remove_cvref_t<invoke_result_t</*maybe-const*/<Const, F>&, /*REPEAT*/(range_reference_t</*Base*/>, N)...>>;using difference_type = range_difference_t</*Base*/>;   /*iterator*/()=default;constexpr/*iterator*/(/*iterator*/<!Const> i) requires Const && convertible_to</*inner-iterator*/<false>, /*inner-iterator*/<Const>>;   constexpr decltype(auto) operator*()constnoexcept(/* see description */);constexpr/*iterator*/& operator++();constexpr/*iterator*/ operator++(int);constexpr/*iterator*/& operator--() requires bidirectional_range</*Base*/>;constexpr/*iterator*/ operator--(int) requires bidirectional_range</*Base*/>;constexpr/*iterator*/& operator+=(difference_type x) requires random_access_range</*Base*/>;constexpr/*iterator*/& operator-=(difference_type x) requires random_access_range</*Base*/>;   constexpr decltype(auto) operator[](difference_type n)const requires random_access_range</*Base*/>;   friendconstexprbool operator==(const/*iterator*/& x, const/*iterator*/& y);friendconstexprbool operator<(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprbool operator>(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprbool operator<=(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprbool operator>=(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprauto operator<=>(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>&& three_way_comparable</*inner-iterator*/<Const>>;   friendconstexpr/*iterator*/ operator+(const/*iterator*/& i, difference_type n) requires random_access_range</*Base*/>;friendconstexpr/*iterator*/ operator+(difference_type n, const/*iterator*/& i) requires random_access_range</*Base*/>;friendconstexpr/*iterator*/ operator-(const/*iterator*/& i, difference_type n) requires random_access_range</*Base*/>;friendconstexpr difference_type operator-(const/*iterator*/& x, const/*iterator*/& y) requires sized_sentinel_for</*inner-iterator*/<Const>, /*inner-iterator*/<Const>>;};}

      [edit]Class template std::ranges::adjacent_transform_view::sentinel

      namespace std::ranges{template<forward_range V, move_constructible F, size_t N> requires view<V>&&(N >0)&& is_object_v<F>&& regular_invocable<F&, /*REPEAT*/(range_reference_t<V>, N)...>&&/*can-reference*/< invoke_result_t<F&, /*REPEAT*/(range_reference_t<V>, N)...>>template<bool Const>class adjacent_transform_view<V, F, N>::/*sentinel*/{/*inner-sentinel*/<Const>/*inner_*/;// exposition-onlyconstexprexplicit/*sentinel*/(/*inner-sentinel*/<Const> inner);// exposition-only   public:/*sentinel*/()=default;constexpr/*sentinel*/(/*sentinel*/<!Const> i) requires Const && convertible_to</*inner-sentinel*/<false>, /*inner-sentinel*/<Const>>;   template<bool OtherConst> requires sentinel_for</*inner-sentinel*/<Const>, /*inner-iterator*/<OtherConst>>friendconstexprbool operator==(const/*iterator*/<OtherConst>& x, const/*sentinel*/& y);   template<bool OtherConst> requires sized_sentinel_for</*inner-sentinel*/<Const>, /*inner-iterator*/<OtherConst>>friendconstexpr range_difference_t</*maybe-const*/<OtherConst, /*InnerView*/>> operator-(const/*iterator*/<OtherConst>& x, const/*sentinel*/& y);   template<bool OtherConst> requires sized_sentinel_for</*inner-sentinel*/<Const>, /*inner-iterator*/<OtherConst>>friendconstexpr range_difference_t</*maybe-const*/<OtherConst, /*InnerView*/>> operator-(const/*sentinel*/& x, const/*iterator*/<OtherConst>& y);};}

      [edit]Class template std::ranges::chunk_view for input_ranges

      namespace std::ranges{template<class I>constexpr I /*div-ceil*/(I num, I denom){// exposition-only I r = num / denom;if(num % denom)++r;return r;}   template<view V> requires input_range<V>class chunk_view :public view_interface<chunk_view<V>>{ V /*base_*/;// exposition-only range_difference_t<V>/*n_*/;// exposition-only range_difference_t<V>/*remainder_*/=0;// exposition-only   /*non-propagating-cache*/<iterator_t<V>>/*current_*/;// exposition-only   // class chunk_view::outer-iteratorclass/*outer-iterator*/;// exposition-only   // class chunk_view::inner-iteratorclass/*inner-iterator*/;// exposition-only   public:constexprexplicit chunk_view(V base, range_difference_t<V> n);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexpr/*outer-iterator*/ begin();constexpr default_sentinel_t end()constnoexcept;   constexprauto size() requires sized_range<V>;constexprauto size()const requires sized_range<const V>;   constexprauto reserve_hint() requires approximately_sized_range<V>;constexprauto reserve_hint()const requires approximately_sized_range<const V>;};   template<class R> chunk_view(R&&, range_difference_t<R>)-> chunk_view<views::all_t<R>>;}

      [edit]Class template std::ranges::chunk_view::outer_iterator for input_ranges

      namespace std::ranges{template<view V> requires input_range<V>class chunk_view<V>::/*outer-iterator*/{ chunk_view*/*parent_*/;// exposition-only   constexprexplicit/*outer-iterator*/(chunk_view& parent);// exposition-only   public:using iterator_concept = input_iterator_tag;using difference_type = range_difference_t<V>;   // class chunk_view::outer-iterator::value_typestruct value_type;   /*outer-iterator*/(/*outer-iterator*/&&)=default;/*outer-iterator*/& operator=(/*outer-iterator*/&&)=default;   constexpr value_type operator*()const;constexpr/*outer-iterator*/& operator++();constexprvoid operator++(int);   friendconstexprbool operator==(const/*outer-iterator*/& x, default_sentinel_t);   friendconstexpr difference_type operator-(default_sentinel_t y, const/*outer-iterator*/& x) requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;friendconstexpr difference_type operator-(const/*outer-iterator*/& x, default_sentinel_t y) requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;};}

      [edit]Class template std::ranges::chunk_view::outer_iterator::value_type for input_ranges

      namespace std::ranges{template<view V> requires input_range<V>struct chunk_view<V>::/*outer-iterator*/::value_type: view_interface<value_type>{private: chunk_view*/*parent_*/;// exposition-only   constexprexplicit value_type(chunk_view& parent);// exposition-only   public:constexpr/*inner-iterator*/ begin()constnoexcept;constexpr default_sentinel_t end()constnoexcept;   constexprauto size()const requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;};}

      [edit]Class template std::ranges::chunk_view::inner_iterator for input_ranges

      namespace std::ranges{template<view V> requires input_range<V>class chunk_view<V>::/*inner-iterator*/{ chunk_view*/*parent_*/;// exposition-only   constexprexplicit/*inner-iterator*/(chunk_view& parent)noexcept;// exposition-only   public:using iterator_concept = input_iterator_tag;using difference_type = range_difference_t<V>;using value_type = range_value_t<V>;   /*inner-iterator*/(/*inner-iterator*/&&)=default;/*inner-iterator*/& operator=(/*inner-iterator*/&&)=default;   constexprconst iterator_t<V>& base()const&;   constexpr range_reference_t<V> operator*()const;constexpr/*inner-iterator*/& operator++();constexprvoid operator++(int);   friendconstexprbool operator==(const/*inner-iterator*/& x, default_sentinel_t);   friendconstexpr difference_type operator-(default_sentinel_t y, const/*inner-iterator*/& x) requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;friendconstexpr difference_type operator-(const/*inner-iterator*/& x, default_sentinel_t y) requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;   friendconstexpr range_rvalue_reference_t<V> iter_move(const/*inner-iterator*/& i)noexcept(noexcept(ranges::iter_move(*i./*parent_*/->/*current_*/)));   friendconstexprvoid iter_swap(const/*inner-iterator*/& x, const/*inner-iterator*/& y)noexcept(noexcept(ranges::iter_swap(*x./*parent_*/->/*current_*/, *y./*parent_*/->/*current_*/))) requires indirectly_swappable<iterator_t<V>>;};}

      [edit]Class template std::ranges::chunk_view for forward_ranges

      namespace std::ranges{template<view V> requires forward_range<V>class chunk_view<V>:public view_interface<chunk_view<V>>{ V /*base_*/;// exposition-only range_difference_t<V>/*n_*/;// exposition-only   // class template chunk_view::iteratortemplate<bool>class/*iterator*/;// exposition-only   public:constexprexplicit chunk_view(V base, range_difference_t<V> n);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexprauto begin() requires(!/*simple-view*/<V>){return/*iterator*/<false>(this, ranges::begin(/*base_*/));}   constexprauto begin()const requires forward_range<const V>{return/*iterator*/<true>(this, ranges::begin(/*base_*/));}   constexprauto end() requires(!/*simple-view*/<V>){ifconstexpr(common_range<V>&& sized_range<V>){auto missing =(/*n_*/-ranges::distance(/*base_*/)%/*n_*/)%/*n_*/;return/*iterator*/<false>(this, ranges::end(/*base_*/), missing);}elseifconstexpr(common_range<V>&&!bidirectional_range<V>){return/*iterator*/<false>(this, ranges::end(/*base_*/));}else{return default_sentinel;}}   constexprauto end()const requires forward_range<const V>{ifconstexpr(common_range<const V>&& sized_range<const V>){auto missing =(/*n_*/-ranges::distance(/*base_*/)%/*n_*/)%/*n_*/;return/*iterator*/<true>(this, ranges::end(/*base_*/), missing);}elseifconstexpr(common_range<const V>&&!bidirectional_range<const V>){return/*iterator*/<true>(this, ranges::end(/*base_*/));}else{return default_sentinel;}}   constexprauto size() requires sized_range<V>;constexprauto size()const requires sized_range<const V>;   constexprauto reserve_hint() requires approximately_sized_range<V>;constexprauto reserve_hint()const requires approximately_sized_range<const V>;};}

      [edit]Class template std::ranges::chunk_view::iterator for forward_ranges

      namespace std::ranges{template<view V> requires forward_range<V>template<bool Const>class chunk_view<V>::/*iterator*/{using/*Parent*/=/*maybe-const*/<Const, chunk_view>;// exposition-onlyusing/*Base*/=/*maybe-const*/<Const, V>;// exposition-only   iterator_t</*Base*/>/*current_*/= iterator_t</*Base*/>();// exposition-only sentinel_t</*Base*/>/*end_*/= sentinel_t</*Base*/>();// exposition-only range_difference_t</*Base*/>/*n_*/=0;// exposition-only range_difference_t</*Base*/>/*missing_*/=0;// exposition-only   constexpr/*iterator*/(/*Parent*/* parent, iterator_t</*Base*/> current, // exposition-only range_difference_t</*Base*/> missing =0);   public:using iterator_category = input_iterator_tag;using iterator_concept =/* see description */;using value_type = decltype(views::take(subrange(/*current_*/, /*end_*/), /*n_*/));using difference_type = range_difference_t</*Base*/>;   /*iterator*/()=default;constexpr/*iterator*/(/*iterator*/<!Const> i) requires Const && convertible_to<iterator_t<V>, iterator_t</*Base*/>>&& convertible_to<sentinel_t<V>, sentinel_t</*Base*/>>;   constexpr iterator_t</*Base*/> base()const;   constexpr value_type operator*()const;constexpr/*iterator*/& operator++();constexpr/*iterator*/ operator++(int);   constexpr/*iterator*/& operator--() requires bidirectional_range</*Base*/>;constexpr/*iterator*/ operator--(int) requires bidirectional_range</*Base*/>;   constexpr/*iterator*/& operator+=(difference_type x) requires random_access_range</*Base*/>;constexpr/*iterator*/& operator-=(difference_type x) requires random_access_range</*Base*/>;   constexpr value_type operator[](difference_type n)const requires random_access_range</*Base*/>;   friendconstexprbool operator==(const/*iterator*/& x, const/*iterator*/& y);friendconstexprbool operator==(const/*iterator*/& x, default_sentinel_t);   friendconstexprbool operator<(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprbool operator>(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprbool operator<=(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprbool operator>=(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprauto operator<=>(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>&& three_way_comparable<iterator_t</*Base*/>>;   friendconstexpr/*iterator*/ operator+(const/*iterator*/& i, difference_type n) requires random_access_range</*Base*/>;friendconstexpr/*iterator*/ operator+(difference_type n, const/*iterator*/& i) requires random_access_range</*Base*/>;friendconstexpr/*iterator*/ operator-(const/*iterator*/& i, difference_type n) requires random_access_range</*Base*/>;friendconstexpr difference_type operator-(const/*iterator*/& x, const/*iterator*/& y) requires sized_sentinel_for<iterator_t</*Base*/>, iterator_t</*Base*/>>;   friendconstexpr difference_type operator-(default_sentinel_t y, const/*iterator*/& x) requires sized_sentinel_for<sentinel_t</*Base*/>, iterator_t</*Base*/>>;friendconstexpr difference_type operator-(const/*iterator*/& x, default_sentinel_t y) requires sized_sentinel_for<sentinel_t</*Base*/>, iterator_t</*Base*/>>;};}

      [edit]Class template std::ranges::slide_view

      namespace std::ranges{template<class V> concept /*slide-caches-nothing*/= random_access_range<V>&& sized_range<V>;// exposition-only   template<class V> concept /*slide-caches-last*/=// exposition-only!/*slide-caches-nothing*/<V>&& bidirectional_range<V>&& common_range<V>;   template<class V> concept /*slide-caches-first*/=// exposition-only!/*slide-caches-nothing*/<V>&&!/*slide-caches-last*/<V>;   template<forward_range V> requires view<V>class slide_view :public view_interface<slide_view<V>>{ V /*base_*/;// exposition-only range_difference_t<V>/*n_*/;// exposition-only   // class template slide_view::iteratortemplate<bool>class/*iterator*/;// exposition-only   // class slide_view::sentinelclass/*sentinel*/;// exposition-only   public:constexprexplicit slide_view(V base, range_difference_t<V> n);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexprauto begin() requires(!(/*simple-view*/<V>&&/*slide-caches-nothing*/<const V>));constexprauto begin()const requires /*slide-caches-nothing*/<const V>;   constexprauto end() requires(!(/*simple-view*/<V>&&/*slide-caches-nothing*/<const V>));constexprauto end()const requires /*slide-caches-nothing*/<const V>;   constexprauto size() requires sized_range<V>;constexprauto size()const requires sized_range<const V>;   constexprauto reserve_hintsize() requires approximately_sized_range<V>;constexprauto reserve_hintsize()const requires approximately_sized_range<const V>;};   template<class R> slide_view(R&&, range_difference_t<R>)-> slide_view<views::all_t<R>>;}

      [edit]Class template std::ranges::slide_view::iterator

      namespace std::ranges{template<forward_range V> requires view<V>template<bool Const>class slide_view<V>::/*iterator*/{using/*Base*/=/*maybe-const*/<Const, V>;// exposition-only iterator_t</*Base*/>/*current_*/= iterator_t</*Base*/>();// exposition-only iterator_t</*Base*/>/*last-ele_*/= iterator_t</*Base*/>();// exposition-only// present only if Base models slide-caches-first range_difference_t</*Base*/>/*n_*/=0;// exposition-only   constexpr/*iterator*/(iterator_t</*Base*/> current, range_difference_t</*Base*/> n)// exposition-only requires(!/*slide-caches-first*/</*Base*/>);   constexpr/*iterator*/(iterator_t</*Base*/> current, iterator_t</*Base*/> last_ele, // exposition-only range_difference_t</*Base*/> n) requires /*slide-caches-first*/</*Base*/>;   public:using iterator_category = input_iterator_tag;using iterator_concept =/* see description */;using value_type = decltype(views::counted(/*current_*/, /*n_*/));using difference_type = range_difference_t</*Base*/>;   /*iterator*/()=default;constexpr/*iterator*/(/*iterator*/<!Const> i) requires Const && convertible_to<iterator_t<V>, iterator_t</*Base*/>>;   constexprauto operator*()const;constexpr/*iterator*/& operator++();constexpr/*iterator*/ operator++(int);   constexpr/*iterator*/& operator--() requires bidirectional_range</*Base*/>;constexpr/*iterator*/ operator--(int) requires bidirectional_range</*Base*/>;   constexpr/*iterator*/& operator+=(difference_type x) requires random_access_range</*Base*/>;constexpr/*iterator*/& operator-=(difference_type x) requires random_access_range</*Base*/>;   constexprauto operator[](difference_type n)const requires random_access_range</*Base*/>;   friendconstexprbool operator==(const/*iterator*/& x, const/*iterator*/& y);   friendconstexprbool operator<(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprbool operator>(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprbool operator<=(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprbool operator>=(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;friendconstexprauto operator<=>(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>&& three_way_comparable<iterator_t</*Base*/>>;   friendconstexpr/*iterator*/ operator+(const/*iterator*/& i, difference_type n) requires random_access_range</*Base*/>;friendconstexpr/*iterator*/ operator+(difference_type n, const/*iterator*/& i) requires random_access_range</*Base*/>;friendconstexpr/*iterator*/ operator-(const/*iterator*/& i, difference_type n) requires random_access_range</*Base*/>;friendconstexpr difference_type operator-(const/*iterator*/& x, const/*iterator*/& y) requires sized_sentinel_for<iterator_t</*Base*/>, iterator_t</*Base*/>>;};}

      [edit]Class template std::ranges::slide_view::sentinel

      namespace std::ranges{template<forward_range V> requires view<V>class slide_view<V>::/*sentinel*/{ sentinel_t<V>/*end_*/= sentinel_t<V>();// exposition-onlyconstexprexplicit/*sentinel*/(sentinel_t<V> end);// exposition-only   public:/*sentinel*/()=default;   friendconstexprbool operator==(const/*iterator*/<false>& x, const/*sentinel*/& y);   friendconstexpr range_difference_t<V> operator-(const/*iterator*/<false>& x, const/*sentinel*/& y) requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;   friendconstexpr range_difference_t<V> operator-(const/*sentinel*/& y, const/*iterator*/<false>& x) requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;};}

      [edit]Class template std::ranges::chunk_by_view

      namespace std::ranges{template<forward_range V, indirect_binary_predicate<iterator_t<V>, iterator_t<V>> Pred> requires view<V>&& is_object_v<Pred>class chunk_by_view :public view_interface<chunk_by_view<V, Pred>>{ V /*base_*/= V();// exposition-only/*movable-box*/<Pred>/*pred_*/;// exposition-only   // class chunk_by_view::iteratorclass/*iterator*/;// exposition-only   public: chunk_by_view() requires default_initializable<V>&& default_initializable<Pred>=default;constexprexplicit chunk_by_view(V base, Pred pred);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexprconst Pred& pred()const;   constexpr/*iterator*/ begin();constexprauto end();   constexpr iterator_t<V>/*find-next*/(iterator_t<V>);// exposition-onlyconstexpr iterator_t<V>/*find-prev*/(iterator_t<V>)// exposition-only requires bidirectional_range<V>;};   template<class R, class Pred> chunk_by_view(R&&, Pred)-> chunk_by_view<views::all_t<R>, Pred>;}

      [edit]Class template std::ranges::chunk_by_view::iterator

      namespace std::ranges{template<forward_range V, indirect_binary_predicate<iterator_t<V>, iterator_t<V>> Pred> requires view<V>&& is_object_v<Pred>class chunk_by_view<V, Pred>::/*iterator*/{ chunk_by_view*/*parent_*/= nullptr;// exposition-only iterator_t<V>/*current_*/= iterator_t<V>();// exposition-only iterator_t<V>/*next_*/= iterator_t<V>();// exposition-only   constexpr/*iterator*/(chunk_by_view& parent, iterator_t<V> current, // exposition-only iterator_t<V> next);   public:using value_type = subrange<iterator_t<V>>;using difference_type = range_difference_t<V>;using iterator_category = input_iterator_tag;using iterator_concept =/* see description */;   /*iterator*/()=default;   constexpr value_type operator*()const;constexpr/*iterator*/& operator++();constexpr/*iterator*/ operator++(int);   constexpr/*iterator*/& operator--() requires bidirectional_range<V>;constexpr/*iterator*/ operator--(int) requires bidirectional_range<V>;   friendconstexprbool operator==(const/*iterator*/& x, const/*iterator*/& y);friendconstexprbool operator==(const/*iterator*/& x, default_sentinel_t);};}

      [edit]Class template std::ranges::stride_view

      namespace std::ranges{template<input_range V> requires view<V>class stride_view :public view_interface<stride_view<V>>{ V /*base_*/;// exposition-only range_difference_t<V>/*stride_*/;// exposition-only// class template stride_view::iteratortemplate<bool>class/*iterator*/;// exposition-onlypublic:constexprexplicit stride_view(V base, range_difference_t<V> stride);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexpr range_difference_t<V> stride()constnoexcept;   constexprauto begin() requires(!/*simple-view*/<V>){return/*iterator*/<false>(this, ranges::begin(/*base_*/));}   constexprauto begin()const requires range<const V>{return/*iterator*/<true>(this, ranges::begin(/*base_*/));}   constexprauto end() requires(!/*simple-view*/<V>){ifconstexpr(common_range<V>&& sized_range<V>&& forward_range<V>){auto missing =(/*stride_*/-ranges::distance(/*base_*/)%/*stride_*/)%/*stride_*/;return/*iterator*/<false>(this, ranges::end(/*base_*/), missing);}elseifconstexpr(common_range<V>&&!bidirectional_range<V>){return/*iterator*/<false>(this, ranges::end(/*base_*/));}else{return default_sentinel;}}   constexprauto end()const requires range<const V>{ifconstexpr(common_range<const V>&& sized_range<const V>&& forward_range<const V>){auto missing =(/*stride_*/-ranges::distance(/*base_*/)%/*stride_*/)%/*stride_*/;return/*iterator*/<true>(this, ranges::end(/*base_*/), missing);}elseifconstexpr(common_range<const V>&&!bidirectional_range<const V>){return/*iterator*/<true>(this, ranges::end(/*base_*/));}else{return default_sentinel;}}   constexprauto size() requires sized_range<V>;constexprauto size()const requires sized_range<const V>;   constexprauto reserve_hint() requires approximately_sized_range<V>;constexprauto reserve_hint()const requires approximately_sized_range<const V>;};   template<class R> stride_view(R&&, range_difference_t<R>)-> stride_view<views::all_t<R>>;}

      [edit]Class template std::ranges::stride_view::iterator

      namespace std::ranges{template<input_range V> requires view<V>template<bool Const>class stride_view<V>::/*iterator*/{using/*Parent*/=/*maybe-const*/<Const, stride_view>;// exposition-onlyusing/*Base*/=/*maybe-const*/<Const, V>;// exposition-only   iterator_t</*Base*/>/*current_*/= iterator_t</*Base*/>();// exposition-only sentinel_t</*Base*/>/*end_*/= sentinel_t</*Base*/>();// exposition-only range_difference_t</*Base*/>/*stride_*/=0;// exposition-only range_difference_t</*Base*/>/*missing_*/=0;// exposition-only   constexpr/*iterator*/(/*Parent*/* parent, iterator_t</*Base*/> current, // exposition-only range_difference_t</*Base*/> missing =0);   public:using difference_type = range_difference_t</*Base*/>;using value_type = range_value_t</*Base*/>;using iterator_concept =/* see description */;using iterator_category =/* see description */;// not always present   /*iterator*/() requires default_initializable<iterator_t</*Base*/>>=default;   constexpr/*iterator*/(/*iterator*/<!Const> other) requires Const && convertible_to<iterator_t<V>, iterator_t</*Base*/>>&& convertible_to<sentinel_t<V>, sentinel_t</*Base*/>>;   constexpr iterator_t</*Base*/> base()&&;constexprconst iterator_t</*Base*/>& base()const&noexcept;   constexpr decltype(auto) operator*()const{return*/*current_*/;}   constexpr/*iterator*/& operator++();constexprvoid operator++(int);constexpr/*iterator*/ operator++(int) requires forward_range</*Base*/>;   constexpr/*iterator*/& operator--() requires bidirectional_range</*Base*/>;constexpr/*iterator*/ operator--(int) requires bidirectional_range</*Base*/>;   constexpr/*iterator*/& operator+=(difference_type n) requires random_access_range</*Base*/>;constexpr/*iterator*/& operator-=(difference_type n) requires random_access_range</*Base*/>;   constexpr decltype(auto) operator[](difference_type n)const requires random_access_range</*Base*/>{return*(*this + n);}   friendconstexprbool operator==(const/*iterator*/& x, default_sentinel_t);   friendconstexprbool operator==(const/*iterator*/& x, const/*iterator*/& y) requires equality_comparable<iterator_t</*Base*/>>;   friendconstexprbool operator<(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;   friendconstexprbool operator>(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;   friendconstexprbool operator<=(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;   friendconstexprbool operator>=(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>;   friendconstexprauto operator<=>(const/*iterator*/& x, const/*iterator*/& y) requires random_access_range</*Base*/>&& three_way_comparable<iterator_t</*Base*/>>;   friendconstexpr/*iterator*/ operator+(const/*iterator*/& x, difference_type n) requires random_access_range</*Base*/>;friendconstexpr/*iterator*/ operator+(difference_type n, const/*iterator*/& x) requires random_access_range</*Base*/>;friendconstexpr/*iterator*/ operator-(const/*iterator*/& x, difference_type n) requires random_access_range</*Base*/>;friendconstexpr difference_type operator-(const/*iterator*/& x, const/*iterator*/& y) requires sized_sentinel_for<iterator_t</*Base*/>, iterator_t</*Base*/>>;   friendconstexpr difference_type operator-(default_sentinel_t y, const/*iterator*/& x) requires sized_sentinel_for<sentinel_t</*Base*/>, iterator_t</*Base*/>>;friendconstexpr difference_type operator-(const/*iterator*/& x, default_sentinel_t y) requires sized_sentinel_for<sentinel_t</*Base*/>, iterator_t</*Base*/>>;   friendconstexpr range_rvalue_reference_t</*Base*/> iter_move(const/*iterator*/& i)noexcept(noexcept(ranges::iter_move(i./*current_*/)));   friendconstexprvoid iter_swap(const/*iterator*/& x, const/*iterator*/& y)noexcept(noexcept(ranges::iter_swap(x./*current_*/, y./*current_*/))) requires indirectly_swappable<iterator_t</*Base*/>>;};}

      [edit]Class template std::ranges::cartesian_product_view

      namespace std::ranges{template<bool Const, class First, class... Vs> concept /*cartesian-product-is-random-access*/=// exposition-only(random_access_range</*maybe-const*/<Const, First>>&& ... &&(random_access_range</*maybe-const*/<Const, Vs>>&& sized_range</*maybe-const*/<Const, Vs>>));   template<class R> concept /*cartesian-product-common-arg*/=// exposition-only common_range<R>||(sized_range<R>&& random_access_range<R>);   template<bool Const, class First, class... Vs> concept /*cartesian-product-is-bidirectional*/=// exposition-only(bidirectional_range</*maybe-const*/<Const, First>>&& ... &&(bidirectional_range</*maybe-const*/<Const, Vs>>&&/*cartesian-product-common-arg*/</*maybe-const*/<Const, Vs>>));   template<class First, class...> concept /*cartesian-product-is-common*/=// exposition-only/*cartesian-product-common-arg*/<First>;   template<class... Vs> concept /*cartesian-product-is-sized*/=// exposition-only(sized_range<Vs>&& ...);   template<bool Const, template<class>class FirstSent, class First, class... Vs> concept /*cartesian-is-sized-sentinel*/=// exposition-only(sized_sentinel_for<FirstSent</*maybe-const*/<Const, First>>, iterator_t</*maybe-const*/<Const, First>>>&& ... &&(sized_range</*maybe-const*/<Const, Vs>>&& sized_sentinel_for<iterator_t</*maybe-const*/<Const, Vs>>, iterator_t</*maybe-const*/<Const, Vs>>>));   template</*cartesian-product-common-arg*/ R>constexprauto/*cartesian-common-arg-end*/(R& r){// exposition-onlyifconstexpr(common_range<R>){returnranges::end(r);}else{returnranges::begin(r)+ranges::distance(r);}}   template<input_range First, forward_range... Vs> requires(view<First>&& ... && view<Vs>)class cartesian_product_view :public view_interface<cartesian_product_view<First, Vs...>>{private: tuple<First, Vs...>/*bases_*/;// exposition-only// class template cartesian_product_view::iteratortemplate<bool Const>class/*iterator*/;// exposition-only   public:constexpr cartesian_product_view()=default;constexprexplicit cartesian_product_view(First first_base, Vs... bases);   constexpr/*iterator*/<false> begin() requires(!/*simple-view*/<First>|| ... ||!/*simple-view*/<Vs>);constexpr/*iterator*/<true> begin()const requires(range<const First>&& ... && range<const Vs>);   constexpr/*iterator*/<false> end() requires((!/*simple-view*/<First>|| ... ||!/*simple-view*/<Vs>)&&/*cartesian-product-is-common*/<First, Vs...>);constexpr/*iterator*/<true> end()const requires /*cartesian-product-is-common*/<const First, const Vs...>;constexpr default_sentinel_t end()constnoexcept;   constexpr/* see description */ size() requires /*cartesian-product-is-sized*/<First, Vs...>;constexpr/* see description */ size()const requires /*cartesian-product-is-sized*/<const First, const Vs...>;};   template<class... Vs> cartesian_product_view(Vs&&...)-> cartesian_product_view<views::all_t<Vs>...>;}

      [edit]Class template std::ranges::cartesian_product_view::iterator

      namespace std::ranges{template<input_range First, forward_range... Vs> requires(view<First>&& ... && view<Vs>)template<bool Const>class cartesian_product_view<First, Vs...>::/*iterator*/{public:using iterator_category = input_iterator_tag;using iterator_concept =/* see description */;using value_type = tuple<range_value_t</*maybe-const*/<Const, First>>, range_value_t</*maybe-const*/<Const, Vs>>...>;using reference = tuple<range_reference_t</*maybe-const*/<Const, First>>, range_reference_t</*maybe-const*/<Const, Vs>>...>;using difference_type =/* see description */;   /*iterator*/()=default;   constexpr/*iterator*/(/*iterator*/<!Const> i) requires Const &&(convertible_to<iterator_t<First>, iterator_t<const First>>&& ... && convertible_to<iterator_t<Vs>, iterator_t<const Vs>>);   constexprauto operator*()const;constexpr/*iterator*/& operator++();constexprvoid operator++(int);constexpr/*iterator*/ operator++(int) requires forward_range</*maybe-const*/<Const, First>>;   constexpr/*iterator*/& operator--() requires /*cartesian-product-is-bidirectional*/<Const, First, Vs...>;constexpr/*iterator*/ operator--(int) requires /*cartesian-product-is-bidirectional*/<Const, First, Vs...>;   constexpr/*iterator*/& operator+=(difference_type x) requires /*cartesian-product-is-random-access*/<Const, First, Vs...>;constexpr/*iterator*/& operator-=(difference_type x) requires /*cartesian-product-is-random-access*/<Const, First, Vs...>;   constexpr reference operator[](difference_type n)const requires /*cartesian-product-is-random-access*/<Const, First, Vs...>;   friendconstexprbool operator==(const/*iterator*/& x, const/*iterator*/& y) requires equality_comparable<iterator_t</*maybe-const*/<Const, First>>>;   friendconstexprbool operator==(const/*iterator*/& x, default_sentinel_t);   friendconstexprauto operator<=>(const/*iterator*/& x, const/*iterator*/& y) requires /*all-random-access*/<Const, First, Vs...>;   friendconstexpr/*iterator*/ operator+(const/*iterator*/& x, difference_type y) requires /*cartesian-product-is-random-access*/<Const, First, Vs...>;friendconstexpr/*iterator*/ operator+(difference_type x, const/*iterator*/& y) requires /*cartesian-product-is-random-access*/<Const, First, Vs...>;friendconstexpr/*iterator*/ operator-(const/*iterator*/& x, difference_type y) requires /*cartesian-product-is-random-access*/<Const, First, Vs...>;friendconstexpr difference_type operator-(const/*iterator*/& x, const/*iterator*/& y) requires /*cartesian-is-sized-sentinel*/<Const, iterator_t, First, Vs...>;   friendconstexpr difference_type operator-(const/*iterator*/& i, default_sentinel_t) requires /*cartesian-is-sized-sentinel*/<Const, sentinel_t, First, Vs...>;friendconstexpr difference_type operator-(default_sentinel_t, const/*iterator*/& i) requires /*cartesian-is-sized-sentinel*/<Const, sentinel_t, First, Vs...>;   friendconstexprauto iter_move(const/*iterator*/& i)noexcept(/* see description */);   friendconstexprvoid iter_swap(const/*iterator*/& l, const/*iterator*/& r)noexcept(/* see description */) requires(indirectly_swappable<iterator_t</*maybe-const*/<Const, First>>>&& ... && indirectly_swappable<iterator_t</*maybe-const*/<Const, Vs>>>);   private:using/*Parent*/=/*maybe-const*/<Const, cartesian_product_view>;// exposition-only/*Parent*/*/*parent_*/= nullptr;// exposition-only tuple<iterator_t</*maybe-const*/<Const, First>>, iterator_t</*maybe-const*/<Const, Vs>>...>/*current_*/;// exposition-only   template<size_t N = sizeof...(Vs)>constexprvoid/*next*/();// exposition-only   template<size_t N = sizeof...(Vs)>constexprvoid/*prev*/();// exposition-only   template<class Tuple>constexpr difference_type /*distance-from*/(const Tuple& t)const;// exposition-only   constexpr/*iterator*/(/*Parent*/& parent, tuple<iterator_t</*maybe-const*/<Const, First>>, iterator_t</*maybe-const*/<Const, Vs>>...> current);// exposition-only};}

      [edit]Class template std::ranges::cache_latest_view

      namespace std::ranges{template<input_range V> requires view<V>class cache_latest_view :public view_interface<cache_latest_view<V>>{ V /*base_*/= V();// exposition-onlyusing/*cache-t*/= conditional_t<is_reference_v<range_reference_t<V>>, // exposition-only add_pointer_t<range_reference_t<V>>, range_reference_t<V>>;   /*non-propagating-cache*/</*cache-t*/>/*cache_*/;// exposition-only   // class cache_latest_view::iteratorclass/*iterator*/;// exposition-only// class cache_latest_view::sentinelclass/*sentinel*/;// exposition-only   public: cache_latest_view() requires default_initializable<V>=default;constexprexplicit cache_latest_view(V base);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexprauto begin();constexprauto end();   constexprauto size() requires sized_range<V>;constexprauto size()const requires sized_range<const V>;};   template<class R> cache_latest_view(R&&)-> cache_latest_view<views::all_t<R>>;}

      [edit]Class template std::ranges::cache_latest_view::iterator

      namespace std::ranges{template<input_range V> requires view<V>class cache_latest_view<V>::/*iterator*/{ cache_latest_view*/*parent_*/;// exposition-only iterator_t<V>/*current_*/;// exposition-only   constexprexplicit/*iterator*/(cache_latest_view& parent);// exposition-only   public:using difference_type = range_difference_t<V>;using value_type = range_value_t<V>;using iterator_concept = input_iterator_tag;   /*iterator*/(/*iterator*/&&)=default;/*iterator*/& operator=(/*iterator*/&&)=default;   constexpr iterator_t<V> base()&&;constexprconst iterator_t<V>& base()const&noexcept;   constexpr range_reference_t<V>& operator*()const;   constexpr/*iterator*/& operator++();constexprvoid operator++(int);   friendconstexpr range_rvalue_reference_t<V> iter_move(const/*iterator*/& i)noexcept(noexcept(ranges::iter_move(i./*current_*/)));   friendconstexprvoid iter_swap(const/*iterator*/& x, const/*iterator*/& y)noexcept(noexcept(ranges::iter_swap(x./*current_*/, y./*current_*/))) requires indirectly_swappable<iterator_t<V>>;};}

      [edit]Class template std::ranges::cache_latest_view::sentinel

      namespace std::ranges{template<input_range V> requires view<V>class cache_latest_view<V>::/*sentinel*/{ sentinel_t<V>/*end_*/= sentinel_t<V>();// exposition-only   constexprexplicit/*sentinel*/(cache_latest_view& parent);// exposition-only   public:/*sentinel*/()=default;   constexpr sentinel_t<V> base()const;   friendconstexprbool operator==(const/*iterator*/& x, const/*sentinel*/& y);   friendconstexpr range_difference_t<V> operator-(const/*iterator*/& x, const/*sentinel*/& y) requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;friendconstexpr range_difference_t<V> operator-(const/*sentinel*/& x, const/*iterator*/& y) requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;};}

      [edit]Class template std::ranges::to_input_view

      namespace std::ranges{template<input_range V> requires view<V>class to_input_view :public view_interface<to_input_view<V>>{ V /*base_*/= V();// exposition-only   // class template to_input_view::iteratortemplate<bool Const>class/*iterator*/;// exposition-only   public: to_input_view() requires default_initializable<V>=default;constexprexplicit to_input_view(V base);   constexpr V base()const& requires copy_constructible<V>{return/*base_*/;}constexpr V base()&&{return std::move(/*base_*/);}   constexprauto begin() requires(!/*simple-view*/<V>);constexprauto begin()const requires range<const V>;   constexprauto end() requires(!/*simple-view*/<V>);constexprauto end()const requires range<const V>;   constexprauto size() requires sized_range<V>;constexprauto size()const requires sized_range<const V>;};   template<class R> to_input_view(R&&)-> to_input_view<views::all_t<R>>;}

      [edit]Class template std::ranges::to_input_view::iterator

      namespace std::ranges{template<input_range V> requires view<V>template<bool Const>class to_input_view<V>::/*iterator*/{using/*Base*/=/*maybe-const*/<Const, V>;// exposition-only   iterator_t</*Base*/>/*current_*/= iterator_t</*Base*/>();// exposition-only   constexprexplicit/*iterator*/(iterator_t</*Base*/> current);// exposition-only   public:using difference_type = range_difference_t</*Base*/>;using value_type = range_value_t</*Base*/>;using iterator_concept = input_iterator_tag;   /*iterator*/() requires default_initializable<iterator_t</*Base*/>>=default;   /*iterator*/(/*iterator*/&&)=default;/*iterator*/& operator=(/*iterator*/&&)=default;   constexpr/*iterator*/(/*iterator*/<!Const> i) requires Const && convertible_to<iterator_t<V>, iterator_t</*Base*/>>;   constexpr iterator_t</*Base*/> base()&&;constexprconst iterator_t</*Base*/>& base()const&noexcept;   constexpr decltype(auto) operator*()const{return*/*current_*/;}   constexpr/*iterator*/& operator++();constexprvoid operator++(int);   friendconstexprbool operator==(const/*iterator*/& x, const sentinel_t</*Base*/>& y);   friendconstexpr difference_type operator-(const sentinel_t</*Base*/>& y, const/*iterator*/& x) requires sized_sentinel_for<sentinel_t</*Base*/>, iterator_t</*Base*/>>;friendconstexpr difference_type operator-(const/*iterator*/& x, const sentinel_t</*Base*/>& y) requires sized_sentinel_for<sentinel_t</*Base*/>, iterator_t</*Base*/>>;   friendconstexpr range_rvalue_reference_t</*Base*/> iter_move(const/*iterator*/& i)noexcept(noexcept(ranges::iter_move(i./*current_*/)));   friendconstexprvoid iter_swap(const/*iterator*/& x, const/*iterator*/& y)noexcept(noexcept(ranges::iter_swap(x./*current_*/, y./*current_*/))) requires indirectly_swappable<iterator_t</*Base*/>>;};}

      [edit]Defect reports

      The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

      DR Applied to Behavior as published Correct behavior
      LWG 3914C++23 the constraint of std::ranges::enumerate_view
      was incorrectly specified in the synopsis       		corrected
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/header/ranges&oldid=182464"
      close