Utility

## Description

Utility classes.

## Modules

| Concepts
| Concept-checking classes and utilities.

## Classes

struct | ranges::v3::aux::move_fn
struct | ranges::v3::back_insert_iterator< Container >
struct | ranges::v3::back_inserter_fn
struct | ranges::v3::basic_common_reference< T, U, TQual, UQual >
| Users can specialize this to hook the `CommonReference` concept. More...
struct | ranges::v3::basic_iterator< Cur >
struct | ranges::v3::basic_mixin< T >
struct | ranges::v3::bind_element< T >
struct | ranges::v3::bind_element< reference_wrapper< T > >
struct | ranges::v3::bind_element< std::reference_wrapper< T > >
struct | ranges::v3::bitwise_or
class | ranges::v3::box< Element, Tag, box_compress >
class | ranges::v3::box< Element, Tag, detail::box_compress::coalesce >
class | ranges::v3::box< Element, Tag, detail::box_compress::ebo >
struct | ranges::v3::coerce< T >
struct | ranges::v3::coerce< T & >
struct | ranges::v3::coerce< T && >
struct | ranges::v3::coerce< T const >
struct | ranges::v3::common_reference< Ts >
| Users can specialize this to hook the `CommonReference` concept. More...
struct | ranges::v3::common_reference< T >
struct | ranges::v3::common_reference< T, U >
struct | ranges::v3::common_reference< T, U, Vs... >
struct | ranges::v3::common_type< Ts >
| Users should specialize this to hook the `Common` concept until `std` gets a SFINAE-friendly `std::common_type` and there's some sane way to deal with cv and ref qualifiers. More...
struct | ranges::v3::common_type< T >
struct | ranges::v3::common_type< T, U >
struct | ranges::v3::common_type< T, U, Vs... >
struct | ranges::v3::compose_fn
struct | ranges::v3::composed< Second, First >
struct | ranges::v3::constant< T, v >
struct | ranges::v3::convert_to< T >
struct | ranges::v3::dereference_fn
struct | ranges::v3::equal_to
struct | ranges::v3::front_insert_iterator< Container >
struct | ranges::v3::front_inserter_fn
struct | ranges::v3::get_cursor_fn
| Get a cursor from a basic_iterator. More...
struct | ranges::v3::ident
struct | ranges::v3::in_place_t
struct | ranges::v3::indirect_fn
struct | ranges::v3::indirected< Fn >
struct | ranges::v3::insert_iterator< Container >
struct | ranges::v3::inserter_fn
struct | ranges::v3::invoke_fn
struct | ranges::v3::is_indirectly_swappable< T, U >
struct | ranges::v3::is_nothrow_indirectly_swappable< T, U >
struct | ranges::v3::is_nothrow_swappable< T >
struct | ranges::v3::is_nothrow_swappable_with< T, U >
struct | ranges::v3::is_pipeable< T >
struct | ranges::v3::is_pipeable< T & >
struct | ranges::v3::is_reference_wrapper< T >
struct | ranges::v3::is_reference_wrapper< reference_wrapper< T > >
struct | ranges::v3::is_reference_wrapper< std::reference_wrapper< T > >
struct | ranges::v3::is_swappable< T >
struct | ranges::v3::is_swappable_with< T, U >
struct | ranges::v3::iter_distance_compare_fn
struct | ranges::v3::iter_distance_fn
struct | ranges::v3::iter_enumerate_fn
struct | ranges::v3::iter_size_fn
struct | ranges::v3::iterator_category< iterator_wrapper< I > >
struct | ranges::v3::iterator_wrapper< I >
struct | ranges::v3::less
struct | ranges::v3::logical_negate_< FD >
struct | ranges::v3::make_move_iterator_fn
struct | ranges::v3::make_move_sentinel_fn
struct | ranges::v3::make_pipeable_fn
struct | ranges::v3::make_tuple_fn
struct | ranges::v3::minus
struct | ranges::v3::move_into_fn
struct | ranges::v3::move_iterator< I >
struct | ranges::v3::move_sentinel< S >
struct | ranges::v3::multiplies
struct | ranges::v3::mutable_< T >
struct | ranges::v3::next_fn
struct | ranges::v3::not_equal_to
struct | ranges::v3::not_fn_fn
struct | ranges::v3::on_fn
struct | ranges::v3::ordered_less
struct | ranges::v3::ostream_iterator< T, Char, Traits >
struct | ranges::v3::ostreambuf_iterator< Char, Traits >
struct | ranges::v3::overload_fn
struct | ranges::v3::overloaded< First, Rest... >
struct | ranges::v3::overloaded<>
struct | ranges::v3::pipeable< Derived >
struct | ranges::v3::pipeable_access
struct | ranges::v3::pipeable_base
struct | ranges::v3::plus
struct | ranges::v3::prev_fn
struct | ranges::v3::protect_fn
struct | ranges::v3::raw_buffer< Val >
struct | ranges::v3::raw_storage_iterator< O, Val >
struct | ranges::v3::ref_fn
struct | ranges::v3::reference_wrapper< T >
struct | ranges::v3::result_of< Sig, Enable >
struct | ranges::v3::result_of< Fun(Args...), meta::void_< decltype(invoke(std::declval< Fun >(), std::declval< Args >()...))> >
struct | ranges::v3::semiregular< T >
struct | ranges::v3::semiregular< T & >
struct | ranges::v3::semiregular< T && >
struct | ranges::v3::static_const< T >
struct | ranges::v3::transformed< Fn1, Fn2 >
struct | ranges::v3::tuple_apply_fn
struct | ranges::v3::tuple_foldl_fn
struct | ranges::v3::tuple_for_each_fn
struct | ranges::v3::tuple_transform_fn
struct | ranges::v3::unreachable
struct | ranges::v3::unwrap_reference_fn
struct | ranges::v3::value_type< iterator_wrapper< I > >
struct | ranges::v3::with_braced_init_args< ImplFn >

