\rSec0[meta]{Metaprogramming library}

\rSec1[meta.general]{General}

This Clause describes metaprogramming facilities.

These facilities are summarized in \tref{meta.summary}.

\begin{libsumtab}{Metaprogramming library summary}{meta.summary}

\ref{intseq} & Integer sequences & \tcode{<utility>} \\ \rowsep

\ref{type.traits} & Type traits & \tcode{<type_traits>} \\ \rowsep

\ref{meta.reflection} & Reflection & \tcode{<meta>} \\ \rowsep

\ref{ratio} & Rational arithmetic & \tcode{<ratio>} \\

\end{libsumtab}

\rSec1[intseq]{Compile-time integer sequences}

\rSec2[intseq.general]{General}

The library provides a class template that can represent an integer sequence.

When used as an argument to a function template the template parameter pack defining the

sequence can be deduced and used in a pack expansion.

\begin{note}

The \tcode{index_sequence} alias template is provided for the common case of

an integer sequence of type \tcode{size_t}; see also \ref{tuple.apply}.

\end{note}

\rSec2[intseq.intseq]{Class template \tcode{integer_sequence}}

\indexlibraryglobal{integer_sequence}%

\indexlibrarymember{value_type}{integer_sequence}%

\begin{codeblock}

namespace std {

template<class T, T... I> struct integer_sequence {

using value_type = T;

static constexpr size_t size() noexcept { return sizeof...(I); }

};

}

\end{codeblock}

\tcode{T} is an integer type.

\rSec2[intseq.make]{Alias template \tcode{make_integer_sequence}}

\indexlibraryglobal{make_integer_sequence}%

\begin{itemdecl}

template<class T, T N>

using make_integer_sequence = integer_sequence<T, @\seebelow{}@>;

\end{itemdecl}

\begin{itemdescr}

$\tcode{N} \geq 0$.

The alias template

\tcode{make_integer_sequence} denotes a specialization of

\tcode{integer_sequence} with \tcode{N} constant template arguments.

The type \tcode{make_integer_sequence<T, N>} is an alias for the type

\tcode{integer_sequence<T, 0, 1, $\dotsc$, N - 1>}.

\begin{note}

\tcode{make_integer_sequence<int, 0>} is an alias for the type

\tcode{integer_sequence<int>}.

\end{note}

\end{itemdescr}

\rSec2[intseq.binding]{Structured binding support}

\indexlibraryglobal{tuple_size}%

\indexlibraryglobal{tuple_element}%

\begin{itemdecl}

template<class T, T... Values>

struct tuple_size<integer_sequence<T, Values...>>

: integral_constant<size_t, sizeof...(Values)> { };

template<size_t I, class T, T... Values>

struct tuple_element<I, integer_sequence<T, Values...>> {

using type = T;

};

template<size_t I, class T, T... Values>

struct tuple_element<I, const integer_sequence<T, Values...>> {

using type = T;

};

\end{itemdecl}

\begin{itemdescr}

$\tcode{I} < \tcode{sizeof...(Values)}$.

\end{itemdescr}

\indexlibrarymember{get}{integer_sequence}%

\begin{itemdecl}

template<size_t I, class T, T... Values>

constexpr T get(integer_sequence<T, Values...>) noexcept;

\end{itemdecl}

\begin{itemdescr}

$\tcode{I} < \tcode{sizeof...(Values)}$.

\tcode{Values...[I]}.

\end{itemdescr}

\rSec1[type.traits]{Metaprogramming and type traits}

\rSec2[type.traits.general]{General}

Subclause \ref{type.traits} describes components used by \Cpp{} programs, particularly in

templates, to support the widest possible range of types, optimize

template code usage, detect type related user errors, and perform

type inference and transformation at compile time. It includes type

classification traits, type property inspection traits, and type

transformations. The type classification traits describe a complete taxonomy

of all possible \Cpp{} types, and state where in that taxonomy a given

type belongs. The type property inspection traits allow important

characteristics of types or of combinations of types to be inspected. The

type transformations allow certain properties of types to be manipulated.

\indextext{signal-safe!type traits}%

All functions specified in \ref{type.traits} are signal-safe\iref{support.signal}.

\rSec2[meta.rqmts]{Requirements}

A \defnoldconcept{UnaryTypeTrait} describes a property

of a type. It shall be a class template that takes one template type

argument and, optionally, additional arguments that help define the

property being described. It shall be \oldconcept{DefaultConstructible},

\oldconcept{CopyConstructible},

and publicly and unambiguously derived, directly or indirectly, from

its \defn{base characteristic}, which is

a specialization of the template

\tcode{integral_constant}\iref{meta.help}, with

the arguments to the template \tcode{integral_constant} determined by the

requirements for the particular property being described.

The member names of the base characteristic shall not be hidden and shall be

unambiguously available in the \oldconcept{UnaryTypeTrait}.

A \defnoldconcept{BinaryTypeTrait} describes a

relationship between two types. It shall be a class template that

takes two template type arguments and, optionally, additional

arguments that help define the relationship being described. It shall

be \oldconcept{DefaultConstructible}, \oldconcept{CopyConstructible},

and publicly and unambiguously derived, directly or

indirectly, from

its \term{base characteristic}, which is a specialization

