Range-v3 Range algorithms, views, and actions for the Standard Library |

Classes | Typedefs | Enumerations | Functions | Variables
Views

## Description

Lazy, non-owning, non-mutating, composable range views.

## Classes
struct | ranges::adaptor_base
struct | ranges::adaptor_cursor< BaseIter, Adapt >
struct | ranges::adaptor_sentinel< BaseSent, Adapt >
struct | ranges::adjacent_filter_view< Rng, Pred >
struct | ranges::adjacent_remove_if_view< Rng, Pred >
struct | ranges::any_view< Ref, Cat, enable >
| A type-erased view. More...
struct | ranges::base_adaptor_sentinel< BaseSent, Adapt >
struct | ranges::cache1_view< Rng >
struct | ranges::cartesian_product_view< Views >
struct | ranges::chunk_view< Rng >
struct | ranges::chunk_view_< Rng, IsForwardRange >
struct | ranges::chunk_view_< Rng, false >
struct | ranges::closed_iota_view< From, To >
| An iota view in a closed range. More...
struct | ranges::common_view< Rng, bool >
struct | ranges::common_view< Rng, true >
struct | ranges::concat_view< Rngs >
struct | ranges::const_view< Rng >
struct | ranges::counted_view< I >
struct | ranges::cycled_view< Rng, bool >
struct | ranges::cycled_view< Rng, true >
struct | ranges::delimit_view< Rng, Val >
struct | ranges::drop_exactly_view< Rng >
struct | ranges::drop_last_view< Rng, typename >
struct | ranges::drop_last_view< Rng, detail::drop_last_view::mode_bidi >
struct | ranges::drop_last_view< Rng, detail::drop_last_view::mode_forward >
struct | ranges::drop_last_view< Rng, detail::drop_last_view::mode_sized >
struct | ranges::drop_view< Rng >
struct | ranges::drop_while_view< Rng, Pred >
struct | ranges::empty_view< T >
struct | ranges::exclusive_scan_view< Rng, T, Fun >
struct | ranges::filter_view< Rng, Pred >
struct | ranges::generate_n_view< G >
struct | ranges::generate_view< G >
struct | ranges::getlines_fn
struct | ranges::getlines_view
struct | ranges::group_by_view< Rng, Fun >
struct | ranges::identity_adaptor< Rng >
struct | ranges::indirect_view< Rng >
struct | ranges::intersperse_view< Rng >
struct | ranges::iota_view< From, To >
struct | ranges::istream_view< Val >
struct | ranges::iter_take_while_view< Rng, Pred >
struct | ranges::iter_transform2_view< Rng1, Rng2, Fun >
struct | ranges::iter_transform_view< Rng, Fun >
struct | ranges::iter_zip_with_view< Fun, Rngs >
struct | ranges::join_view< Rng >
struct | ranges::join_with_view< Rng, ValRng >
struct | ranges::lazy_yield_if_fn
struct | ranges::make_subrange_fn
struct | ranges::make_view_closure_fn
struct | ranges::move_view< Rng >
struct | ranges::partial_sum_view< Rng, Fun >
struct | ranges::ref_view< Rng >
struct | ranges::remove_if_view< Rng, Pred >
struct | ranges::repeat_n_view< Val >
struct | ranges::repeat_view< Val >
struct | ranges::reverse_view< Rng >
struct | ranges::reverse_view< reverse_view< Rng > >
class | ranges::sample_view< Rng, URNG >
struct | ranges::single_view< T >
struct | ranges::slice_view< Rng >
struct | ranges::sliding_view< Rng, sliding_view_detail::cache::first >
struct | ranges::sliding_view< Rng, sliding_view_detail::cache::last >
struct | ranges::sliding_view< Rng, sliding_view_detail::cache::none >
struct | ranges::span< T, N >
struct | ranges::split_view< V, Pattern >
struct | ranges::split_when_view< Rng, Fun >
struct | ranges::stride_view< Rng >
struct | ranges::subrange< I, S, K >
struct | ranges::tail_view< Rng >
struct | ranges::take_view< Rng >
struct | ranges::take_while_view< Rng, Pred >
struct | ranges::tokenize_view< Rng, Regex, SubMatchRange >
struct | ranges::transform2_view< Rng1, Rng2, Fun >
struct | ranges::transform_view< Rng, Fun >
struct | ranges::trim_view< Rng, Pred >
struct | ranges::unbounded_view< I >
struct | ranges::view_adaptor< Derived, BaseRng, Cardinality >
struct | ranges::view_facade< Derived, Cardinality >
| A utility for constructing a view from a (derived) type that implements begin and end cursors. More...
struct | ranges::view_interface< Derived, Cardinality >
struct | ranges::views::c_str_fn
| View a `\0`-terminated C string (e.g. from a const char*) as a range. More...
struct | ranges::views::generate_fn
struct | ranges::views::intersperse_base_fn
struct | ranges::views::intersperse_fn
struct | ranges::views::linear_distribute_fn
| Distributes `n` values linearly in the closed interval [`from`, `to`]. More...
struct | ranges::views::linear_distribute_view< T >
struct | ranges::views::ref_fn
struct | ranges::yield_fn
struct | ranges::yield_from_fn
struct | ranges::yield_if_fn
struct | ranges::zip_view< Rngs >
struct | ranges::zip_with_view< Fun, Rngs >

