Range-v3
Range algorithms, views, and actions for the Standard Library
concepts.hpp File Reference

Classes

struct  concepts::detail::and_< T, U >
 
struct  concepts::detail::and_< T, U >
 
struct  concepts::detail::boolean
 
struct  concepts::detail::boolean_< Fn >
 
struct  concepts::detail::bools<... >
 
struct  concepts::detail::false_type
 
struct  concepts::detail::first_impl< U >
 
struct  concepts::detail::ignore
 
struct  concepts::detail::Nil
 
struct  concepts::detail::not_< T >
 
struct  concepts::detail::or_< T, U >
 
struct  concepts::detail::or_< T, U >
 
struct  concepts::detail::tag<... >
 
struct  concepts::detail::true_type
 
struct  concepts::return_t_< typename >
 

Macros

#define CPP_arg(ARG)   CPP_arg_2 ARG
 
#define CPP_arg_2(...)   __VA_ARGS__
 
#define CPP_assert(...)
 
#define CPP_assert_msg   static_assert
 
#define CPP_auto_fun(X)   X CPP_AUTO_FUN_IMPL_
 
#define CPP_AUTO_FUN_DECLTYPE_NOEXCEPT_(...)
 
#define CPP_AUTO_FUN_IMPL_(...)   (__VA_ARGS__) CPP_AUTO_FUN_RETURNS_
 
#define CPP_AUTO_FUN_RETURNS_(...)   CPP_AUTO_FUN_SELECT_RETURNS_(__VA_ARGS__,)(__VA_ARGS__) \
 
#define CPP_AUTO_FUN_RETURNS_CONST_0(...)
 
#define CPP_AUTO_FUN_RETURNS_CONST_1(...)   __VA_ARGS__ CPP_AUTO_FUN_RETURNS_CONST_0 \
 
#define CPP_AUTO_FUN_RETURNS_CONST_2(...)   CPP_PP_CAT(CPP_PP_EAT_MUTABLE_, __VA_ARGS__) CPP_AUTO_FUN_RETURNS_CONST_0
 
#define CPP_AUTO_FUN_RETURNS_return
 
#define CPP_AUTO_FUN_SELECT_RETURNS_(MAYBE_CONST, ...)
 
#define CPP_broken_friend_ret(...)   __VA_ARGS__ CPP_PP_EXPAND \
 
#define CPP_concept   META_CONCEPT
 
#define CPP_concept_bool   META_CONCEPT
 
#define CPP_concept_fragment(NAME, ARGS, ...)   META_CONCEPT NAME = __VA_ARGS__
 
#define CPP_ctor(TYPE)   TYPE CPP_CTOR_IMPL_1_
 
#define CPP_CTOR_IMPL_1_(...)   (__VA_ARGS__) CPP_PP_EXPAND \
 
#define CPP_ctor_sfinae(TYPE)
 
#define CPP_CTOR_SFINAE_EAT_NOEXCEPT_noexcept(...)
 
#define CPP_CTOR_SFINAE_IMPL_1_(...)
 
#define CPP_CTOR_SFINAE_MAKE_PROBE(FIRST, ...)   CPP_PP_CAT(CPP_CTOR_SFINAE_PROBE_NOEXCEPT_, FIRST) \
 
#define CPP_CTOR_SFINAE_PROBE_NOEXCEPT_noexcept   CPP_PP_PROBE(~) \
 
#define CPP_CTOR_SFINAE_REQUIRES(...)
 
#define CPP_CTOR_SFINAE_REQUIRES_0(...)
 
#define CPP_CTOR_SFINAE_REQUIRES_1(...)
 
#define CPP_CTOR_SFINAE_SHOW_NOEXCEPT_noexcept(...)
 
#define CPP_CXX_CONCEPTS   201800L
 
#define CPP_CXX_VA_OPT   0
 
#define CPP_defer(CONCEPT, ...)   CONCEPT<__VA_ARGS__>
 
#define CPP_defer_(CONCEPT, ...)   CONCEPT<__VA_ARGS__>
 
#define CPP_FORCE_TO_BOOL
 
#define CPP_fragment(NAME, ...)   NAME<__VA_ARGS__>
 
#define CPP_fun(X)   X CPP_FUN_IMPL_1_
 
#define CPP_FUN_IMPL_1_(...)
 
#define CPP_fwd(ARG)   ((decltype(ARG)&&) ARG)
 
#define CPP_INSTANCE(...)   __VA_ARGS__
 
#define CPP_literal(...)   __VA_ARGS__
 
