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

Files changed (1) hide show

tmp/tmpi5mr76ok/{from.md → to.md} +464 -102

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

@@ -53,11 +53,11 @@ 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.
@@ -73,10 +73,26 @@ namespace std {
   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;
@@ -88,10 +104,11 @@ namespace std {
   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;
@@ -101,18 +118,20 @@ namespace std {
   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;
@@ -153,10 +172,11 @@ namespace std {
   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;
@@ -171,10 +191,11 @@ namespace std {
   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;
@@ -182,69 +203,72 @@ namespace std {
   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;
@@ -254,35 +278,38 @@ namespace std {
   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;
@@ -316,10 +343,12 @@ namespace std {
     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>
@@ -338,14 +367,14 @@ namespace std {
   // [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>
@@ -354,10 +383,12 @@ namespace std {
     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>
@@ -385,43 +416,35 @@ namespace std {
   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>
@@ -430,12 +453,16 @@ namespace std {
     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;
@@ -457,10 +484,12 @@ namespace std {
   // [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>
@@ -473,12 +502,15 @@ namespace std {
   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>
@@ -492,10 +524,11 @@ namespace std {
   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>
@@ -515,10 +548,268 @@ namespace std {
 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
@@ -528,32 +819,33 @@ 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,
@@ -639,71 +931,80 @@ 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
@@ -738,19 +1039,19 @@ implicit conversions to the return type of the function:
 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*]
@@ -764,44 +1065,59 @@ 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*]
@@ -842,13 +1158,13 @@ Given types `A` and `B`, let `X` be `remove_reference_t<A>`, let `Y` be
 - 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
@@ -879,15 +1195,14 @@ as follows:
   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
@@ -895,12 +1210,12 @@ 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
@@ -926,12 +1241,12 @@ follows:
   `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
@@ -1101,19 +1416,19 @@ 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*]
@@ -1146,5 +1461,52 @@ constexpr void f(unsigned char *p, int n) {
 }
 ```
 — *end example*]

 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.
   template<bool B>
     using bool_constant = integral_constant<bool, B>;
   using true_type  = bool_constant<true>;
   using false_type = bool_constant<false>;
+  // [const.wrap.class], class template constant_wrapper
+  template<class T>
+    struct cw-fixed-value;                                      // exposition only
+  template<cw-fixed-value X, class = typename decltype(X)::type>
+    struct constant_wrapper;
+  template<class T>
+    concept constexpr-param =                                   // exposition only
+      requires { typename constant_wrapper<T::value>; };
+  struct cw-operators;                                          // exposition only
+  template<cw-fixed-value X>
+    constexpr auto cw = constant_wrapper<X>{};
   // [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_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;
   // [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_member_pointer;
   // [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, 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, 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 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 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;
   // [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    = remove_const<T>::type;
   template<class T>
+    using remove_volatile_t = remove_volatile<T>::type;
   template<class T>
+    using remove_cv_t       = remove_cv<T>::type;
   template<class T>
+    using add_const_t       = add_const<T>::type;
   template<class T>
+    using add_volatile_t    = add_volatile<T>::type;
   template<class T>
+    using add_cv_t          = 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     = remove_reference<T>::type;
   template<class T>
+    using add_lvalue_reference_t = add_lvalue_reference<T>::type;
   template<class T>
+    using add_rvalue_reference_t = 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   = make_signed<T>::type;
   template<class T>
+    using make_unsigned_t = 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      = remove_extent<T>::type;
   template<class T>
+    using remove_all_extents_t = 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 = remove_pointer<T>::type;
   template<class T>
+    using add_pointer_t    = 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<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 type_identity_t    = type_identity<T>::type;
   template<class T>
+    using remove_cvref_t     = remove_cvref<T>::type;
   template<class T>
+    using decay_t            = decay<T>::type;
   template<bool B, class T = void>
+    using enable_if_t        = enable_if<B, T>::type;
   template<bool B, class T, class F>
+    using conditional_t      = conditional<B, T, F>::type;
   template<class... T>
+    using common_type_t      = common_type<T...>::type;
   template<class... T>
+    using common_reference_t = common_reference<T...>::type;
   template<class T>
+    using underlying_type_t  = underlying_type<T>::type;
   template<class Fn, class... ArgTypes>
+    using invoke_result_t    = invoke_result<Fn, ArgTypes...>::type;
+  template<class Fn, class Tuple>
+    using apply_result_t     = apply_result<Fn, Tuple>::type;
   template<class T>
+    using unwrap_reference_t = unwrap_reference<T>::type;
   template<class T>
+    using unwrap_ref_decay_t = unwrap_ref_decay<T>::type;
   template<class...>
     using void_t             = void;
   // [meta.logical], logical operator traits
   template<class... B> struct conjunction;
     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;
+  template<class T>
+    constexpr bool is_reflection_v = is_reflection<T>::value;
   // [meta.unary.comp], composite type categories
   template<class T>
     constexpr bool is_reference_v = is_reference<T>::value;
   template<class T>
   // [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_trivially_copyable_v = is_trivially_copyable<T>::value;
+  template<class T>
+    constexpr bool is_trivially_relocatable_v = is_trivially_relocatable<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_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_consteval_only_v = is_consteval_only<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>
   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_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_nothrow_relocatable_v = is_nothrow_relocatable<T>::value;
   template<class T>
     constexpr bool is_implicit_lifetime_v = is_implicit_lifetime<T>::value;
+  template<class T>
+    constexpr bool is_replaceable_v = is_replaceable<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;
   // [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 Base, class Derived>
+    constexpr bool is_virtual_base_of_v = is_virtual_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>
   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;
+  template<class Fn, class Tuple>
+    constexpr bool is_applicable_v = is_applicable<Fn, Tuple>::value;
+  template<class Fn, class Tuple>
+    constexpr bool is_nothrow_applicable_v = is_nothrow_applicable<Fn, Tuple>::value;
   // [meta.logical], logical operator traits
   template<class... B>
     constexpr bool conjunction_v = conjunction<B...>::value;
   template<class... B>
   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;
+  consteval bool is_within_lifetime(const auto*) noexcept;
 }
 ```
 ### Helper classes <a id="meta.help">[[meta.help]]</a>
 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.
+### Class template `constant_wrapper` <a id="const.wrap.class">[[const.wrap.class]]</a>
+``` cpp
+namespace std {
+  template<class T>
+  struct cw-fixed-value {                                                         // exposition only
+    using type = T;                                                               // exposition only
+    constexpr cw-fixed-value(type v) noexcept : data(v) {}
+    T data;                                                                       // exposition only
+  };
+  template<class T, size_t Extent>
+  struct cw-fixed-value<T[Extent]> {                                              // exposition only
+    using type = T[Extent];                                                       // exposition only
+    constexpr cw-fixed-value(T (&arr)[Extent]) noexcept;
+    T data[Extent];                                                               // exposition only
+  };
+  template<class T, size_t Extent>
+    cw-fixed-value(T (&)[Extent]) -> cw-fixed-value<T[Extent]>;                   // exposition only
+  struct cw-operators {                                                           // exposition only
+    // unary operators
+    template<constexpr-param T>
+      friend constexpr auto operator+(T) noexcept -> constant_wrapper<(+T::value)>
+        { return {}; }
+    template<constexpr-param T>
+      friend constexpr auto operator-(T) noexcept -> constant_wrapper<(-T::value)>
+        { return {}; }
+    template<constexpr-param T>
+      friend constexpr auto operator~(T) noexcept -> constant_wrapper<(~T::value)>
+        { return {}; }
+    template<constexpr-param T>
+      friend constexpr auto operator!(T) noexcept -> constant_wrapper<(!T::value)>
+        { return {}; }
+    template<constexpr-param T>
+      friend constexpr auto operator&(T) noexcept -> constant_wrapper<(&T::value)>
+        { return {}; }
+    template<constexpr-param T>
+      friend constexpr auto operator*(T) noexcept -> constant_wrapper<(*T::value)>
+        { return {}; }
+    // binary operators
+    template<constexpr-param L, constexpr-param R>
+      friend constexpr auto operator+(L, R) noexcept -> constant_wrapper<(L::value + R::value)>
+        { return {}; }
+    template<constexpr-param L, constexpr-param R>
+      friend constexpr auto operator-(L, R) noexcept -> constant_wrapper<(L::value - R::value)>
+        { return {}; }
+    template<constexpr-param L, constexpr-param R>
+      friend constexpr auto operator*(L, R) noexcept -> constant_wrapper<(L::value * R::value)>
+        { return {}; }
+    template<constexpr-param L, constexpr-param R>
+      friend constexpr auto operator/(L, R) noexcept -> constant_wrapper<(L::value / R::value)>
+        { return {}; }
+    template<constexpr-param L, constexpr-param R>
+      friend constexpr auto operator%(L, R) noexcept -> constant_wrapper<(L::value % R::value)>
+        { return {}; }
+    template<constexpr-param L, constexpr-param R>
+      friend constexpr auto operator<<(L, R) noexcept -> constant_wrapper<(L::value << R::value)>
+        { return {}; }
+    template<constexpr-param L, constexpr-param R>
+      friend constexpr auto operator>>(L, R) noexcept -> constant_wrapper<(L::value >> R::value)>
+        { return {}; }
+    template<constexpr-param L, constexpr-param R>
+      friend constexpr auto operator&(L, R) noexcept -> constant_wrapper<(L::value & R::value)>
+        { return {}; }
+    template<constexpr-param L, constexpr-param R>
+      friend constexpr auto operator|(L, R) noexcept -> constant_wrapper<(L::value | R::value)>
+        { return {}; }
+    template<constexpr-param L, constexpr-param R>
+      friend constexpr auto operator^(L, R) noexcept -> constant_wrapper<(L::value ^ R::value)>
+        { return {}; }
+    template<constexpr-param L, 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<constexpr-param L, 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<constexpr-param L, constexpr-param R>
+      friend constexpr auto operator<=>(L, R) noexcept
+        -> constant_wrapper<(L::value <=> R::value)>
+          { return {}; }
+    template<constexpr-param L, constexpr-param R>
+      friend constexpr auto operator<(L, R) noexcept -> constant_wrapper<(L::value < R::value)>
+        { return {}; }
+    template<constexpr-param L, constexpr-param R>
+      friend constexpr auto operator<=(L, R) noexcept -> constant_wrapper<(L::value <= R::value)>
+        { return {}; }
+    template<constexpr-param L, constexpr-param R>
+      friend constexpr auto operator==(L, R) noexcept -> constant_wrapper<(L::value == R::value)>
+        { return {}; }
+    template<constexpr-param L, constexpr-param R>
+      friend constexpr auto operator!=(L, R) noexcept -> constant_wrapper<(L::value != R::value)>
+        { return {}; }
+    template<constexpr-param L, constexpr-param R>
+      friend constexpr auto operator>(L, R) noexcept -> constant_wrapper<(L::value > R::value)>
+        { return {}; }
+    template<constexpr-param L, constexpr-param R>
+      friend constexpr auto operator>=(L, R) noexcept -> constant_wrapper<(L::value >= R::value)>
+        { return {}; }
+    template<constexpr-param L, constexpr-param R>
+      friend constexpr auto operator,(L, R) noexcept = delete;
+    template<constexpr-param L, constexpr-param R>
+      friend constexpr auto operator->*(L, R) noexcept -> constant_wrapper<L::value->*(R::value)>
+        { return {}; }
+    // call and index
+    template<constexpr-param T, 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<constexpr-param T, constexpr-param... Args>
+      constexpr auto operator[](this T, Args...) noexcept
+        -> constant_wrapper<(T::value[Args::value...])>
+          { return {}; }
+    // pseudo-mutators
+    template<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<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<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<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<constexpr-param T, 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<constexpr-param T, 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<constexpr-param T, 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<constexpr-param T, 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<constexpr-param T, 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<constexpr-param T, 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<constexpr-param T, 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<constexpr-param T, 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<constexpr-param T, 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<constexpr-param T, 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<cw-fixed-value X, class>
+  struct constant_wrapper : cw-operators {
+    static constexpr const auto & value = X.data;
+    using type = constant_wrapper;
+    using value_type = decltype(X)::type;
+    template<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; }
+  };
+}
+```
+The class template `constant_wrapper` aids in metaprogramming by
+ensuring that the evaluation of expressions comprised entirely of
+`constant_wrapper` are core constant expressions [[expr.const]],
+regardless of the context in which they appear. In particular, this
+enables use of `constant_wrapper` values that are passed as arguments to
+constexpr functions to be used in constant expressions.
+[*Note 1*: The unnamed second template parameter to `constant_wrapper`
+is present to aid argument-dependent lookup [[basic.lookup.argdep]] in
+finding overloads for which `constant_wrapper`’s wrapped value is a
+suitable argument, but for which the `constant_wrapper` itself is
+not. — *end note*]
+[*Example 1*:
+``` cpp
+  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: gathered == available
+                                                    // is not a constant expression
+  }
+```
+— *end example*]
+``` cpp
+constexpr cw-fixed-value(T (&arr)[Extent]) noexcept;
+```
+*Effects:* Initialize elements of *data* with corresponding elements of
+`arr`.
 ### 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
 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 specified in [[meta.unary.cat]] 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>
+The templates specified in [[meta.unary.comp]] 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>
+The templates specified in [[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 `X` declared in this subclause,
 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>
+The templates specified in [[meta.unary.prop.query]] 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:
+static_assert(rank_v<int> == 0);
+static_assert(rank_v<int[2]> == 1);
+static_assert(rank_v<int[][4]> == 2);
 ```
 — *end example*]
 [*Example 2*:
 ``` cpp
 // the following assertions hold:
+static_assert(extent_v<int> == 0);
+static_assert(extent_v<int[2]> == 2);
+static_assert(extent_v<int[2][4]> == 2);
+static_assert(extent_v<int[][4]> == 0);
+static_assert(extent_v<int, 1> == 0);
+static_assert(extent_v<int[2], 1> == 0);
+static_assert(extent_v<int[2][4], 1> == 4);
+static_assert(extent_v<int[][4], 1> == 4);
 ```
 — *end example*]
 ### Relationships between types <a id="meta.rel">[[meta.rel]]</a>
+The templates specified in [[meta.rel]] 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`.
+Let `ELEMS-OF(T)` be the parameter pack `get<N>(declval<T>())`, where
+*`N`* is the pack of `size_t` template arguments of the specialization
+of `index_sequence` denoted by
+`make_index_sequence<tuple_size_v<remove_reference_t<T>>>`.
+[*Note 1*: Virtual base classes that are private, protected, or
+ambiguous are, nonetheless, virtual base classes. — *end note*]
 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
 To test() {
   return declval<From>();
 }
 ```
+[*Note 2*: 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 3*: 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*]
 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>
+The templates specified in [[meta.trans.cv]] add or remove
+cv-qualifications [[basic.type.qualifier]].
 #### Reference modifications <a id="meta.trans.ref">[[meta.trans.ref]]</a>
+The templates specified in [[meta.trans.ref]] add or remove references.
 #### Sign modifications <a id="meta.trans.sign">[[meta.trans.sign]]</a>
+The templates specified in [[meta.trans.sign]] convert an integer type
+to its corresponding signed or unsigned type.
 #### Array modifications <a id="meta.trans.arr">[[meta.trans.arr]]</a>
+The templates specified in [[meta.trans.arr]] modify array types.
 [*Example 1*:
 ``` cpp
 // the following assertions hold:
+static_assert(is_same_v<remove_extent_t<int>, int>);
+static_assert(is_same_v<remove_extent_t<int[2]>, int>);
+static_assert(is_same_v<remove_extent_t<int[2][3]>, int[3]>);
+static_assert(is_same_v<remove_extent_t<int[][3]>, int[3]>);
 ```
 — *end example*]
 [*Example 2*:
 ``` cpp
 // the following assertions hold:
+static_assert(is_same_v<remove_all_extents_t<int>, int>);
+static_assert(is_same_v<remove_all_extents_t<int[2]>, int>);
+static_assert(is_same_v<remove_all_extents_t<int[2][3]>, int>);
+static_assert(is_same_v<remove_all_extents_t<int[][3]>, int>);
 ```
 — *end example*]
 #### Pointer modifications <a id="meta.trans.ptr">[[meta.trans.ptr]]</a>
+The templates specified in [[meta.trans.ptr]] add or remove pointers.
 #### Other transformations <a id="meta.trans.other">[[meta.trans.other]]</a>
+The templates specified in [[meta.trans.other]] perform other
+modifications of a type.
 [*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*]
 - 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.
+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
   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`.
+Notwithstanding the provisions of [[meta.rqmts]], 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
 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.
+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
   `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`.
+Notwithstanding the provisions of [[meta.rqmts]], 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
 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, int>( &C::b ) );
+  // Forces the use of class C, and the result is false.
 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, int, int>( &C::a, &C::b ) );
+  // Forces the use of class C, and the result is false.
 ```
 — *end example*]
 — *end note*]
 }
 ```
 — *end example*]
+``` cpp
+consteval bool is_within_lifetime(const auto* p) noexcept;
+```
+*Returns:* `true` if `p` is a pointer to an object that is within its
+lifetime [[basic.life]]; otherwise, `false`.
+*Remarks:* During the evaluation of an expression `E` as a core constant
+expression, a call to this function is ill-formed unless `p` points to
+an object that is usable in constant expressions or whose complete
+object’s lifetime began within `E`.
+[*Example 2*:
+``` cpp
+struct OptBool {
+  union { bool b; char c; };
+  // note: this assumes common implementation properties for bool and char:
+  // * sizeof(bool) == sizeof(char), and
+  // * the value representations for true and false are distinct
+  //   from the value representation for 2
+  constexpr OptBool() : c(2) { }
+  constexpr OptBool(bool b) : b(b) { }
+  constexpr auto has_value() const -> bool {
+    if consteval {
+      return std::is_within_lifetime(&b);       // during constant evaluation, cannot read from c
+    } else {
+      return c != 2;                            // during runtime, must read from c
+    }
+  }
+  constexpr auto operator*() const -> const bool& {
+    return b;
+  }
+};
+constexpr OptBool disengaged;
+constexpr OptBool engaged(true);
+static_assert(!disengaged.has_value());
+static_assert(engaged.has_value());
+static_assert(*engaged);
+```
+— *end example*]

Diff to HTML by rtfpessoa