\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}

\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 define 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{const.wrap.class}, class template \tcode{constant_wrapper}

template<class T>

struct @\exposidnc{cw-fixed-value}@; // \expos

template<@\exposidnc{cw-fixed-value}@ X, class = typename decltype(X)::@\exposid{type}@>

struct constant_wrapper;

template<class T>

concept @\defexposconceptnc{constexpr-param}@ = // \expos

requires { typename constant_wrapper<T::value>; };

struct @\exposidnc{cw-operators}@; // \expos

template<@\exposid{cw-fixed-value}@ X>

constexpr auto @\libglobal{cw}@ = constant_wrapper<X>{};

// \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_trivially_relocatable;

template<class T> struct is_replaceable;

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_consteval_only;

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_nothrow_relocatable;

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_trivially_relocatable_v}@ = is_trivially_relocatable<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_consteval_only_v}@ = is_consteval_only<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_nothrow_relocatable_v}@ = is_nothrow_relocatable<T>::value;

template<class T>

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

template<class T>

constexpr bool @\libglobal{is_replaceable_v}@ = is_replaceable<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;

consteval bool is_within_lifetime(const auto*) 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[const.wrap.class]{Class template \tcode{constant_wrapper}}

\begin{codeblock}

namespace std {

template<class T>

struct @\exposidnc{cw-fixed-value}@ { // \expos

using @\exposidnc{type}@ = T; // \expos

constexpr @\exposidnc{cw-fixed-value}@(@\exposidnc{type}@ v) noexcept : @\exposidnc{data}@(v) {}

T @\exposidnc{data}@; // \expos

};

template<class T, size_t Extent>

struct @\exposidnc{cw-fixed-value}@<T[Extent]> { // \expos

using @\exposidnc{type}@ = T[Extent]; // \expos

constexpr @\exposidnc{cw-fixed-value}@(T (&arr)[Extent]) noexcept;

T @\exposidnc{data}@[Extent]; // \expos

};

template<class T, size_t Extent>

@\exposidnc{cw-fixed-value}@(T (&)[Extent]) -> @\exposidnc{cw-fixed-value}@<T[Extent]>; // \expos

struct @\exposidnc{cw-operators}@ { // \expos

// unary operators

template<@\exposconcept{constexpr-param}@ T>

friend constexpr auto operator+(T) noexcept -> constant_wrapper<(+T::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ T>

friend constexpr auto operator-(T) noexcept -> constant_wrapper<(-T::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ T>

friend constexpr auto operator~(T) noexcept -> constant_wrapper<(~T::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ T>

friend constexpr auto operator!(T) noexcept -> constant_wrapper<(!T::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ T>

friend constexpr auto operator&(T) noexcept -> constant_wrapper<(&T::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ T>

friend constexpr auto operator*(T) noexcept -> constant_wrapper<(*T::value)>

{ return {}; }

// binary operators

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

friend constexpr auto operator+(L, R) noexcept -> constant_wrapper<(L::value + R::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

friend constexpr auto operator-(L, R) noexcept -> constant_wrapper<(L::value - R::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

friend constexpr auto operator*(L, R) noexcept -> constant_wrapper<(L::value * R::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

friend constexpr auto operator/(L, R) noexcept -> constant_wrapper<(L::value / R::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

friend constexpr auto operator%(L, R) noexcept -> constant_wrapper<(L::value % R::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

friend constexpr auto operator<<(L, R) noexcept -> constant_wrapper<(L::value << R::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

friend constexpr auto operator>>(L, R) noexcept -> constant_wrapper<(L::value >> R::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

friend constexpr auto operator&(L, R) noexcept -> constant_wrapper<(L::value & R::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

friend constexpr auto operator|(L, R) noexcept -> constant_wrapper<(L::value | R::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

friend constexpr auto operator^(L, R) noexcept -> constant_wrapper<(L::value ^ R::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

requires (!is_constructible_v<bool, decltype(L::value)> ||

!is_constructible_v<bool, decltype(R::value)>)

friend constexpr auto operator&&(L, R) noexcept

-> constant_wrapper<(L::value && R::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

requires (!is_constructible_v<bool, decltype(L::value)> ||

!is_constructible_v<bool, decltype(R::value)>)

friend constexpr auto operator||(L, R) noexcept

-> constant_wrapper<(L::value || R::value)>

{ return {}; }

// comparisons

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

friend constexpr auto operator<=>(L, R) noexcept

-> constant_wrapper<(L::value <=> R::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

friend constexpr auto operator<(L, R) noexcept -> constant_wrapper<(L::value < R::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

friend constexpr auto operator<=(L, R) noexcept -> constant_wrapper<(L::value <= R::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

friend constexpr auto operator==(L, R) noexcept -> constant_wrapper<(L::value == R::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

friend constexpr auto operator!=(L, R) noexcept -> constant_wrapper<(L::value != R::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

friend constexpr auto operator>(L, R) noexcept -> constant_wrapper<(L::value > R::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

friend constexpr auto operator>=(L, R) noexcept -> constant_wrapper<(L::value >= R::value)>

{ return {}; }

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

friend constexpr auto operator,(L, R) noexcept = delete;

template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>

friend constexpr auto operator->*(L, R) noexcept -> constant_wrapper<L::value->*(R::value)>

{ return {}; }

// call and index

template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@... Args>

constexpr auto operator()(this T, Args...) noexcept

requires requires { constant_wrapper<T::value(Args::value...)>(); }

{ return constant_wrapper<T::value(Args::value...)>{}; }

template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@... Args>

constexpr auto operator[](this T, Args...) noexcept

-> constant_wrapper<(T::value[Args::value...])>

{ return {}; }

// pseudo-mutators

template<@\exposconcept{constexpr-param}@ T>

constexpr auto operator++(this T) noexcept

requires requires(T::value_type x) { ++x; }

{ return constant_wrapper<[] { auto c = T::value; return ++c; }()>{}; }

template<@\exposconcept{constexpr-param}@ T>

constexpr auto operator++(this T, int) noexcept

requires requires(T::value_type x) { x++; }

{ return constant_wrapper<[] { auto c = T::value; return c++; }()>{}; }

template<@\exposconcept{constexpr-param}@ T>

constexpr auto operator--(this T) noexcept

requires requires(T::value_type x) { --x; }

{ return constant_wrapper<[] { auto c = T::value; return --c; }()>{}; }

template<@\exposconcept{constexpr-param}@ T>

constexpr auto operator--(this T, int) noexcept

requires requires(T::value_type x) { x--; }

{ return constant_wrapper<[] { auto c = T::value; return c--; }()>{}; }

template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>

constexpr auto operator+=(this T, R) noexcept

requires requires(T::value_type x) { x += R::value; }

{ return constant_wrapper<[] { auto v = T::value; return v += R::value; }()>{}; }

template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>

constexpr auto operator-=(this T, R) noexcept

requires requires(T::value_type x) { x -= R::value; }

{ return constant_wrapper<[] { auto v = T::value; return v -= R::value; }()>{}; }

template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>

constexpr auto operator*=(this T, R) noexcept

requires requires(T::value_type x) { x *= R::value; }

{ return constant_wrapper<[] { auto v = T::value; return v *= R::value; }()>{}; }

template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>

constexpr auto operator/=(this T, R) noexcept

requires requires(T::value_type x) { x /= R::value; }

{ return constant_wrapper<[] { auto v = T::value; return v /= R::value; }()>{}; }

template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>

constexpr auto operator%=(this T, R) noexcept

requires requires(T::value_type x) { x %= R::value; }

{ return constant_wrapper<[] { auto v = T::value; return v %= R::value; }()>{}; }

template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>

constexpr auto operator&=(this T, R) noexcept

requires requires(T::value_type x) { x &= R::value; }

{ return constant_wrapper<[] { auto v = T::value; return v &= R::value; }()>{}; }

template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>

constexpr auto operator|=(this T, R) noexcept

requires requires(T::value_type x) { x |= R::value; }

{ return constant_wrapper<[] { auto v = T::value; return v |= R::value; }()>{}; }

template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>

constexpr auto operator^=(this T, R) noexcept

requires requires(T::value_type x) { x ^= R::value; }

{ return constant_wrapper<[] { auto v = T::value; return v ^= R::value; }()>{}; }

template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>

constexpr auto operator<<=(this T, R) noexcept

requires requires(T::value_type x) { x <<= R::value; }

{ return constant_wrapper<[] { auto v = T::value; return v <<= R::value; }()>{}; }

template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>

constexpr auto operator>>=(this T, R) noexcept

requires requires(T::value_type x) { x >>= R::value; }

{ return constant_wrapper<[] { auto v = T::value; return v >>= R::value; }()>{}; }

};

template<@\exposid{cw-fixed-value}@ X, class>

struct @\libglobal{constant_wrapper}@ : @\exposid{cw-operators}@ {

static constexpr const auto & value = X.@\exposid{data}@;

using type = constant_wrapper;

using value_type = decltype(X)::@\exposid{type}@;

template<@\exposconcept{constexpr-param}@ R>

constexpr auto operator=(R) const noexcept

requires requires(value_type x) { x = R::value; }

{ return constant_wrapper<[] { auto v = value; return v = R::value; }()>{}; }

constexpr operator decltype(auto)() const noexcept { return value; }

};

}

\end{codeblock}

The class template \tcode{constant_wrapper} aids in metaprogramming by ensuring

that the evaluation of expressions comprised entirely of \tcode{constant_wrapper}

are core constant expressions\iref{expr.const},

regardless of the context in which they appear.

In particular, this enables use of \tcode{constant_wrapper} values

that are passed as arguments to constexpr functions to be used in constant expressions.

\begin{note}

The unnamed second template parameter to \tcode{constant_wrapper} is present

to aid argument-dependent lookup\iref{basic.lookup.argdep}

in finding overloads for which \tcode{constant_wrapper}'s wrapped value is a suitable argument,

but for which the \tcode{constant_wrapper} itself is not.

\end{note}

\begin{example}

\begin{codeblock}

constexpr auto initial_phase(auto quantity_1, auto quantity_2) {

return quantity_1 + quantity_2;

}

constexpr auto middle_phase(auto tbd) {

return tbd;

}

void final_phase(auto gathered, auto available) {

if constexpr (gathered == available)

std::cout << "Profit!\n";

}

void impeccable_underground_planning() {

auto gathered_quantity = middle_phase(initial_phase(std::cw<42>, std::cw<13>));

static_assert(gathered_quantity == 55);

auto all_available = std::cw<55>;

final_phase(gathered_quantity, all_available);

}

void deeply_flawed_underground_planning() {

constexpr auto gathered_quantity = middle_phase(initial_phase(42, 13));

constexpr auto all_available = 55;

final_phase(gathered_quantity, all_available); // error: \tcode{gathered == available}

// is not a constant expression

}

\end{codeblock}

\end{example}

\begin{itemdecl}

constexpr @\exposid{cw-fixed-value}@(T (&arr)[Extent]) noexcept;

\end{itemdecl}

\begin{itemdescr}

Initialize elements of \exposid{data} with corresponding elements of \tcode{arr}.

\end{itemdescr}

\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