of the template

\tcode{integral_constant}\iref{meta.help}, with

the arguments to the template \tcode{integral_constant} determined by the

requirements for the particular relationship being described.

The member names of the base characteristic shall not be hidden and shall be

unambiguously available in the \oldconcept{BinaryTypeTrait}.

A \defnoldconcept{TransformationTrait}

modifies a property

of a type. It shall be a class template that takes one

template type argument and, optionally, additional arguments that help

define the modification. It shall declare a publicly accessible nested type

named \tcode{type}, which shall be a synonym for the modified type.

Unless otherwise specified,

the behavior of a program that adds specializations

for any of the templates specified in \ref{type.traits}

is undefined.

Unless otherwise specified, an incomplete type may be used

to instantiate a template specified in \ref{type.traits}.

The behavior of a program is undefined if

\begin{itemize}

an instantiation of a template specified in \ref{type.traits}

directly or indirectly depends on

an incompletely-defined object type \tcode{T}, and

that instantiation could yield a different result

were \tcode{T} hypothetically completed.

\end{itemize}

\rSec2[meta.type.synop]{Header \tcode{<type_traits>} synopsis}

\indexheader{type_traits}%

\begin{codeblock}

// all freestanding

namespace std {

// \ref{meta.help}, helper class

template<class T, T v> struct integral_constant;

template<bool B>

using @\libglobal{bool_constant}@ = integral_constant<bool, B>;

using @\libglobal{true_type}@ = bool_constant<true>;

using @\libglobal{false_type}@ = bool_constant<false>;

// \ref{meta.unary.cat}, primary type categories

template<class T> struct is_void;

template<class T> struct is_null_pointer;

template<class T> struct is_integral;

template<class T> struct is_floating_point;

template<class T> struct is_array;

template<class T> struct is_pointer;

template<class T> struct is_lvalue_reference;

template<class T> struct is_rvalue_reference;

template<class T> struct is_member_object_pointer;

template<class T> struct is_member_function_pointer;

template<class T> struct is_enum;

template<class T> struct is_union;

template<class T> struct is_class;

template<class T> struct is_function;

template<class T> struct is_reflection;

// \ref{meta.unary.comp}, composite type categories

template<class T> struct is_reference;

template<class T> struct is_arithmetic;

template<class T> struct is_fundamental;

template<class T> struct is_object;

template<class T> struct is_scalar;

template<class T> struct is_compound;

template<class T> struct is_member_pointer;

// \ref{meta.unary.prop}, type properties

template<class T> struct is_const;

template<class T> struct is_volatile;

template<class T> struct is_trivially_copyable;

template<class T> struct is_standard_layout;

template<class T> struct is_empty;

template<class T> struct is_polymorphic;

template<class T> struct is_abstract;

template<class T> struct is_final;

template<class T> struct is_aggregate;

template<class T> struct is_structural;

template<class T> struct is_signed;

template<class T> struct is_unsigned;

template<class T> struct is_bounded_array;

template<class T> struct is_unbounded_array;

template<class T> struct is_scoped_enum;

template<class T, class... Args> struct is_constructible;

template<class T> struct is_default_constructible;

template<class T> struct is_copy_constructible;

template<class T> struct is_move_constructible;

template<class T, class U> struct is_assignable;

template<class T> struct is_copy_assignable;

template<class T> struct is_move_assignable;

template<class T, class U> struct is_swappable_with;

template<class T> struct is_swappable;

template<class T> struct is_destructible;

template<class T, class... Args> struct is_trivially_constructible;

template<class T> struct is_trivially_default_constructible;

template<class T> struct is_trivially_copy_constructible;

template<class T> struct is_trivially_move_constructible;

template<class T, class U> struct is_trivially_assignable;

template<class T> struct is_trivially_copy_assignable;

template<class T> struct is_trivially_move_assignable;

template<class T> struct is_trivially_destructible;

template<class T, class... Args> struct is_nothrow_constructible;

template<class T> struct is_nothrow_default_constructible;

template<class T> struct is_nothrow_copy_constructible;

template<class T> struct is_nothrow_move_constructible;

template<class T, class U> struct is_nothrow_assignable;

template<class T> struct is_nothrow_copy_assignable;

template<class T> struct is_nothrow_move_assignable;

template<class T, class U> struct is_nothrow_swappable_with;

template<class T> struct is_nothrow_swappable;

template<class T> struct is_nothrow_destructible;

template<class T> struct is_implicit_lifetime;

template<class T> struct has_virtual_destructor;

template<class T> struct has_unique_object_representations;

template<class T, class U> struct reference_constructs_from_temporary;

template<class T, class U> struct reference_converts_from_temporary;

// \ref{meta.unary.prop.query}, type property queries

template<class T> struct alignment_of;

template<class T> struct rank;

template<class T, unsigned I = 0> struct extent;

// \ref{meta.rel}, type relations

template<class T, class U> struct is_same;

template<class Base, class Derived> struct is_base_of;

template<class Base, class Derived> struct is_virtual_base_of;

template<class From, class To> struct is_convertible;

template<class From, class To> struct is_nothrow_convertible;

template<class T, class U> struct is_layout_compatible;

template<class Base, class Derived> struct is_pointer_interconvertible_base_of;

template<class Fn, class... ArgTypes> struct is_invocable;

template<class R, class Fn, class... ArgTypes> struct is_invocable_r;

template<class Fn, class... ArgTypes> struct is_nothrow_invocable;

template<class R, class Fn, class... ArgTypes> struct is_nothrow_invocable_r;

template<class Fn, class Tuple> struct is_applicable;

template<class Fn, class Tuple> struct is_nothrow_applicable;

// \ref{meta.trans.cv}, const-volatile modifications

template<class T> struct remove_const;

template<class T> struct remove_volatile;

template<class T> struct remove_cv;

template<class T> struct add_const;

template<class T> struct add_volatile;

template<class T> struct add_cv;

template<class T>

using @\libglobal{remove_const_t}@ = remove_const<T>::type;

template<class T>

using @\libglobal{remove_volatile_t}@ = remove_volatile<T>::type;

template<class T>

using @\libglobal{remove_cv_t}@ = remove_cv<T>::type;

template<class T>

using @\libglobal{add_const_t}@ = add_const<T>::type;

template<class T>

using @\libglobal{add_volatile_t}@ = add_volatile<T>::type;

template<class T>

using @\libglobal{add_cv_t}@ = add_cv<T>::type;

// \ref{meta.trans.ref}, reference modifications

template<class T> struct remove_reference;

template<class T> struct add_lvalue_reference;

template<class T> struct add_rvalue_reference;

template<class T>

using @\libglobal{remove_reference_t}@ = remove_reference<T>::type;

template<class T>

using @\libglobal{add_lvalue_reference_t}@ = add_lvalue_reference<T>::type;

template<class T>

using @\libglobal{add_rvalue_reference_t}@ = add_rvalue_reference<T>::type;

// \ref{meta.trans.sign}, sign modifications

template<class T> struct make_signed;

template<class T> struct make_unsigned;

template<class T>

using @\libglobal{make_signed_t}@ = make_signed<T>::type;

template<class T>

using @\libglobal{make_unsigned_t}@ = make_unsigned<T>::type;

// \ref{meta.trans.arr}, array modifications

template<class T> struct remove_extent;

template<class T> struct remove_all_extents;

template<class T>

using @\libglobal{remove_extent_t}@ = remove_extent<T>::type;

template<class T>

using @\libglobal{remove_all_extents_t}@ = remove_all_extents<T>::type;

// \ref{meta.trans.ptr}, pointer modifications

template<class T> struct remove_pointer;

template<class T> struct add_pointer;

template<class T>

using @\libglobal{remove_pointer_t}@ = remove_pointer<T>::type;

template<class T>

using @\libglobal{add_pointer_t}@ = add_pointer<T>::type;

// \ref{meta.trans.other}, other transformations

template<class T> struct type_identity;

template<class T> struct remove_cvref;

template<class T> struct decay;

template<bool, class T = void> struct enable_if;

template<bool, class T, class F> struct conditional;

template<class... T> struct common_type;

template<class T, class U, template<class> class TQual, template<class> class UQual>

struct basic_common_reference { };

template<class... T> struct common_reference;

template<class T> struct underlying_type;

template<class Fn, class... ArgTypes> struct invoke_result;

template<class Fn, class Tuple> struct apply_result;

template<class T> struct unwrap_reference;

template<class T> struct unwrap_ref_decay;

template<class T>

using @\libglobal{type_identity_t}@ = type_identity<T>::type;

template<class T>

using @\libglobal{remove_cvref_t}@ = remove_cvref<T>::type;

template<class T>

using @\libglobal{decay_t}@ = decay<T>::type;

template<bool B, class T = void>

using @\libglobal{enable_if_t}@ = enable_if<B, T>::type;

template<bool B, class T, class F>

using @\libglobal{conditional_t}@ = conditional<B, T, F>::type;

template<class... T>

using @\libglobal{common_type_t}@ = common_type<T...>::type;

template<class... T>

using @\libglobal{common_reference_t}@ = common_reference<T...>::type;

template<class T>

using @\libglobal{underlying_type_t}@ = underlying_type<T>::type;

template<class Fn, class... ArgTypes>

using @\libglobal{invoke_result_t}@ = invoke_result<Fn, ArgTypes...>::type;

template<class Fn, class Tuple>

using @\libglobal{apply_result_t}@ = apply_result<Fn, Tuple>::type;

template<class T>

using @\libglobal{unwrap_reference_t}@ = unwrap_reference<T>::type;

template<class T>

using @\libglobal{unwrap_ref_decay_t}@ = unwrap_ref_decay<T>::type;

template<class...>

using @\libglobal{void_t}@ = void;

// \ref{meta.logical}, logical operator traits

template<class... B> struct conjunction;

template<class... B> struct disjunction;

template<class B> struct negation;

// \ref{meta.unary.cat}, primary type categories

template<class T>

constexpr bool @\libglobal{is_void_v}@ = is_void<T>::value;

template<class T>

constexpr bool @\libglobal{is_null_pointer_v}@ = is_null_pointer<T>::value;

template<class T>

constexpr bool @\libglobal{is_integral_v}@ = is_integral<T>::value;

template<class T>

constexpr bool @\libglobal{is_floating_point_v}@ = is_floating_point<T>::value;

template<class T>

constexpr bool @\libglobal{is_array_v}@ = is_array<T>::value;

template<class T>

constexpr bool @\libglobal{is_pointer_v}@ = is_pointer<T>::value;

template<class T>

constexpr bool @\libglobal{is_lvalue_reference_v}@ = is_lvalue_reference<T>::value;

template<class T>

constexpr bool @\libglobal{is_rvalue_reference_v}@ = is_rvalue_reference<T>::value;

template<class T>

constexpr bool @\libglobal{is_member_object_pointer_v}@ = is_member_object_pointer<T>::value;

template<class T>

constexpr bool @\libglobal{is_member_function_pointer_v}@ = is_member_function_pointer<T>::value;

template<class T>

constexpr bool @\libglobal{is_enum_v}@ = is_enum<T>::value;

template<class T>

constexpr bool @\libglobal{is_union_v}@ = is_union<T>::value;

template<class T>

constexpr bool @\libglobal{is_class_v}@ = is_class<T>::value;

template<class T>

constexpr bool @\libglobal{is_function_v}@ = is_function<T>::value;

template<class T>

constexpr bool @\libglobal{is_reflection_v}@ = is_reflection<T>::value;

// \ref{meta.unary.comp}, composite type categories

template<class T>

constexpr bool @\libglobal{is_reference_v}@ = is_reference<T>::value;

template<class T>

constexpr bool @\libglobal{is_arithmetic_v}@ = is_arithmetic<T>::value;

template<class T>

constexpr bool @\libglobal{is_fundamental_v}@ = is_fundamental<T>::value;

template<class T>

constexpr bool @\libglobal{is_object_v}@ = is_object<T>::value;

template<class T>

constexpr bool @\libglobal{is_scalar_v}@ = is_scalar<T>::value;

template<class T>

constexpr bool @\libglobal{is_compound_v}@ = is_compound<T>::value;

template<class T>

constexpr bool @\libglobal{is_member_pointer_v}@ = is_member_pointer<T>::value;

// \ref{meta.unary.prop}, type properties

template<class T>

constexpr bool @\libglobal{is_const_v}@ = is_const<T>::value;

template<class T>

constexpr bool @\libglobal{is_volatile_v}@ = is_volatile<T>::value;

template<class T>

constexpr bool @\libglobal{is_trivially_copyable_v}@ = is_trivially_copyable<T>::value;

template<class T>

constexpr bool @\libglobal{is_standard_layout_v}@ = is_standard_layout<T>::value;

template<class T>

constexpr bool @\libglobal{is_empty_v}@ = is_empty<T>::value;

template<class T>

constexpr bool @\libglobal{is_polymorphic_v}@ = is_polymorphic<T>::value;

template<class T>

constexpr bool @\libglobal{is_abstract_v}@ = is_abstract<T>::value;

template<class T>

constexpr bool @\libglobal{is_final_v}@ = is_final<T>::value;

template<class T>

constexpr bool @\libglobal{is_aggregate_v}@ = is_aggregate<T>::value;

template<class T>

constexpr bool @\libglobal{is_structural_v}@ = is_structural<T>::value;

template<class T>

constexpr bool @\libglobal{is_signed_v}@ = is_signed<T>::value;

template<class T>

constexpr bool @\libglobal{is_unsigned_v}@ = is_unsigned<T>::value;

template<class T>

constexpr bool @\libglobal{is_bounded_array_v}@ = is_bounded_array<T>::value;

template<class T>

constexpr bool @\libglobal{is_unbounded_array_v}@ = is_unbounded_array<T>::value;

template<class T>

constexpr bool @\libglobal{is_scoped_enum_v}@ = is_scoped_enum<T>::value;

template<class T, class... Args>

constexpr bool @\libglobal{is_constructible_v}@ = is_constructible<T, Args...>::value;

template<class T>

constexpr bool @\libglobal{is_default_constructible_v}@ = is_default_constructible<T>::value;

template<class T>

constexpr bool @\libglobal{is_copy_constructible_v}@ = is_copy_constructible<T>::value;

template<class T>

constexpr bool @\libglobal{is_move_constructible_v}@ = is_move_constructible<T>::value;

template<class T, class U>

constexpr bool @\libglobal{is_assignable_v}@ = is_assignable<T, U>::value;

template<class T>

constexpr bool @\libglobal{is_copy_assignable_v}@ = is_copy_assignable<T>::value;

template<class T>

constexpr bool @\libglobal{is_move_assignable_v}@ = is_move_assignable<T>::value;

template<class T, class U>

constexpr bool @\libglobal{is_swappable_with_v}@ = is_swappable_with<T, U>::value;

template<class T>

constexpr bool @\libglobal{is_swappable_v}@ = is_swappable<T>::value;

template<class T>

constexpr bool @\libglobal{is_destructible_v}@ = is_destructible<T>::value;

template<class T, class... Args>

constexpr bool @\libglobal{is_trivially_constructible_v}@ = is_trivially_constructible<T, Args...>::value;

template<class T>

constexpr bool @\libglobal{is_trivially_default_constructible_v}@

= is_trivially_default_constructible<T>::value;

template<class T>

constexpr bool @\libglobal{is_trivially_copy_constructible_v}@ = is_trivially_copy_constructible<T>::value;

template<class T>

constexpr bool @\libglobal{is_trivially_move_constructible_v}@ = is_trivially_move_constructible<T>::value;

template<class T, class U>

constexpr bool @\libglobal{is_trivially_assignable_v}@ = is_trivially_assignable<T, U>::value;

template<class T>

constexpr bool @\libglobal{is_trivially_copy_assignable_v}@ = is_trivially_copy_assignable<T>::value;

template<class T>

constexpr bool @\libglobal{is_trivially_move_assignable_v}@ = is_trivially_move_assignable<T>::value;

template<class T>

constexpr bool @\libglobal{is_trivially_destructible_v}@ = is_trivially_destructible<T>::value;

template<class T, class... Args>

constexpr bool @\libglobal{is_nothrow_constructible_v}@ = is_nothrow_constructible<T, Args...>::value;

template<class T>

constexpr bool @\libglobal{is_nothrow_default_constructible_v}@

= is_nothrow_default_constructible<T>::value;

template<class T>

constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<T>::value;

template<class T>

constexpr bool @\libglobal{is_nothrow_move_constructible_v}@ = is_nothrow_move_constructible<T>::value;

template<class T, class U>

constexpr bool @\libglobal{is_nothrow_assignable_v}@ = is_nothrow_assignable<T, U>::value;

template<class T>

constexpr bool @\libglobal{is_nothrow_copy_assignable_v}@ = is_nothrow_copy_assignable<T>::value;

template<class T>

constexpr bool @\libglobal{is_nothrow_move_assignable_v}@ = is_nothrow_move_assignable<T>::value;

template<class T, class U>

constexpr bool @\libglobal{is_nothrow_swappable_with_v}@ = is_nothrow_swappable_with<T, U>::value;

template<class T>

constexpr bool @\libglobal{is_nothrow_swappable_v}@ = is_nothrow_swappable<T>::value;

template<class T>

constexpr bool @\libglobal{is_nothrow_destructible_v}@ = is_nothrow_destructible<T>::value;

template<class T>

constexpr bool @\libglobal{is_implicit_lifetime_v}@ = is_implicit_lifetime<T>::value;

template<class T>

constexpr bool @\libglobal{has_virtual_destructor_v}@ = has_virtual_destructor<T>::value;

template<class T>

constexpr bool @\libglobal{has_unique_object_representations_v}@

= has_unique_object_representations<T>::value;

template<class T, class U>

constexpr bool @\libglobal{reference_constructs_from_temporary_v}@

= reference_constructs_from_temporary<T, U>::value;

template<class T, class U>

constexpr bool @\libglobal{reference_converts_from_temporary_v}@

= reference_converts_from_temporary<T, U>::value;

// \ref{meta.unary.prop.query}, type property queries

template<class T>

constexpr size_t @\libglobal{alignment_of_v}@ = alignment_of<T>::value;

template<class T>

constexpr size_t @\libglobal{rank_v}@ = rank<T>::value;

template<class T, unsigned I = 0>

constexpr size_t @\libglobal{extent_v}@ = extent<T, I>::value;

// \ref{meta.rel}, type relations

template<class T, class U>

constexpr bool @\libglobal{is_same_v}@ = is_same<T, U>::value;

template<class Base, class Derived>

constexpr bool @\libglobal{is_base_of_v}@ = is_base_of<Base, Derived>::value;

template<class Base, class Derived>

constexpr bool @\libglobal{is_virtual_base_of_v}@ = is_virtual_base_of<Base, Derived>::value;

template<class From, class To>

constexpr bool @\libglobal{is_convertible_v}@ = is_convertible<From, To>::value;

template<class From, class To>

constexpr bool @\libglobal{is_nothrow_convertible_v}@ = is_nothrow_convertible<From, To>::value;

template<class T, class U>

constexpr bool @\libglobal{is_layout_compatible_v}@ = is_layout_compatible<T, U>::value;

template<class Base, class Derived>

constexpr bool @\libglobal{is_pointer_interconvertible_base_of_v}@

= is_pointer_interconvertible_base_of<Base, Derived>::value;

template<class Fn, class... ArgTypes>

constexpr bool @\libglobal{is_invocable_v}@ = is_invocable<Fn, ArgTypes...>::value;

template<class R, class Fn, class... ArgTypes>

constexpr bool @\libglobal{is_invocable_r_v}@ = is_invocable_r<R, Fn, ArgTypes...>::value;

template<class Fn, class... ArgTypes>

constexpr bool @\libglobal{is_nothrow_invocable_v}@ = is_nothrow_invocable<Fn, ArgTypes...>::value;

template<class R, class Fn, class... ArgTypes>

constexpr bool @\libglobal{is_nothrow_invocable_r_v}@ = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;

template<class Fn, class Tuple>

constexpr bool @\libglobal{is_applicable_v}@ = is_applicable<Fn, Tuple>::value;

template<class Fn, class Tuple>

constexpr bool @\libglobal{is_nothrow_applicable_v}@ = is_nothrow_applicable<Fn, Tuple>::value;

// \ref{meta.logical}, logical operator traits

template<class... B>

constexpr bool @\libglobal{conjunction_v}@ = conjunction<B...>::value;

template<class... B>

constexpr bool @\libglobal{disjunction_v}@ = disjunction<B...>::value;

template<class B>

constexpr bool @\libglobal{negation_v}@ = negation<B>::value;

// \ref{meta.member}, member relationships

template<class S, class M>

constexpr bool is_pointer_interconvertible_with_class(M S::*m) noexcept;

template<class S1, class S2, class M1, class M2>

constexpr bool is_corresponding_member(M1 S1::*m1, M2 S2::*m2) noexcept;

// \ref{meta.const.eval}, constant evaluation context

constexpr bool is_constant_evaluated() noexcept;

template<class U = void, class T>

consteval bool is_within_lifetime(const T*) noexcept;

}

