Range

Core range functionality. More...

## Modules

| Range Concepts
| Range concepts.

## Classes

struct | ranges::at_fn
| Checked indexed range access. More...
struct | ranges::back_fn
struct | ranges::dangling
| A placeholder for an iterator or a sentinel into a range that may no longer be valid. More...
struct | ranges::front_fn
struct | ranges::index_fn
| Unchecked indexed range access. More...
struct | ranges::range_cardinality< Rng, Void >

## Typedefs

template<typename I , typename S >
using | ranges::common_iterator_t = meta::conditional_t< std::is_same< I, S >::value, I, detail::common_iterator_impl_t< I, S > >
template<typename Rng >
using | ranges::range_common_iterator_t = common_iterator_t< iterator_t< Rng >, sentinel_t< Rng > >
template<typename Rng >
using | ranges::range_common_reference_t = iter_common_reference_t< iterator_t< Rng > >
template<typename Rng >
using | ranges::range_difference_t = iter_difference_t< iterator_t< Rng > >
template<typename Rng >
using | ranges::range_reference_t = iter_reference_t< iterator_t< Rng > >
template<typename Rng >
using | ranges::range_rvalue_reference_t = iter_rvalue_reference_t< iterator_t< Rng > >
template<typename Rng >
using | ranges::range_size_t = decltype(ranges::size(std::declval< Rng & >()))
template<typename Rng >
using | ranges::range_value_t = iter_value_t< iterator_t< Rng > >

## Functions

template<typename Cont , typename Rng >
CPP_TEMPLATE_AUX_0 | ranges::a (requires input_range< Rng > &&(!detail::convertible_to_cont< Rng, Cont >) &&detail::convertible_to_cont_cont< Rng, Cont >) aaauto to(Rng &&rng) -> Cont
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<template< typename... > class ContT, typename Rng , typename C = meta::invoke<detail::from_range<ContT>, Rng>>
CPP_TEMPLATE_AUX_0 | ranges::a (requires range< Rng > &&detail::convertible_to_cont< Rng, C >) aaauto to(Rng &&rng) -> C
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename Cont , typename Rng >
CPP_TEMPLATE_AUX_0 | ranges::a (requires range< Rng > &&detail::convertible_to_cont< Rng, Cont >) aaauto to(Rng &&rng) -> Cont
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<template< typename... > class ContT>
auto | ranges::to () -> detail::to_container_fn< detail::from_range< ContT >>
| For initializing a container of the specified type with the elements of an Range. More...

## Variables

constexpr at_fn | ranges::at {}
| Checked indexed range access. More...
constexpr back_fn | ranges::back {}
constexpr _begin_::fn | ranges::begin {}
constexpr _cbegin_::fn | ranges::cbegin {}
template<typename T >
concept | ranges::ccontainer
| \concept container More...
constexpr _cdata_::fn | ranges::cdata {}
constexpr _cend_::fn | ranges::cend {}
concept | ranges::container_ =
template<typename T >
| ranges::CPP_TEMPLATE_AUX_1
| \concept container_ More...
constexpr _crbegin_::fn | ranges::crbegin {}
constexpr _crend_::fn | ranges::crend {}
template<typename Rng , typename I , typename S >
concept | ranges::eerasable_range
| \concept erasable_range More...
constexpr _empty_::fn | ranges::empty {}
constexpr _end_::fn | ranges::end {}
template<typename Rng , typename I , typename S >
concept | ranges::erasable_range_ = requires( Rng && rng, I first, S last ) { ranges::erase((Rng &&) rng, first, last) ; }
| \concept erasable_range_ More...
constexpr front_fn | ranges::front {}
constexpr index_fn | ranges::index {}
| Unchecked indexed range access. More...
template<typename T >
concept | ranges::llvalue_container_like
| \concept lvalue_container_like More...
concept | ranges::lvalue_container_like_ =
constexpr _rbegin_::fn | ranges::rbegin {}
constexpr _rend_::fn | ranges::rend {}
template<typename C >
concept | ranges::reservable_ = requires( C & c, C const & cc ) { c.reserve(ranges::size(c)), cc.capacity(), cc.max_size(), concepts::requires_<same_as<decltype(cc.capacity()), decltype(ranges::size(c))>>, concepts::requires_<same_as<decltype(cc.max_size()), decltype(ranges::size(c))>> ; }
| \concept reservable_ More...
template<typename C , typename I >
concept | ranges::reservable_with_assign_ = requires( C & c, I i ) { c.assign(i, i) ; }
| \concept reservable_with_assign_ More...
template<typename C >
concept | ranges::rrandom_access_reservable
| \concept random_access_reservable More...
template<typename C >
concept | ranges::rreservable
| \concept reservable More...
template<typename C , typename I >
concept | ranges::rreservable_with_assign
| \concept reservable_with_assign More...
constexpr _size_::fn | ranges::size {}
template<typename T >
concept | ranges::ssemi_container
| \concept semi_container More...
constexpr detail::to_container_fn< detail::from_range< std::vector > > | ranges::to_vector {}