#define CPP_member
 
#define CPP_member_sfinae   CPP_broken_friend_member \
 
#define CPP_name_of(...)   CPP_PP_EAT __VA_ARGS__
 
#define CPP_param(...)   auto&& CPP_name_of(__VA_ARGS__)
 
#define CPP_PP_CAT(X, ...)   CPP_PP_CAT_(X, __VA_ARGS__)
 
#define CPP_PP_CAT2(X, ...)   CPP_PP_CAT2_(X, __VA_ARGS__)
 
#define CPP_PP_CAT2_(X, ...)   X ## __VA_ARGS__
 
#define CPP_PP_CAT_(X, ...)   X ## __VA_ARGS__
 
#define CPP_PP_CHECK(...)   CPP_PP_CHECK_N(__VA_ARGS__, 0,)
 
#define CPP_PP_CHECK_N(x, n, ...)   n
 
#define CPP_PP_COMMA()   ,
 
#define CPP_PP_COMMA_IIF(X)   CPP_PP_IIF(X)(CPP_PP_EMPTY, CPP_PP_COMMA)() \
 
#define CPP_PP_COUNT(...)
 
#define CPP_PP_COUNT_( _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, N, ...)   N \
 
#define CPP_PP_EAT(...)
 
#define CPP_PP_EAT_MUTABLE_mutable
 
#define CPP_PP_EMPTY()
 
#define CPP_PP_EVAL(X, ...)   X(__VA_ARGS__)
 
#define CPP_PP_EVAL2(X, ...)   X(__VA_ARGS__)
 
#define CPP_PP_EXPAND(...)   __VA_ARGS__
 
#define CPP_PP_FOR_EACH(M, ...)   CPP_PP_FOR_EACH_N(CPP_PP_COUNT(__VA_ARGS__), M, __VA_ARGS__)
 
#define CPP_PP_FOR_EACH_1(M, _1)   M(_1)
 
#define CPP_PP_FOR_EACH_2(M, _1, _2)   M(_1), M(_2)
 
#define CPP_PP_FOR_EACH_3(M, _1, _2, _3)   M(_1), M(_2), M(_3)
 
#define CPP_PP_FOR_EACH_4(M, _1, _2, _3, _4)   M(_1), M(_2), M(_3), M(_4)
 
#define CPP_PP_FOR_EACH_5(M, _1, _2, _3, _4, _5)   M(_1), M(_2), M(_3), M(_4), M(_5)
 
#define CPP_PP_FOR_EACH_6(M, _1, _2, _3, _4, _5, _6)   M(_1), M(_2), M(_3), M(_4), M(_5), M(_6)
 
#define CPP_PP_FOR_EACH_7(M, _1, _2, _3, _4, _5, _6, _7)   M(_1), M(_2), M(_3), M(_4), M(_5), M(_6), M(_7)
 
#define CPP_PP_FOR_EACH_8(M, _1, _2, _3, _4, _5, _6, _7, _8)   M(_1), M(_2), M(_3), M(_4), M(_5), M(_6), M(_7), M(_8)
 
#define CPP_PP_FOR_EACH_N(N, M, ...)   CPP_PP_CAT(CPP_PP_FOR_EACH_, N)(M, __VA_ARGS__)
 
#define CPP_PP_IGNORE_CXX2A_COMPAT_BEGIN
 
#define CPP_PP_IGNORE_CXX2A_COMPAT_END
 
#define CPP_PP_IIF(BIT)   CPP_PP_CAT_(CPP_PP_IIF_, BIT)
 
#define CPP_PP_IIF_0(TRUE, ...)   __VA_ARGS__
 
#define CPP_PP_IIF_1(TRUE, ...)   TRUE
 
#define CPP_PP_IS_NOT_EMPTY(...)
 
#define CPP_PP_IS_PAREN(x)   CPP_PP_CHECK(CPP_PP_IS_PAREN_PROBE x)
 
#define CPP_PP_IS_PAREN_PROBE(...)   CPP_PP_PROBE(~)
 
#define CPP_PP_LBRACE()   {
 
#define CPP_PP_LPAREN   (
 
#define CPP_PP_NOT(BIT)   CPP_PP_CAT_(CPP_PP_NOT_, BIT)
 
#define CPP_PP_NOT_0   1
 
#define CPP_PP_NOT_1   0
 
#define CPP_PP_PROBE(x)   x, 1,
 
#define CPP_PP_PROBE_CONST_MUTABLE_PROBE_const   CPP_PP_PROBE_N(~, 1)
 