\end{codeblock}

\rSec2[meta.help]{Helper classes}

\indexlibrarymember{value_type}{integral_constant}%

\begin{codeblock}

namespace std {

template<class T, T v> struct @\libglobal{integral_constant}@ {

static constexpr T value = v;

using value_type = T;

using type = integral_constant<T, v>;

constexpr operator value_type() const noexcept { return value; }

constexpr value_type operator()() const noexcept { return value; }

};

}

\end{codeblock}

\indexlibraryglobal{bool_constant}%

\indexlibraryglobal{true_type}%

\indexlibraryglobal{false_type}%

The class template \tcode{integral_constant},

alias template \tcode{bool_constant}, and

its associated \grammarterm{typedef-name}{s}

\tcode{true_type} and \tcode{false_type}

are used as base classes to define

the interface for various type traits.

\rSec2[meta.unary]{Unary type traits}

\rSec3[meta.unary.general]{General}

Subclause \ref{meta.unary} contains templates that may be used to query the

properties of a type at compile time.

Each of these templates shall be a

\oldconcept{UnaryTypeTrait}\iref{meta.rqmts}

with a base characteristic of

\tcode{true_type} if the corresponding condition is \tcode{true}, otherwise

\tcode{false_type}.

\rSec3[meta.unary.cat]{Primary type categories}

