Views

## Description

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

## Classes

struct | boost::range_const_iterator< ::ranges::v3::generate_view< Ts... >, ::meta::if_c<(bool)::ranges::BoundedRange< ::ranges::v3::generate_view< Ts... > const >()> >
struct | boost::range_const_iterator< ::ranges::v3::intersperse_view< Ts... >, ::meta::if_c<(bool)::ranges::BoundedRange< ::ranges::v3::intersperse_view< Ts... > const >()> >
struct | boost::range_mutable_iterator< ::ranges::v3::generate_view< Ts... >, ::meta::if_c<(bool)::ranges::BoundedRange< ::ranges::v3::generate_view< Ts... > >()> >
struct | boost::range_mutable_iterator< ::ranges::v3::intersperse_view< Ts... >, ::meta::if_c<(bool)::ranges::BoundedRange< ::ranges::v3::intersperse_view< Ts... > >()> >
struct | boost::range_size< ::ranges::v3::generate_view< Ts... > >
struct | boost::range_size< ::ranges::v3::generate_view< Ts... > const >
struct | boost::range_size< ::ranges::v3::intersperse_view< Ts... > >
struct | boost::range_size< ::ranges::v3::intersperse_view< Ts... > const >
struct | boost::range_value< ::ranges::v3::generate_view< Ts... > >
struct | boost::range_value< ::ranges::v3::intersperse_view< Ts... > >
struct | ranges::v3::adjacent_filter_view< Rng, Pred >
struct | ranges::v3::adjacent_remove_if_view< Rng, Pred >
struct | ranges::v3::any_view< Ref, Cat, enable >
| A type-erased view. More...
struct | ranges::v3::bounded_view< Rng >
struct | ranges::v3::chunk_view< Rng, bool >
struct | ranges::v3::chunk_view< Rng, false >
struct | ranges::v3::closed_iota_view< From, To >
| An iota view in a closed range with non-random access iota value type. More...
struct | ranges::v3::concat_view< Rngs >
struct | ranges::v3::const_view< Rng >
struct | ranges::v3::counted_view< I >
struct | ranges::v3::cycled_view< Rng >
struct | ranges::v3::delimit_view< Rng, Val >
struct | ranges::v3::drop_exactly_view< Rng >
struct | ranges::v3::drop_view< Rng >
struct | ranges::v3::drop_while_view< Rng, Pred >
struct | ranges::v3::generate_n_view< G >
struct | ranges::v3::generate_view< G >
struct | ranges::v3::group_by_view< Rng, Fun >
struct | ranges::v3::indirect_view< Rng >
struct | ranges::v3::intersperse_view< Rng >
struct | ranges::v3::iota_view< From, To >
struct | ranges::v3::iota_view< From, void >
struct | ranges::v3::iter_take_while_view< Rng, Pred >
struct | ranges::v3::iter_transform2_view< Rng1, Rng2, Fun >
struct | ranges::v3::iter_transform_view< Rng, Fun >
struct | ranges::v3::iter_zip_with_view< Fun, Rngs >
struct | ranges::v3::join_view< Rng, ValRng >
struct | ranges::v3::join_view< Rng, void >
struct | ranges::v3::move_view< Rng >
struct | ranges::v3::partial_sum_view< Rng, Fun >
struct | ranges::v3::remove_if_view< Rng, Pred >
struct | ranges::v3::repeat_n_view< Val >
struct | ranges::v3::repeat_view< Val >
struct | ranges::v3::reverse_view< Rng >
class | ranges::v3::sample_view< Rng, URNG >
struct | ranges::v3::single_view< Val >
struct | ranges::v3::slice_view< Rng >
struct | ranges::v3::sliding_view< Rng, sliding_view_detail::cache::first >
struct | ranges::v3::sliding_view< Rng, sliding_view_detail::cache::last >
struct | ranges::v3::sliding_view< Rng, sliding_view_detail::cache::none >
struct | ranges::v3::split_view< Rng, Fun >
struct | ranges::v3::stride_view< Rng >
struct | ranges::v3::tail_view< Rng >
struct | ranges::v3::take_while_view< Rng, Pred >
struct | ranges::v3::tokenize_view< Rng, Regex, SubMatchRange >
struct | ranges::v3::transform2_view< Rng1, Rng2, Fun >
struct | ranges::v3::transform_view< Rng, Fun >
struct | ranges::v3::unbounded_view< I >
struct | ranges::v3::view::c_str_fn
| View a `\0`-terminated C string (e.g. from a const char*) as a range. More...
struct | ranges::v3::view::generate_fn
struct | ranges::v3::view::intersperse_fn
struct | ranges::v3::view::linear_distribute_fn
| Distributes `n` values linearly in the closed interval [`from`, `to`]. More...
struct | ranges::v3::view::linear_distribute_view< T >
struct | ranges::v3::view::make_view_fn
struct | ranges::v3::view::view< View >
struct | ranges::v3::view::view_access
struct | ranges::v3::view::view_access::impl< View >
struct | ranges::v3::zip_view< Rngs >
struct | ranges::v3::zip_with_view< Fun, Rngs >