#define CPP_PP_PROBE_CONST_MUTABLE_PROBE_mutable   CPP_PP_PROBE_N(~, 2)
 
#define CPP_PP_PROBE_EMPTY()
 
#define CPP_PP_PROBE_EMPTY_PROBE_CPP_PP_PROBE_EMPTY   CPP_PP_PROBE(~) \
 
#define CPP_PP_PROBE_N(x, n)   x, n,
 
#define CPP_PP_RBRACE()   }
 
#define CPP_requires(...)   CPP_requires_n(CPP_PP_COUNT(__VA_ARGS__), __VA_ARGS__)
 
#define CPP_requires_(...)   CPP_requires_n_(CPP_PP_COUNT(__VA_ARGS__), __VA_ARGS__)
 
#define CPP_requires_n(N, ...)
 
#define CPP_requires_n_   CPP_requires_n
 
#define CPP_ret(...)   __VA_ARGS__ CPP_PP_EXPAND \
 
#define CPP_template(...)   template<__VA_ARGS__> CPP_PP_EXPAND \
 
#define CPP_template_def   CPP_template \
 
#define CPP_template_def_sfinae(...)   template<__VA_ARGS__ CPP_TEMPLATE_DEF_SFINAE_AUX_ \
 
#define CPP_TEMPLATE_DEF_SFINAE_AUX_(...)
 
#define CPP_template_sfinae(...)   template<__VA_ARGS__ CPP_TEMPLATE_SFINAE_AUX_ \
 
#define CPP_TEMPLATE_SFINAE_AUX_(...)
 
#define CPP_TEMPLATE_SFINAE_AUX_3_requires
 
#define CPP_type(...)   __VA_ARGS__
 
#define CPP_type_of(...)   CPP_PP_EXPAND(CPP_type_of_2 __VA_ARGS__))
 
#define CPP_type_of_2(...)   __VA_ARGS__ CPP_PP_EAT CPP_PP_LPAREN
 
#define CPP_valid_expressions
 

Typedefs

template<bool B>
using concepts::bool_ = std::integral_constant< bool, B >
 
template<class T , class U >
using concepts::detail::first_t = meta::invoke< first_impl< sizeof(U) ^ sizeof(U)>, T >
 
template<class T >
using concepts::detail::id_t = T
 
template<typename Fun , typename... Args>
using concepts::detail::invoke_result_t = decltype(((Fun &&(*)()) nullptr)()(((Args &&(*)()) nullptr)()...))
 
template<typename T >
using concepts::detail::remove_cvref_t = typename std::remove_cv< typename std::remove_reference< T >::type >::type
 
template<typename T , typename EnableIf >
using concepts::return_t = meta::invoke< return_t_< EnableIf >, T >
 
using concepts::detail::xNil = Nil
 

Functions

constexpr std::true_type concepts::detail::CPP_true (Nil)
 
template<class Fn >
constexpr boolean_< Fn > concepts::detail::make_boolean (Fn) noexcept
 
template<typename >
constexpr bool concepts::detail::requires_ ()
 
template<typename ... Args, typename ExprsFn >
auto concepts::detail::test_concept (tag< Args... > *, ExprsFn) -> first_t< true_type, invoke_result_t< ExprsFn, int, Args... >>
 
false_type concepts::detail::test_concept (void *, ignore)
 
template<typename ArgsFn , typename ExprsFn >
auto concepts::detail::test_concept_ (ArgsFn const args, ExprsFn exprs) -> decltype(args((ExprsFn &&) exprs))
 
false_type concepts::detail::test_concept_ (ignore, ignore)
 

Variables

template<bool... Bs>
constexpr bool concepts::and_v
 
template<typename T , typename U >
concept concepts::defs::assignable_from
 
template<typename T , typename U >
concept concepts::defs::defer::assignable_from
 
template<typename T , typename U >
concept concepts::defs::common_reference_with
 
template<typename T , typename U >
concept concepts::defs::defer::common_reference_with
 
template<typename T , typename U >
concept concepts::defs::common_reference_with_ = same_as<common_reference_t<T, U>, common_reference_t<U, T>> && convertible_to<T, common_reference_t<T, U>> && convertible_to<U, common_reference_t<T, U>>
 
template<typename T , typename U >
concept concepts::defs::common_with
 
template<typename T , typename U >
concept concepts::defs::defer::common_with
 
