[meta] - C++17 → C++20

Files changed (1) hide show

tmp/tmpn27ez3zh/{from.md → to.md} +453 -227

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

@@ -1,53 +1,67 @@
 ## Metaprogramming and type traits <a id="meta">[[meta]]</a>
-This subclause describes components used by C++programs, particularly in
-templates, to support the widest possible range of types, optimise
 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 this subclause are signal-safe (
-[[csignal.syn]]).
 ### Requirements <a id="meta.rqmts">[[meta.rqmts]]</a>
-A *UnaryTypeTrait* describes a property of a type. It shall be a class
-template that takes one template type argument and, optionally,
-additional arguments that help define the property being described. It
-shall be `DefaultConstructible`, `CopyConstructible`, 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
-`UnaryTypeTrait`.
-A *BinaryTypeTrait* describes a relationship between two types. It shall
-be a class template that takes two template type arguments and,
-optionally, additional arguments that help define the relationship being
-described. It shall be `DefaultConstructible`, `CopyConstructible`, 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 `BinaryTypeTrait`.
-A *TransformationTrait* modifies a property of a type. It shall be a
-class template that takes one template type argument and, optionally,
-additional arguments that help define the modification. It shall define
-a publicly accessible nested type named `type`, which shall be a synonym
-for the modified type.
 ### Header `<type_traits>` synopsis <a id="meta.type.synop">[[meta.type.synop]]</a>
 ``` cpp
 namespace std {
@@ -88,19 +102,20 @@ namespace std {
   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_pod;
   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, 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;
@@ -149,10 +164,13 @@ namespace std {
   // [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 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;
@@ -217,227 +235,269 @@ namespace std {
     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 <size_t Len,
- size_t Align = default-alignment> // see [meta.trans.other]
     struct aligned_storage;
   template<size_t Len, class... Types> struct aligned_union;
   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> struct underlying_type;
   template<class Fn, class... ArgTypes> struct invoke_result;
-  template <size_t Len,
-            size_t Align = default-alignment> // see [meta.trans.other]
     using aligned_storage_t  = typename aligned_storage<Len, Align>::type;
   template<size_t Len, class... Types>
     using aligned_union_t    = typename aligned_union<Len, Types...>::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 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...>
     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> inline constexpr bool is_void_v
-    = is_void<T>::value;
-  template <class T> inline constexpr bool is_null_pointer_v
-    = is_null_pointer<T>::value;
-  template <class T> inline constexpr bool is_integral_v
-    = is_integral<T>::value;
-  template <class T> inline constexpr bool is_floating_point_v
-    = is_floating_point<T>::value;
-  template <class T> inline constexpr bool is_array_v
-    = is_array<T>::value;
-  template <class T> inline constexpr bool is_pointer_v
-    = is_pointer<T>::value;
-  template <class T> inline constexpr bool is_lvalue_reference_v
-    = is_lvalue_reference<T>::value;
-  template <class T> inline constexpr bool is_rvalue_reference_v
-    = is_rvalue_reference<T>::value;
-  template <class T> inline constexpr bool is_member_object_pointer_v
-    = is_member_object_pointer<T>::value;
-  template <class T> inline constexpr bool is_member_function_pointer_v
-    = is_member_function_pointer<T>::value;
-  template <class T> inline constexpr bool is_enum_v
-    = is_enum<T>::value;
-  template <class T> inline constexpr bool is_union_v
-    = is_union<T>::value;
-  template <class T> inline constexpr bool is_class_v
-    = is_class<T>::value;
-  template <class T> inline constexpr bool is_function_v
-    = is_function<T>::value;
   // [meta.unary.comp], composite type categories
-  template <class T> inline constexpr bool is_reference_v
-    = is_reference<T>::value;
-  template <class T> inline constexpr bool is_arithmetic_v
-    = is_arithmetic<T>::value;
-  template <class T> inline constexpr bool is_fundamental_v
-    = is_fundamental<T>::value;
-  template <class T> inline constexpr bool is_object_v
-    = is_object<T>::value;
-  template <class T> inline constexpr bool is_scalar_v
-    = is_scalar<T>::value;
-  template <class T> inline constexpr bool is_compound_v
-    = is_compound<T>::value;
-  template <class T> inline constexpr bool is_member_pointer_v
-    = is_member_pointer<T>::value;
   // [meta.unary.prop], type properties
-  template <class T> inline constexpr bool is_const_v
-    = is_const<T>::value;
-  template <class T> inline constexpr bool is_volatile_v
-    = is_volatile<T>::value;
-  template <class T> inline constexpr bool is_trivial_v
-    = is_trivial<T>::value;
-  template <class T> inline constexpr bool is_trivially_copyable_v
-    = is_trivially_copyable<T>::value;
-  template <class T> inline constexpr bool is_standard_layout_v
-    = is_standard_layout<T>::value;
-  template <class T> inline constexpr bool is_pod_v
-    = is_pod<T>::value;
-  template <class T> inline constexpr bool is_empty_v
-    = is_empty<T>::value;
-  template <class T> inline constexpr bool is_polymorphic_v
-    = is_polymorphic<T>::value;
-  template <class T> inline constexpr bool is_abstract_v
-    = is_abstract<T>::value;
-  template <class T> inline constexpr bool is_final_v
-    = is_final<T>::value;
-  template <class T> inline constexpr bool is_aggregate_v
-    = is_aggregate<T>::value;
-  template <class T> inline constexpr bool is_signed_v
-    = is_signed<T>::value;
-  template <class T> inline constexpr bool is_unsigned_v
-    = is_unsigned<T>::value;
-  template <class T, class... Args> inline constexpr bool is_constructible_v
-    = is_constructible<T, Args...>::value;
-  template <class T> inline constexpr bool is_default_constructible_v
-    = is_default_constructible<T>::value;
-  template <class T> inline constexpr bool is_copy_constructible_v
-    = is_copy_constructible<T>::value;
-  template <class T> inline constexpr bool is_move_constructible_v
-    = is_move_constructible<T>::value;
-  template <class T, class U> inline constexpr bool is_assignable_v
-    = is_assignable<T, U>::value;
-  template <class T> inline constexpr bool is_copy_assignable_v
-    = is_copy_assignable<T>::value;
-  template <class T> inline constexpr bool is_move_assignable_v
-    = is_move_assignable<T>::value;
-  template <class T, class U> inline constexpr bool is_swappable_with_v
-    = is_swappable_with<T, U>::value;
-  template <class T> inline constexpr bool is_swappable_v
-    = is_swappable<T>::value;
-  template <class T> inline constexpr bool is_destructible_v
-    = is_destructible<T>::value;
-  template <class T, class... Args> inline constexpr bool is_trivially_constructible_v
       = is_trivially_constructible<T, Args...>::value;
-  template <class T> inline constexpr bool is_trivially_default_constructible_v
       = is_trivially_default_constructible<T>::value;
-  template <class T> inline constexpr bool is_trivially_copy_constructible_v
       = is_trivially_copy_constructible<T>::value;
-  template <class T> inline constexpr bool is_trivially_move_constructible_v
       = is_trivially_move_constructible<T>::value;
-  template <class T, class U> inline constexpr bool is_trivially_assignable_v
-    = is_trivially_assignable<T, U>::value;
-  template <class T> inline constexpr bool is_trivially_copy_assignable_v
       = is_trivially_copy_assignable<T>::value;
-  template <class T> inline constexpr bool is_trivially_move_assignable_v
       = is_trivially_move_assignable<T>::value;
-  template <class T> inline constexpr bool is_trivially_destructible_v
-    = is_trivially_destructible<T>::value;
-  template <class T, class... Args> inline constexpr bool is_nothrow_constructible_v
       = is_nothrow_constructible<T, Args...>::value;
-  template <class T> inline constexpr bool is_nothrow_default_constructible_v
       = is_nothrow_default_constructible<T>::value;
-  template <class T> inline constexpr bool is_nothrow_copy_constructible_v
     = is_nothrow_copy_constructible<T>::value;
-  template <class T> inline constexpr bool is_nothrow_move_constructible_v
       = is_nothrow_move_constructible<T>::value;
-  template <class T, class U> inline constexpr bool is_nothrow_assignable_v
-    = is_nothrow_assignable<T, U>::value;
-  template <class T> inline constexpr bool is_nothrow_copy_assignable_v
-    = is_nothrow_copy_assignable<T>::value;
-  template <class T> inline constexpr bool is_nothrow_move_assignable_v
-    = is_nothrow_move_assignable<T>::value;
-  template <class T, class U> inline constexpr bool is_nothrow_swappable_with_v
-    = is_nothrow_swappable_with<T, U>::value;
-  template <class T> inline constexpr bool is_nothrow_swappable_v
-    = is_nothrow_swappable<T>::value;
-  template <class T> inline constexpr bool is_nothrow_destructible_v
-    = is_nothrow_destructible<T>::value;
-  template <class T> inline constexpr bool has_virtual_destructor_v
-    = has_virtual_destructor<T>::value;
-  template <class T> inline constexpr bool has_unique_object_representations_v
       = has_unique_object_representations<T>::value;
   // [meta.unary.prop.query], type property queries
-  template <class T> inline constexpr size_t alignment_of_v
-    = alignment_of<T>::value;
-  template <class T> inline constexpr size_t rank_v
-    = rank<T>::value;
-  template <class T, unsigned I = 0> inline constexpr size_t extent_v
-    = extent<T, I>::value;
   // [meta.rel], type relations
-  template <class T, class U> inline constexpr bool is_same_v
-    = is_same<T, U>::value;
-  template <class Base, class Derived> inline constexpr bool is_base_of_v
-    = is_base_of<Base, Derived>::value;
-  template <class From, class To> inline constexpr bool is_convertible_v
-    = is_convertible<From, To>::value;
-  template <class Fn, class... ArgTypes> inline constexpr bool is_invocable_v
-    = is_invocable<Fn, ArgTypes...>::value;
-  template <class R, class Fn, class... ArgTypes> inline constexpr bool is_invocable_r_v
-    = is_invocable_r<R, Fn, ArgTypes...>::value;
-  template <class Fn, class... ArgTypes> inline constexpr bool is_nothrow_invocable_v
- = is_nothrow_invocable<Fn, ArgTypes...>::value;
-  template <class R, class Fn, class... ArgTypes> inline constexpr bool is_nothrow_invocable_r_v
       = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;
   // [meta.logical], logical operator traits
-  template<class... B> inline constexpr bool conjunction_v = conjunction<B...>::value;
-  template<class... B> inline constexpr bool disjunction_v = disjunction<B...>::value;
-  template<class B> inline constexpr bool negation_v = negation<B>::value;
 }
 ```