The primary type categories specified in \tref{meta.unary.cat}

correspond to the descriptions given in

subclause~\ref{basic.types} of the \Cpp{} standard.

For any given type \tcode{T}, the result of applying one of these templates to

\tcode{T} and to \cv{}~\tcode{T} shall yield the same result.

\begin{note}

For any given type \tcode{T}, exactly one of the primary type categories

has a \tcode{value} member that evaluates to \tcode{true}.

\end{note}

\begin{libreqtab3e}{Primary type category predicates}{meta.unary.cat}

\\ \topline

\lhdr{Template} & \chdr{Condition} & \rhdr{Comments} \\\capsep

\lhdr{Template} & \chdr{Condition} & \rhdr{Comments} \\ \capsep

\indexlibraryglobal{is_void}%

\tcode{template<class T>}\br

\tcode{struct is_void;} &

\tcode{T} is \keyword{void} & \\ \rowsep

\indexlibraryglobal{is_null_pointer}%

\tcode{template<class T>}\br

\tcode{struct is_null_pointer;} &

\tcode{T} is \tcode{nullptr_t}\iref{basic.fundamental} & \\ \rowsep

\indexlibraryglobal{is_integral}%

\tcode{template<class T>}\br

\tcode{struct is_integral;} &

\tcode{T} is an integral type\iref{basic.fundamental} & \\ \rowsep