## Typedefs

template<typename G >
using | ranges::v3::view::generate_fn::Concept = meta::and_< Invocable< G & >, MoveConstructible< G >, std::is_object< detail::decay_t< result_of_t< G &()> >>, Constructible< detail::decay_t< result_of_t< G &()> >, result_of_t< G &()> >, Assignable< detail::decay_t< result_of_t< G &()> > &, result_of_t< G &()> >>
template<typename Rng , typename T = range_value_type_t<Rng>>
using | ranges::v3::view::intersperse_fn::Constraint = meta::and_< InputRange< Rng >, ConvertibleTo< T, range_value_type_t< Rng > >, ConvertibleTo< range_reference_t< Rng >, range_value_type_t< Rng > >, SemiRegular< range_value_type_t< Rng > >>
template<typename Rng >
using | ranges::v3::take_exactly_view = detail::take_exactly_view_< Rng >
using | boost::range_const_iterator< ::ranges::v3::generate_view< Ts... >, ::meta::if_c<(bool)::ranges::BoundedRange< ::ranges::v3::generate_view< Ts... > const >()> >::type = ::ranges::iterator_t< ::ranges::v3::generate_view< Ts... > const >
using | boost::range_value< ::ranges::v3::generate_view< Ts... > >::type = ::ranges::range_value_type_t< ::ranges::v3::generate_view< Ts... > >
using | boost::range_mutable_iterator< ::ranges::v3::generate_view< Ts... >, ::meta::if_c<(bool)::ranges::BoundedRange< ::ranges::v3::generate_view< Ts... > >()> >::type = ::ranges::iterator_t< ::ranges::v3::generate_view< Ts... > >
using | boost::range_const_iterator< ::ranges::v3::intersperse_view< Ts... >, ::meta::if_c<(bool)::ranges::BoundedRange< ::ranges::v3::intersperse_view< Ts... > const >()> >::type = ::ranges::iterator_t< ::ranges::v3::intersperse_view< Ts... > const >
using | boost::range_value< ::ranges::v3::intersperse_view< Ts... > >::type = ::ranges::range_value_type_t< ::ranges::v3::intersperse_view< Ts... > >
using | boost::range_mutable_iterator< ::ranges::v3::intersperse_view< Ts... >, ::meta::if_c<(bool)::ranges::BoundedRange< ::ranges::v3::intersperse_view< Ts... > >()> >::type = ::ranges::iterator_t< ::ranges::v3::intersperse_view< Ts... > >
template<typename Rng >
using | ranges::v3::view::ViewableRange = meta::and_< Range< Rng >, meta::or_< std::is_lvalue_reference< Rng >, View< uncvref_t< Rng > >> >

## Functions