## Detailed Description

Core range functionality.

## Function Documentation

## to()

template<template< typename... > class ContT>

auto ranges::to | ( |  | ) | -> detail::to_container_fn<detail::from_range<ContT>>

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

For initializing a container of the specified type with the elements of an Range.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## Variable Documentation

## at

constexpr at_fn ranges::at {}

constexpr

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

Checked indexed range access.

See also
  `at_fn`

## back

constexpr back_fn ranges::back {}

constexpr

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

See also
  `back_fn`

## begin

constexpr _begin_::fn ranges::begin {}

constexpr

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

Parameters

  r |

Returns
  `r`, if `r` is an array. Otherwise, `r.begin()` if that expression is well-formed and returns an input_or_output_iterator. Otherwise, `begin(r)` if that expression returns an input_or_output_iterator.

Referenced by ranges::view_interface< Derived, Cardinality >::c().

## cbegin

constexpr _cbegin_::fn ranges::cbegin {}

constexpr

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

Parameters

  r |

Returns
  The result of calling `ranges::begin` with a const-qualified reference to r.

## ccontainer

template<typename T >

concept ranges::ccontainer

`#include <range/v3/action/concepts.hpp>`

Initial value:
=
semi_container<T> &&
ranges::container_ < T >

\concept container

The `container` concept

## cdata

constexpr _cdata_::fn ranges::cdata {}

constexpr

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

Parameters

  r |

Returns
  The result of calling `ranges::data` with a const-qualified (lvalue or rvalue) reference to `r`.

## cend

constexpr _cend_::fn ranges::cend {}

constexpr

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

Parameters

  r |

Returns
  The result of calling `ranges::end` with a const-qualified reference to r.

## CPP_TEMPLATE_AUX_1

template<typename T >

ranges::CPP_TEMPLATE_AUX_1

`#include <range/v3/action/concepts.hpp>`

\concept container_

\concept invocable_view_closure_

\concept simple_view_impl_

\concept exclusive_scan_constraints_

\concept cartesian_produce_view_can_bidi_

\concept cartesian_produce_view_can_random_

\concept cartesian_produce_view_can_distance_

\concept cartesian_produce_view_can_size_

\concept uniform_random_bit_generator_

\concept sized_range_

\concept common_range_

\concept contiguous_range_

\concept random_access_range_

\concept bidirectional_range_

\concept forward_range_

\concept input_range_

\concept output_range_

\concept partial_sum_constraints_

\concept indirect_semigroup_

\concept inner_product_constraints_

\concept differenceable_

\concept projected_indirect_strict_weak_order_

\concept projected_indirect_relation_

\concept indirectly_copyable_storable_

\concept indirectly_copyable_

\concept indirectly_movable_storable_

\concept indirectly_movable_

\concept indirect_strict_weak_order_

\concept indirect_relation_

\concept indirect_binary_predicate_impl_

\concept indirect_unary_predicate_

\concept indirectly_regular_unary_invocable_

\concept contiguous_iterator_

\concept with_category_

