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

Files changed (1) hide show

tmp/tmpmvupy_aw/{from.md → to.md} +549 -157

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

@@ -10,35 +10,38 @@ 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.
 ### 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
-*BaseCharacteristic*, 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 BaseCharacteristic
 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
-*BaseCharacteristic*, 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 BaseCharacteristic
-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
@@ -46,16 +49,19 @@ for the modified type.
 ### Header `<type_traits>` synopsis <a id="meta.type.synop">[[meta.type.synop]]</a>
 ``` cpp
 namespace std {
-  // [meta.help], helper class:
   template <class T, T v> struct integral_constant;
-  typedef integral_constant<bool, true>  true_type;
-  typedef integral_constant<bool, false> false_type;
- // [meta.unary.cat], primary type categories:
   template <class T> struct is_void;
   template <class T> struct is_null_pointer;
   template <class T> struct is_integral;
   template <class T> struct is_floating_point;
   template <class T> struct is_array;
@@ -67,31 +73,31 @@ namespace std {
   template <class T> struct is_enum;
   template <class T> struct is_union;
   template <class T> struct is_class;
   template <class T> struct is_function;
-  // [meta.unary.comp], composite type categories:
   template <class T> struct is_reference;
   template <class T> struct is_arithmetic;
   template <class T> struct is_fundamental;
   template <class T> struct is_object;
   template <class T> struct is_scalar;
   template <class T> struct is_compound;
   template <class T> struct is_member_pointer;
-  // [meta.unary.prop], type properties:
   template <class T> struct is_const;
   template <class T> struct is_volatile;
   template <class T> struct is_trivial;
   template <class T> struct is_trivially_copyable;
   template <class T> struct is_standard_layout;
   template <class T> struct is_pod;
-  template <class T> struct is_literal_type;
   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_signed;
   template <class T> struct is_unsigned;
   template <class T, class... Args> struct is_constructible;
@@ -101,10 +107,13 @@ namespace std {
   template <class T, class U> struct is_assignable;
   template <class T> struct is_copy_assignable;
   template <class T> struct is_move_assignable;
   template <class T> struct is_destructible;
   template <class T, class... Args> struct is_trivially_constructible;
   template <class T> struct is_trivially_default_constructible;
   template <class T> struct is_trivially_copy_constructible;
@@ -122,24 +131,36 @@ namespace std {
   template <class T, class U> struct is_nothrow_assignable;
   template <class T> struct is_nothrow_copy_assignable;
   template <class T> struct is_nothrow_move_assignable;
   template <class T> struct is_nothrow_destructible;
   template <class T> struct has_virtual_destructor;
- // [meta.unary.prop.query], type property queries:
   template <class T> struct alignment_of;
   template <class T> struct rank;
   template <class T, unsigned I = 0> struct extent;
-  // [meta.rel], type relations:
   template <class T, class U> struct is_same;
   template <class Base, class Derived> struct is_base_of;
   template <class From, class To> struct is_convertible;
- // [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;
@@ -156,11 +177,11 @@ namespace std {
   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>
@@ -168,54 +189,53 @@ namespace std {
   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 <std::size_t Len,
- std::size_t Align = default-alignment> // see [meta.trans.other]
     struct aligned_storage;
-  template <std::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> class result_of;   // not defined
-  template <class F, class... ArgTypes> class result_of<F(ArgTypes...)>;
-  template <std::size_t Len,
- std::size_t Align = default-alignment > // see [meta.trans.other]
     using aligned_storage_t = typename aligned_storage<Len, Align>::type;
-  template <std::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;
@@ -223,311 +243,683 @@ namespace std {
     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 T>
-    using result_of_t       = typename result_of<T>::type;
-} // namespace std
 ```
-The behavior of a program that adds specializations for any of the class
 templates defined in this subclause is undefined unless otherwise
 specified.
 ### 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;
- typedef T value_type;
- typedef integral_constant<T,v> type;
     constexpr operator value_type() const noexcept { return value; }
     constexpr value_type operator()() const noexcept { return value; }
   };
