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, int > | concepts::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{})) \
), \
::concepts::detail::Nil \
> = {}) \
CPP_PP_IGNORE_CXX2A_COMPAT_END \
concepts::detail::Nil
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{})) \
), \
::concepts::detail::Nil \
> = {}) \
CPP_PP_EXPAND(CPP_PP_CAT(CPP_CTOR_SFINAE_SHOW_NOEXCEPT_, __VA_ARGS__))) \
concepts::detail::Nil
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
meta::requires
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)>>
)
meta::requires
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 )
(
concepts::swap(t, u)
)
meta::requires
requires(sizeof...(Ts) > 0) using lambda
For creating anonymous Invocables.
swap
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 ))
)
meta::requires
requires(sizeof...(Ts) > 0) using lambda
For creating anonymous Invocables.
swap
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
)
meta::requires
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 >
meta::requires
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...> >
meta::list
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
)
meta::requires
requires(sizeof...(Ts) > 0) using lambda
For creating anonymous Invocables.