template<typename T , typename U >
concept concepts::defs::common_with_ = same_as<common_type_t<T, U>, common_type_t<U, T>> && convertible_to<T, common_type_t<T, U>> && convertible_to<U, common_type_t<T, U>> && common_reference_with< std::add_lvalue_reference_t<T const>, std::add_lvalue_reference_t<U const>> && common_reference_with< std::add_lvalue_reference_t<common_type_t<T, U>>, common_reference_t< std::add_lvalue_reference_t<T const>, std::add_lvalue_reference_t<U const>>>
 
template<typename T , typename... Args>
concept concepts::defs::constructible_from
 
template<typename T , typename... Args>
concept concepts::defs::defer::constructible_from
 
template<typename From , typename To >
concept concepts::defs::convertible_to
 
template<typename From , typename To >
concept concepts::defs::defer::convertible_to
 
template<typename T >
concept concepts::defs::copy_constructible
 
template<typename T >
concept concepts::defs::defer::copy_constructible
 
template<typename T >
concept concepts::defs::copyable
 
template<typename T >
concept concepts::defs::defer::copyable
 
template<typename T >
concept concepts::defs::default_constructible
 
template<typename T >
concept concepts::defs::defer::default_constructible
 
template<typename T , typename U >
concept concepts::defs::derived_from
 
template<typename T , typename U >
concept concepts::defs::defer::derived_from
 
template<typename T , typename U >
concept concepts::defs::derived_from_ = convertible_to<T const volatile *, U const volatile *>
 
template<typename T >
concept concepts::defs::destructible
 
template<typename T >
concept concepts::defs::defer::destructible
 
template<typename T >
concept concepts::defs::equality_comparable
 
template<typename T >
concept concepts::defs::defer::equality_comparable
 
template<typename T , typename U >
concept concepts::defs::equality_comparable_with
 
template<typename T , typename U >
concept concepts::defs::defer::equality_comparable_with
 
template<typename T , typename U >
concept concepts::defs::equality_comparable_with_ = equality_comparable< common_reference_t<detail::as_cref_t<T>, detail::as_cref_t<U>>>
 
template<typename T >
constexpr T concepts::detail::instance_ = T{}
 
template<typename T >
concept concepts::defs::integral
 
template<typename T >
concept concepts::defs::defer::integral
 
template<bool B>
concept concepts::defs::is_true = B
 
template<bool B>
concept concepts::defs::defer::is_true
 
template<typename T >
concept concepts::defs::movable
 
template<typename T >
concept concepts::defs::defer::movable
 
template<typename T >
concept concepts::defs::move_constructible
 
template<typename T >
concept concepts::defs::defer::move_constructible
 
template<bool... Bs>
constexpr bool concepts::or_v
 
template<typename T >
concept concepts::defs::regular
 
template<typename T >
concept concepts::defs::defer::regular
 
template<bool B>
constexpr std::enable_if_t< B, intconcepts::requires_ = 0
 
template<typename A , typename B >
concept concepts::defs::same_as
 
template<typename A , typename B >
concept concepts::defs::defer::same_as
 
template<class T , template< typename... > class Trait, typename... Args>
concept concepts::defs::satisfies
 
template<class T , template< typename... > class Trait, typename... Args>
concept concepts::defs::defer::satisfies
 
template<typename T >
concept concepts::defs::semiregular
 
template<typename T >
concept concepts::defs::defer::semiregular
 
template<typename T >
concept concepts::defs::signed_integral
 
template<typename T >
concept concepts::defs::defer::signed_integral
 
template<typename T >
concept concepts::defs::swappable
 
template<typename T >
concept concepts::defs::defer::swappable
 
template<typename T , typename U >
concept concepts::defs::swappable_with
 
template<typename T , typename U >
concept concepts::defs::defer::swappable_with
 
template<typename T >
concept concepts::defs::totally_ordered
 
template<typename T >
concept concepts::defs::defer::totally_ordered
 
template<typename T , typename U >
concept concepts::defs::totally_ordered_with
 
template<typename T , typename U >
concept concepts::defs::defer::totally_ordered_with
 
template<typename T , typename U >
concept concepts::defs::totally_ordered_with_ = totally_ordered< common_reference_t<detail::as_cref_t<T>, detail::as_cref_t<U>>>
 
template<typename... Args>
concept concepts::defs::type = true
 
template<typename... Ts>
concept concepts::defs::defer::type
 
template<typename T >
concept concepts::defs::unsigned_integral
 
template<typename T >
concept concepts::defs::defer::unsigned_integral
 