-The behavior of a program that adds specializations for any of the
-templates defined in this subclause is undefined unless otherwise
-specified.
-Unless otherwise specified, an incomplete type may be used to
-instantiate a template in this subclause.
 ### 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; }
   };
 }
 ```
@@ -449,29 +509,29 @@ as base classes to define the interface for various type traits.
 ### Unary type traits <a id="meta.unary">[[meta.unary]]</a>
 This subclause contains templates that may be used to query the
 properties of a type at compile time.
-Each of these templates shall be a `UnaryTypeTrait` ([[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
-section  [[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 section
 [[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.
@@ -485,16 +545,16 @@ 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 must be 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 ([[basic.types]], [[special]]) function call that is not an
-odr-use ([[basic.def.odr]]) of `declval` in the context of the
 corresponding definition notwithstanding the restrictions of
 [[declval]].
 [*Note 1*: A union is a class type that can be marked with
 `final`. — *end note*]
@@ -575,19 +635,18 @@ if:
 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 unsigned 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 `UnaryTypeTrait` ([[meta.rqmts]])
 with a base characteristic of `integral_constant<size_t, Value>`.
 [*Example 1*:
 ``` cpp
@@ -618,21 +677,21 @@ assert((extent_v<int[][4], 1>) == 4);
 ### 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 `BinaryTypeTrait` ([[meta.rqmts]])
 with a base characteristic of `true_type` if the corresponding condition
 is true, otherwise `false_type`.
 [*Note 1*: Base classes that are private, protected, or ambiguous are,
 nonetheless, 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 ([[basic.types]], [[special]]) function call that is not an
-odr-use ([[basic.def.odr]]) of `declval` in the context of the
 corresponding definition notwithstanding the restrictions of
 [[declval]].
 [*Example 1*:
@@ -663,17 +722,17 @@ implicit conversions to the return type of the function:
 To test() {
   return declval<From>();
 }
 ```
-[*Note 2*: This requirement gives well defined results for reference
 types, void types, array types, and function types. — *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 (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
@@ -683,22 +742,22 @@ in the program being ill-formed. — *end note*]
 This subclause contains templates that may be used to transform one type
 to another following some predefined rule.
 Each of the templates in this subclause shall be a
-`TransformationTrait` ([[meta.rqmts]]).
 #### Const-volatile modifications <a id="meta.trans.cv">[[meta.trans.cv]]</a>
 [*Example 1*: `remove_const_t<const volatile int>` evaluates to
 `volatile int`, whereas `remove_const_t<const int*>` evaluates to
 `const int*`. — *end example*]
 #### Reference modifications <a id="meta.trans.ref">[[meta.trans.ref]]</a>
-[*Note 1*: This rule reflects the semantics of reference collapsing (
-[[dcl.ref]]). — *end note*]
 #### Sign modifications <a id="meta.trans.sign">[[meta.trans.sign]]</a>
 #### Array modifications <a id="meta.trans.arr">[[meta.trans.arr]]</a>
@@ -732,16 +791,15 @@ assert((is_same_v<remove_all_extents_t<int[][3]>, int>));
 #### Pointer modifications <a id="meta.trans.ptr">[[meta.trans.ptr]]</a>
 #### Other transformations <a id="meta.trans.other">[[meta.trans.other]]</a>
-[*Note 1*: This behavior is similar to the lvalue-to-rvalue (
-[[conv.lval]]), array-to-pointer ([[conv.array]]), and
-function-to-pointer ([[conv.func]]) conversions applied when an lvalue
-expression is used as an rvalue, but also strips cv-qualifiers from
-class types in order to more closely model by-value argument
-passing. — *end note*]
 [*Note 2*:
 A typical implementation would define `aligned_storage` as:
@@ -754,16 +812,51 @@ struct aligned_storage {
 };
 ```
 — *end note*]
-It is *implementation-defined* whether any extended alignment is
-supported ([[basic.align]]).
-Note A: For the `common_type` 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`.
 - 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
@@ -772,17 +865,22 @@ follows:
   `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>`.
-  - Otherwise, let `C` denote the same type, if any, as
     ``` cpp
     decay_t<decltype(false ? declval<D1>() : declval<D2>())>
     ```
- \[*Note 3*: This will not apply if there is a specialization
-    `common_type<D1, D2>`. — *end note*]
   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
@@ -806,11 +904,59 @@ unambiguous cv-unqualified non-reference type `C` 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.
-[*Example 1*:
 Given these definitions:
 ``` cpp
 using PF1 = bool  (&)();
@@ -850,29 +996,29 @@ template<class... B> struct conjunction : see below { };
 ```
 The class template `conjunction` forms the logical conjunction of its
 template type arguments.
-For a specialization `conjunction<B1, ..., BN>`, if there is a template
-type argument `Bi` for which `bool(Bi::value)` is `false`, then
-instantiating `conjunction<B1, ..., BN>::value` does not require the
-instantiation of `Bj::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 `Bi::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<B1, ..., BN>` has a public and
 unambiguous base that is either
-- the first type `Bi` in the list `true_type, B1, ..., BN` for which
-  `bool(Bi::value)` is `false`, or
-- if there is no such `Bi`, 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*]
@@ -885,29 +1031,29 @@ template<class... B> struct disjunction : see below { };
 ```
 The class template `disjunction` forms the logical disjunction of its
 template type arguments.
-For a specialization `disjunction<B1, ..., BN>`, if there is a template
-type argument `Bi` for which `bool(Bi::value)` is `true`, then
-instantiating `disjunction<B1, ..., BN>::value` does not require the
-instantiation of `Bj::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 `Bi::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<B1, ..., BN>` has a public and
 unambiguous base that is either