## Typedefs

template<typename T >
using | ranges::v3::bind_element_t = meta::_t< bind_element< T > >
template<typename T >
using | ranges::v3::is_reference_wrapper_t = meta::_t< is_reference_wrapper< T > >
template<typename Pred >
using | ranges::v3::logical_negate = logical_negate_< detail::decay_t< Pred > >
template<typename R >
using | ranges::v3::aux::move_t = meta::if_< std::is_reference< R >, meta::_t< std::remove_reference< R > > &&, detail::decay_t< R > >
template<typename T >
using | ranges::v3::movesemiregular_t = meta::if_c< Movable< T >() &&DefaultConstructible< T >(), T, semiregular< T > >
template<typename T >
using | ranges::v3::ref_t = decltype(ref(std::declval< T >()))
using | ranges::v3::reference_wrapper< T >::reference = meta::if_< std::is_reference< T >, T, T & >
template<typename T , bool IsConst = false>
using | ranges::v3::semiregular_ref_or_val_t = meta::if_< SemiRegular< T >, meta::if_c< IsConst, T, reference_wrapper< T > >, reference_wrapper< meta::if_c< IsConst, semiregular< T > const, semiregular< T > >> >
template<typename T >
using | ranges::v3::semiregular_t = meta::if_< SemiRegular< T >, T, semiregular< T > >
template<typename Tup >
using | ranges::v3::tuple_indices_t = meta::make_index_sequence< std::tuple_size< typename std::remove_reference< Tup >::type >::value >
using | ranges::v3::reference_wrapper< T >::type = meta::_t< std::remove_reference< T > >
using | ranges::v3::result_of< Fun(Args...), meta::void_< decltype(invoke(std::declval< Fun >(), std::declval< Args >()...))> >::type = decltype(invoke(std::declval< Fun >(), std::declval< Args >()...))
template<typename T >
using | ranges::v3::unwrap_reference_t = decltype(unwrap_reference(std::declval< T >()))