## Typedefs
template<typename D >
using | ranges::adaptor_cursor_t = adaptor_cursor< detail::adapted_iterator_t< D >, detail::begin_adaptor_t< D > >
template<typename D >
using | ranges::adaptor_sentinel_t = meta::if_c< same_as< detail::adapted_iterator_t< D >, detail::adapted_sentinel_t< D > > &&same_as< detail::begin_adaptor_t< D >, detail::end_adaptor_t< D > >, adaptor_cursor_t< D >, adaptor_sentinel< detail::adapted_sentinel_t< D >, detail::end_adaptor_t< D > >>
template<typename R >
using | ranges::borrowed_subrange_t = detail::maybe_dangling_< R, subrange< iterator_t< R > >>
template<typename Rng >
using | ranges::cpp20::ref_view = ranges::ref_view< Rng >
template<typename R >
using | ranges::safe_subrange_t = borrowed_subrange_t< R >
template<typename Rng1 , typename Rng2 , typename C , typename P1 , typename P2 >
using | ranges::set_difference_view = detail::set_algorithm_view< Rng1, Rng2, C, P1, P2, detail::set_difference_cursor, detail::set_difference_cardinality(range_cardinality< Rng1 >::value, range_cardinality< Rng2 >::value)>
template<typename Rng1 , typename Rng2 , typename C , typename P1 , typename P2 >
using | ranges::set_intersection_view = detail::set_algorithm_view< Rng1, Rng2, C, P1, P2, detail::set_intersection_cursor, detail::set_intersection_cardinality(range_cardinality< Rng1 >::value, range_cardinality< Rng2 >::value)>
template<typename Rng1 , typename Rng2 , typename C , typename P1 , typename P2 >
using | ranges::set_symmetric_difference_view = detail::set_algorithm_view< Rng1, Rng2, C, P1, P2, detail::set_symmetric_difference_cursor, detail::set_symmetric_difference_cardinality(range_cardinality< Rng1 >::value, range_cardinality< Rng2 >::value)>
template<typename Rng1 , typename Rng2 , typename C , typename P1 , typename P2 >
using | ranges::set_union_view = detail::set_algorithm_view< Rng1, Rng2, C, P1, P2, detail::set_union_cursor, detail::set_union_cardinality(range_cardinality< Rng1 >::value, range_cardinality< Rng2 >::value)>
template<typename Rng >
using | ranges::take_exactly_view = detail::take_exactly_view_< Rng >

## Enumerations
enum | subrange_kind : bool { unsized, sized }