template<typename T , typename U >
concept concepts::detail::weakly_equality_comparable_with_
 

Macro Definition Documentation

◆ CPP_assert

#define CPP_assert (   ...)
Value:
static_assert(static_cast<bool>(__VA_ARGS__), \
"Concept assertion failed : " #__VA_ARGS__) \

◆ CPP_AUTO_FUN_DECLTYPE_NOEXCEPT_

#define CPP_AUTO_FUN_DECLTYPE_NOEXCEPT_ (   ...)
Value:
noexcept(noexcept(decltype(__VA_ARGS__)(__VA_ARGS__))) -> \
decltype(__VA_ARGS__) \
{ return (__VA_ARGS__); } \

◆ CPP_AUTO_FUN_RETURNS_CONST_0

#define CPP_AUTO_FUN_RETURNS_CONST_0 (   ...)
Value:
CPP_PP_EVAL(CPP_AUTO_FUN_DECLTYPE_NOEXCEPT_, \
CPP_PP_CAT(CPP_AUTO_FUN_RETURNS_, __VA_ARGS__)) \

◆ CPP_AUTO_FUN_SELECT_RETURNS_

#define CPP_AUTO_FUN_SELECT_RETURNS_ (   MAYBE_CONST,
  ... 
)
Value:
CPP_PP_CAT(CPP_AUTO_FUN_RETURNS_CONST_, \
CPP_PP_CHECK(CPP_PP_CAT( \
CPP_PP_PROBE_CONST_MUTABLE_PROBE_, MAYBE_CONST))) \

◆ CPP_ctor_sfinae

#define CPP_ctor_sfinae (   TYPE)
Value:
CPP_PP_IGNORE_CXX2A_COMPAT_BEGIN \
TYPE CPP_CTOR_SFINAE_IMPL_1_ \

◆ CPP_CTOR_SFINAE_IMPL_1_

#define CPP_CTOR_SFINAE_IMPL_1_ (   ...)
Value:
(__VA_ARGS__ \
CPP_PP_COMMA_IIF( \
CPP_PP_NOT(CPP_PP_IS_NOT_EMPTY(__VA_ARGS__))) \
CPP_CTOR_SFINAE_REQUIRES \

◆ CPP_CTOR_SFINAE_REQUIRES

#define CPP_CTOR_SFINAE_REQUIRES (   ...)
Value:
CPP_PP_CAT(CPP_CTOR_SFINAE_REQUIRES_, \
CPP_PP_CHECK(CPP_CTOR_SFINAE_MAKE_PROBE(__VA_ARGS__,)))(__VA_ARGS__) \

◆ CPP_CTOR_SFINAE_REQUIRES_0

#define CPP_CTOR_SFINAE_REQUIRES_0 (   ...)
Value:
std::enable_if_t< \
CPP_FORCE_TO_BOOL( \
CPP_PP_CAT(CPP_TEMPLATE_SFINAE_AUX_3_, __VA_ARGS__) && \
CPP_INSTANCE(CPP_true(::concepts::detail::xNil{})) \
), \
> = {}) \
CPP_PP_IGNORE_CXX2A_COMPAT_END \
Definition: concepts.hpp:848

◆ CPP_CTOR_SFINAE_REQUIRES_1

#define CPP_CTOR_SFINAE_REQUIRES_1 (   ...)
Value:
std::enable_if_t< \
CPP_FORCE_TO_BOOL( \
CPP_PP_CAT(CPP_TEMPLATE_SFINAE_AUX_3_, \
CPP_PP_CAT(CPP_CTOR_SFINAE_EAT_NOEXCEPT_, __VA_ARGS__) \
) && CPP_INSTANCE(CPP_true(::concepts::detail::xNil{})) \
), \
> = {}) \
CPP_PP_EXPAND(CPP_PP_CAT(CPP_CTOR_SFINAE_SHOW_NOEXCEPT_, __VA_ARGS__))) \
Definition: concepts.hpp:848

◆ CPP_CTOR_SFINAE_SHOW_NOEXCEPT_noexcept

#define CPP_CTOR_SFINAE_SHOW_NOEXCEPT_noexcept (   ...)
Value:
noexcept(__VA_ARGS__) \
CPP_PP_IGNORE_CXX2A_COMPAT_END \
CPP_PP_EAT CPP_PP_LPAREN \

◆ CPP_FUN_IMPL_1_

#define CPP_FUN_IMPL_1_ (   ...)
Value:
(__VA_ARGS__) \
CPP_PP_EXPAND \