\indexlibraryglobal{is_floating_point}%

\tcode{template<class T>}\br

\tcode{struct is_floating_point;} &

\tcode{T} is a floating-point type\iref{basic.fundamental} & \\ \rowsep

\indexlibraryglobal{is_array}%

\tcode{template<class T>}\br

\tcode{struct is_array;} &

\tcode{T} is an array type\iref{basic.compound} of known or unknown extent &

Class template \tcode{array}\iref{array}

is not an array type. \\ \rowsep

\indexlibraryglobal{is_pointer}%

\tcode{template<class T>}\br

\tcode{struct is_pointer;} &

\tcode{T} is a pointer type\iref{basic.compound} &

Includes pointers to functions

but not pointers to non-static members. \\ \rowsep

\indexlibraryglobal{is_lvalue_reference}%

\tcode{template<class T>}\br

\tcode{struct is_lvalue_reference;} &

\tcode{T} is an lvalue reference type\iref{dcl.ref} & \\ \rowsep

\indexlibraryglobal{is_rvalue_reference}%

\tcode{template<class T>}\br

\tcode{struct is_rvalue_reference;} &

\tcode{T} is an rvalue reference type\iref{dcl.ref} & \\ \rowsep

\indexlibraryglobal{is_member_object_pointer}%

\tcode{template<class T>}\br