## Functions
template<typename Rng , typename Fun >
| ranges::adjacent_filter_view (Rng &&, Fun) -> adjacent_filter_view< views::all_t< Rng >, Fun >
template<typename Rng , typename Fun >
| ranges::adjacent_remove_if_view (Rng &&, Fun) -> adjacent_remove_if_view< views::all_t< Rng >, Fun >
constexpr auto | ranges::intersperse_view< Rng >::cursor_adaptor< Const >::advance (iterator_t< CRng > &it, range_difference_t< CRng > n) -> void
template<typename T , detail::span_index_t N>
span< unsigned char const, detail::byte_size< T >N)> | ranges::as_bytes (span< T, N > s) noexcept
template<typename T , detail::span_index_t N>
span< unsigned char, detail::byte_size< T >N)> | ranges::as_writeable_bytes (span< T, N > s) noexcept
constexpr Rng & | ranges::ref_view< Rng >::base () const noexcept
constexpr iterator_t< Rng > | ranges::ref_view< Rng >::begin () const noexcept(noexcept(ranges::begin(*rng_)))
template<typename View >
constexpr iterator_t< CRng > | ranges::intersperse_view< Rng >::cursor_adaptor< Const >::begin (View &view)
template<typename Rng >
| ranges::cache1_view (Rng &&) -> cache1_view< views::all_t< Rng >>
result_t & | ranges::generate_view< G >::cached ()
template<typename... Rng>
| ranges::cartesian_product_view (Rng &&...) -> cartesian_product_view< views::all_t< Rng >... >
template<typename Rng >
| ranges::chunk_view (Rng &&, range_difference_t< Rng >) -> chunk_view< views::all_t< Rng >>
template<typename From , typename To >
| ranges::closed_iota_view (From, To) -> closed_iota_view< From, To >
template<typename Rng >
| ranges::common_view (Rng &&) -> common_view< views::all_t< Rng >>
template<typename... Rng>
| ranges::concat_view (Rng &&...) -> concat_view< views::all_t< Rng >... >
template<typename Rng >
| ranges::const_view (Rng &&) -> const_view< views::all_t< Rng >>
template<typename I >
| ranges::counted_view (I, iter_difference_t< I >) -> counted_view< I >
| ranges::generate_view< G >::cursor::cursor (generate_view *view)
template<bool Other>
| ranges::intersperse_view< Rng >::cursor_adaptor< Const >::cursor_adaptor (cursor_adaptor< Other > that)
constexpr | ranges::intersperse_view< Rng >::cursor_adaptor< Const >::cursor_adaptor (range_value_t< Rng > const &val)
template<typename Rng >
| ranges::cycled_view (Rng &&) -> cycled_view< views::all_t< Rng >>
constexpr auto | ranges::ref_view< Rng >::data () const
template<typename Rng , typename Val >
| ranges::delimit_view (Rng &&, Val) -> delimit_view< views::all_t< Rng >, Val >
constexpr auto | ranges::intersperse_view< Rng >::cursor_adaptor< Const >::distance_to (iterator_t< CRng > const &it, iterator_t< CRng > const &other_it, cursor_adaptor const &other) const -> range_difference_t< Rng >
template<typename Rng >
| ranges::drop_exactly_view (Rng &&, range_difference_t< Rng >) -> drop_exactly_view< views::all_t< Rng >>
template<typename Rng >
| ranges::drop_last_view (Rng &&, range_difference_t< Rng >) -> drop_last_view< views::all_t< Rng >>
template<typename Rng >
| ranges::drop_view (Rng &&, range_difference_t< Rng >) -> drop_view< views::all_t< Rng >>
template<typename Rng , typename Fun >
| ranges::drop_while_view (Rng &&, Fun) -> drop_while_view< views::all_t< Rng >, Fun >
constexpr auto | ranges::ref_view< Rng >::empty () const noexcept(noexcept(ranges::empty(*rng_))) -> bool
static constexpr bool | ranges::intersperse_view< Rng >::sentinel_adaptor< Const >::empty (iterator_t< CRng > const &it, cursor_adaptor< Const > const &, sentinel_t< CRng > const &sent)
constexpr sentinel_t< Rng > | ranges::ref_view< Rng >::end () const noexcept(noexcept(ranges::end(*rng_)))
constexpr auto | ranges::intersperse_view< Rng >::cursor_adaptor< Const >::equal (iterator_t< CRng > const &it0, iterator_t< CRng > const &it1, cursor_adaptor const &other) const -> bool
template<typename Rng , typename T , typename Fun >
| ranges::exclusive_scan_view (Rng &&, T, Fun) -> exclusive_scan_view< views::all_t< Rng >, T, Fun >
template<typename Rng , typename Pred >
| ranges::filter_view (Rng &&, Pred) -> filter_view< views::all_t< Rng >, Pred >
| ranges::generate_view< G >::generate_view (G g)
template<typename Rng , typename Fun >
| ranges::group_by_view (Rng &&, Fun) -> group_by_view< views::all_t< Rng >, Fun >
template<typename Rng >
| ranges::indirect_view (Rng &&) -> indirect_view< views::all_t< Rng >>
template<typename Rng >
| ranges::intersperse_view (Rng &&, range_value_t< Rng >) -> intersperse_view< views::all_t< Rng >>
constexpr | ranges::intersperse_view< Rng >::intersperse_view (Rng rng, range_value_t< Rng > val)
template<typename From , typename To >
| ranges::iota_view (From, To) -> iota_view< From, To >
template<typename Val >
istream_view< Val > | ranges::istream (std::istream &sin)
constexpr | ranges::views::linear_distribute_view< T >::linear_distribute_view (T from, T to__, std::ptrdiff_t n) noexcept
template<typename ElementType >
constexpr span< ElementType > | ranges::make_span (ElementType *first, ElementType *last) noexcept
template<typename ElementType >
constexpr span< ElementType > | ranges::make_span (ElementType *ptr, detail::span_index_t cnt) noexcept
template<typename Rng >
constexpr span< detail::element_t< Rng > > | ranges::make_span (Rng &&rng) noexcept(noexcept(ranges::data(rng), ranges::size(rng)))
template<typename Rng >
| ranges::move_view (Rng &&) -> move_view< views::all_t< Rng >>
void | ranges::generate_view< G >::cursor::next ()
constexpr void | ranges::intersperse_view< Rng >::cursor_adaptor< Const >::next (iterator_t< CRng > &it)
template<typename Char >
ranges::delimit_view< ranges::subrange< Char *, ranges::unreachable_sentinel_t >, meta::_t< std::remove_cv< Char > > > | ranges::views::c_str_fn::operator() (Char *sz) const volatile
template<typename Char , std::size_t N>
ranges::subrange< Char * > | ranges::views::c_str_fn::operator() (Char(&sz)[N]) const
template<typename G >
generate_view< G > | ranges::views::generate_fn::operator() (G g) const
template<typename Rng >
constexpr intersperse_view< all_t< Rng > > | ranges::views::intersperse_base_fn::operator() (Rng &&rng, range_value_t< Rng > val) const
template<typename Rng >
constexpr ref_view< Rng > | ranges::views::ref_fn::operator() (Rng &rng) const noexcept
template<typename Rng >
void | ranges::views::ref_fn::operator() (Rng const &&rng) const =delete
template<typename T >
constexpr auto | ranges::views::linear_distribute_fn::operator() (T from, T to, std::ptrdiff_t n) const
template<typename T >
constexpr auto | ranges::views::intersperse_fn::operator() (T t) const
template<typename Rng , typename Fun >
| ranges::partial_sum_view (Rng &&, Fun) -> partial_sum_view< views::all_t< Rng >, Fun >
constexpr auto | ranges::intersperse_view< Rng >::cursor_adaptor< Const >::prev (iterator_t< CRng > &it) -> void
result_t && | ranges::generate_view< G >::cursor::read () const
constexpr range_value_t< Rng > | ranges::intersperse_view< Rng >::cursor_adaptor< Const >::read (iterator_t< CRng > const &it) const
template<typename R >
| ranges::ref_view (R &) -> ref_view< R >
constexpr | ranges::ref_view< Rng >::ref_view (Rng &rng) noexcept
template<typename Rng , typename Pred >
| ranges::remove_if_view (Rng &&, Pred) -> remove_if_view< views::all_t< Rng >, Pred >
template<typename Rng >
| ranges::reverse_view (reverse_view< Rng >) -> reverse_view< reverse_view< Rng >>
template<typename Rng >
| ranges::reverse_view (Rng &&) -> reverse_view< views::all_t< Rng >>
template<typename Rng , typename URNG >
| ranges::sample_view (Rng &&, range_difference_t< Rng >, URNG &) -> sample_view< views::all_t< Rng >, URNG >
template<bool Other>
| ranges::intersperse_view< Rng >::sentinel_adaptor< Const >::sentinel_adaptor (sentinel_adaptor< Other >)
template<typename Rng >
constexpr bool | ranges::simple_view () noexcept
template<class T >
| ranges::single_view (T &&) -> single_view< detail::decay_t< T >>
constexpr auto | ranges::intersperse_view< Rng >::size ()
constexpr auto | ranges::intersperse_view< Rng >::size () const
constexpr auto | ranges::ref_view< Rng >::size () const
constexpr std::size_t | ranges::views::linear_distribute_view< T >::size () const noexcept
template<typename Rng >
| ranges::slice_view (Rng &&, range_difference_t< Rng >, range_difference_t< Rng >) -> slice_view< views::all_t< Rng >>
template<typename Rng >
| ranges::sliding_view (Rng &&, range_difference_t< Rng >) -> sliding_view< views::all_t< Rng >>
template<typename Rng >
| ranges::span (Rng &&rng) -> span< detail::element_t< Rng >,(range_cardinality< Rng >::value< cardinality() ? dynamic_extent :static_cast< detail::span_index_t >(range_cardinality< Rng >::value))>
template<typename R , typename P >
| ranges::split_view (R &&, P &&) -> split_view< views::all_t< R >, views::all_t< P >>
template<typename R >
| ranges::split_view (R &&, range_value_t< R >) -> split_view< views::all_t< R >, single_view< range_value_t< R >>>
template<typename Rng , typename Fun >
| ranges::split_when_view (Rng &&, Fun) -> split_when_view< views::all_t< Rng >, Fun >
template<typename Rng >
| ranges::stride_view (Rng &&, range_difference_t< Rng >) -> stride_view< views::all_t< Rng >>
template<typename I , typename S >
| ranges::subrange (I, S) -> subrange< I, S >
template<typename I , typename S >
| ranges::subrange (I, S, detail::iter_size_t< I >) -> subrange< I, S, subrange_kind::sized >
template<typename R >
| ranges::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<typename R >
| ranges::subrange (R &&, detail::iter_size_t< iterator_t< R >>) -> subrange< iterator_t< R >, sentinel_t< R >, subrange_kind::sized >
template<typename Rng >
| ranges::tail_view (Rng &&) -> tail_view< views::all_t< Rng >>
template<typename Rng >
| ranges::take_view (Rng &&, range_difference_t< Rng >) -> take_view< views::all_t< Rng >>
template<typename Rng , typename Fun >
| ranges::take_while_view (Rng &&, Fun) -> take_while_view< views::all_t< Rng >, Fun >
template<typename Rng , typename Regex , typename SubMatchRange >
| ranges::tokenize_view (Rng &&, Regex, SubMatchRange) -> tokenize_view< views::all_t< Rng >, Regex, SubMatchRange >
template<typename Rng , typename Fun >
| ranges::transform_view (Rng &&, Fun) -> transform_view< views::all_t< Rng >, Fun >
template<typename Rng , typename Pred >
| ranges::trim_view (Rng &&, Pred) -> trim_view< views::all_t< Rng >, Pred >
template<typename... Rng>
| ranges::zip_view (Rng &&...) -> zip_view< views::all_t< Rng >... >
template<typename Fun , typename... Rng>
| ranges::zip_with_view (Fun, Rng &&...) -> zip_with_view< Fun, views::all_t< Rng >... >