◆ CPP_PP_COUNT

#define CPP_PP_COUNT (   ...)
Value:
CPP_PP_COUNT_(__VA_ARGS__, \
50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31, \
30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11, \
10,9,8,7,6,5,4,3,2,1,) \

◆ CPP_PP_IS_NOT_EMPTY

#define CPP_PP_IS_NOT_EMPTY (   ...)
Value:
CPP_PP_CHECK(CPP_PP_CAT(CPP_PP_PROBE_EMPTY_PROBE_, \
CPP_PP_PROBE_EMPTY __VA_ARGS__ ())) \

◆ CPP_requires_n

#define CPP_requires_n (   N,
  ... 
)
Value:
requires(CPP_PP_FOR_EACH_N(N, CPP_arg, __VA_ARGS__)) \
CPP_valid_expressions
requires(sizeof...(Ts) > 0) using lambda
For creating anonymous Invocables.

◆ CPP_TEMPLATE_DEF_SFINAE_AUX_

#define CPP_TEMPLATE_DEF_SFINAE_AUX_ (   ...)
Value:
, \
typename CPP_true_, \
std::enable_if_t< \
CPP_FORCE_TO_BOOL( \
CPP_PP_CAT(CPP_TEMPLATE_SFINAE_AUX_3_, __VA_ARGS__) && CPP_true_{} \
), \
int \
>> \

◆ CPP_TEMPLATE_SFINAE_AUX_

#define CPP_TEMPLATE_SFINAE_AUX_ (   ...)
Value:
, \
typename CPP_true_ = std::true_type, \
std::enable_if_t< \
CPP_FORCE_TO_BOOL( \
CPP_PP_CAT(CPP_TEMPLATE_SFINAE_AUX_3_, __VA_ARGS__) && CPP_true_{} \
), \
int \
> = 0> \

Variable Documentation

◆ and_v

template<bool... Bs>
constexpr bool concepts::and_v
Initial value:
=
std::is_same< detail::bools<Bs..., true>, detail::bools<true, Bs...> >::value

◆ assignable_from [1/2]

template<typename T , typename U >
concept concepts::defs::assignable_from
Initial value:
=
std::is_lvalue_reference<T>::value &&
requires( T t , U && u )
(
t = (U &&) u,
requires_<same_as<T, decltype(t = (U &&) u)>>
)
requires(sizeof...(Ts) > 0) using lambda
For creating anonymous Invocables.

◆ assignable_from [2/2]

template<typename T , typename U >
concept concepts::defs::defer::assignable_from
Initial value:
=
defs::assignable_from < T, U >

◆ common_reference_with [1/2]

template<typename T , typename U >
concept concepts::defs::common_reference_with
Initial value:
=
concepts::common_reference_with_ < T, U >

◆ common_reference_with [2/2]

template<typename T , typename U >
concept concepts::defs::defer::common_reference_with
Initial value:
=
defs::common_reference_with < T, U >

◆ common_with [1/2]

template<typename T , typename U >
concept concepts::defs::common_with
Initial value:
=
concepts::common_with_ < T, U >

◆ common_with [2/2]

template<typename T , typename U >
concept concepts::defs::defer::common_with
Initial value:
=
defs::common_with < T, U >

◆ constructible_from [1/2]

template<typename T , typename... Args>
concept concepts::defs::constructible_from
Initial value:
=
destructible<T> &&
std::is_constructible< T, Args... >::value

◆ constructible_from [2/2]

template<typename T , typename... Args>
concept concepts::defs::defer::constructible_from
Initial value:
=
defs::constructible_from < T , Args... >

◆ convertible_to [1/2]

template<typename From , typename To >
concept concepts::defs::convertible_to
Initial value:
=
implicitly_convertible_to<From, To> &&
explicitly_convertible_to<From, To>

◆ convertible_to [2/2]

template<typename From , typename To >
concept concepts::defs::defer::convertible_to
Initial value:
=
defs::convertible_to < From, To >

◆ copy_constructible [1/2]

template<typename T >
concept concepts::defs::copy_constructible
Initial value:
=
move_constructible<T> &&
constructible_from<T, T &> &&
constructible_from<T, T const &> &&
constructible_from<T, T const> &&
convertible_to<T &, T> &&
convertible_to<T const &, T> &&
convertible_to<T const, T>

◆ copy_constructible [2/2]

template<typename T >
concept concepts::defs::defer::copy_constructible
Initial value:
=
defs::copy_constructible < T >

◆ copyable [1/2]

