[type.traits] - C++20 → C++23

Files changed (1) hide show

tmp/tmpsraslzar/{from.md → to.md} +1150 -0

tmp/tmpsraslzar/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,1150 @@

+## Metaprogramming and type traits <a id="type.traits">[[type.traits]]</a>
+### General <a id="type.traits.general">[[type.traits.general]]</a>
+Subclause [[type.traits]] describes components used by C++ 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 C++ 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.
+All functions specified in [[type.traits]] are signal-safe
+[[support.signal]].
+### Requirements <a id="meta.rqmts">[[meta.rqmts]]</a>
+A 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
+*Cpp17DefaultConstructible*, *Cpp17CopyConstructible*, and publicly and
+unambiguously derived, directly or indirectly, from its *base
+characteristic*, which is a specialization of the template
+`integral_constant` [[meta.help]], with the arguments to the template
+`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
+*Cpp17UnaryTypeTrait*.
+A 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 *Cpp17DefaultConstructible*, *Cpp17CopyConstructible*, and
+publicly and unambiguously derived, directly or indirectly, from its
+*base characteristic*, which is a specialization of the template
+`integral_constant` [[meta.help]], with the arguments to the template
+`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 *Cpp17BinaryTypeTrait*.
+A 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 `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 [[type.traits]] is
+undefined.
+Unless otherwise specified, an incomplete type may be used to
+instantiate a template specified in [[type.traits]]. The behavior of a
+program is undefined if:
+- an instantiation of a template specified in [[type.traits]] directly
+  or indirectly depends on an incompletely-defined object type `T`, and
+- that instantiation could yield a different result were `T`
+  hypothetically completed.
+### Header `<type_traits>` synopsis <a id="meta.type.synop">[[meta.type.synop]]</a>
+``` cpp
+// all freestanding
+namespace std {
+  // [meta.help], helper class
+  template<class T, T v> struct integral_constant;
+  template<bool B>
+    using bool_constant = integral_constant<bool, B>;
+  using true_type  = bool_constant<true>;
+  using false_type = bool_constant<false>;
+  // [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;
+  // [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;
+  // [meta.unary.prop], type properties
+  template<class T> struct is_const;
+  template<class T> struct is_volatile;
+  template<class T> struct is_trivial;
+  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_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;
+  // [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;
+  // [meta.rel], type relations
+  template<class T, class U> struct is_same;
+  template<class Base, class Derived> struct is_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;
+  // [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 remove_const_t    = typename remove_const<T>::type;
+  template<class T>
+    using remove_volatile_t = typename remove_volatile<T>::type;
+  template<class T>
+    using remove_cv_t       = typename remove_cv<T>::type;
+  template<class T>
+    using add_const_t       = typename add_const<T>::type;
+  template<class T>
+    using add_volatile_t    = typename add_volatile<T>::type;
+  template<class T>
+    using add_cv_t          = typename add_cv<T>::type;
+  // [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 remove_reference_t     = typename remove_reference<T>::type;
+  template<class T>
+    using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;
+  template<class T>
+    using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;
+  // [meta.trans.sign], sign modifications
+  template<class T> struct make_signed;
+  template<class T> struct make_unsigned;
+  template<class T>
+    using make_signed_t   = typename make_signed<T>::type;
+  template<class T>
+    using make_unsigned_t = typename make_unsigned<T>::type;
+  // [meta.trans.arr], array modifications
+  template<class T> struct remove_extent;
+  template<class T> struct remove_all_extents;
+  template<class T>
+    using remove_extent_t      = typename remove_extent<T>::type;
+  template<class T>
+    using remove_all_extents_t = typename remove_all_extents<T>::type;
+  // [meta.trans.ptr], pointer modifications
+  template<class T> struct remove_pointer;
+  template<class T> struct add_pointer;
+  template<class T>
+    using remove_pointer_t = typename remove_pointer<T>::type;
+  template<class T>
+    using add_pointer_t    = typename add_pointer<T>::type;
+  // [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 T> struct unwrap_reference;
+  template<class T> struct unwrap_ref_decay;
+  template<class T>
+    using type_identity_t    = typename type_identity<T>::type;
+  template<class T>
+    using remove_cvref_t     = typename remove_cvref<T>::type;
+  template<class T>
+    using decay_t            = typename decay<T>::type;
+  template<bool B, class T = void>
+    using enable_if_t        = typename enable_if<B, T>::type;
+  template<bool B, class T, class F>
+    using conditional_t      = typename conditional<B, T, F>::type;
+  template<class... T>
+    using common_type_t      = typename common_type<T...>::type;
+  template<class... T>
+    using common_reference_t = typename common_reference<T...>::type;
+  template<class T>
+    using underlying_type_t  = typename underlying_type<T>::type;
+  template<class Fn, class... ArgTypes>
+    using invoke_result_t    = typename invoke_result<Fn, ArgTypes...>::type;
+  template<class T>
+    using unwrap_reference_t = typename unwrap_reference<T>::type;
+  template<class T>
+    using unwrap_ref_decay_t = typename unwrap_ref_decay<T>::type;
+  template<class...>
+    using void_t             = void;
+  // [meta.logical], logical operator traits
+  template<class... B> struct conjunction;
+  template<class... B> struct disjunction;
+  template<class B> struct negation;
+  // [meta.unary.cat], primary type categories
+  template<class T>
+    constexpr bool is_void_v = is_void<T>::value;
+  template<class T>
+    constexpr bool is_null_pointer_v = is_null_pointer<T>::value;
+  template<class T>
+    constexpr bool is_integral_v = is_integral<T>::value;
+  template<class T>
+    constexpr bool is_floating_point_v = is_floating_point<T>::value;
+  template<class T>
+    constexpr bool is_array_v = is_array<T>::value;
+  template<class T>
+    constexpr bool is_pointer_v = is_pointer<T>::value;
+  template<class T>
+    constexpr bool is_lvalue_reference_v = is_lvalue_reference<T>::value;
+  template<class T>
+    constexpr bool is_rvalue_reference_v = is_rvalue_reference<T>::value;
+  template<class T>
+    constexpr bool is_member_object_pointer_v = is_member_object_pointer<T>::value;
+  template<class T>
+    constexpr bool is_member_function_pointer_v = is_member_function_pointer<T>::value;
+  template<class T>
+    constexpr bool is_enum_v = is_enum<T>::value;
+  template<class T>
+    constexpr bool is_union_v = is_union<T>::value;
+  template<class T>
+    constexpr bool is_class_v = is_class<T>::value;
+  template<class T>
+    constexpr bool is_function_v = is_function<T>::value;
+  // [meta.unary.comp], composite type categories
+  template<class T>
+    constexpr bool is_reference_v = is_reference<T>::value;
+  template<class T>
+    constexpr bool is_arithmetic_v = is_arithmetic<T>::value;
+  template<class T>
+    constexpr bool is_fundamental_v = is_fundamental<T>::value;
+  template<class T>
+    constexpr bool is_object_v = is_object<T>::value;
+  template<class T>
+    constexpr bool is_scalar_v = is_scalar<T>::value;
+  template<class T>
+    constexpr bool is_compound_v = is_compound<T>::value;
+  template<class T>
+    constexpr bool is_member_pointer_v = is_member_pointer<T>::value;
+  // [meta.unary.prop], type properties
+  template<class T>
+    constexpr bool is_const_v = is_const<T>::value;
+  template<class T>
+    constexpr bool is_volatile_v = is_volatile<T>::value;
+  template<class T>
+    constexpr bool is_trivial_v = is_trivial<T>::value;
+  template<class T>
+    constexpr bool is_trivially_copyable_v = is_trivially_copyable<T>::value;
+  template<class T>
+    constexpr bool is_standard_layout_v = is_standard_layout<T>::value;
+  template<class T>
+    constexpr bool is_empty_v = is_empty<T>::value;
+  template<class T>
+    constexpr bool is_polymorphic_v = is_polymorphic<T>::value;
+  template<class T>
+    constexpr bool is_abstract_v = is_abstract<T>::value;
+  template<class T>
+    constexpr bool is_final_v = is_final<T>::value;
+  template<class T>
+    constexpr bool is_aggregate_v = is_aggregate<T>::value;
+  template<class T>
+    constexpr bool is_signed_v = is_signed<T>::value;
+  template<class T>
+    constexpr bool is_unsigned_v = is_unsigned<T>::value;
+  template<class T>
+    constexpr bool is_bounded_array_v = is_bounded_array<T>::value;
+  template<class T>
+    constexpr bool is_unbounded_array_v = is_unbounded_array<T>::value;
+  template<class T>
+    constexpr bool is_scoped_enum_v = is_scoped_enum<T>::value;
+  template<class T, class... Args>
+    constexpr bool is_constructible_v = is_constructible<T, Args...>::value;
+  template<class T>
+    constexpr bool is_default_constructible_v = is_default_constructible<T>::value;
+  template<class T>
+    constexpr bool is_copy_constructible_v = is_copy_constructible<T>::value;
+  template<class T>
+    constexpr bool is_move_constructible_v = is_move_constructible<T>::value;
+  template<class T, class U>
+    constexpr bool is_assignable_v = is_assignable<T, U>::value;
+  template<class T>
+    constexpr bool is_copy_assignable_v = is_copy_assignable<T>::value;
+  template<class T>
+    constexpr bool is_move_assignable_v = is_move_assignable<T>::value;
+  template<class T, class U>
+    constexpr bool is_swappable_with_v = is_swappable_with<T, U>::value;
+  template<class T>
+    constexpr bool is_swappable_v = is_swappable<T>::value;
+  template<class T>
+    constexpr bool is_destructible_v = is_destructible<T>::value;
+  template<class T, class... Args>
+    constexpr bool is_trivially_constructible_v
+      = is_trivially_constructible<T, Args...>::value;
+  template<class T>
+    constexpr bool is_trivially_default_constructible_v
+      = is_trivially_default_constructible<T>::value;
+  template<class T>
+    constexpr bool is_trivially_copy_constructible_v
+      = is_trivially_copy_constructible<T>::value;
+  template<class T>
+    constexpr bool is_trivially_move_constructible_v
+      = is_trivially_move_constructible<T>::value;
+  template<class T, class U>
+    constexpr bool is_trivially_assignable_v = is_trivially_assignable<T, U>::value;
+  template<class T>
+    constexpr bool is_trivially_copy_assignable_v
+      = is_trivially_copy_assignable<T>::value;
+  template<class T>
+    constexpr bool is_trivially_move_assignable_v
+      = is_trivially_move_assignable<T>::value;
+  template<class T>
+    constexpr bool is_trivially_destructible_v = is_trivially_destructible<T>::value;
+  template<class T, class... Args>
+    constexpr bool is_nothrow_constructible_v
+      = is_nothrow_constructible<T, Args...>::value;
+  template<class T>
+    constexpr bool 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 is_nothrow_move_constructible_v
+      = is_nothrow_move_constructible<T>::value;
+  template<class T, class U>
+    constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<T, U>::value;
+  template<class T>
+    constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<T>::value;
+  template<class T>
+    constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<T>::value;
+  template<class T, class U>
+    constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with<T, U>::value;
+  template<class T>
+    constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<T>::value;
+  template<class T>
+    constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<T>::value;
+  template<class T>
+    constexpr bool is_implicit_lifetime_v = is_implicit_lifetime<T>::value;
+  template<class T>
+    constexpr bool has_virtual_destructor_v = has_virtual_destructor<T>::value;
+  template<class T>
+    constexpr bool has_unique_object_representations_v
+      = has_unique_object_representations<T>::value;
+  template<class T, class U>
+    constexpr bool reference_constructs_from_temporary_v
+      = reference_constructs_from_temporary<T, U>::value;
+  template<class T, class U>
+    constexpr bool reference_converts_from_temporary_v
+      = reference_converts_from_temporary<T, U>::value;
+  // [meta.unary.prop.query], type property queries
+  template<class T>
+    constexpr size_t alignment_of_v = alignment_of<T>::value;
+  template<class T>
+    constexpr size_t rank_v = rank<T>::value;
+  template<class T, unsigned I = 0>
+    constexpr size_t extent_v = extent<T, I>::value;
+  // [meta.rel], type relations
+  template<class T, class U>
+    constexpr bool is_same_v = is_same<T, U>::value;
+  template<class Base, class Derived>
+    constexpr bool is_base_of_v = is_base_of<Base, Derived>::value;
+  template<class From, class To>
+    constexpr bool is_convertible_v = is_convertible<From, To>::value;
+  template<class From, class To>
+    constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<From, To>::value;
+  template<class T, class U>
+    constexpr bool is_layout_compatible_v = is_layout_compatible<T, U>::value;
+  template<class Base, class Derived>
+    constexpr bool is_pointer_interconvertible_base_of_v
+      = is_pointer_interconvertible_base_of<Base, Derived>::value;
+  template<class Fn, class... ArgTypes>
+    constexpr bool is_invocable_v = is_invocable<Fn, ArgTypes...>::value;
+  template<class R, class Fn, class... ArgTypes>
+    constexpr bool is_invocable_r_v = is_invocable_r<R, Fn, ArgTypes...>::value;
+  template<class Fn, class... ArgTypes>
+    constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<Fn, ArgTypes...>::value;
+  template<class R, class Fn, class... ArgTypes>
+    constexpr bool is_nothrow_invocable_r_v
+      = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;
+  // [meta.logical], logical operator traits
+  template<class... B>
+    constexpr bool conjunction_v = conjunction<B...>::value;
+  template<class... B>
+    constexpr bool disjunction_v = disjunction<B...>::value;
+  template<class B>
+    constexpr bool negation_v = negation<B>::value;
+  // [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;
+  // [meta.const.eval], constant evaluation context
+  constexpr bool is_constant_evaluated() noexcept;
+}
+```
+### Helper classes <a id="meta.help">[[meta.help]]</a>
+``` cpp
+namespace std {
+  template<class T, T v> struct 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; }
+  };
+}
+```
+The class template `integral_constant`, alias template `bool_constant`,
+and its associated *typedef-name*s `true_type` and `false_type` are used
+as base classes to define the interface for various type traits.
+### Unary type traits <a id="meta.unary">[[meta.unary]]</a>
+#### General <a id="meta.unary.general">[[meta.unary.general]]</a>
+Subclause [[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 *Cpp17UnaryTypeTrait* [[meta.rqmts]]
+with a base characteristic of `true_type` if the corresponding condition
+is `true`, otherwise `false_type`.
+#### Primary type categories <a id="meta.unary.cat">[[meta.unary.cat]]</a>
+The primary type categories correspond to the descriptions given in
+subclause  [[basic.types]] of the C++ standard.
+For any given type `T`, the result of applying one of these templates to
+`T` and to cv `T` shall yield the same result.
+[*Note 1*: For any given type `T`, exactly one of the primary type
+categories has a `value` member that evaluates to `true`. — *end note*]
+#### Composite type traits <a id="meta.unary.comp">[[meta.unary.comp]]</a>
+These templates provide convenient compositions of the primary type
+categories, corresponding to the descriptions given in subclause
+[[basic.types]].
+For any given type `T`, the result of applying one of these templates to
+`T` and to cv `T` shall yield the same result.
+#### Type properties <a id="meta.unary.prop">[[meta.unary.prop]]</a>
+These templates 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 `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 `X` require that the
+argument is a complete type.
+For the purpose of defining the templates in this subclause, a function
+call expression `declval<T>()` for any type `T` is considered to be a
+trivial [[term.trivial.type]], [[special]] function call that is not an
+odr-use [[term.odr.use]] of `declval` in the context of the
+corresponding definition notwithstanding the restrictions of
+[[declval]].
+For the purpose of defining the templates in this subclause, let
+`VAL<T>` for some type `T` be an expression defined as follows:
+- If `T` is a reference or function type, `VAL<T>` is an expression with
+  the same type and value category as `declval<T>()`.
+- Otherwise, `VAL<T>` is a prvalue that initially has type `T`.
+  \[*Note 1*: If `T` is cv-qualified, the cv-qualification is subject to
+  adjustment [[expr.type]]. — *end note*]
+[*Example 1*:
+``` cpp
+is_const_v<const volatile int>      // true
+is_const_v<const int*>              // false
+is_const_v<const int&>              // false
+is_const_v<int[3]>                  // false
+is_const_v<const int[3]>            // true
+```
+— *end example*]
+[*Example 2*:
+``` cpp
+remove_const_t<const volatile int>  // volatile int
+remove_const_t<const int* const>    // const int*
+remove_const_t<const int&>          // const int&
+remove_const_t<const int[3]>        // int[3]
+```
+— *end example*]
+[*Example 3*:
+``` cpp
+// Given:
+struct P final { };
+union U1 { };
+union U2 final { };
+// the following assertions hold:
+static_assert(!is_final_v<int>);
+static_assert(is_final_v<P>);
+static_assert(!is_final_v<U1>);
+static_assert(is_final_v<U2>);
+```
+— *end example*]
+The predicate condition for a template specialization
+`is_constructible<T, Args...>` shall be satisfied if and only if the
+following variable definition would be well-formed for some invented
+variable `t`:
+``` cpp
+T t(declval<Args>()...);
+```
+[*Note 2*: These tokens are never interpreted as a function
+declaration. — *end note*]
+Access checking is performed as if in a context unrelated to `T` and any
+of the `Args`. Only the validity of the immediate context of the
+variable initialization is considered.
+[*Note 3*: The evaluation of the initialization can result in side
+effects such as the instantiation of class template specializations and
+function template specializations, the generation of implicitly-defined
+functions, and so on. Such side effects are not in the “immediate
+context” and can result in the program being ill-formed. — *end note*]
+The predicate condition for a template specialization
+`has_unique_object_representations<T>` shall be satisfied if and only
+if:
+- `T` is trivially copyable, and
+- any two objects of type `T` with the same value have the same object
+  representation, where two objects of array or non-union class type are
+  considered to have the same value if their respective sequences of
+  direct subobjects have the same values, and two objects of union type
+  are considered to have the same value if they have the same active
+  member and the corresponding members have the same value.
+The set of scalar types for which this condition holds is
+*implementation-defined*.
+[*Note 4*: If a type has padding bits, the condition does not hold;
+otherwise, the condition holds true for integral types. — *end note*]
+### Type property queries <a id="meta.unary.prop.query">[[meta.unary.prop.query]]</a>
+This subclause contains templates that may be used to query properties
+of types at compile time.
+Each of these templates shall be a *Cpp17UnaryTypeTrait* [[meta.rqmts]]
+with a base characteristic of `integral_constant<size_t, Value>`.
+[*Example 1*:
+``` cpp
+// the following assertions hold:
+assert(rank_v<int> == 0);
+assert(rank_v<int[2]> == 1);
+assert(rank_v<int[][4]> == 2);
+```
+— *end example*]
+[*Example 2*:
+``` cpp
+// the following assertions hold:
+assert(extent_v<int> == 0);
+assert(extent_v<int[2]> == 2);
+assert(extent_v<int[2][4]> == 2);
+assert(extent_v<int[][4]> == 0);
+assert((extent_v<int, 1>) == 0);
+assert((extent_v<int[2], 1>) == 0);
+assert((extent_v<int[2][4], 1>) == 4);
+assert((extent_v<int[][4], 1>) == 4);
+```
+— *end example*]
+### Relationships between types <a id="meta.rel">[[meta.rel]]</a>
+This subclause contains templates that may be used to query
+relationships between types at compile time.
+Each of these templates shall be a *Cpp17BinaryTypeTrait* [[meta.rqmts]]
+with a base characteristic of `true_type` if the corresponding condition
+is true, otherwise `false_type`.
+For the purpose of defining the templates in this subclause, a function
+call expression `declval<T>()` for any type `T` is considered to be a
+trivial [[term.trivial.type]], [[special]] function call that is not an
+odr-use [[term.odr.use]] of `declval` in the context of the
+corresponding definition notwithstanding the restrictions of
+[[declval]].
+[*Example 1*:
+``` cpp
+struct B {};
+struct B1 : B {};
+struct B2 : B {};
+struct D : private B1, private B2 {};
+is_base_of_v<B, D>              // true
+is_base_of_v<const B, D>        // true
+is_base_of_v<B, const D>        // true
+is_base_of_v<B, const B>        // true
+is_base_of_v<D, B>              // false
+is_base_of_v<B&, D&>            // false
+is_base_of_v<B[3], D[3]>        // false
+is_base_of_v<int, int>          // false
+```
+— *end example*]
+The predicate condition for a template specialization
+`is_convertible<From, To>` shall be satisfied if and only if the return
+expression in the following code would be well-formed, including any
+implicit conversions to the return type of the function:
+``` cpp
+To test() {
+  return declval<From>();
+}
+```
+[*Note 1*: This requirement gives well-defined results for reference
+types, array types, function types, and cv `void`. — *end note*]
+Access checking is performed in a context unrelated to `To` and `From`.
+Only the validity of the immediate context of the *expression* of the
+`return` statement [[stmt.return]] (including initialization of the
+returned object or reference) is considered.
+[*Note 2*: The initialization can result in side effects such as the
+instantiation of class template specializations and function template
+specializations, the generation of implicitly-defined functions, and so
+on. Such side effects are not in the “immediate context” and can result
+in the program being ill-formed. — *end note*]
+### Transformations between types <a id="meta.trans">[[meta.trans]]</a>
+#### General <a id="meta.trans.general">[[meta.trans.general]]</a>
+Subclause [[meta.trans]] contains templates that may be used to
+transform one type to another following some predefined rule.
+Each of the templates in [[meta.trans]] shall be a
+*Cpp17TransformationTrait* [[meta.rqmts]].
+#### Const-volatile modifications <a id="meta.trans.cv">[[meta.trans.cv]]</a>
+#### Reference modifications <a id="meta.trans.ref">[[meta.trans.ref]]</a>
+#### Sign modifications <a id="meta.trans.sign">[[meta.trans.sign]]</a>
+#### Array modifications <a id="meta.trans.arr">[[meta.trans.arr]]</a>
+[*Example 1*:
+``` cpp
+// the following assertions hold:
+assert((is_same_v<remove_extent_t<int>, int>));
+assert((is_same_v<remove_extent_t<int[2]>, int>));
+assert((is_same_v<remove_extent_t<int[2][3]>, int[3]>));
+assert((is_same_v<remove_extent_t<int[][3]>, int[3]>));
+```
+— *end example*]
+[*Example 2*:
+``` cpp
+// the following assertions hold:
+assert((is_same_v<remove_all_extents_t<int>, int>));
+assert((is_same_v<remove_all_extents_t<int[2]>, int>));
+assert((is_same_v<remove_all_extents_t<int[2][3]>, int>));
+assert((is_same_v<remove_all_extents_t<int[][3]>, int>));
+```
+— *end example*]
+#### Pointer modifications <a id="meta.trans.ptr">[[meta.trans.ptr]]</a>
+#### Other transformations <a id="meta.trans.other">[[meta.trans.other]]</a>
+[*Note 1*: The compilation of the expression can result in side effects
+such as the instantiation of class template specializations and function
+template specializations, the generation of implicitly-defined
+functions, and so on. Such side effects are not in the “immediate
+context” and can result in the program being ill-formed. — *end note*]
+In addition to being available via inclusion of the `<type_traits>`
+header, the templates `unwrap_reference`, `unwrap_ref_decay`,
+`unwrap_reference_t`, and `unwrap_ref_decay_t` are available when the
+header `<functional>` [[functional.syn]] is included.
+Let:
+- `CREF(A)` be `add_lvalue_reference_t<const remove_reference_t<A>{}>`,
+- `XREF(A)` denote a unary alias template `T` such that `T<U>` denotes
+  the same type as `U` with the addition of `A`’s cv and reference
+  qualifiers, for a non-reference cv-unqualified type `U`,
+- `COPYCV(FROM, TO)` be an alias for type `TO` with the addition of
+  `FROM`’s top-level cv-qualifiers,
+  \[*Example 1*: `COPYCV(const int, volatile short)` is an alias for
+  `const volatile short`. — *end example*]
+- `COND-RES(X, Y)` be
+  `decltype(false ? declval<X(&)()>()() : declval<Y(&)()>()())`.
+Given types `A` and `B`, let `X` be `remove_reference_t<A>`, let `Y` be
+`remove_reference_t<B>`, and let `COMMON-{REF}(A, B)` be:
+- If `A` and `B` are both lvalue reference types, `COMMON-REF(A, B)` is
+  `COND-RES(COPYCV(X, Y) &,
+      COPYCV({}Y, X) &)` if that type exists and is a reference type.
+- Otherwise, let `C` be `remove_reference_t<COMMON-REF(X&, Y&)>&&`. If
+  `A` and `B` are both rvalue reference types, `C` is well-formed, and
+  `is_convertible_v<A, C> && is_convertible_v<B, C>` is `true`, then
+  `COMMON-REF(A, B)` is `C`.
+- Otherwise, let `D` be `COMMON-REF(const X&, Y&)`. If `A` is an rvalue
+  reference and `B` is an lvalue reference and `D` is well-formed and
+  `is_convertible_v<A, D>` is `true`, then `COMMON-REF(A, B)` is `D`.
+- Otherwise, if `A` is an lvalue reference and `B` is an rvalue
+  reference, then `COMMON-REF(A, B)` is `COMMON-REF(B, A)`.
+- Otherwise, `COMMON-REF(A, B)` is ill-formed.
+If any of the types computed above is ill-formed, then
+`COMMON-REF(A, B)` is ill-formed.
+Note A: For the `common_type` trait applied to a template parameter pack
+`T` of types, the member `type` shall be either defined or not present
+as follows:
+- If `sizeof...(T)` is zero, there shall be no member `type`.
+- If `sizeof...(T)` is one, let `T0` denote the sole type constituting
+  the pack `T`. The member *typedef-name* `type` shall denote the same
+  type, if any, as `common_type_t<T0, T0>`; otherwise there shall be no
+  member `type`.
+- If `sizeof...(T)` is two, let the first and second types constituting
+  `T` be denoted by `T1` and `T2`, respectively, and let `D1` and `D2`
+  denote the same types as `decay_t<T1>` and `decay_t<T2>`,
+  respectively.
+  - If `is_same_v<T1, D1>` is `false` or `is_same_v<T2, D2>` is `false`,
+    let `C` denote the same type, if any, as `common_type_t<D1, D2>`.
+  - \[*Note 2*: None of the following will apply if there is a
+    specialization `common_type<D1, D2>`. — *end note*]
+  - Otherwise, if
+    ``` cpp
+    decay_t<decltype(false ? declval<D1>() : declval<D2>())>
+    ```
+    denotes a valid type, let `C` denote that type.
+  - Otherwise, if `COND-RES(CREF(D1),
+          CREF(D2))` denotes a type, let `C` denote the type
+    `decay_t<COND-RES(CREF(D1),
+          CREF(D2))>`.
+  In either case, the member *typedef-name* `type` shall denote the same
+  type, if any, as `C`. Otherwise, there shall be no member `type`.
+- If `sizeof...(T)` is greater than two, let `T1`, `T2`, and `R`,
+  respectively, denote the first, second, and (pack of) remaining types
+  constituting `T`. Let `C` denote the same type, if any, as
+  `common_type_t<T1, T2>`. If there is such a type `C`, the member
+  *typedef-name* `type` shall denote the same type, if any, as
+  `common_type_t<C, R...>`. Otherwise, there shall be no member `type`.
+Note B: Notwithstanding the provisions of [[meta.type.synop]], and
+pursuant to [[namespace.std]], a program may specialize
+`common_type<T1, T2>` for types `T1` and `T2` such that
+`is_same_v<T1, decay_t<T1>>` and `is_same_v<T2, decay_t<T2>>` are each
+`true`.
+[*Note 3*: Such specializations are needed when only explicit
+conversions are desired between the template arguments. — *end note*]
+Such a specialization need not have a member named `type`, but if it
+does, the *qualified-id* `common_type<T1, T2>::type` shall denote a
+cv-unqualified non-reference type to which each of the types `T1` and
+`T2` is explicitly convertible. Moreover, `common_type_t<T1, T2>` shall
+denote the same type, if any, as does `common_type_t<T2, T1>`. No
+diagnostic is required for a violation of this Note’s rules.
+Note C: For the `common_reference` trait applied to a parameter pack `T`
+of types, the member `type` shall be either defined or not present as
+follows:
+- If `sizeof...(T)` is zero, there shall be no member `type`.
+- Otherwise, if `sizeof...(T)` is one, let `T0` denote the sole type in
+  the pack `T`. The member typedef `type` shall denote the same type as
+  `T0`.
+- Otherwise, if `sizeof...(T)` is two, let `T1` and `T2` denote the two
+  types in the pack `T`. Then
+  - Let `R` be `COMMON-REF(T1, T2)`. If `T1` and `T2` are reference
+    types, `R` is well-formed, and
+    `is_convertible_v<add_pointer_t<T1>, add_pointer_t<R>> && is_convertible_v<add_poin{}ter_t<T2>, add_pointer_t<R>>`
+    is `true`, then the member typedef `type` denotes `R`.
+  - Otherwise, if
+    `basic_common_reference<remove_cvref_t<T1>, remove_cvref_t<T2>,
+          {}XREF({}T1), XREF(T2)>::type` is well-formed, then the member
+    typedef `type` denotes that type.
+  - Otherwise, if `COND-RES(T1, T2)` is well-formed, then the member
+    typedef `type` denotes that type.
+  - Otherwise, if `common_type_t<T1, T2>` is well-formed, then the
+    member typedef `type` denotes that type.
+  - Otherwise, there shall be no member `type`.
+- Otherwise, if `sizeof...(T)` is greater than two, let `T1`, `T2`, and
+  `Rest`, respectively, denote the first, second, and (pack of)
+  remaining types comprising `T`. Let `C` be the type
+  `common_reference_t<T1, T2>`. Then:
+  - If there is such a type `C`, the member typedef `type` shall denote
+    the same type, if any, as `common_reference_t<C, Rest...>`.
+  - Otherwise, there shall be no member `type`.
+Note D: Notwithstanding the provisions of [[meta.type.synop]], and
+pursuant to [[namespace.std]], a program may partially specialize
+`basic_common_reference<T, U, TQual, UQual>` for types `T` and `U` such
+that `is_same_v<T, decay_t<T>>` and `is_same_v<U, decay_t<U>>` are each
+`true`.
+[*Note 4*: Such specializations can be used to influence the result of
+`common_reference`, and are needed when only explicit conversions are
+desired between the template arguments. — *end note*]
+Such a specialization need not have a member named `type`, but if it
+does, the *qualified-id*
+`basic_common_reference<T, U, TQual, UQual>::type` shall denote a type
+to which each of the types `TQual<T>` and `UQual<U>` is convertible.
+Moreover, `basic_common_reference<T, U, TQual, UQual>::type` shall
+denote the same type, if any, as does
+`basic_common_reference<U, T, UQual, TQual>::type`. No diagnostic is
+required for a violation of these rules.
+[*Example 2*:
+Given these definitions:
+``` cpp
+using PF1 = bool  (&)();
+using PF2 = short (*)(long);
+struct S {
+  operator PF2() const;
+  double operator()(char, int&);
+  void fn(long) const;
+  char data;
+};
+using PMF = void (S::*)(long) const;
+using PMD = char  S::*;
+```
+the following assertions will hold:
+``` cpp
+static_assert(is_same_v<invoke_result_t<S, int>, short>);
+static_assert(is_same_v<invoke_result_t<S&, unsigned char, int&>, double>);
+static_assert(is_same_v<invoke_result_t<PF1>, bool>);
+static_assert(is_same_v<invoke_result_t<PMF, unique_ptr<S>, int>, void>);
+static_assert(is_same_v<invoke_result_t<PMD, S>, char&&>);
+static_assert(is_same_v<invoke_result_t<PMD, const S*>, const char&>);
+```
+— *end example*]
+### Logical operator traits <a id="meta.logical">[[meta.logical]]</a>
+This subclause describes type traits for applying logical operators to
+other type traits.
+``` cpp
+template<class... B> struct conjunction : see below { };
+```
+The class template `conjunction` forms the logical conjunction of its
+template type arguments.
+For a specialization `conjunction<``B₁``, `…`, ``B_N``>`, if there is a
+template type argument `Bᵢ` for which `bool(``Bᵢ``::value)` is `false`,
+then instantiating `conjunction<``B₁``, `…`, ``B_N``>::value` does not
+require the instantiation of `Bⱼ``::value` for j > i.
+[*Note 1*: This is analogous to the short-circuiting behavior of the
+built-in operator `&&`. — *end note*]
+Every template type argument for which `Bᵢ``::value` is instantiated
+shall be usable as a base class and shall have a member `value` which is
+convertible to `bool`, is not hidden, and is unambiguously available in
+the type.
+The specialization `conjunction<``B₁``, `…`, ``B_N``>` has a public and
+unambiguous base that is either
+- the first type `Bᵢ` in the list `true_type, ``B₁``, `…`, ``B_N` for
+  which `bool(``Bᵢ``::value)` is `false`, or
+- if there is no such `Bᵢ`, the last type in the list.
+[*Note 2*: This means a specialization of `conjunction` does not
+necessarily inherit from either `true_type` or
+`false_type`. — *end note*]
+The member names of the base class, other than `conjunction` and
+`operator=`, shall not be hidden and shall be unambiguously available in
+`conjunction`.
+``` cpp
+template<class... B> struct disjunction : see below { };
+```
+The class template `disjunction` forms the logical disjunction of its
+template type arguments.
+For a specialization `disjunction<``B₁``, `…`, ``B_N``>`, if there is a
+template type argument `Bᵢ` for which `bool(``Bᵢ``::value)` is `true`,
+then instantiating `disjunction<``B₁``, `…`, ``B_N``>::value` does not
+require the instantiation of `Bⱼ``::value` for j > i.
+[*Note 3*: This is analogous to the short-circuiting behavior of the
+built-in operator `||`. — *end note*]
+Every template type argument for which `Bᵢ``::value` is instantiated
+shall be usable as a base class and shall have a member `value` which is
+convertible to `bool`, is not hidden, and is unambiguously available in
+the type.
+The specialization `disjunction<``B₁``, `…`, ``B_N``>` has a public and
+unambiguous base that is either
+- the first type `Bᵢ` in the list `false_type, ``B₁``, `…`, ``B_N` for
+  which `bool(``Bᵢ``::value)` is `true`, or
+- if there is no such `Bᵢ`, the last type in the list.
+[*Note 4*: This means a specialization of `disjunction` does not
+necessarily inherit from either `true_type` or
+`false_type`. — *end note*]
+The member names of the base class, other than `disjunction` and
+`operator=`, shall not be hidden and shall be unambiguously available in
+`disjunction`.
+``` cpp
+template<class B> struct negation : see below { };
+```
+The class template `negation` forms the logical negation of its template
+type argument. The type `negation<B>` is a *Cpp17UnaryTypeTrait* with a
+base characteristic of `bool_constant<!bool(B::value)>`.
+### Member relationships <a id="meta.member">[[meta.member]]</a>
+``` cpp
+template<class S, class M>
+  constexpr bool is_pointer_interconvertible_with_class(M S::*m) noexcept;
+```
+*Mandates:* `S` is a complete type.
+*Returns:* `true` if and only if `S` is a standard-layout type, `M` is
+an object type, `m` is not null, and each object `s` of type `S` is
+pointer-interconvertible [[basic.compound]] with its subobject `s.*m`.
+``` cpp
+template<class S1, class S2, class M1, class M2>
+  constexpr bool is_corresponding_member(M1 S1::*m1, M2 S2::*m2) noexcept;
+```
+*Mandates:* `S1` and `S2` are complete types.
+*Returns:* `true` if and only if `S1` and `S2` are standard-layout
+struct [[class.prop]] types, `M1` and `M2` are object types, `m1` and
+`m2` are not null, and `m1` and `m2` point to corresponding members of
+the common initial sequence [[class.mem]] of `S1` and `S2`.
+[*Note 1*:
+The type of a pointer-to-member expression `&C::b` is not always a
+pointer to member of `C`, leading to potentially surprising results when
+using these functions in conjunction with inheritance.
+[*Example 1*:
+``` cpp
+struct A { int a; };                    // a standard-layout class
+struct B { int b; };                    // a standard-layout class
+struct C: public A, public B { };       // not a standard-layout class
+static_assert( is_pointer_interconvertible_with_class( &C::b ) );
+  // Succeeds because, despite its appearance, &C::b has type
+  // ``pointer to member of B of type int''.
+static_assert( is_pointer_interconvertible_with_class<C>( &C::b ) );
+  // Forces the use of class C, and fails.
+static_assert( is_corresponding_member( &C::a, &C::b ) );
+  // Succeeds because, despite its appearance, &C::a and &C::b have types
+  // ``pointer to member of A of type int'' and
+  // ``pointer to member of B of type int'', respectively.
+static_assert( is_corresponding_member<C, C>( &C::a, &C::b ) );
+  // Forces the use of class C, and fails.
+```
+— *end example*]
+— *end note*]
+### Constant evaluation context <a id="meta.const.eval">[[meta.const.eval]]</a>
+``` cpp
+constexpr bool is_constant_evaluated() noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+if consteval {
+  return true;
+} else {
+  return false;
+}
+```
+[*Example 1*:
+``` cpp
+constexpr void f(unsigned char *p, int n) {
+  if (std::is_constant_evaluated()) {           // should not be a constexpr if statement
+    for (int k = 0; k<n; ++k) p[k] = 0;
+  } else {
+    memset(p, 0, n);                            // not a core constant expression
+  }
+}
+```
+— *end example*]

Diff to HTML by rtfpessoa