## Variables
constexpr view_closure< addressof_fn > | addressof {}
constexpr adjacent_filter_fn | adjacent_filter {}
constexpr adjacent_remove_if_fn | adjacent_remove_if {}
constexpr view_closure< all_fn > | all {}
constexpr c_str_fn | c_str {}
constexpr view_closure< cache1_fn > | cache1 {}
template<typename IsConst , typename... Views>
concept | ranges::cartesian_produce_view_can_bidi
template<typename IsConst , typename... Views>
concept | ranges::cartesian_produce_view_can_bidi__concept_ = and_v<common_range<meta::const_if<IsConst, Views>>..., bidirectional_iterator<iterator_t<meta::const_if<IsConst, Views>>>...>
template<typename... Views>
concept | ranges::cartesian_produce_view_can_const
template<typename IsConst , typename... Views>
concept | ranges::cartesian_produce_view_can_distance
template<typename IsConst , typename... Views>
concept | ranges::cartesian_produce_view_can_distance__concept_ = and_v<sized_sentinel_for< iterator_t<meta::const_if<IsConst, Views>>, iterator_t<meta::const_if<IsConst, Views>>>...>
template<typename IsConst , typename... Views>
concept | ranges::cartesian_produce_view_can_random
template<typename IsConst , typename... Views>
concept | ranges::cartesian_produce_view_can_random__concept_ = and_v<random_access_iterator<iterator_t<meta::const_if<IsConst, Views>>>...>
template<typename IsConst , typename... Views>
concept | ranges::cartesian_produce_view_can_size
template<typename IsConst , typename... Views>
concept | ranges::cartesian_produce_view_can_size__concept_ = and_v<common_with<std::uintmax_t, range_size_t<meta::const_if<IsConst, Views>>>...>
constexpr chunk_fn | chunk {}
constexpr closed_indices_fn | closed_indices {}
constexpr closed_iota_fn | closed_iota {}
constexpr view_closure< common_fn > | common {}
constexpr concat_fn | concat {}
constexpr view_closure< const_fn > | const_ {}
constexpr counted_fn | counted {}
constexpr view_closure< cycle_fn > | cycle {}
constexpr delimit_fn | delimit {}
template<typename Rng , typename Pred >
constexpr bool | ranges::disable_sized_range< drop_while_view< Rng, Pred > >
template<typename Rng , typename Pred >
constexpr bool | ranges::disable_sized_range< trim_view< Rng, Pred > > = true
constexpr drop_fn | drop {}
constexpr drop_exactly_fn | drop_exactly {}
constexpr drop_while_fn | drop_while {}
constexpr detail::span_index_t | ranges::dynamic_extent = -1
template<typename Rng >
constexpr bool | ranges::enable_borrowed_range< chunk_view< Rng > >
template<typename From , typename To >
constexpr bool | ranges::enable_borrowed_range< closed_iota_view< From, To > >
template<typename Rng , bool B>
constexpr bool | ranges::enable_borrowed_range< common_view< Rng, B > >
template<typename Rng >
constexpr bool | ranges::enable_borrowed_range< const_view< Rng > >
template<typename I >
constexpr bool | ranges::enable_borrowed_range< counted_view< I > > = true
template<typename Rng , typename Val >
constexpr bool | ranges::enable_borrowed_range< delimit_view< Rng, Val > >
template<typename Rng >
constexpr bool | ranges::enable_borrowed_range< drop_exactly_view< Rng > >
template<typename Rng , typename T >
constexpr bool | ranges::enable_borrowed_range< drop_last_view< Rng, T > >
template<typename Rng >
constexpr bool | ranges::enable_borrowed_range< drop_view< Rng > >
template<typename Rng , typename Pred >
constexpr bool | ranges::enable_borrowed_range< drop_while_view< Rng, Pred > >
template<typename T >
constexpr bool | ranges::enable_borrowed_range< empty_view< T > > = true
template<typename Rng >
constexpr bool | ranges::enable_borrowed_range< indirect_view< Rng > >
template<typename Rng >
constexpr bool | ranges::enable_borrowed_range< intersperse_view< Rng > >
template<typename From , typename To >
constexpr bool | ranges::enable_borrowed_range< iota_view< From, To > > = true
template<typename Rng >
constexpr bool | ranges::enable_borrowed_range< keys_range_view< Rng > >
template<typename Rng >
constexpr bool | ranges::enable_borrowed_range< move_view< Rng > >
template<typename Rng >
constexpr bool | ranges::enable_borrowed_range< reverse_view< Rng > >
template<typename Rng >
constexpr bool | ranges::enable_borrowed_range< slice_view< Rng > >
template<typename Rng >
constexpr bool | ranges::enable_borrowed_range< sliding_view< Rng > >
template<typename T , detail::span_index_t N>
constexpr bool | ranges::enable_borrowed_range< span< T, N > > = true
template<typename I , typename S , subrange_kind K>
constexpr bool | ranges::enable_borrowed_range< subrange< I, S, K > > = true
template<typename Rng >
constexpr bool | ranges::enable_borrowed_range< tail_view< Rng > >
template<typename Rng >
constexpr bool | ranges::enable_borrowed_range< take_view< Rng > >
template<typename Rng , typename Pred >
constexpr bool | ranges::enable_borrowed_range< trim_view< Rng, Pred > >
template<typename I >
constexpr bool | ranges::enable_borrowed_range< unbounded_view< I > > = true
template<typename Rng >
constexpr bool | ranges::enable_borrowed_range< values_view< Rng > >
template<typename... Rng>
constexpr bool | ranges::enable_borrowed_range< zip_view< Rng... > >
constexpr view_closure< enumerate_fn > | enumerate {}
constexpr exclusive_scan_fn | exclusive_scan {}
static constexpr index_type | ranges::span< T, N >::extent = N
constexpr filter_fn | filter {}
constexpr generate_fn | generate {}
constexpr generate_n_fn | generate_n {}
constexpr getlines_fn | ranges::getlines {}
constexpr group_by_fn | group_by {}
constexpr indices_fn | indices {}
constexpr view_closure< indirect_fn > | indirect {}
constexpr intersperse_fn | intersperse {}
constexpr ints_fn | ints {}
template<typename ViewFn , typename Rng >
concept | ranges::invocable_view_closure
template<typename ViewFn , typename Rng >
concept | ranges::invocable_view_closure__concept_ = !derived_from<invoke_result_t<ViewFn, Rng>, detail::view_closure_base_>
constexpr iota_fn | iota {}
constexpr iter_take_while_fn | iter_take_while {}
constexpr iter_transform_fn | iter_transform {}
constexpr iter_zip_with_fn | iter_zip_with {}
constexpr view_closure< join_fn > | join {}
constexpr view_closure< keys_fn > | keys {}
constexpr lazy_yield_if_fn | lazy_yield_if {}
constexpr linear_distribute_fn | linear_distribute {}
constexpr make_subrange_fn | make_subrange {}
constexpr make_view_closure_fn | ranges::make_view_closure {}
constexpr view_closure< move_fn > | move {}
constexpr view_closure< partial_sum_fn > | partial_sum {}
constexpr ref_fn | ref {}
constexpr remove_fn | remove {}
constexpr remove_if_fn | remove_if {}
constexpr repeat_fn | repeat {}
constexpr repeat_n_fn | repeat_n {}
constexpr replace_fn | replace {}
constexpr replace_if_fn | replace_if {}
constexpr view_closure< reverse_fn > | reverse {}
constexpr sample_fn | sample {}
constexpr shared_closure< shared_fn > | shared {}
template<typename Rng >
concept | ranges::simple_view_
template<typename Rng >
concept | ranges::simple_view_impl__concept_ = same_as<iterator_t<Rng>, iterator_t<Rng const>> && same_as<sentinel_t<Rng>, sentinel_t<Rng const>>
constexpr single_fn | single {}
constexpr slice_fn | slice {}
constexpr sliding_fn | sliding {}
constexpr split_fn | split {}
constexpr split_when_fn | split_when {}
constexpr stride_fn | stride {}
constexpr view_closure< tail_fn > | tail {}
constexpr take_exactly_fn | take_exactly {}
constexpr take_while_fn | take_while {}
constexpr tokenize_fn | tokenize {}
constexpr transform_fn | transform {}
constexpr trim_fn | trim {}
constexpr unbounded_fn | unbounded {}
constexpr view_closure< unique_fn > | unique {}
constexpr view_closure< values_fn > | values {}
constexpr yield_fn | yield {}
constexpr yield_from_fn | yield_from {}
constexpr yield_if_fn | yield_if {}
constexpr zip_fn | zip {}
constexpr zip_with_fn | zip_with {}