\concept sized_sentinel_for_

\concept input_or_output_iterator_

\concept weakly_incrementable_

\concept readable_

\concept lvalue_container_like_

The `container_` concept `std::vector` is a container, `std::array` is not

The `lvalue_container_like_` concept

The `readable_` concept

The `weakly_incrementable_` concept

The `input_or_output_iterator_` concept

The `sized_sentinel_for_` concept

The `with_category_` concept

The `contiguous_iterator_` concept

The `indirectly_regular_unary_invocable_` concept

The `indirect_unary_predicate_` concept

The `indirect_binary_predicate_impl_` concept

The `indirect_relation_` concept

The `indirect_strict_weak_order_` concept

The `indirectly_movable_` concept

The `indirectly_movable_storable_` concept

The `indirectly_copyable_` concept

The `indirectly_copyable_storable_` concept

The `projected_indirect_relation_` concept

The `projected_indirect_strict_weak_order_` concept

The `differenceable_` concept

The `inner_product_constraints_` concept

The `indirect_semigroup_` concept

The `partial_sum_constraints_` concept

The `output_range_` concept

The `input_range_` concept

The `forward_range_` concept

The `bidirectional_range_` concept

The `random_access_range_` concept

The `contiguous_range_` concept

The `common_range_` concept

The `sized_range_` concept

The `uniform_random_bit_generator_` concept

The `cartesian_produce_view_can_size_` concept

The `cartesian_produce_view_can_distance_` concept

The `cartesian_produce_view_can_random_` concept

The `cartesian_produce_view_can_bidi_` concept

The `exclusive_scan_constraints_` concept

The `simple_view_impl_` concept

The `invocable_view_closure_` concept

## crbegin

constexpr _crbegin_::fn ranges::crbegin {}

constexpr

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

Parameters

  r |

Returns
  The result of calling `ranges::rbegin` with a const-qualified reference to r.

## crend

constexpr _crend_::fn ranges::crend {}

constexpr

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

Parameters

  r |

Returns
  The result of calling `ranges::rend` with a const-qualified reference to r.

## eerasable_range

template<typename Rng , typename I , typename S >

concept ranges::eerasable_range

`#include <range/v3/action/erase.hpp>`

Initial value:
=
range<Rng> && ranges::erasable_range_ < Rng, I, S >

\concept erasable_range

The `erasable_range` concept

## empty

constexpr _empty_::fn ranges::empty {}

constexpr

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

Returns
  true if and only if range contains no elements.

## end

constexpr _end_::fn ranges::end {}

constexpr

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

Parameters

  r |

Returns
  `r+size`(r), if `r` is an array. Otherwise, `r.end()` if that expression is well-formed and returns an input_or_output_iterator. Otherwise, `end(r)` if that expression returns an input_or_output_iterator.

Referenced by ranges::view_interface< Derived, Cardinality >::c().

## erasable_range_

template<typename Rng , typename I , typename S >

concept ranges::erasable_range_ = requires( Rng && rng, I first, S last ) { ranges::erase((Rng &&) rng, first, last) ; }

`#include <range/v3/action/erase.hpp>`

\concept erasable_range_

The `erasable_range_` concept

## front

constexpr front_fn ranges::front {}

constexpr

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

See also
  `front_fn`

## index

constexpr index_fn ranges::index {}

constexpr

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

Unchecked indexed range access.

See also
  `index_fn`

## llvalue_container_like

template<typename T >

concept ranges::llvalue_container_like

`#include <range/v3/action/concepts.hpp>`

Initial value:
=
forward_range<T> &&
ranges::lvalue_container_like_ < T >

\concept lvalue_container_like

The `lvalue_container_like` concept

## rbegin

constexpr _rbegin_::fn ranges::rbegin {}

constexpr

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

Parameters

  r |

Returns
  `make_reverse_iterator(r + ranges::size(r))` if r is an array. Otherwise, `r.rbegin()` if that expression is well-formed and returns an input_or_output_iterator. Otherwise, `make_reverse_iterator(ranges::end(r))` if `ranges::begin(r)` and `ranges::end(r)` are both well-formed and have the same type that satisfies `bidirectional_iterator`.