template<typename T >
concept concepts::defs::copyable
Initial value:
=
copy_constructible<T> &&
movable<T> &&
assignable_from<T &, T const &>

◆ copyable [2/2]

template<typename T >
concept concepts::defs::defer::copyable
Initial value:
=
defs::copyable < T >

◆ default_constructible [1/2]

template<typename T >
concept concepts::defs::default_constructible
Initial value:
=
constructible_from<T>

◆ default_constructible [2/2]

template<typename T >
concept concepts::defs::defer::default_constructible
Initial value:
=
defs::default_constructible < T >

◆ derived_from [1/2]

template<typename T , typename U >
concept concepts::defs::derived_from
Initial value:
=
std::is_base_of< U, T >::value &&
concepts::derived_from_ < T, U >

◆ derived_from [2/2]

template<typename T , typename U >
concept concepts::defs::defer::derived_from
Initial value:
=
defs::derived_from < T, U >

◆ destructible [1/2]

template<typename T >
concept concepts::defs::destructible
Initial value:
=
std::is_nothrow_destructible<T>::value

◆ destructible [2/2]

template<typename T >
concept concepts::defs::defer::destructible
Initial value:
=
defs::destructible < T >

◆ equality_comparable [1/2]

template<typename T >
concept concepts::defs::equality_comparable
Initial value:
=
detail::weakly_equality_comparable_with_<T, T>

◆ equality_comparable [2/2]

template<typename T >
concept concepts::defs::defer::equality_comparable
Initial value:
=
defs::equality_comparable < T >

◆ equality_comparable_with [1/2]

template<typename T , typename U >
concept concepts::defs::equality_comparable_with
Initial value:
=
equality_comparable<T> &&
equality_comparable<U> &&
detail::weakly_equality_comparable_with_<T, U> &&
common_reference_with<detail::as_cref_t<T>, detail::as_cref_t<U>> &&
concepts::equality_comparable_with_ < T, U >

◆ equality_comparable_with [2/2]

template<typename T , typename U >
concept concepts::defs::defer::equality_comparable_with
Initial value:
=
defs::equality_comparable_with < T, U >

◆ integral [1/2]

template<typename T >
concept concepts::defs::integral
Initial value:
=
std::is_integral<T>::value

◆ integral [2/2]

template<typename T >
concept concepts::defs::defer::integral
Initial value:
=
defs::integral < T >

◆ is_true

template<bool B>
concept concepts::defs::defer::is_true
Initial value:
=
defs::is_true < B >

◆ movable [1/2]

template<typename T >
concept concepts::defs::movable
Initial value:
=
std::is_object<T>::value &&
move_constructible<T> &&
assignable_from<T &, T> &&
swappable<T>

◆ movable [2/2]

template<typename T >
concept concepts::defs::defer::movable
Initial value:
=
defs::movable < T >

◆ move_constructible [1/2]

template<typename T >
concept concepts::defs::move_constructible
Initial value:
=
constructible_from<T, T> &&
convertible_to<T, T>

◆ move_constructible [2/2]

template<typename T >
concept concepts::defs::defer::move_constructible
Initial value:
=
defs::move_constructible < T >

◆ or_v

template<bool... Bs>
constexpr bool concepts::or_v
Initial value:
=
!std::is_same< detail::bools<Bs..., false>, detail::bools<false, Bs...> >::value

◆ regular [1/2]

template<typename T >
concept concepts::defs::regular
Initial value:
=
semiregular<T> &&
equality_comparable<T>

◆ regular [2/2]

template<typename T >
concept concepts::defs::defer::regular
Initial value:
=
defs::regular < T >

◆ same_as [1/2]

template<typename A , typename B >
concept concepts::defs::same_as
Initial value:
=
std::is_same< A, B >::value && std::is_same< B, A >::value

◆ same_as [2/2]

template<typename A , typename B >
concept concepts::defs::defer::same_as
Initial value:
=
defs::same_as < A, B >

◆ satisfies [1/2]

template<class T , template< typename... > class Trait, typename... Args>
concept concepts::defs::satisfies
Initial value:
=
static_cast<bool>(Trait<T, Args...>::type::value)

◆ satisfies [2/2]

template<class T , template< typename... > class Trait, typename... Args>
concept concepts::defs::defer::satisfies
Initial value:
=
defs::satisfies < T , Trait, Args... >

◆ semiregular [1/2]

template<typename T >
concept concepts::defs::semiregular
Initial value:
=
copyable<T> &&
default_constructible<T>