## Typedef Documentation

## ◆ ref_view

template<typename Rng >

using ranges::cpp20::ref_view = typedef ranges::ref_view<Rng>

`#include <range/v3/view/ref.hpp>`

Precondition
  requires `std::is_object<Rng>::value` //

## Function Documentation

## ◆ adjacent_filter_view()

template<typename Rng , typename Fun >

ranges::adjacent_filter_view | ( | Rng && | ,
|  | Fun |
| ) |  | -> adjacent_filter_view< views::all_t< Rng >, Fun >

`#include <range/v3/view/adjacent_filter.hpp>`

Precondition
  requires `copy_constructible<Rng>`

## ◆ adjacent_remove_if_view()

template<typename Rng , typename Fun >

ranges::adjacent_remove_if_view | ( | Rng && | ,
|  | Fun |
| ) |  | -> adjacent_remove_if_view< views::all_t< Rng >, Fun >

`#include <range/v3/view/adjacent_remove_if.hpp>`

Precondition
  requires `copy_constructible<Rng>`

## ◆ closed_iota_view()

template<typename From , typename To >

ranges::closed_iota_view | ( | From | ,
|  | To |
| ) |  | -> closed_iota_view< From, To >

`#include <range/v3/view/iota.hpp>`

Precondition
  requires `weakly_incrementable<From> && semiregular<To> && (!integral<From> || !integral<To> || std::is_signed<From>::value == std::is_signed<To>::value)` //

## ◆ common_view()

template<typename Rng >

ranges::common_view | ( | Rng && |  | ) | -> common_view< views::all_t< Rng >>

`#include <range/v3/view/common.hpp>`

Precondition
  requires `(!common_range<Rng>)` //

## ◆ cursor_adaptor()

template<typename Rng >
template<bool Const>
template<bool Other>

ranges::intersperse_view< Rng >::cursor_adaptor< Const >::cursor_adaptor | ( | cursor_adaptor< Other > | that | ) |

`#include <range/v3/view/intersperse.hpp>`

Precondition
  requires `Const && (!(Other))` //

## ◆ delimit_view()

template<typename Rng , typename Val >

ranges::delimit_view | ( | Rng && | ,
|  | Val |
| ) |  | -> delimit_view< views::all_t< Rng >, Val >

`#include <range/v3/view/delimit.hpp>`

Precondition
  requires `copy_constructible<Val>`

## ◆ drop_while_view()

template<typename Rng , typename Fun >

ranges::drop_while_view | ( | Rng && | ,
|  | Fun |
| ) |  | -> drop_while_view< views::all_t< Rng >, Fun >

`#include <range/v3/view/drop_while.hpp>`

Precondition
  requires `copy_constructible<Fun>`

## ◆ exclusive_scan_view()

template<typename Rng , typename T , typename Fun >

ranges::exclusive_scan_view | ( | Rng && | ,
|  | T | ,
|  | Fun |
| ) |  | -> exclusive_scan_view< views::all_t< Rng >, T, Fun >

`#include <range/v3/view/exclusive_scan.hpp>`

Precondition
  requires `copy_constructible<T> && copy_constructible<Fun>`

## ◆ filter_view()

template<typename Rng , typename Pred >

ranges::filter_view | ( | Rng && | ,
|  | Pred |
| ) |  | -> filter_view< views::all_t< Rng >, Pred >

`#include <range/v3/view/filter.hpp>`