-  typedef integral_constant<bool, true> true_type;
-  typedef integral_constant<bool, false> false_type;
 }
 ```
-The class template `integral_constant` and its associated typedefs
-`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>
-This sub-clause 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 BaseCharacteristic 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-qualified* `T` shall yield the same result.
-For any given type `T`, exactly one of the primary type categories has a
-`value` member that evaluates to `true`.
 #### 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-qualified* `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 Clause,
 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.
 ``` cpp
-is_const<const volatile int>::value     // true
-is_const<const int*>::value             // false
-is_const<const int&>::value             // false
-is_const<int[3]>::value                 // false
-is_const<const int[3]>::value           // true
 ```
 ``` cpp
 remove_const_t<const volatile int>  // volatile int
 remove_const_t<const int* const>    // const int*
 remove_const_t<const int&>          // const int&
 remove_const_t<const int[3]>        // int[3]
 ```
 ``` cpp
 // Given:
 struct P final { };
 union U1 { };
 union U2 final { };
 // the following assertions hold:
-static_assert(!is_final<int>::value, "Error!");
-static_assert( is_final<P>::value, "Error!");
-static_assert(!is_final<U1>::value, "Error!");
-static_assert( is_final<U2>::value, "Error!");
 ```
-Given the following function prototype:
-``` cpp
-template <class T>
-  add_rvalue_reference_t<T> create() noexcept;
-```
-the predicate condition for a template specialization
 `is_constructible<T, Args...>` shall be satisfied if and only if the
 following variable definition would be well-formed for some invented
 variable `t`:
 ``` cpp
-T t(create<Args>()...);
 ```
-These tokens are never interpreted as a function declaration. Access
-checking is performed as if in a context unrelated to `T` and any of the
-`Args`. Only the validity of the immediate context of the variable
-initialization is considered. The evaluation of the initialization can
-result in side effects such as the instantiation of class template
-specializations and function template specializations, the generation of
-implicitly-defined functions, and so on. Such side effects are not in
-the “immediate context” and can result in the program being ill-formed.
 ### Type property queries <a id="meta.unary.prop.query">[[meta.unary.prop.query]]</a>
-This sub-clause 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 `BaseCharacteristic` of `integral_constant<size_t, Value>`.
 ``` cpp
 // the following assertions hold:
-assert(rank<int>::value == 0);
-assert(rank<int[2]>::value == 1);
-assert(rank<int[][4]>::value == 2);
 ```
 ``` cpp
 // the following assertions hold:
-assert(extent<int>::value == 0);
-assert(extent<int[2]>::value == 2);
-assert(extent<int[2][4]>::value == 2);
-assert(extent<int[][4]>::value == 0);
-assert((extent<int, 1>::value) == 0);
-assert((extent<int[2], 1>::value) == 0);
-assert((extent<int[2][4], 1>::value) == 4);
-assert((extent<int[][4], 1>::value) == 4);
 ```
 ### Relationships between types <a id="meta.rel">[[meta.rel]]</a>
-This sub-clause 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 BaseCharacteristic of `true_type` if the corresponding condition
 is true, otherwise `false_type`.
 ``` cpp
 struct B {};
 struct B1 : B {};
 struct B2 : B {};
 struct D : private B1, private B2 {};
-is_base_of<B, D>::value         // true
-is_base_of<const B, D>::value   // true
-is_base_of<B, const D>::value   // true
-is_base_of<B, const B>::value   // true
-is_base_of<D, B>::value         // false
-is_base_of<B&, D&>::value       // false
-is_base_of<B[3], D[3]>::value   // false
-is_base_of<int, int>::value     // false
 ```
-Given the following function prototype:
-``` cpp
-template <class T>
-  add_rvalue_reference_t<T> create() noexcept;
-```
-the predicate condition for a template specialization
 `is_convertible<From, To>` shall be satisfied if and only if the return
 expression in the following code would be well-formed, including any
 implicit conversions to the return type of the function:
 ``` cpp
 To test() {
-  return create<From>();
 }
 ```
-This requirement gives well defined results for reference types, void
-types, array types, and function types.Access checking is performed as
-if in a context unrelated to `To` and `From`. Only the validity of the
-immediate context of the expression of the *return-statement* (including
-conversions to the return type) is considered. The evaluation of the
-conversion 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.
 ### Transformations between types <a id="meta.trans">[[meta.trans]]</a>