## Functions

template<typename T >
constexpr T * | ranges::v3::_nullptr_v ()
template<typename T , typename U = meta::if_< std::is_lvalue_reference<T>, std::reference_wrapper<meta::_t<std::remove_reference<T>>>, T &&>>
U | ranges::v3::bind_forward (meta::_t< std::remove_reference< T >> &t) noexcept
template<typename T >
T && | ranges::v3::bind_forward (meta::_t< std::remove_reference< T >> &&t) noexcept
template<typename T >
T & | ranges::v3::get (meta::id_t< T > &value)
template<typename T >
T const & | ranges::v3::get (meta::id_t< T > const &value)
template<typename T >
T && | ranges::v3::get (meta::id_t< T > &&value)
template<typename T >
auto | ranges::v3::get (meta::id_t< semiregular< T >> &t) noexcept(noexcept(decltype(t.get())(t.get()))) -> decltype(t.get())
template<typename T >
auto | ranges::v3::get (meta::id_t< semiregular< T >> const &t) noexcept(noexcept(decltype(t.get())(t.get()))) -> decltype(t.get())
template<typename T >
auto | ranges::v3::get (meta::id_t< semiregular< T >> &&t) noexcept(noexcept(decltype(detail::move(t).get())(detail::move(t).get()))) -> decltype(detail::move(t).get())
template<typename Tag , typename Element , detail::box_compress BC>
Element & | ranges::v3::get (box< Element, Tag, BC > &b) noexcept
template<typename Tag , typename Element , detail::box_compress BC>
constexpr Element const & | ranges::v3::get (box< Element, Tag, BC > const &b) noexcept
template<typename Tag , typename Element , detail::box_compress BC>
Element && | ranges::v3::get (box< Element, Tag, BC > &&b) noexcept
template<std::size_t I, typename Element , detail::box_compress BC>
Element & | ranges::v3::get (box< Element, meta::size_t< I >, BC > &b) noexcept
template<std::size_t I, typename Element , detail::box_compress BC>
constexpr Element const & | ranges::v3::get (box< Element, meta::size_t< I >, BC > const &b) noexcept
template<std::size_t I, typename Element , detail::box_compress BC>
Element && | ranges::v3::get (box< Element, meta::size_t< I >, BC > &&b) noexcept
template<typename I , requires = (Iterator<I>())>
iterator_wrapper< I > | ranges::v3::iter_ref (I &i)
template<typename Val >
raw_buffer< Val > | ranges::v3::make_raw_buffer (Val *val)
template<typename I >
reverse_iterator< I > | ranges::v3::make_reverse_iterator (I i)
template<typename I1 , typename I2 , requires = (EqualityComparable<I1, I2>())>
bool | ranges::v3::operator!= (move_iterator< I1 > const &x, move_iterator< I2 > const &y)
template<typename I , typename S , requires = (Sentinel<S, I>())>
bool | ranges::v3::operator!= (move_iterator< S > const &i, move_sentinel< S > const &s)
template<typename I , typename S , requires = (Sentinel<S, I>())>
bool | ranges::v3::operator!= (move_sentinel< S > const &s, move_iterator< S > const &i)
template<typename F , typename Obj , typename First , typename... Rest, meta::if_c< detail::is_function< F >::value, int > = 0>

constexpr auto