Precondition
  requires `input_range<Rng> && indirect_unary_predicate<Pred, iterator_t<Rng>> && view_<Rng> && std::is_object<Pred>::value` //

## ◆ group_by_view()

template<typename Rng , typename Fun >

ranges::group_by_view | ( | Rng && | ,
|  | Fun |
| ) |  | -> group_by_view< views::all_t< Rng >, Fun >

`#include <range/v3/view/group_by.hpp>`

Precondition
  requires `copy_constructible<Fun>`

References ranges::begin, and ranges::end.

## ◆ iota_view()

template<typename From , typename To >

ranges::iota_view | ( | From | ,
|  | To |
| ) |  | -> iota_view< From, To >

`#include <range/v3/view/iota.hpp>`

Precondition
  requires `weakly_incrementable<From> && semiregular<To> && (!integral<From> || !integral<To> || std::is_signed<From>::value == std::is_signed<To>::value)` //

## ◆ istream()

template<typename Val >

istream_view<Val> ranges::istream | ( | std::istream & | sin | ) |

`#include <range/v3/view/istream.hpp>`

Precondition
  requires `copy_constructible<Val> && default_constructible<Val>`

## ◆ make_span()

template<typename Rng >

constexpr span<detail::element_t<Rng> > ranges::make_span | ( | Rng && | rng | ) |
| constexpr noexcept

`#include <range/v3/view/span.hpp>`

Precondition
  requires `contiguous_range<Rng> && (range_cardinality<Rng>::value < cardinality())` //

## ◆ operator()() [1/7]

template<typename Char >

ranges::delimit_view< ranges::subrange<Char *, ranges::unreachable_sentinel_t>, meta::_t<std::remove_cv<Char> > > ranges::views::c_str_fn::operator() | ( | Char * | sz | ) | const volatile

`#include <range/v3/view/c_str.hpp>`

Precondition
  requires `detail::is_char_type<Char>::value` //

## ◆ operator()() [2/7]

template<typename Char , std::size_t N>

ranges::subrange<Char *> ranges::views::c_str_fn::operator() | ( | Char(&) | sz[N] | ) | const

`#include <range/v3/view/c_str.hpp>`

Precondition
  requires `detail::is_char_type<Char>::value` //

## ◆ operator()() [3/7]

template<typename G >

generate_view<G> ranges::views::generate_fn::operator() | ( | G | g | ) | const

`#include <range/v3/view/generate.hpp>`

Precondition
  requires `invocable<G &> && copy_constructible<G> && std::is_object<detail::decay_t<invoke_result_t<G &>>>::value && constructible_from<detail::decay_t<invoke_result_t<G &>>, invoke_result_t<G &>> && assignable_from<detail::decay_t<invoke_result_t<G &>> &, invoke_result_t<G &>>`

## ◆ operator()() [4/7]

template<typename Rng >

constexpr intersperse_view<all_t<Rng> > ranges::views::intersperse_base_fn::operator() | ( | Rng && | rng,
|  | range_value_t< Rng > | val
| ) |  | const
| constexpr

`#include <range/v3/view/intersperse.hpp>`

Precondition
  requires `viewable_range<Rng> && input_range<Rng> && convertible_to<range_reference_t<Rng>, range_value_t<Rng>> && semiregular<range_value_t<Rng>>`

## ◆ operator()() [5/7]

template<typename Rng >

constexpr ref_view<Rng> ranges::views::ref_fn::operator() | ( | Rng & | rng | ) | const
| constexpr noexcept

`#include <range/v3/view/ref.hpp>`

Precondition
  requires `range<Rng>`

## ◆ operator()() [6/7]

template<typename T >

constexpr auto ranges::views::linear_distribute_fn::operator() | ( | T | from,
|  | T | to,
|  | std::ptrdiff_t | n
| ) |  | const
| constexpr

`#include <range/v3/view/linear_distribute.hpp>`

Precondition
  requires `std::is_arithmetic<T>::value`

## ◆ operator()() [7/7]

template<typename T >

constexpr auto ranges::views::intersperse_fn::operator() | ( | T | t | ) | const
| constexpr

`#include <range/v3/view/intersperse.hpp>`

Precondition
  requires `copyable<T>`

## ◆ partial_sum_view()

template<typename Rng , typename Fun >

ranges::partial_sum_view | ( | Rng && | ,
|  | Fun |
| ) |  | -> partial_sum_view< views::all_t< Rng >, Fun >

`#include <range/v3/view/partial_sum.hpp>`

Precondition
  requires `copy_constructible<Fun>`

## ◆ ref_view()

template<typename R >

ranges::ref_view | ( | R & |  | ) | -> ref_view< R >

`#include <range/v3/view/ref.hpp>`

Precondition
  requires `range<R>`

## ◆ remove_if_view()

template<typename Rng , typename Pred >

ranges::remove_if_view | ( | Rng && | ,
|  | Pred |
| ) |  | -> remove_if_view< views::all_t< Rng >, Pred >

`#include <range/v3/view/remove_if.hpp>`

Precondition
  requires `copy_constructible<Pred>`

## ◆ sentinel_adaptor()

template<typename Rng >
template<bool Const>
template<bool Other>

ranges::intersperse_view< Rng >::sentinel_adaptor< Const >::sentinel_adaptor | ( | sentinel_adaptor< Other > |  | ) |

`#include <range/v3/view/intersperse.hpp>`

Precondition
  requires `Const && (!(Other))` //

## ◆ size()

template<typename Rng >

constexpr auto ranges::intersperse_view< Rng >::size | ( |  | ) |
| constexpr

`#include <range/v3/view/intersperse.hpp>`

Precondition
  requires `sized_range<Rng>`

## ◆ span()

template<typename Rng >

ranges::span | ( | Rng && | rng | ) | -> span< detail::element_t< Rng >,(range_cardinality< Rng >::value< cardinality() ? dynamic_extent :static_cast< detail::span_index_t >(range_cardinality< Rng >::value))>

`#include <range/v3/view/span.hpp>`

Precondition
  requires `contiguous_range<Rng>`

## ◆ split_view() [1/2]

template<typename R , typename P >

ranges::split_view | ( | R && | ,
|  | P && |
| ) |  | -> split_view< views::all_t< R >, views::all_t< P >>

`#include <range/v3/view/split.hpp>`