-This sub-clause 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>
 #### 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>
 ``` cpp
 // the following assertions hold:
-assert((is_same<remove_extent_t<int>, int>::value));
-assert((is_same<remove_extent_t<int[2]>, int>::value));
-assert((is_same<remove_extent_t<int[2][3]>, int[3]>::value));
-assert((is_same<remove_extent_t<int[][3]>, int[3]>::value));
 ```
 ``` cpp
 // the following assertions hold:
-assert((is_same<remove_all_extents_t<int>, int>::value));
-assert((is_same<remove_all_extents_t<int[2]>, int>::value));
-assert((is_same<remove_all_extents_t<int[2][3]>, int>::value));
-assert((is_same<remove_all_extents_t<int[][3]>, int>::value));
 ```
 #### Pointer modifications <a id="meta.trans.ptr">[[meta.trans.ptr]]</a>
 #### Other transformations <a id="meta.trans.other">[[meta.trans.other]]</a>
 A typical implementation would define `aligned_storage` as:
 ``` cpp
-template <std::size_t Len, std::size_t Alignment>
 struct aligned_storage {
   typedef struct {
     alignas(Alignment) unsigned char __data[Len];
   } type;
 };
 ```
 It is *implementation-defined* whether any extended alignment is
 supported ([[basic.align]]).
-The nested typedef `common_type::type` shall be defined as follows:
     ``` cpp
-template <class ...T> struct common_type;
-template <class T>
-struct common_type<T> {
-  typedef decay_t<T> type;
-};
-template <class T, class U>
-struct common_type<T, U> {
-  typedef decay_t<decltype(true ? declval<T>() : declval<U>())> type;
-};
-template <class T, class U, class... V>
-struct common_type<T, U, V...> {
-  typedef common_type_t<common_type_t<T, U>, V...> type;
-};
     ```
 Given these definitions:
 ``` cpp
-typedef bool (&PF1)();
-typedef short (*PF2)(long);
 struct S {
   operator PF2() const;
   double operator()(char, int&);
   void fn(long) const;
   char data;
 };
-typedef void (S::*PMF)(long) const;
-typedef char S::*PMD;
 ```
 the following assertions will hold:
 ``` cpp
-static_assert(is_same<result_of_t<S(int)>, short>::value, "Error!");
-static_assert(is_same<result_of_t<S&(unsigned char, int&)>, double>::value, "Error!");
-static_assert(is_same<result_of_t<PF1()>, bool>::value, "Error!");
-static_assert(is_same<result_of_t<PMF(unique_ptr<S>, int)>, void>::value, "Error!");
-static_assert(is_same<result_of_t<PMD(S)>, char&&>::value, "Error!");
-static_assert(is_same<result_of_t<PMD(const S*)>, const char&>::value, "Error!");
 ```

 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
 ### Header `<type_traits>` synopsis <a id="meta.type.synop">[[meta.type.synop]]</a>
 ``` cpp
 namespace std {
+  // [meta.help], helper class
   template <class T, T v> struct integral_constant;
+ template <bool B>
+    using bool_constant = integral_constant<bool, B>;
+  using true_type  = bool_constant<true>;
+  using false_type = bool_constant<false>;
+  // [meta.unary.cat], primary type categories
   template <class T> struct is_void;
   template <class T> struct is_null_pointer;
   template <class T> struct is_integral;
   template <class T> struct is_floating_point;
   template <class T> struct is_array;
   template <class T> struct is_enum;
   template <class T> struct is_union;
   template <class T> struct is_class;
   template <class T> struct is_function;
+  // [meta.unary.comp], composite type categories
   template <class T> struct is_reference;
   template <class T> struct is_arithmetic;
   template <class T> struct is_fundamental;
   template <class T> struct is_object;
   template <class T> struct is_scalar;
   template <class T> struct is_compound;
   template <class T> struct is_member_pointer;
+  // [meta.unary.prop], type properties
   template <class T> struct is_const;
   template <class T> struct is_volatile;
   template <class T> struct is_trivial;
   template <class T> struct is_trivially_copyable;
   template <class T> struct is_standard_layout;
   template <class T> struct is_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, class U> struct is_assignable;
   template <class T> struct is_copy_assignable;
   template <class T> struct is_move_assignable;
+  template <class T, class U> struct is_swappable_with;
+  template <class T> struct is_swappable;
   template <class T> struct is_destructible;
   template <class T, class... Args> struct is_trivially_constructible;
   template <class T> struct is_trivially_default_constructible;
   template <class T> struct is_trivially_copy_constructible;
   template <class T, class U> struct is_nothrow_assignable;
   template <class T> struct is_nothrow_copy_assignable;
   template <class T> struct is_nothrow_move_assignable;
+  template <class T, class U> struct is_nothrow_swappable_with;
+  template <class T> struct is_nothrow_swappable;
   template <class T> struct is_nothrow_destructible;
   template <class T> struct has_virtual_destructor;
+ template <class T> struct has_unique_object_representations;
+  // [meta.unary.prop.query], type property queries
   template <class T> struct alignment_of;
   template <class T> struct rank;
   template <class T, unsigned I = 0> struct extent;
+  // [meta.rel], type relations
   template <class T, class U> struct is_same;
   template <class Base, class Derived> struct is_base_of;
   template <class From, class To> struct is_convertible;
+ template <class Fn, class... ArgTypes> struct is_invocable;
+  template <class R, class Fn, class... ArgTypes> struct is_invocable_r;
+  template <class Fn, class... ArgTypes> struct is_nothrow_invocable;
+  template <class R, class Fn, class... ArgTypes> struct is_nothrow_invocable_r;
+  // [meta.trans.cv], const-volatile modifications
   template <class T> struct remove_const;
   template <class T> struct remove_volatile;
   template <class T> struct remove_cv;
   template <class T> struct add_const;
   template <class T> struct add_volatile;
   template <class T>
     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>
   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 <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;
     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; }
   };
 }
 ```