\tcode{struct is_member_object_pointer;}&

\tcode{T} is a pointer to data member & \\ \rowsep

\indexlibraryglobal{is_member_function_pointer}%

\tcode{template<class T>}\br

\tcode{struct is_member_function_pointer;}&

\tcode{T} is a pointer to member function & \\ \rowsep

\indexlibraryglobal{is_enum}%

\tcode{template<class T>}\br

\tcode{struct is_enum;} &

\tcode{T} is an enumeration type\iref{basic.compound} & \\ \rowsep

\indexlibraryglobal{is_union}%

\tcode{template<class T>}\br

\tcode{struct is_union;} &

\tcode{T} is a union type\iref{basic.compound} & \\ \rowsep

\indexlibraryglobal{is_class}%

\tcode{template<class T>}\br

\tcode{struct is_class;} &

\tcode{T} is a non-union class type\iref{basic.compound} & \\ \rowsep

\indexlibraryglobal{is_function}%

\tcode{template<class T>}\br

\tcode{struct is_function;} &

\tcode{T} is a function type\iref{basic.compound} & \\ \rowsep

\indexlibraryglobal{is_reflection}%

\tcode{template<class T>}\br

\tcode{struct is_reflection;} &

\tcode{T} is \tcode{std::meta::info}\iref{basic.fundamental} & \\