Precondition
  requires `input_range<R> && forward_range<P> && viewable_range<R> && viewable_range<P> && indirectly_comparable<iterator_t<R>, iterator_t<P>, ranges::equal_to> && (forward_range<R> || detail::tiny_range<P>)` //

References ranges::end.

## ◆ split_view() [2/2]

template<typename R >

ranges::split_view | ( | R && | ,
|  | range_value_t< R > |
| ) |  | -> split_view< views::all_t< R >, single_view< range_value_t< R >>>

`#include <range/v3/view/split.hpp>`

Precondition
  requires `input_range<R>`

## ◆ split_when_view()

template<typename Rng , typename Fun >

ranges::split_when_view | ( | Rng && | ,
|  | Fun |
| ) |  | -> split_when_view< views::all_t< Rng >, Fun >

`#include <range/v3/view/split_when.hpp>`

Precondition
  requires `copy_constructible<Fun>`

## ◆ subrange() [1/3]

template<typename I , typename S >

ranges::subrange | ( | I | ,
|  | S | ,
|  | detail::iter_size_t< I > |
| ) |  | -> subrange< I, S, subrange_kind::sized >

`#include <range/v3/view/subrange.hpp>`

Precondition
  requires `input_or_output_iterator<I> && sentinel_for<S, I>`

## ◆ subrange() [2/3]

template<typename R >

ranges::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 >

`#include <range/v3/view/subrange.hpp>`

Precondition
  requires `borrowed_range<R>`

## ◆ subrange() [3/3]

template<typename R >

ranges::subrange | ( | R && | ,
|  | detail::iter_size_t< iterator_t< R >> |
| ) |  | -> subrange< iterator_t< R >, sentinel_t< R >, subrange_kind::sized >

`#include <range/v3/view/subrange.hpp>`

Precondition
  requires `borrowed_range<R>`

## ◆ tail_view()

template<typename Rng >

ranges::tail_view | ( | Rng && |  | ) | -> tail_view< views::all_t< Rng >>

`#include <range/v3/view/tail.hpp>`

Precondition
  requires `viewable_range<Rng>`

## ◆ take_while_view()

template<typename Rng , typename Fun >

ranges::take_while_view | ( | Rng && | ,
|  | Fun |
| ) |  | -> take_while_view< views::all_t< Rng >, Fun >

`#include <range/v3/view/take_while.hpp>`

Precondition
  requires `copy_constructible<Fun>`

References ranges::indirect, and ranges::aux::move.

## ◆ tokenize_view()

template<typename Rng , typename Regex , typename SubMatchRange >

ranges::tokenize_view | ( | Rng && | ,
|  | Regex | ,
|  | SubMatchRange |
| ) |  | -> tokenize_view< views::all_t< Rng >, Regex, SubMatchRange >

`#include <range/v3/view/tokenize.hpp>`

Precondition
  requires `copy_constructible<Regex> && copy_constructible<SubMatchRange>`

## ◆ transform_view()

template<typename Rng , typename Fun >

ranges::transform_view | ( | Rng && | ,
|  | Fun |
| ) |  | -> transform_view< views::all_t< Rng >, Fun >

`#include <range/v3/view/transform.hpp>`

Precondition
  requires `copy_constructible<Fun>`

## ◆ zip_with_view()

template<typename Fun , typename... Rng>

ranges::zip_with_view | ( | Fun | ,
|  | Rng && | ...
| ) |  | -> zip_with_view< Fun, views::all_t< Rng >... >

`#include <range/v3/view/zip_with.hpp>`

Precondition
  requires `copy_constructible<Fun>`

References ranges::aux::move.

## Variable Documentation

## ◆ cartesian_produce_view_can_bidi

template<typename IsConst , typename... Views>

concept ranges::cartesian_produce_view_can_bidi

`#include <range/v3/view/cartesian_product.hpp>`

Initial value:
=
cartesian_produce_view_can_random<IsConst, Views...> ||
ranges::cartesian_produce_view_can_bidi__concept_<IsConst, Views...>

## ◆ cartesian_produce_view_can_const

template<typename... Views>

concept ranges::cartesian_produce_view_can_const

`#include <range/v3/view/cartesian_product.hpp>`

Initial value:
=
and_v<range<Views const>...>

## ◆ cartesian_produce_view_can_distance

template<typename IsConst , typename... Views>

concept ranges::cartesian_produce_view_can_distance

`#include <range/v3/view/cartesian_product.hpp>`

Initial value:
=
cartesian_produce_view_can_size<IsConst, Views...> &&
ranges::cartesian_produce_view_can_distance__concept_<IsConst, Views...>

## ◆ cartesian_produce_view_can_random

template<typename IsConst , typename... Views>

concept ranges::cartesian_produce_view_can_random

`#include <range/v3/view/cartesian_product.hpp>`

Initial value:
=
cartesian_produce_view_can_distance<IsConst, Views...> &&
ranges::cartesian_produce_view_can_random__concept_<IsConst, Views...>

## ◆ cartesian_produce_view_can_size

template<typename IsConst , typename... Views>

concept ranges::cartesian_produce_view_can_size

`#include <range/v3/view/cartesian_product.hpp>`

Initial value:
=
and_v<sized_range<meta::const_if<IsConst, Views>>...> &&
ranges::cartesian_produce_view_can_size__concept_<IsConst, Views...>

## ◆ disable_sized_range< drop_while_view< Rng, Pred > >

template<typename Rng , typename Pred >

constexpr bool ranges::disable_sized_range< drop_while_view< Rng, Pred > >
| constexpr

`#include <range/v3/view/drop_while.hpp>`

Initial value:
=
true

## ◆ enable_borrowed_range< chunk_view< Rng > >

template<typename Rng >

constexpr bool ranges::enable_borrowed_range< chunk_view< Rng > >
| constexpr

`#include <range/v3/view/chunk.hpp>`

Initial value:
=
enable_borrowed_range<Rng> && forward_range<Rng>

## ◆ enable_borrowed_range< closed_iota_view< From, To > >

template<typename From , typename To >

constexpr bool ranges::enable_borrowed_range< closed_iota_view< From, To > >
| constexpr

`#include <range/v3/view/iota.hpp>`

Initial value:
=
true

## ◆ enable_borrowed_range< common_view< Rng, B > >

template<typename Rng , bool B>

constexpr bool ranges::enable_borrowed_range< common_view< Rng, B > >
| constexpr

`#include <range/v3/view/common.hpp>`

Initial value:
=
enable_borrowed_range<Rng>