+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>
+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.
 #### Type properties <a id="meta.unary.prop">[[meta.unary.prop]]</a>
 These templates provide access to some of the more important properties
 of types.
 It is unspecified whether the library defines any full or partial
 specializations of any of these templates.
+For all of the class templates `X` declared in this subclause,
 instantiating that template with a template-argument that is a class
 template specialization may result in the implicit instantiation of the
 template argument if and only if the semantics of `X` require that the
 argument 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*]
+[*Example 1*:
 ``` cpp
+is_const_v<const volatile int>     // true
+is_const_v<const int*>             // false
+is_const_v<const int&>             // false
+is_const_v<int[3]>                 // false
+is_const_v<const int[3]>           // true
 ```
+— *end example*]
+[*Example 2*:
 ``` cpp
 remove_const_t<const volatile int>  // volatile int
 remove_const_t<const int* const>    // const int*
 remove_const_t<const int&>          // const int&
 remove_const_t<const int[3]>        // int[3]
 ```
+— *end example*]
+[*Example 3*:
 ``` cpp
 // Given:
 struct P final { };
 union U1 { };
 union U2 final { };
 // the following assertions hold:
+static_assert(!is_final_v<int>);
+static_assert(is_final_v<P>);
+static_assert(!is_final_v<U1>);
+static_assert(is_final_v<U2>);
 ```
+— *end example*]
+The predicate condition for a template specialization
 `is_constructible<T, Args...>` shall be satisfied if and only if the
 following variable definition would be well-formed for some invented
 variable `t`:
 ``` cpp
+T t(declval<Args>()...);
 ```