-- the first type `Bi` in the list `false_type, B1, ..., BN` for which
-  `bool(Bi::value)` is `true`, or
-- if there is no such `Bi`, 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*]
@@ -918,8 +1064,88 @@ The member names of the base class, other than `disjunction` and
 ``` 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 `UnaryTypeTrait` with a base
-characteristic of `bool_constant<!bool(B::value)>`.

 ## Metaprogramming and type traits <a id="meta">[[meta]]</a>
+This subclause describes components used by C++ programs, particularly
+in templates, to support the widest possible range of types, optimise
 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 this subclause 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 this subclause
+[[meta]] is undefined.
+Unless otherwise specified, an incomplete type may be used to
+instantiate a template specified in this subclause. The behavior of a
+program is undefined if:
+- an instantiation of a template specified in subclause  [[meta]]
+  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
 namespace std {
   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, 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;
   // [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;
     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<size_t Len, size_t Align = default-alignment> // see [meta.trans.other]
     struct aligned_storage;
   template<size_t Len, class... Types> struct aligned_union;
+  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<size_t Len, size_t Align = default-alignment> // see [meta.trans.other]
     using aligned_storage_t  = typename aligned_storage<Len, Align>::type;
   template<size_t Len, class... Types>
     using aligned_union_t    = typename aligned_union<Len, Types...>::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>
+ inline constexpr bool is_void_v = is_void<T>::value;
+  template<class T>
+ inline constexpr bool is_null_pointer_v = is_null_pointer<T>::value;
+  template<class T>
+ inline constexpr bool is_integral_v = is_integral<T>::value;
+  template<class T>
+ inline constexpr bool is_floating_point_v = is_floating_point<T>::value;
+  template<class T>
+ inline constexpr bool is_array_v = is_array<T>::value;
+  template<class T>
+ inline constexpr bool is_pointer_v = is_pointer<T>::value;
+  template<class T>
+ inline constexpr bool is_lvalue_reference_v = is_lvalue_reference<T>::value;
+  template<class T>
+ inline constexpr bool is_rvalue_reference_v = is_rvalue_reference<T>::value;
+  template<class T>
+ inline constexpr bool is_member_object_pointer_v = is_member_object_pointer<T>::value;
+  template<class T>
+ inline constexpr bool is_member_function_pointer_v = is_member_function_pointer<T>::value;
+  template<class T>
+ inline constexpr bool is_enum_v = is_enum<T>::value;
+  template<class T>
+ inline constexpr bool is_union_v = is_union<T>::value;
+  template<class T>
+ inline constexpr bool is_class_v = is_class<T>::value;
+  template<class T>
+ inline constexpr bool is_function_v = is_function<T>::value;
   // [meta.unary.comp], composite type categories
+  template<class T>
+ inline constexpr bool is_reference_v = is_reference<T>::value;
+  template<class T>
+ inline constexpr bool is_arithmetic_v = is_arithmetic<T>::value;
+  template<class T>
+ inline constexpr bool is_fundamental_v = is_fundamental<T>::value;
+  template<class T>
+ inline constexpr bool is_object_v = is_object<T>::value;
+  template<class T>
+ inline constexpr bool is_scalar_v = is_scalar<T>::value;
+  template<class T>
+ inline constexpr bool is_compound_v = is_compound<T>::value;
+  template<class T>
+ inline constexpr bool is_member_pointer_v = is_member_pointer<T>::value;
   // [meta.unary.prop], type properties
+  template<class T>
+ inline constexpr bool is_const_v = is_const<T>::value;
+  template<class T>
+ inline constexpr bool is_volatile_v = is_volatile<T>::value;
+  template<class T>
+ inline constexpr bool is_trivial_v = is_trivial<T>::value;
+  template<class T>
+ inline constexpr bool is_trivially_copyable_v = is_trivially_copyable<T>::value;
+  template<class T>
+ inline constexpr bool is_standard_layout_v = is_standard_layout<T>::value;
+  template<class T>
+ inline constexpr bool is_empty_v = is_empty<T>::value;
+  template<class T>
+ inline constexpr bool is_polymorphic_v = is_polymorphic<T>::value;
+  template<class T>
+ inline constexpr bool is_abstract_v = is_abstract<T>::value;
+  template<class T>
+ inline constexpr bool is_final_v = is_final<T>::value;
+  template<class T>
+ inline constexpr bool is_aggregate_v = is_aggregate<T>::value;
+  template<class T>
+ inline constexpr bool is_signed_v = is_signed<T>::value;
+  template<class T>
+ inline constexpr bool is_unsigned_v = is_unsigned<T>::value;
+  template<class T>
+ inline constexpr bool is_bounded_array_v = is_bounded_array<T>::value;
+  template<class T>
+ inline constexpr bool is_unbounded_array_v = is_unbounded_array<T>::value;
+  template<class T, class... Args>
+ inline constexpr bool is_constructible_v = is_constructible<T, Args...>::value;
+  template<class T>
+ inline constexpr bool is_default_constructible_v = is_default_constructible<T>::value;
+  template<class T>
+ inline constexpr bool is_copy_constructible_v = is_copy_constructible<T>::value;
+  template<class T>
+ inline constexpr bool is_move_constructible_v = is_move_constructible<T>::value;
+  template<class T, class U>
+ inline constexpr bool is_assignable_v = is_assignable<T, U>::value;
+  template<class T>
+ inline constexpr bool is_copy_assignable_v = is_copy_assignable<T>::value;
+  template<class T>
+ inline constexpr bool is_move_assignable_v = is_move_assignable<T>::value;
+  template<class T, class U>
+ inline constexpr bool is_swappable_with_v = is_swappable_with<T, U>::value;
+  template<class T>
+ inline constexpr bool is_swappable_v = is_swappable<T>::value;
+  template<class T>
+    inline constexpr bool is_destructible_v = is_destructible<T>::value;
+  template<class T, class... Args>
+    inline constexpr bool is_trivially_constructible_v
       = is_trivially_constructible<T, Args...>::value;
+  template<class T>
+    inline constexpr bool is_trivially_default_constructible_v
       = is_trivially_default_constructible<T>::value;
+  template<class T>
+    inline constexpr bool is_trivially_copy_constructible_v
       = is_trivially_copy_constructible<T>::value;
+  template<class T>
+    inline constexpr bool is_trivially_move_constructible_v
       = is_trivially_move_constructible<T>::value;
+  template<class T, class U>
+ inline constexpr bool is_trivially_assignable_v = is_trivially_assignable<T, U>::value;
+  template<class T>
+    inline constexpr bool is_trivially_copy_assignable_v
       = is_trivially_copy_assignable<T>::value;
+  template<class T>
+    inline constexpr bool is_trivially_move_assignable_v
       = is_trivially_move_assignable<T>::value;
+  template<class T>
+ inline constexpr bool is_trivially_destructible_v = is_trivially_destructible<T>::value;
+  template<class T, class... Args>
+    inline constexpr bool is_nothrow_constructible_v
       = is_nothrow_constructible<T, Args...>::value;
+  template<class T>
+    inline constexpr bool is_nothrow_default_constructible_v
       = is_nothrow_default_constructible<T>::value;
+  template<class T>
+    inline constexpr bool is_nothrow_copy_constructible_v
     = is_nothrow_copy_constructible<T>::value;
+  template<class T>
+    inline constexpr bool is_nothrow_move_constructible_v
       = is_nothrow_move_constructible<T>::value;
+  template<class T, class U>
+ inline constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<T, U>::value;
+  template<class T>
+ inline constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<T>::value;
+  template<class T>
+ inline constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<T>::value;
+  template<class T, class U>
+ inline constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with<T, U>::value;
+  template<class T>
+ inline constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<T>::value;
+  template<class T>
+ inline constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<T>::value;
+  template<class T>
+ inline constexpr bool has_virtual_destructor_v = has_virtual_destructor<T>::value;
+  template<class T>
+    inline constexpr bool has_unique_object_representations_v
       = has_unique_object_representations<T>::value;
   // [meta.unary.prop.query], type property queries
+  template<class T>
+ inline constexpr size_t alignment_of_v = alignment_of<T>::value;
+  template<class T>
+ inline constexpr size_t rank_v = rank<T>::value;
+  template<class T, unsigned I = 0>
+ inline constexpr size_t extent_v = extent<T, I>::value;
   // [meta.rel], type relations
+  template<class T, class U>
+ inline constexpr bool is_same_v = is_same<T, U>::value;
+  template<class Base, class Derived>
+ inline constexpr bool is_base_of_v = is_base_of<Base, Derived>::value;
+  template<class From, class To>
+ inline constexpr bool is_convertible_v = is_convertible<From, To>::value;
+  template<class From, class To>
+ inline constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<From, To>::value;
+  template<class T, class U>
+ inline constexpr bool is_layout_compatible_v = is_layout_compatible<T, U>::value;
+  template<class Base, class Derived>
+ inline constexpr bool is_pointer_interconvertible_base_of_v
+      = is_pointer_interconvertible_base_of<Base, Derived>::value;
+  template<class Fn, class... ArgTypes>
+    inline constexpr bool is_invocable_v = is_invocable<Fn, ArgTypes...>::value;
+  template<class R, class Fn, class... ArgTypes>
+    inline constexpr bool is_invocable_r_v = is_invocable_r<R, Fn, ArgTypes...>::value;
+  template<class Fn, class... ArgTypes>
+    inline constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<Fn, ArgTypes...>::value;
+  template<class R, class Fn, class... ArgTypes>
+    inline constexpr bool is_nothrow_invocable_r_v
       = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;
   // [meta.logical], logical operator traits
+  template<class... B>
+ inline constexpr bool conjunction_v = conjunction<B...>::value;
+  template<class... B>
+    inline constexpr bool disjunction_v = disjunction<B...>::value;
+  template<class B>
+    inline 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; }
   };
 }
 ```
 ### Unary type traits <a id="meta.unary">[[meta.unary]]</a>
 This subclause 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.
 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 ([[basic.types]], [[special]]) function call that is not an