## ◆ enable_borrowed_range< const_view< Rng > >

template<typename Rng >

constexpr bool ranges::enable_borrowed_range< const_view< Rng > >
| constexpr

`#include <range/v3/view/const.hpp>`

Initial value:
=
enable_borrowed_range<Rng>

## ◆ enable_borrowed_range< delimit_view< Rng, Val > >

template<typename Rng , typename Val >

constexpr bool ranges::enable_borrowed_range< delimit_view< Rng, Val > >
| constexpr

`#include <range/v3/view/delimit.hpp>`

Initial value:
=
enable_borrowed_range<Rng>

## ◆ enable_borrowed_range< drop_exactly_view< Rng > >

template<typename Rng >

constexpr bool ranges::enable_borrowed_range< drop_exactly_view< Rng > >
| constexpr

`#include <range/v3/view/drop_exactly.hpp>`

Initial value:
=
enable_borrowed_range<Rng>

## ◆ enable_borrowed_range< drop_last_view< Rng, T > >

template<typename Rng , typename T >

constexpr bool ranges::enable_borrowed_range< drop_last_view< Rng, T > >
| constexpr

`#include <range/v3/view/drop_last.hpp>`

Initial value:
=
enable_borrowed_range<Rng>

## ◆ enable_borrowed_range< drop_view< Rng > >

template<typename Rng >

constexpr bool ranges::enable_borrowed_range< drop_view< Rng > >
| constexpr

`#include <range/v3/view/drop.hpp>`

Initial value:
=
enable_borrowed_range<Rng>

## ◆ enable_borrowed_range< drop_while_view< Rng, Pred > >

template<typename Rng , typename Pred >

constexpr bool ranges::enable_borrowed_range< drop_while_view< Rng, Pred > >
| constexpr

`#include <range/v3/view/drop_while.hpp>`

Initial value:
=
enable_borrowed_range<Rng>

## ◆ enable_borrowed_range< indirect_view< Rng > >

template<typename Rng >

constexpr bool ranges::enable_borrowed_range< indirect_view< Rng > >
| constexpr

`#include <range/v3/view/indirect.hpp>`

Initial value:
=
enable_borrowed_range<Rng>

## ◆ enable_borrowed_range< intersperse_view< Rng > >

template<typename Rng >

constexpr bool ranges::enable_borrowed_range< intersperse_view< Rng > >
| constexpr

`#include <range/v3/view/intersperse.hpp>`

Initial value:
=
enable_borrowed_range<Rng>

## ◆ enable_borrowed_range< keys_range_view< Rng > >

template<typename Rng >

constexpr bool ranges::enable_borrowed_range< keys_range_view< Rng > >
| constexpr

`#include <range/v3/view/map.hpp>`

Initial value:
=
enable_borrowed_range<Rng>

## ◆ enable_borrowed_range< move_view< Rng > >

template<typename Rng >

constexpr bool ranges::enable_borrowed_range< move_view< Rng > >
| constexpr

`#include <range/v3/view/move.hpp>`

Initial value:
=
enable_borrowed_range<Rng>

## ◆ enable_borrowed_range< reverse_view< Rng > >

template<typename Rng >

constexpr bool ranges::enable_borrowed_range< reverse_view< Rng > >
| constexpr

`#include <range/v3/view/reverse.hpp>`

Initial value:
=
enable_borrowed_range<Rng>

## ◆ enable_borrowed_range< slice_view< Rng > >

template<typename Rng >

constexpr bool ranges::enable_borrowed_range< slice_view< Rng > >
| constexpr

`#include <range/v3/view/slice.hpp>`

Initial value:
=
enable_borrowed_range<Rng>

## ◆ enable_borrowed_range< sliding_view< Rng > >

template<typename Rng >

constexpr bool ranges::enable_borrowed_range< sliding_view< Rng > >
| constexpr

`#include <range/v3/view/sliding.hpp>`

Initial value:
=
enable_borrowed_range<Rng>

## ◆ enable_borrowed_range< tail_view< Rng > >

template<typename Rng >

constexpr bool ranges::enable_borrowed_range< tail_view< Rng > >
| constexpr

`#include <range/v3/view/tail.hpp>`

Initial value:
=
enable_borrowed_range<Rng>

## ◆ enable_borrowed_range< take_view< Rng > >

template<typename Rng >

constexpr bool ranges::enable_borrowed_range< take_view< Rng > >
| constexpr

`#include <range/v3/view/take.hpp>`

Initial value:
=
enable_borrowed_range<Rng>

## ◆ enable_borrowed_range< trim_view< Rng, Pred > >

template<typename Rng , typename Pred >

constexpr bool ranges::enable_borrowed_range< trim_view< Rng, Pred > >
| constexpr

`#include <range/v3/view/trim.hpp>`

Initial value:
=
enable_borrowed_range<Rng>

## ◆ enable_borrowed_range< values_view< Rng > >

template<typename Rng >

constexpr bool ranges::enable_borrowed_range< values_view< Rng > >
| constexpr

`#include <range/v3/view/map.hpp>`

Initial value:
=
enable_borrowed_range<Rng>

## ◆ enable_borrowed_range< zip_view< Rng... > >

template<typename... Rng>

constexpr bool ranges::enable_borrowed_range< zip_view< Rng... > >
| constexpr

`#include <range/v3/view/zip.hpp>`

Initial value:
=
and_v<enable_borrowed_range<Rng>...>

## ◆ invocable_view_closure

template<typename ViewFn , typename Rng >

concept ranges::invocable_view_closure

`#include <range/v3/view/view.hpp>`

Initial value:
=
invocable<ViewFn, Rng> &&
ranges::invocable_view_closure__concept_<ViewFn, Rng>

## ◆ make_view_closure

constexpr make_view_closure_fn ranges::make_view_closure {}
| constexpr

`#include <range/v3/view/view.hpp>`

See also
  make_view_closure_fn

Referenced by ranges::join_with_view(), ranges::views::remove_bind_fn::operator()(), ranges::views::drop_while_bind_fn::operator()(), ranges::views::trim_bind_fn::operator()(), ranges::views::take_while_bind_fn::operator()(), and ranges::views::remove_if_bind_fn::operator()().

## ◆ simple_view_

template<typename Rng >

concept ranges::simple_view_

`#include <range/v3/view/view.hpp>`

Initial value:
=
view_<Rng> &&
range<Rng const> &&
ranges::simple_view_impl__concept_<Rng>