\end{libreqtab3e}

\rSec3[meta.unary.comp]{Composite type traits}

The templates specified in \tref{meta.unary.comp}

provide convenient compositions of the primary type categories,

corresponding to the descriptions given in subclause~\ref{basic.types}.

For any given type \tcode{T}, the result of applying one of these templates to

\tcode{T} and to \cv{}~\tcode{T} shall yield the same result.

\begin{libreqtab3b}{Composite type category predicates}{meta.unary.comp}

\\ \topline

\lhdr{Template} & \chdr{Condition} & \rhdr{Comments} \\ \capsep

\lhdr{Template} & \chdr{Condition} & \rhdr{Comments} \\ \capsep

\indexlibraryglobal{is_reference}%

\tcode{template<class T>}\br

\tcode{struct is_reference;} &

\tcode{T} is an lvalue reference or an rvalue reference & \\ \rowsep

\indexlibraryglobal{is_arithmetic}%

\tcode{template<class T>}\br

\tcode{struct is_arithmetic;} &

\tcode{T} is an arithmetic type\iref{basic.fundamental} & \\ \rowsep

\indexlibraryglobal{is_fundamental}%

\tcode{template<class T>}\br

\tcode{struct is_fundamental;} &

\tcode{T} is a fundamental type\iref{basic.fundamental} & \\ \rowsep

\indexlibraryglobal{is_object}%

\tcode{template<class T>}\br

\tcode{struct is_object;} &

\tcode{T} is an object type\iref{term.object.type} & \\ \rowsep

\indexlibraryglobal{is_scalar}%

\tcode{template<class T>}\br

\tcode{struct is_scalar;} &

\tcode{T} is a scalar type\iref{term.scalar.type} & \\ \rowsep

\indexlibraryglobal{is_compound}%

\tcode{template<class T>}\br

\tcode{struct is_compound;} &

\tcode{T} is a compound type\iref{basic.compound} & \\ \rowsep

\indexlibraryglobal{is_member_pointer}%

\tcode{template<class T>}\br

\tcode{struct is_member_pointer;} &

\tcode{T} is a pointer-to-member type\iref{basic.compound} & \\

\end{libreqtab3b}

\rSec3[meta.unary.prop]{Type properties}

The templates specified in \tref{meta.unary.prop}

provide access to some of the more important properties of types.

It is unspecified whether the library defines any full or partial

specializations of any of these templates.

For all of the class templates \tcode{X} declared in this subclause,

instantiating that template with a template-argument that is a class

template specialization may result in the implicit instantiation of

the template argument if and only if the semantics of \tcode{X} require that

the argument is a complete type.

For the purpose of defining the templates in this subclause,

a function call expression \tcode{declval<T>()} for any type \tcode{T}

is considered to be a trivial\iref{term.trivial.type,special} function call

that is not an odr-use\iref{term.odr.use} of \tcode{declval}

in the context of the corresponding definition

notwithstanding the restrictions of~\ref{declval}.

For the purpose of defining the templates in this subclause,

let \tcode{\placeholdernc{VAL}<T>} for some type \tcode{T} be

an expression defined as follows:

\begin{itemize}

If \tcode{T} is a reference or function type,

\tcode{\placeholdernc{VAL}<T>} is an expression

with the same type and value category as \tcode{declval<T>()}.

Otherwise, \tcode{\placeholdernc{VAL}<T>} is a prvalue

that initially has type \tcode{T}.

\begin{note}

If \tcode{T} is cv-qualified,

the cv-qualification is subject to adjustment\iref{expr.type}.

\end{note}

\end{itemize}

\begin{libreqtab3b}{Type property predicates}{meta.unary.prop}

\\ \topline

\lhdr{Template} & \chdr{Condition} & \rhdr{Preconditions} \\ \capsep

\lhdr{Template} & \chdr{Condition} & \rhdr{Preconditions} \\ \capsep

\indexlibraryglobal{is_const}%

\tcode{template<class T>}\br

\tcode{struct is_const;} &

\tcode{T} is const-qualified\iref{basic.type.qualifier} & \\ \rowsep

\indexlibraryglobal{is_volatile}%

\tcode{template<class T>}\br

\tcode{struct is_volatile;} &

\tcode{T} is volatile-qualified\iref{basic.type.qualifier} & \\ \rowsep

\indexlibraryglobal{is_trivially_copyable}%

\tcode{template<class T>}\br

\tcode{struct is_trivially_copyable;} &