+odr-use [[basic.def.odr]] of `declval` in the context of the
 corresponding definition notwithstanding the restrictions of
 [[declval]].
 [*Note 1*: A union is a class type that can be marked with
 `final`. — *end note*]
 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
 ### 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`.
 [*Note 1*: Base classes that are private, protected, or ambiguous are,
 nonetheless, 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 ([[basic.types]], [[special]]) function call that is not an
+odr-use [[basic.def.odr]] of `declval` in the context of the
 corresponding definition notwithstanding the restrictions of
 [[declval]].
 [*Example 1*:
 To test() {
   return declval<From>();
 }
 ```
+[*Note 2*: This requirement gives well-defined results for reference
 types, void types, array types, and function types. — *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
 This subclause contains templates that may be used to transform one type
 to another following some predefined rule.
 Each of the templates in this subclause shall be a
+*Cpp17TransformationTrait* [[meta.rqmts]].
 #### Const-volatile modifications <a id="meta.trans.cv">[[meta.trans.cv]]</a>
 [*Example 1*: `remove_const_t<const volatile int>` evaluates to
 `volatile int`, whereas `remove_const_t<const int*>` evaluates to
 `const int*`. — *end example*]
 #### Reference modifications <a id="meta.trans.ref">[[meta.trans.ref]]</a>
+[*Note 1*: This rule reflects the semantics of reference collapsing
+[[dcl.ref]]. — *end note*]
 #### Sign modifications <a id="meta.trans.sign">[[meta.trans.sign]]</a>
 #### Array modifications <a id="meta.trans.arr">[[meta.trans.arr]]</a>
 #### Pointer modifications <a id="meta.trans.ptr">[[meta.trans.ptr]]</a>
 #### Other transformations <a id="meta.trans.other">[[meta.trans.other]]</a>
+[*Note 1*: This behavior is similar to the lvalue-to-rvalue
+[[conv.lval]], array-to-pointer [[conv.array]], and function-to-pointer
+[[conv.func]] conversions applied when an lvalue is used as an rvalue,
+but also strips cv-qualifiers from class types in order to more closely
+model by-value argument passing. — *end note*]
 [*Note 2*:
 A typical implementation would define `aligned_storage` as:
 };
 ```
 — *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
   `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 3*: 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
 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
+  - If `T1` and `T2` are reference types and `COMMON-REF(T1, T2)` is
+    well-formed, then the member typedef `type` denotes that type.
+  - 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 5*: 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, that member shall be a *typedef-name* for an accessible and
+unambiguous type `C` 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  (&)();
 ```
 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 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*]
 ``` 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
+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;
+```
+*Returns:* `true` if and only if evaluation of the call occurs within
+the evaluation of an expression or conversion that is manifestly
+constant-evaluated [[expr.const]].
+[*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