void | ranges::v3::intersperse_view< Rng >::cursor_adaptor::advance (iterator_t< Rng > &it, range_difference_type_t< Rng > n) noexcept(noexcept(ranges::advance(it, n)))
template<typename View >
iterator_t< Rng > | ranges::v3::intersperse_view< Rng >::cursor_adaptor::begin (View &view) noexcept(std::is_nothrow_move_constructible< iterator_t< Rng >>::value &&noexcept(ranges::begin(view.base()) !=ranges::end(view.base())))
template<typename... Ts, typename V = View>
static auto | ranges::v3::view::view_access::impl< View >::bind (Ts &&...ts) -> decltype(V::bind(static_cast< Ts &&>(ts)...))
result_t & | ranges::v3::generate_view< G >::cached ()
| ranges::v3::generate_view< G >::cursor::cursor (generate_view &view)
constexpr | ranges::v3::intersperse_view< Rng >::cursor_adaptor::cursor_adaptor (intersperse_view const &view) noexcept(std::is_nothrow_copy_constructible< range_value_type_t< Rng >>::value)
constexpr range_difference_type_t< Rng > | ranges::v3::intersperse_view< Rng >::cursor_adaptor::distance_to (iterator_t< Rng > const &it, iterator_t< Rng > const &other_it, cursor_adaptor const &other) const noexcept(noexcept(other_it - it))
static constexpr bool | ranges::v3::intersperse_view< Rng >::sentinel_adaptor::empty (iterator_t< Rng > const &it, cursor_adaptor const &, sentinel_t< Rng > const &sent) noexcept(noexcept(decltype(it==sent)(it==sent)))
constexpr bool | ranges::v3::intersperse_view< Rng >::cursor_adaptor::equal (iterator_t< Rng > const &it0, iterator_t< Rng > const &it1, cursor_adaptor const &other) const noexcept(noexcept(it0==it1))
| ranges::v3::generate_view< G >::generate_view (G g)
constexpr | ranges::v3::intersperse_view< Rng >::intersperse_view (Rng rng, range_value_type_t< Rng > val) noexcept(std::is_nothrow_constructible< typename intersperse_view::view_adaptor, Rng >::value &&std::is_nothrow_move_constructible< range_value_type_t< Rng >>::value)
| ranges::v3::view::linear_distribute_view< T >::linear_distribute_view (T from, T to__, std::ptrdiff_t n) noexcept
void | ranges::v3::generate_view< G >::cursor::next ()
void | ranges::v3::intersperse_view< Rng >::cursor_adaptor::next (iterator_t< Rng > &it) noexcept(noexcept(++it))
template<typename Fun >
view< Fun > | ranges::v3::view::make_view_fn::operator() (Fun fun) const
template<typename Char , std::size_t N, requires = (detail::is_char_type<Char>())>
ranges::iterator_range< Char * > | ranges::v3::view::c_str_fn::operator() (Char(&sz)[N]) const
template<typename Char , requires = (detail::is_char_type<Char>())>
ranges::delimit_view< ranges::iterator_range< Char *, ranges::unreachable >, meta::_t< std::remove_cv< Char > > > | ranges::v3::view::c_str_fn::operator() (Char *sz) const volatile
template<typename T , requires = (std::is_arithmetic<T>())>
constexpr auto | ranges::v3::view::linear_distribute_fn::operator() (T from, T to, std::ptrdiff_t n) const noexcept(noexcept(decltype(linear_distribute_view< T >{from, to, n})(linear_distribute_view< T >{from, to, n}))) -> decltype(linear_distribute_view< T >
template<typename G , requires = (Concept<G>())>
generate_view< G > | ranges::v3::view::generate_fn::operator() (G g) const
template<typename Rng , typename... Rest, requires = (ViewConcept<Rng, Rest...>())>
auto | ranges::v3::view::view< View >::operator() (Rng &&rng, Rest &&... rest) const -> decltype(view_(static_cast< Rng &&>(rng), static_cast< Rest &&>(rest)...))
template<typename... Ts, typename V = View>
auto | ranges::v3::view::view< View >::operator() (Ts &&... ts) const -> decltype(make_view(view_access::impl< V >::bind(view_, static_cast< Ts &&>(ts)...)))
template<typename Rng , requires = (Constraint<Rng>())>
constexpr auto | ranges::v3::view::intersperse_fn::operator() (Rng &&rng, range_value_type_t< Rng > val) const noexcept(noexcept(decltype(intersperse_view< all_t< Rng >>{all(static_cast< Rng &&>(rng)), std::move(val)})(intersperse_view< all_t< Rng >>{all(static_cast< Rng &&>(rng)), std::move(val)}))) -> decltype(intersperse_view< all_t< Rng >>
void | ranges::v3::intersperse_view< Rng >::cursor_adaptor::prev (iterator_t< Rng > &it) noexcept(noexcept(--it))
result_t | ranges::v3::generate_view< G >::cursor::read () const
constexpr range_value_type_t< Rng > | ranges::v3::intersperse_view< Rng >::cursor_adaptor::read (iterator_t< Rng > const &it) const noexcept(noexcept(range_value_type_t< Rng >(*it)) &&std::is_nothrow_copy_constructible< range_value_type_t< Rng >>::value)
constexpr range_size_type_t< Rng > | ranges::v3::intersperse_view< Rng >::size () const noexcept(noexcept(ranges::size(std::declval< Rng const &>())))
range_size_type_t< Rng > | ranges::v3::intersperse_view< Rng >::size () noexcept(noexcept(ranges::size(std::declval< Rng &>())))
constexpr std::size_t | ranges::v3::view::linear_distribute_view< T >::size () const noexcept
| ranges::v3::view::view< View >::view (View a)

## Variables

constexpr view< adjacent_filter_fn > | adjacent_filter {}
constexpr view< adjacent_remove_if_fn > | adjacent_remove_if {}
constexpr all_fn | all {}
constexpr view< bounded_fn > | bounded {}
constexpr c_str_fn | c_str {}
constexpr view< chunk_fn > | chunk {}
constexpr closed_indices_fn | closed_indices {}
constexpr closed_iota_fn | closed_iota {}
constexpr concat_fn | concat {}
constexpr view< const_fn > | const_ {}
constexpr counted_fn | counted {}
constexpr view< cycle_fn > | cycle {}
constexpr delimit_fn | delimit {}
constexpr view< drop_fn > | drop {}
constexpr view< drop_exactly_fn > | drop_exactly {}
constexpr view< drop_while_fn > | drop_while {}
constexpr filter_fn | filter {}
constexpr view< for_each_fn > | for_each {}
constexpr generate_fn | generate {}
constexpr generate_n_fn | generate_n {}
constexpr view< group_by_fn > | group_by {}
constexpr indices_fn | indices {}
constexpr view< indirect_fn > | indirect {}
constexpr view< intersperse_fn > | intersperse {}
constexpr ints_fn | ints {}
constexpr iota_fn | iota {}
constexpr view< iter_take_while_fn > | iter_take_while {}
constexpr view< iter_transform_fn > | iter_transform {}
constexpr iter_zip_with_fn | iter_zip_with {}
constexpr view< join_fn > | join {}
constexpr view< keys_fn > | keys {}
constexpr lazy_yield_if_fn | lazy_yield_if {}
constexpr linear_distribute_fn | linear_distribute {}
constexpr make_view_fn | ranges::v3::view::make_view {}
constexpr view< move_fn > | move {}
constexpr view< partial_sum_fn > | partial_sum {}
constexpr view< remove_if_fn > | remove_if {}
constexpr repeat_fn | repeat {}
constexpr repeat_n_fn | repeat_n {}
constexpr view< replace_fn > | replace {}
constexpr view< replace_if_fn > | replace_if {}
constexpr view< reverse_fn > | reverse {}
constexpr view< sample_fn > | sample {}
constexpr view< set_difference_fn > | set_difference {}
constexpr view< set_intersection_fn > | set_intersection {}
constexpr view< set_symmetric_difference_fn > | set_symmetric_difference {}
constexpr view< set_union_fn > | set_union {}
constexpr shared_fn | shared {}
constexpr single_fn | single {}
constexpr view< slice_fn > | slice {}
constexpr view< sliding_fn > | sliding {}
constexpr view< split_fn > | split {}
constexpr view< stride_fn > | stride {}
constexpr view< tail_fn > | tail {}
constexpr view< take_fn > | take {}
constexpr view< take_exactly_fn > | take_exactly {}
constexpr view< take_while_fn > | take_while {}
constexpr tokenize_fn | tokenize {}
constexpr view< transform_fn > | transform {}
constexpr unbounded_fn | unbounded {}
constexpr view< unique_fn > | unique {}
constexpr view< 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 {}

## Function Documentation

## advance()

template<typename Rng >

void ranges::v3::intersperse_view< Rng >::cursor_adaptor::advance | ( | iterator_t< Rng > & | it,
|  | range_difference_type_t< Rng > | n
| ) |  |

noexcept

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

Precondition
  RandomAccessRange<Rng>()

References ranges::v3::advance, and ranges::v3::view_interface< Derived, Cardinality >::empty().

## distance_to()

template<typename Rng >

constexpr range_difference_type_t<Rng> ranges::v3::intersperse_view< Rng >::cursor_adaptor::distance_to | ( | iterator_t< Rng > const & | it,
|  | iterator_t< Rng > const & | other_it,
|  | cursor_adaptor const & | other
| ) |  | const

noexcept

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

Precondition
  SizedSentinel<iterator_t<Rng> iterator_t<Rng>>())

## equal()

template<typename Rng >

constexpr bool ranges::v3::intersperse_view< Rng >::cursor_adaptor::equal | ( | iterator_t< Rng > const & | it0,
|  | iterator_t< Rng > const & | it1,
|  | cursor_adaptor const & | other
| ) |  | const

noexcept

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

Precondition
  Sentinel<iterator_t<Rng> iterator_t<Rng>>())

References ranges::v3::next.

## prev()

template<typename Rng >

void ranges::v3::intersperse_view< Rng >::cursor_adaptor::prev | ( | iterator_t< Rng > & | it | ) |

noexcept

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

Precondition
  BidirectionalRange<Rng>()

## size() [1/2]

template<typename Rng >

constexpr range_size_type_t<Rng> ranges::v3::intersperse_view< Rng >::size | ( |  | ) | const

noexcept

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

Precondition
  SizedRange<Rng const>()

## size() [2/2]

template<typename Rng >

range_size_type_t<Rng> ranges::v3::intersperse_view< Rng >::size | ( |  | ) |

noexcept

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

Precondition
  !SizedRange<Rng const>="">() && SizedRange<Rng>()

References ranges::v3::view_facade< Derived, Cardinality >::begin(), ranges::v3::begin, and ranges::v3::end.

## Variable Documentation

## make_view

constexpr make_view_fn ranges::v3::view::make_view {}

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

See also
  make_view_fn