\tcode{T} is a trivially copyable type\iref{term.trivially.copyable.type} &

\tcode{remove_all_extents_t<T>} shall be a complete type or

\cv{}~\keyword{void}. \\ \rowsep

\indexlibraryglobal{is_standard_layout}%

\tcode{template<class T>}\br

\tcode{struct is_standard_layout;} &

\tcode{T} is a standard-layout type\iref{term.standard.layout.type} &

\tcode{remove_all_extents_t<T>} shall be a complete

type or \cv{}~\keyword{void}. \\ \rowsep

\indexlibrary{\idxcode{is_empty}!class}%

\tcode{template<class T>}\br

\tcode{struct is_empty;} &

\tcode{T} is a class type, but not a union type, with no non-static data

members other than subobjects of zero size, no virtual member functions,

no virtual base classes, and no base class \tcode{B} for

which \tcode{is_empty_v<B>} is \tcode{false}. &

If \tcode{T} is a non-union class type, \tcode{T} shall be a complete type. \\ \rowsep

\indexlibraryglobal{is_polymorphic}%

\tcode{template<class T>}\br

\tcode{struct is_polymorphic;} &

\tcode{T} is a polymorphic class\iref{class.virtual} &

If \tcode{T} is a non-union class type, \tcode{T} shall be a complete type. \\ \rowsep

\indexlibraryglobal{is_abstract}%

\tcode{template<class T>}\br

\tcode{struct is_abstract;} &

\tcode{T} is an abstract class\iref{class.abstract} &

If \tcode{T} is a non-union class type, \tcode{T} shall be a complete type. \\ \rowsep

\indexlibraryglobal{is_final}%

\tcode{template<class T>}\br

\tcode{struct is_final;} &

\tcode{T} is a class type marked with the \grammarterm{class-property-specifier}

\tcode{final}\iref{class.pre}.

\begin{tailnote}

A union is a class type that

can be marked with \tcode{final}.

\end{tailnote}

&

If \tcode{T} is a class type, \tcode{T} shall be a complete type. \\ \rowsep

\indexlibraryglobal{is_aggregate}%

\tcode{template<class T>}\br

\tcode{struct is_aggregate;} &

\tcode{T} is an aggregate type\iref{dcl.init.aggr} &

\tcode{T} shall be an array type, a complete type, or \cv~\keyword{void}. \\ \rowsep

\indexlibraryglobal{is_structural}%

\tcode{template<class T>}\br

\tcode{struct is_structural;} &

\tcode{T} is a structural type\iref{temp.param} &

\tcode{remove_all_extents_t<T>} shall be a complete type or \cv~\keyword{void}. \\ \rowsep

\indexlibrary{\idxcode{is_signed}!class}%

\tcode{template<class T>}\br

\tcode{struct is_signed;} &

If \tcode{is_arithmetic_v<T>} is \tcode{true}, the same result as

\tcode{T(-1) < T(0)};

otherwise, \tcode{false} & \\ \rowsep

\indexlibraryglobal{is_unsigned}%

\tcode{template<class T>}\br

\tcode{struct is_unsigned;} &

If \tcode{is_arithmetic_v<T>} is \tcode{true}, the same result as

\tcode{T(0) < T(-1)};

otherwise, \tcode{false} & \\ \rowsep

\indexlibraryglobal{is_bounded_array}%

\tcode{template<class T>}\br

\tcode{struct is_bounded_array;} &

\tcode{T} is an array type of known bound\iref{dcl.array}

& \\ \rowsep

\indexlibraryglobal{is_unbounded_array}%

\tcode{template<class T>}\br

\tcode{struct is_unbounded_array;} &

\tcode{T} is an array type of unknown bound\iref{dcl.array}

& \\ \rowsep

\indexlibraryglobal{is_scoped_enum}%

\tcode{template<class T>}\br

\tcode{struct is_scoped_enum;} &

\tcode{T} is a scoped enumeration\iref{dcl.enum}

& \\ \rowsep

\indexlibraryglobal{is_constructible}%

\tcode{template<class T, class... Args>}\br

\tcode{struct is_constructible;} &

For a function type \tcode{T} or

for a \cv{}~\keyword{void} type \tcode{T},

\tcode{is_constructible_v<T, Args...>} is \tcode{false},

otherwise \seebelow &

\tcode{T} and all types in the template parameter pack \tcode{Args}

shall be complete types, \cv{}~\keyword{void},

or arrays of unknown bound. \\ \rowsep

\indexlibraryglobal{is_default_constructible}%

\tcode{template<class T>}\br

\tcode{struct is_default_constructible;} &

\tcode{is_constructible_v<T>} is \tcode{true}. &

\tcode{T} shall be a complete type, \cv{}~\keyword{void},

or an array of unknown bound. \\ \rowsep

\indexlibraryglobal{is_copy_constructible}%

\tcode{template<class T>}\br

\tcode{struct is_copy_constructible;} &

For a referenceable type \tcode{T}\iref{defns.referenceable}, the same result as

\tcode{is_constructible_v<T, const T\&>}, otherwise \tcode{false}. &

\tcode{T} shall be a complete type, \cv{}~\keyword{void},

or an array of unknown bound. \\ \rowsep