## rend

constexpr _rend_::fn ranges::rend {}

constexpr

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

Parameters

  r |

Returns
  `make_reverse_iterator(r)` if `r` is an array. Otherwise, `r.rend()` if that expression is well-formed and returns a type that satisfies `sentinel_for<S, I>` where `I` is the type of `ranges::rbegin(r)`. Otherwise, `make_reverse_iterator(ranges::begin(r))` if `ranges::begin(r)` and `ranges::end(r)` are both well-formed and have the same type that satisfies `bidirectional_iterator`.

## reservable_

template<typename C >

concept ranges::reservable_ = requires( C & c, C const & cc ) { c.reserve(ranges::size(c)), cc.capacity(), cc.max_size(), concepts::requires_<same_as<decltype(cc.capacity()), decltype(ranges::size(c))>>, concepts::requires_<same_as<decltype(cc.max_size()), decltype(ranges::size(c))>> ; }

`#include <range/v3/action/concepts.hpp>`

\concept reservable_

The `reservable_` concept

## reservable_with_assign_

template<typename C , typename I >

concept ranges::reservable_with_assign_ = requires( C & c, I i ) { c.assign(i, i) ; }

`#include <range/v3/action/concepts.hpp>`

\concept reservable_with_assign_

The `reservable_with_assign_` concept

## rrandom_access_reservable

template<typename C >

concept ranges::rrandom_access_reservable

`#include <range/v3/action/concepts.hpp>`

Initial value:
=
reservable<C> && random_access_range<C>

\concept random_access_reservable

The `random_access_reservable` concept

## rreservable

template<typename C >

concept ranges::rreservable

`#include <range/v3/action/concepts.hpp>`

Initial value:
=
container<C> && sized_range<C> && ranges::reservable_ < C >

\concept reservable

The `reservable` concept

## rreservable_with_assign

template<typename C , typename I >

concept ranges::rreservable_with_assign

`#include <range/v3/action/concepts.hpp>`

Initial value:
=
reservable<C> &&
input_iterator<I> &&
ranges::reservable_with_assign_ < C, I >

\concept reservable_with_assign

The `reservable_with_assign` concept

## size

constexpr _size_::fn ranges::size {}

constexpr

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

Returns
  For a given expression `E` of type `T`, `ranges::size(E)` is equivalent to:
  - `+extent_v<T>` if `T` is an array type.
  - Otherwise, `+E.size()` if it is a valid expression and its type `I` models `integral` and `disable_sized_range<std::remove_cvref_t<T>>` is false.
  - Otherwise, `+size(E)` if it is a valid expression and its type `I` models `integral` with overload resolution performed in a context that includes the declaration:
    template<class T> void size(T&&) = delete;
    meta::size
    meta::size_t< L::size()> size
    An integral constant wrapper that is the size of the meta::list L.
    Definition: meta.hpp:1696
    and does not include a declaration of `ranges::size`, and `disable_sized_range<std::remove_cvref_t<T>>` is false.
  - Otherwise, `static_cast<U>(ranges::end(E) - ranges::begin(E))` where `U` is `std::make_unsigned_t<iter_difference_t<iterator_t<T>>>` if `iter_difference_t<iterator_t<T>>` satisfies `integral` and `iter_difference_t<iterator_t<T>>` otherwise; except that `E` is evaluated once, if it is a valid expression and the types `I` and `S` of `ranges::begin(E)` and `ranges::end(E)` model `sized_sentinel_for<S, I>` and `forward_iterator<I>`.
  - Otherwise, `ranges::size(E)` is ill-formed.

## ssemi_container

template<typename T >

concept ranges::ssemi_container

`#include <range/v3/action/concepts.hpp>`

Initial value:
=
forward_range<T> && default_constructible<uncvref_t<T>> &&
movable<uncvref_t<T>> &&
!view_<T>

\concept semi_container

The `semi_container` concept `std::array` is a `semi_container`, native arrays are not.