◆ semiregular [2/2]

template<typename T >
concept concepts::defs::defer::semiregular
Initial value:
=
defs::semiregular < T >

◆ signed_integral [1/2]

template<typename T >
concept concepts::defs::signed_integral
Initial value:
=
integral<T> &&
std::is_signed<T>::value

◆ signed_integral [2/2]

template<typename T >
concept concepts::defs::defer::signed_integral
Initial value:
=
defs::signed_integral < T >

◆ swappable [1/2]

template<typename T >
concept concepts::defs::swappable
Initial value:
=
requires( T & t , T & u )
(
)
requires(sizeof...(Ts) > 0) using lambda
For creating anonymous Invocables.
constexpr uncvref_t< decltype(concepts::swap)> swap
Definition: swap.hpp:45

◆ swappable [2/2]

template<typename T >
concept concepts::defs::defer::swappable
Initial value:
=
defs::swappable < T >

◆ swappable_with [1/2]

template<typename T , typename U >
concept concepts::defs::swappable_with
Initial value:
=
common_reference_with<detail::as_cref_t<T>, detail::as_cref_t<U>> &&
requires( T && t , U && u )
(
concepts::swap(((decltype( t )&&) t ), ((decltype( t )&&) t )),
concepts::swap(((decltype( u )&&) u ), ((decltype( u )&&) u )),
concepts::swap(((decltype( u )&&) u ), ((decltype( t )&&) t )),
concepts::swap(((decltype( t )&&) t ), ((decltype( u )&&) u ))
)
requires(sizeof...(Ts) > 0) using lambda
For creating anonymous Invocables.
constexpr uncvref_t< decltype(concepts::swap)> swap
Definition: swap.hpp:45

◆ swappable_with [2/2]

template<typename T , typename U >
concept concepts::defs::defer::swappable_with
Initial value:
=
defs::swappable_with < T, U >

◆ totally_ordered [1/2]

template<typename T >
concept concepts::defs::totally_ordered
Initial value:
=
equality_comparable<T> &&
requires( detail::as_cref_t<T> t , detail::as_cref_t<T> u )
(
t < u ? 1 : 0,
t > u ? 1 : 0,
u <= t ? 1 : 0,
u >= t ? 1 : 0
)
requires(sizeof...(Ts) > 0) using lambda
For creating anonymous Invocables.

◆ totally_ordered [2/2]

template<typename T >
concept concepts::defs::defer::totally_ordered
Initial value:
=
defs::totally_ordered < T >

◆ totally_ordered_with [1/2]

template<typename T , typename U >
concept concepts::defs::totally_ordered_with
Initial value:
=
requires( detail::as_cref_t<T> t , detail::as_cref_t<U> u )
(
t < u ? 1 : 0,
t > u ? 1 : 0,
t <= u ? 1 : 0,
t >= u ? 1 : 0,
u < t ? 1 : 0,
u > t ? 1 : 0,
u <= t ? 1 : 0,
u >= t ? 1 : 0
) &&
totally_ordered<T> &&
totally_ordered<U> &&
equality_comparable_with<T, U> &&
common_reference_with<detail::as_cref_t<T>, detail::as_cref_t<U>> &&
concepts::totally_ordered_with_ < T, U >
requires(sizeof...(Ts) > 0) using lambda
For creating anonymous Invocables.

◆ totally_ordered_with [2/2]

template<typename T , typename U >
concept concepts::defs::defer::totally_ordered_with
Initial value:
=
defs::totally_ordered_with < T, U >

◆ type

template<typename... Ts>
concept concepts::defs::defer::type
Initial value:
=
defs::type < meta::list<Ts...> >
A list of types.
Definition: meta.hpp:1651

◆ unsigned_integral [1/2]

template<typename T >
concept concepts::defs::unsigned_integral
Initial value:
=
integral<T> &&
!signed_integral<T>

◆ unsigned_integral [2/2]

template<typename T >
concept concepts::defs::defer::unsigned_integral
Initial value:
=
defs::unsigned_integral < T >

◆ weakly_equality_comparable_with_

template<typename T , typename U >
concept concepts::detail::weakly_equality_comparable_with_
Initial value:
=
requires( detail::as_cref_t<T> t , detail::as_cref_t<U> u )
(
(t == u) ? 1 : 0,
(t != u) ? 1 : 0,
(u == t) ? 1 : 0,
(u != t) ? 1 : 0
)
requires(sizeof...(Ts) > 0) using lambda
For creating anonymous Invocables.