Utility classes. More...

Classes
struct	concepts::basic_common_reference< T, U, TQual, UQual >
	Users can specialize this to hook the `common_reference_with` concept. More...

struct	concepts::common_reference< Ts >
	Users can specialize this to hook the `common_reference_with` concept. More...

struct	concepts::common_reference< T >

struct	concepts::common_reference< T, U >

struct	concepts::common_reference< T, U, Vs... >

struct	concepts::common_type< Ts >
	Users should specialize this to hook the `common_with` 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	concepts::common_type< T >

struct	concepts::common_type< T, U >

struct	concepts::common_type< T, U, Vs... >

struct	concepts::is_nothrow_swappable< T >

struct	concepts::is_nothrow_swappable_with< T, U >

struct	concepts::is_swappable< T >

struct	concepts::is_swappable_with< T, U >

struct	ranges::aux::move_fn

class	ranges::box< Element, Tag, box_compress >

class	ranges::box< Element, Tag, detail::box_compress::coalesce >

class	ranges::box< Element, Tag, detail::box_compress::ebo >

struct	ranges::in_place_t

struct	ranges::indirectly_readable_traits< iterator_wrapper< I > >

struct	ranges::iterator_wrapper< I >

struct	ranges::make_tuple_fn

struct	ranges::raw_buffer< Val >

struct	ranges::raw_storage_iterator< O, Val >

struct	ranges::semiregular_box< T >

struct	ranges::semiregular_box< T & >

struct	ranges::semiregular_box< T && >

struct	ranges::static_const< T >

struct	ranges::tuple_apply_fn

struct	ranges::tuple_foldl_fn

struct	ranges::tuple_for_each_fn

struct	ranges::tuple_transform_fn

Typedefs
template<typename... Ts>
using	concepts::common_reference_t = typename common_reference< Ts... >::type

template<typename... Ts>
using	concepts::common_type_t = typename common_type< Ts... >::type

template<typename R >
using	ranges::aux::move_t = meta::if_c< std::is_reference< R >::value, meta::_t< std::remove_reference< R > > &&, detail::decay_t< R > >

template<typename T , bool IsConst = false>
using	ranges::semiregular_box_ref_or_val_t = meta::if_c<(bool) semiregular< T >, meta::if_c< IsConst\|\|std::is_empty< T >::value, T, reference_wrapper< T > >, reference_wrapper< meta::if_c< IsConst, semiregular_box< T > const, semiregular_box< T > > > >

template<typename T >
using	ranges::semiregular_box_t = meta::if_c<(bool) semiregular< T >, T, semiregular_box< T > >

template<typename Tup >
using	ranges::tuple_indices_t = meta::make_index_sequence< std::tuple_size< typename std::remove_reference< Tup >::type >::value >

Functions
template<std::size_t I, typename Element , detail::box_compress BC>
constexpr Element &&	ranges::get (box< Element, meta::size_t< I >, BC > &&b) noexcept

template<std::size_t I, typename Element , detail::box_compress BC>
constexpr Element &	ranges::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::get (box< Element, meta::size_t< I >, BC > const &b) noexcept

template<typename Tag , typename Element , detail::box_compress BC>
constexpr Element &&	ranges::get (box< Element, Tag, BC > &&b) noexcept

template<typename Tag , typename Element , detail::box_compress BC>
constexpr Element &	ranges::get (box< Element, Tag, BC > &b) noexcept

template<typename Tag , typename Element , detail::box_compress BC>
constexpr Element const &	ranges::get (box< Element, Tag, BC > const &b) noexcept

template<typename T >
T &&	ranges::get (meta::id_t< T > &&value) noexcept

template<typename T >
T &	ranges::get (meta::id_t< T > &value) noexcept

template<typename T >
T const &	ranges::get (meta::id_t< T > const &value) noexcept

template<std::size_t I, typename TupleLike >
constexpr auto	ranges::get (TupleLike &&t) noexcept(noexcept(decltype(detail::adl_get< I >(static_cast< TupleLike && >(t)))(detail::adl_get< I >(static_cast< TupleLike && >(t))))) -> decltype(detail::adl_get< I >(static_cast< TupleLike && >(t)))

template<typename I > requires input_or_output_iterator<I>
iterator_wrapper< I >	ranges::iter_ref (I &i)

template<typename Val >
raw_buffer< Val >	ranges::make_raw_buffer (Val *val)

Variables
constexpr bind_back_fn	ranges::bind_back {}

constexpr copy_fn	ranges::aux::copy {}

constexpr make_common_tuple_fn	ranges::make_common_tuple {}

constexpr make_compressed_pair_fn	ranges::make_compressed_pair {}

constexpr make_compressed_tuple_fn	ranges::make_compressed_tuple {}

constexpr make_tuple_fn	ranges::make_tuple {}

constexpr move_fn	ranges::aux::move {}

constexpr uncvref_t< decltype(concepts::swap)>	swap {}

constexpr tuple_apply_fn	ranges::tuple_apply {}

constexpr tuple_foldl_fn	ranges::tuple_foldl {}

constexpr tuple_for_each_fn	ranges::tuple_for_each {}

constexpr tuple_transform_fn	ranges::tuple_transform {}

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

Friends
template<typename T > requires constructible_from<detail::decay_t<T>, T>
constexpr auto	ranges::aux::copy_fn::operator\| (T &&t, copy_fn) -> detail::decay_t< T >

template<typename T >
constexpr decltype(auto)	ranges::aux::move_fn::operator\| (T &&t, move_fn move) noexcept