+[*Note 2*: These tokens are never interpreted as a function
+declaration. — *end note*]
+Access checking is performed as if in a context unrelated to `T` and any
+of the `Args`. Only the validity of the immediate context of the
+variable initialization is considered.
+[*Note 3*: The evaluation of the initialization can result in side
+effects such as the instantiation of class template specializations and
+function template specializations, the generation of implicitly-defined
+functions, and so on. Such side effects are not in the “immediate
+context” and can result in the program being ill-formed. — *end note*]
+The predicate condition for a template specialization
+`has_unique_object_representations<T>` shall be satisfied if and only
+if:
+- `T` is trivially copyable, and
+- any two objects of type `T` with the same value have the same object
+  representation, where two objects of array or non-union class type are
+  considered to have the same value if their respective sequences of
+  direct subobjects have the same values, and two objects of union type
+  are considered to have the same value if they have the same active
+  member and the corresponding members have the same value.
+The set of scalar types for which this condition holds is
+*implementation-defined*.
+[*Note 4*: If a type has padding bits, the condition does not hold;
+otherwise, the condition holds true for 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
 // 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 `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*:
 ``` cpp
 struct B {};
 struct B1 : B {};
 struct B2 : B {};
 struct D : private B1, private B2 {};
+is_base_of_v<B, D>         // true
+is_base_of_v<const B, D>   // true
+is_base_of_v<B, const D>   // true
+is_base_of_v<B, const B>   // true
+is_base_of_v<D, B>         // false
+is_base_of_v<B&, D&>       // false
+is_base_of_v<B[3], D[3]>   // false
+is_base_of_v<int, int>     // false
 ```
+— *end example*]
+The predicate condition for a template specialization
 `is_convertible<From, To>` shall be satisfied if and only if the return
 expression in the following code would be well-formed, including any
 implicit conversions to the return type of the function:
 ``` cpp
 To test() {
+  return declval<From>();
 }
 ```
+[*Note 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
+in the program being ill-formed. — *end note*]
 ### Transformations between types <a id="meta.trans">[[meta.trans]]</a>
+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>
+[*Note 1*: For multidimensional arrays, only the first array dimension
+is removed. For a type “array of `const U`”, the resulting type is
+`const U`. — *end note*]
+[*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*: 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:
 ``` cpp
+template <size_t Len, size_t Alignment>
 struct aligned_storage {
   typedef struct {
     alignas(Alignment) unsigned char __data[Len];
   } type;
 };
 ```
+— *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
+  member `type`.
+- If `sizeof...(T)` is two, let the first and second types constituting
+  `T` be denoted by `T1` and `T2`, respectively, and let `D1` and `D2`
+  denote the same types as `decay_t<T1>` and `decay_t<T2>`,
+  respectively.
+  - If `is_same_v<T1, D1>` is `false` or `is_same_v<T2, D2>` is `false`,
+    let `C` denote the same type, if any, as `common_type_t<D1, D2>`.
+  - 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
+  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 4*: Such specializations are needed when only explicit
+conversions are desired between the template arguments. — *end note*]
+Such a specialization need not have a member named `type`, but if it
+does, that member shall be a *typedef-name* for an accessible and
+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  (&)();
+using PF2 = short (*)(long);
 struct S {
   operator PF2() const;
   double operator()(char, int&);
   void fn(long) const;
   char data;
 };
+using PMF = void (S::*)(long) const;
+using PMD = char  S::*;
 ```
 the following assertions will hold:
 ``` cpp
+static_assert(is_same_v<invoke_result_t<S, int>, short>);
+static_assert(is_same_v<invoke_result_t<S&, unsigned char, int&>, double>);
+static_assert(is_same_v<invoke_result_t<PF1>, bool>);
+static_assert(is_same_v<invoke_result_t<PMF, unique_ptr<S>, int>, void>);
+static_assert(is_same_v<invoke_result_t<PMD, S>, char&&>);
+static_assert(is_same_v<invoke_result_t<PMD, const S*>, const char&>);
 ```
+— *end example*]
+### Logical operator traits <a id="meta.logical">[[meta.logical]]</a>
+This subclause describes type traits for applying logical operators to
+other type traits.
+``` cpp
+template<class... B> struct conjunction : see below { };
+```
+The class template `conjunction` forms the logical conjunction of its
+template type arguments.
+For a specialization `conjunction<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*]
+The member names of the base class, other than `conjunction` and
+`operator=`, shall not be hidden and shall be unambiguously available in
+`conjunction`.
+``` cpp
+template<class... B> struct disjunction : see below { };
+```
+The class template `disjunction` forms the logical disjunction of its
+template type arguments.
+For a specialization `disjunction<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*]
+The member names of the base class, other than `disjunction` and
+`operator=`, shall not be hidden and shall be unambiguously available in
+`disjunction`.
+``` cpp
+template<class B> struct negation : see below { };
+```
+The class template `negation` forms the logical negation of its template
+type argument. The type `negation<B>` is a `UnaryTypeTrait` with a base
+characteristic of `bool_constant<!bool(B::value)>`.

Diff to HTML by rtfpessoa