ranges::v3::invoke_fn::operator() (F Obj::*ptr, First &&first, Rest &&... rest) const noexcept(noexcept(decltype(invoke_member_fn(std::is_base_of< Obj, detail::decay_t< First >>{}, is_reference_wrapper_t< detail::decay_t< First >>{}, ptr, static_cast< First &&>(first), static_cast< Rest &&>(rest)...))(invoke_member_fn(std::is_base_of< Obj, detail::decay_t< First >>{}, is_reference_wrapper_t< detail::decay_t< First >>{}, ptr, static_cast< First &&>(first), static_cast< Rest &&>(rest)...)))) -> decltype(invoke_member_fn(std::is_base_of< Obj, detail::decay_t< First >>

template<typename Data , typename Obj , typename First , meta::if_c<!detail::is_function< Data >::value, int > = 0>

constexpr auto

ranges::v3::invoke_fn::operator() (Data Obj::*ptr, First &&first) const noexcept(noexcept(decltype(invoke_member_data(std::is_base_of< Obj, detail::decay_t< First >>{}, is_reference_wrapper_t< detail::decay_t< First >>{}, ptr, static_cast< First &&>(first)))(invoke_member_data(std::is_base_of< Obj, detail::decay_t< First >>{}, is_reference_wrapper_t< detail::decay_t< First >>{}, ptr, static_cast< First &&>(first))))) -> decltype(invoke_member_data(std::is_base_of< Obj, detail::decay_t< First >>

template<typename F , typename... Args, meta::if_c<!std::is_member_pointer< uncvref_t< F >>::value, int > = 0>
constexpr auto | ranges::v3::invoke_fn::operator() (F &&fn, Args &&... args) const noexcept(noexcept(decltype(static_cast< F &&>(fn)(static_cast< Args &&>(args)...))(static_cast< F &&>(fn)(static_cast< Args &&>(args)...)))) -> decltype(static_cast< F &&>(fn)(static_cast< Args &&>(args)...))
template<typename I , requires = (RandomAccessIterator<I>())>
move_iterator< I > | ranges::v3::operator+ (difference_type_t< I > n, move_iterator< I > const &x)
template<typename I1 , typename I2 , requires = (SizedSentinel<I1, I2>())>
difference_type_t< I2 > | ranges::v3::operator- (move_iterator< I1 > const &x, move_iterator< I2 > const &y)
template<typename I1 , typename I2 , requires = (TotallyOrdered<I1, I2>())>
bool | ranges::v3::operator< (move_iterator< I1 > const &x, move_iterator< I2 > const &y)
template<typename I1 , typename I2 , requires = (TotallyOrdered<I1, I2>())>
bool | ranges::v3::operator<= (move_iterator< I1 > const &x, move_iterator< I2 > const &y)
template<typename I1 , typename I2 , requires = (EqualityComparable<I1, I2>())>
bool | ranges::v3::operator== (move_iterator< I1 > const &x, move_iterator< I2 > const &y)
template<typename I , typename S , requires = (Sentinel<S, I>())>
bool | ranges::v3::operator== (move_iterator< I > const &i, move_sentinel< S > const &s)
template<typename I , typename S , requires = (Sentinel<S, I>())>
bool | ranges::v3::operator== (move_sentinel< S > const &s, move_iterator< S > const &i)
template<typename I1 , typename I2 , requires = (TotallyOrdered<I1, I2>())>
bool | ranges::v3::operator> (move_iterator< I1 > const &x, move_iterator< I2 > const &y)
template<typename I1 , typename I2 , requires = (TotallyOrdered<I1, I2>())>
bool | ranges::v3::operator>= (move_iterator< I1 > const &x, move_iterator< I2 > const &y)
template<typename T , requires = (Constructible<detail::decay_t<T>, T>())>
detail::decay_t< T > | ranges::v3::aux::operator| (T &&t, copy_fn)
template<typename T >
meta::_t< std::remove_reference< T > > && | ranges::v3::aux::operator| (T &&t, move_fn move) noexcept
template<typename Arg , typename Pipe , requires = (!is_pipeable<Arg>() && is_pipeable<Pipe>())>
auto | ranges::v3::operator| (Arg &&arg, Pipe pipe) -> decltype(pipeable_access::impl< Pipe >::pipe(static_cast< Arg &&>(arg), pipe))
template<typename Pipe0 , typename Pipe1 , requires = (is_pipeable<Pipe0>() && is_pipeable<Pipe1>())>
auto | ranges::v3::operator| (Pipe0 pipe0, Pipe1 pipe1) -> decltype(make_pipeable(detail::composed_pipe< Pipe0, Pipe1 >
template<typename U , requires = (Constructible<base_, U>() && !Same<uncvref_t<U>, reference_wrapper>())>
constexpr | ranges::v3::reference_wrapper< T >::reference_wrapper (U &&u) noexcept(std::is_nothrow_constructible< base_, U >::value)
| ranges::v3::invoke_fn::static_cast (rest)...))
| ranges::v3::invoke_fn::static_cast (first)

## Variables

constexpr adl_advance_detail::advance_fn | ranges::v3::advance {}
constexpr back_inserter_fn | ranges::v3::back_inserter {}
constexpr compose_fn | ranges::v3::compose {}
constexpr copy_fn | ranges::v3::aux::copy {}
constexpr dereference_fn | ranges::v3::dereference {}
constexpr front_inserter_fn | ranges::v3::front_inserter {}
constexpr get_cursor_fn | ranges::v3::get_cursor {}
constexpr indirect_fn | ranges::v3::indirect {}
constexpr inserter_fn | ranges::v3::inserter {}
constexpr invoke_fn | ranges::v3::invoke {}
constexpr iter_distance_fn | ranges::v3::iter_distance {}
constexpr iter_distance_compare_fn | ranges::v3::iter_distance_compare {}
constexpr iter_enumerate_fn | ranges::v3::iter_enumerate {}
constexpr iter_size_fn | ranges::v3::iter_size {}
constexpr adl_swap_detail::iter_swap_fn | iter_swap {}
constexpr make_common_pair_fn | ranges::v3::make_common_pair {}
constexpr make_common_tuple_fn | ranges::v3::make_common_tuple {}
constexpr make_move_iterator_fn | ranges::v3::make_move_iterator {}
constexpr make_move_sentinel_fn | ranges::v3::make_move_sentinel {}
constexpr make_pipeable_fn | ranges::v3::make_pipeable {}
constexpr make_tuple_fn | ranges::v3::make_tuple {}
constexpr move_fn | ranges::v3::aux::move {}
constexpr move_into_fn | ranges::v3::move_into {}
constexpr next_fn | ranges::v3::next {}
constexpr not_fn_fn | ranges::v3::not_fn {}
constexpr on_fn | ranges::v3::on {}
constexpr overload_fn | ranges::v3::overload {}
constexpr prev_fn | ranges::v3::prev {}
constexpr protect_fn | ranges::v3::protect {}
| Protect a callable so that it can be safely used in a bind expression without accidentally becoming a "nested" bind. More...
| ranges::v3::invoke_fn::ptr
constexpr adl_uncounted_recounted_detail::recounted_fn | ranges::v3::recounted {}
constexpr ref_fn | ranges::v3::ref {}
constexpr adl_swap_detail::swap_fn | swap {}
constexpr tuple_apply_fn | ranges::v3::tuple_apply {}
constexpr tuple_foldl_fn | ranges::v3::tuple_foldl {}
constexpr tuple_for_each_fn | ranges::v3::tuple_for_each {}
constexpr tuple_transform_fn | ranges::v3::tuple_transform {}
constexpr adl_uncounted_recounted_detail::uncounted_fn | ranges::v3::uncounted {}
constexpr unwrap_reference_fn | ranges::v3::unwrap_reference {}
static constexpr T | ranges::v3::static_const< T >::value {}

## Typedef Documentation

## move_t

template<typename R >

using ranges::v3::aux::move_t = typedef meta::if_< std::is_reference<R>, meta::_t<std::remove_reference<R> > &&, detail::decay_t<R> >

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

See also
  `move_fn`

## Function Documentation

## operator|() [1/2]

template<typename T , requires = (Constructible<detail::decay_t<T>, T>())>

detail::decay_t<T> ranges::v3::aux::operator| | ( | T && | t,
|  | copy_fn |
| ) |  |

`#include <range/v3/utility/copy.hpp>`

See also
  `copy_fn`

## operator|() [2/2]

template<typename T >

meta::_t<std::remove_reference<T> >&& ranges::v3::aux::operator| | ( | T && | t,
|  | move_fn | move
| ) |  |

noexcept

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

See also
  `move_fn`

References ranges::v3::aux::move.

## Variable Documentation

## advance

constexpr adl_advance_detail::advance_fn ranges::v3::advance {}

`#include <range/v3/utility/iterator.hpp>`

See also
  `advance_fn`

Referenced by ranges::v3::intersperse_view< Rng >::cursor_adaptor::advance(), ranges::v3::basic_iterator< Cur >::operator+=(), and ranges::v3::basic_iterator< Cur >::operator-=().

## back_inserter

constexpr back_inserter_fn ranges::v3::back_inserter {}

`#include <range/v3/utility/iterator.hpp>`

See also
  `back_inserter_fn`

## compose

constexpr compose_fn ranges::v3::compose {}

`#include <range/v3/utility/functional.hpp>`

See also
  `compose_fn`

## copy

constexpr copy_fn ranges::v3::aux::copy {}

`#include <range/v3/utility/copy.hpp>`

See also
  `copy_fn`

## front_inserter

constexpr front_inserter_fn ranges::v3::front_inserter {}

`#include <range/v3/utility/iterator.hpp>`

See also
  `front_inserter_fn`

## get_cursor

constexpr get_cursor_fn ranges::v3::get_cursor {}

`#include <range/v3/utility/basic_iterator.hpp>`

See also
  `get_cursor_fn`

## indirect

constexpr indirect_fn ranges::v3::indirect {}

related

`#include <range/v3/utility/functional.hpp>`

See also
  `indirect_fn`

Referenced by ranges::v3::iter_transform_view< Rng, indirected< Fun > >::size().

## inserter

constexpr inserter_fn ranges::v3::inserter {}

`#include <range/v3/utility/iterator.hpp>`

See also
  `inserter_fn`

## iter_distance

constexpr iter_distance_fn ranges::v3::iter_distance {}

`#include <range/v3/utility/iterator.hpp>`

See also
  `iter_distance_fn`

## iter_distance_compare

constexpr iter_distance_compare_fn ranges::v3::iter_distance_compare {}

`#include <range/v3/utility/iterator.hpp>`

See also
  `iter_distance_compare_fn`

## iter_enumerate

constexpr iter_enumerate_fn ranges::v3::iter_enumerate {}

`#include <range/v3/utility/iterator.hpp>`

See also
  `iter_enumerate_fn`

## iter_size

constexpr iter_size_fn ranges::v3::iter_size {}

`#include <range/v3/utility/iterator.hpp>`

See also
  `iter_size_fn`

## iter_swap

constexpr adl_swap_detail::iter_swap_fn iter_swap {}

`#include <range/v3/utility/swap.hpp>`

## make_common_pair

constexpr make_common_pair_fn ranges::v3::make_common_pair {}

`#include <range/v3/utility/common_tuple.hpp>`

See also
  `make_common_pair_fn`

## make_common_tuple

constexpr make_common_tuple_fn ranges::v3::make_common_tuple {}

`#include <range/v3/utility/common_tuple.hpp>`

See also
  `make_common_tuple_fn`

## make_pipeable

constexpr make_pipeable_fn ranges::v3::make_pipeable {}

`#include <range/v3/utility/functional.hpp>`

See also
  `make_pipeable_fn`

## make_tuple

constexpr make_tuple_fn ranges::v3::make_tuple {}

`#include <range/v3/utility/tuple_algorithm.hpp>`

See also
  `make_tuple_fn`

## move

constexpr move_fn ranges::v3::aux::move {}

related

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

See also
  `move_fn`

Referenced by ranges::v3::aux::operator|().

## move_into

constexpr move_into_fn ranges::v3::move_into {}

`#include <range/v3/utility/iterator.hpp>`

See also
  `move_into_fn`

## next

constexpr next_fn ranges::v3::next {}

`#include <range/v3/utility/iterator.hpp>`

See also
  `next_fn`

Referenced by ranges::v3::tail_view< Rng >::begin(), ranges::v3::intersperse_view< Rng >::cursor_adaptor::equal(), ranges::v3::adjacent_find_fn::operator()(), ranges::v3::unique_fn::operator()(), ranges::v3::basic_iterator< Cur >::operator++(), ranges::v3::join_view< Rng, void >::size(), and ranges::v3::join_view< Rng, ValRng >::size().

## not_fn

constexpr not_fn_fn ranges::v3::not_fn {}

`#include <range/v3/utility/functional.hpp>`

See also
  `not_fn_fn`

## on

constexpr on_fn ranges::v3::on {}

`#include <range/v3/utility/functional.hpp>`

See also
  `on_fn`

## overload

constexpr overload_fn ranges::v3::overload {}

`#include <range/v3/utility/functional.hpp>`

See also
  `overload_fn`

## prev

constexpr prev_fn ranges::v3::prev {}

`#include <range/v3/utility/iterator.hpp>`

See also
  `prev_fn`

Referenced by ranges::v3::view_interface< partial_sum_view< Rng, Fun >, Cardinality >::back(), ranges::v3::back_fn::operator()(), and ranges::v3::basic_iterator< Cur >::operator--().

## protect

constexpr protect_fn ranges::v3::protect {}

`#include <range/v3/utility/functional.hpp>`

Protect a callable so that it can be safely used in a bind expression without accidentally becoming a "nested" bind.

See also
  `protect_fn`

## ref

constexpr ref_fn ranges::v3::ref {}

`#include <range/v3/utility/functional.hpp>`

See also
  `ref_fn`

Referenced by ranges::v3::binary_search_fn::operator()(), and ranges::v3::unique_fn::operator()().

## swap

constexpr adl_swap_detail::swap_fn swap {}

`#include <range/v3/utility/swap.hpp>`

Referenced by ranges::v3::tagged_detail::tagged< Base, Tags >::tagged().

## tuple_apply

constexpr tuple_apply_fn ranges::v3::tuple_apply {}

`#include <range/v3/utility/tuple_algorithm.hpp>`

See also
  `tuple_apply_fn`

## tuple_foldl

constexpr tuple_foldl_fn ranges::v3::tuple_foldl {}

`#include <range/v3/utility/tuple_algorithm.hpp>`

See also
  `tuple_foldl_fn`

Referenced by ranges::v3::iter_zip_with_view< detail::indirect_zip_fn_, Rngs... >::size(), ranges::v3::cartesian_product_view< Views >::size(), and ranges::v3::concat_view< Rngs >::size().

## tuple_for_each

constexpr tuple_for_each_fn ranges::v3::tuple_for_each {}

`#include <range/v3/utility/tuple_algorithm.hpp>`

See also
  `tuple_for_each_fn`

## tuple_transform

constexpr tuple_transform_fn ranges::v3::tuple_transform {}

`#include <range/v3/utility/tuple_algorithm.hpp>`

See also
  `tuple_transform_fn`

Referenced by ranges::v3::iter_zip_with_view< detail::indirect_zip_fn_, Rngs... >::size(), and ranges::v3::concat_view< Rngs >::size().

## unwrap_reference

constexpr unwrap_reference_fn ranges::v3::unwrap_reference {}

`#include <range/v3/utility/functional.hpp>`

See also
  `unwrap_reference_fn`

## value

template<typename T>

constexpr T ranges::v3::static_const< T >::value {}

static

See also
  `static_const`