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

Files changed (1) hide show

tmp/tmp0zp6zs62/{from.md → to.md} +518 -185

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

@@ -1,20 +1,81 @@
-## 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
@@ -46,26 +107,26 @@ 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 {
   // [meta.help], helper class
   template<class T, T v> struct integral_constant;
   template<bool B>
@@ -112,10 +173,11 @@ namespace std {
   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;
@@ -151,14 +213,19 @@ namespace std {
   template<class T, class U> struct is_nothrow_swappable_with;
   template<class T> struct is_nothrow_swappable;
   template<class T> struct is_nothrow_destructible;
   template<class T> struct 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;
@@ -236,13 +303,10 @@ namespace std {
   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;
@@ -254,22 +318,18 @@ namespace std {
   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>
@@ -288,194 +348,204 @@ namespace std {
   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>
@@ -506,12 +576,14 @@ 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 *Cpp17UnaryTypeTrait* [[meta.rqmts]]
 with a base characteristic of `true_type` if the corresponding condition
 is `true`, otherwise `false_type`.
@@ -549,17 +621,23 @@ 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*]
 [*Example 1*:
 ``` cpp
 is_const_v<const volatile int>      // true
@@ -681,17 +759,14 @@ 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*:
@@ -722,51 +797,42 @@ 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 [[stmt.return]] (including initialization of the
 returned object or reference) is considered.
-[*Note 3*: The initialization can result in side effects such as the
 instantiation of class template specializations and function template
 specializations, the generation of implicitly-defined functions, and so
 on. Such side effects are not in the “immediate context” and can result
 in the program being ill-formed. — *end note*]
 ### 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
 *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>
-[*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>));
@@ -791,30 +857,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 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*]
 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.
@@ -865,11 +916,11 @@ as 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>`.
-  - \[*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>())>
     ```
@@ -893,20 +944,19 @@ 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.
 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:
@@ -914,12 +964,14 @@ follows:
 - 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
@@ -936,23 +988,23 @@ follows:
   - 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*:
@@ -1088,13 +1140,13 @@ template<class S1, class S2, class M1, class M2>
 ```
 *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
@@ -1129,13 +1181,19 @@ static_assert( is_corresponding_member<C, C>( &C::a, &C::b ) );
 ``` 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) {
@@ -1147,5 +1205,280 @@ constexpr void f(unsigned char *p, int n) {
 }
 ```
 — *end example*]

+# Metaprogramming library <a id="meta">[[meta]]</a>
+## General <a id="meta.general">[[meta.general]]</a>
+This Clause describes metaprogramming facilities. These facilities are
+summarized in [[meta.summary]].
+**Table: Metaprogramming library summary** <a id="meta.summary">[meta.summary]</a>
+| Subclause       |                     | Header          |
+| --------------- | ------------------- | --------------- |
+| [[intseq]]      | Integer sequences   | `<utility>`     |
+| [[type.traits]] | Type traits         | `<type_traits>` |
+| [[ratio]]       | Rational arithmetic | `<ratio>`       |
+## Compile-time integer sequences <a id="intseq">[[intseq]]</a>
+### In general <a id="intseq.general">[[intseq.general]]</a>
+The library provides a class template that can represent an integer
+sequence. When used as an argument to a function template the template
+parameter pack defining the sequence can be deduced and used in a pack
+expansion.
+[*Note 1*: The `index_sequence` alias template is provided for the
+common case of an integer sequence of type `size_t`; see also
+[[tuple.apply]]. — *end note*]
+### Class template `integer_sequence` <a id="intseq.intseq">[[intseq.intseq]]</a>
+``` cpp
+namespace std {
+  template<class T, T... I> struct integer_sequence {
+    using value_type = T;
+    static constexpr size_t size() noexcept { return sizeof...(I); }
+  };
+}
+```
+*Mandates:* `T` is an integer type.
+### Alias template `make_integer_sequence` <a id="intseq.make">[[intseq.make]]</a>
+``` cpp
+template<class T, T N>
+  using make_integer_sequence = integer_sequence<T, see below>;
+```
+*Mandates:* `N` ≥ 0.
+The alias template `make_integer_sequence` denotes a specialization of
+`integer_sequence` with `N` non-type template arguments. The type
+`make_integer_sequence<T, N>` is an alias for the type
+`integer_sequence<T, 0, 1, ..., N-1>`.
+[*Note 1*: `make_integer_sequence<int, 0>` is an alias for the type
+`integer_sequence<int>`. — *end note*]
+## Metaprogramming and type traits <a id="type.traits">[[type.traits]]</a>
+### General <a id="type.traits.general">[[type.traits.general]]</a>
+Subclause [[type.traits]] describes components used by C++ programs,
+particularly in templates, to support the widest possible range of
+types, optimize template code usage, detect type related user errors,
+and perform type inference and transformation at compile time. It
+includes type classification traits, type property inspection traits,
+and type transformations. The type classification traits describe a
+complete taxonomy of all possible C++ types, and state where in that
+taxonomy a given type belongs. The type property inspection traits allow
+important characteristics of types or of combinations of types to be
+inspected. The type transformations allow certain properties of types to
+be manipulated.
+All functions specified in [[type.traits]] are signal-safe
 [[support.signal]].
 ### Requirements <a id="meta.rqmts">[[meta.rqmts]]</a>
 A describes a property of a type. It shall be a class template that
 help define the modification. It shall define a publicly accessible
 nested type named `type`, which shall be a synonym for the modified
 type.
 Unless otherwise specified, the behavior of a program that adds
+specializations for any of the templates specified in [[type.traits]] is
+undefined.
 Unless otherwise specified, an incomplete type may be used to
+instantiate a template specified in [[type.traits]]. The behavior of a
 program is undefined if:
+- an instantiation of a template specified in [[type.traits]] directly
+  or indirectly depends on an incompletely-defined object type `T`, and
 - that instantiation could yield a different result were `T`
   hypothetically completed.
 ### Header `<type_traits>` synopsis <a id="meta.type.synop">[[meta.type.synop]]</a>
 ``` cpp
+// all freestanding
 namespace std {
   // [meta.help], helper class
   template<class T, T v> struct integral_constant;
   template<bool B>
   template<class T> struct is_signed;
   template<class T> struct is_unsigned;
   template<class T> struct is_bounded_array;
   template<class T> struct is_unbounded_array;
+  template<class T> struct is_scoped_enum;
   template<class T, class... Args> struct is_constructible;
   template<class T> struct is_default_constructible;
   template<class T> struct is_copy_constructible;
   template<class T> struct is_move_constructible;
   template<class T, class U> struct is_nothrow_swappable_with;
   template<class T> struct is_nothrow_swappable;
   template<class T> struct is_nothrow_destructible;
+  template<class T> struct is_implicit_lifetime;
   template<class T> struct has_virtual_destructor;
   template<class T> struct has_unique_object_representations;
+  template<class T, class U> struct reference_constructs_from_temporary;
+  template<class T, class U> struct reference_converts_from_temporary;
   // [meta.unary.prop.query], type property queries
   template<class T> struct alignment_of;
   template<class T> struct rank;
   template<class T, unsigned I = 0> struct extent;
   template<class T>
     using add_pointer_t    = typename add_pointer<T>::type;
   // [meta.trans.other], other transformations
   template<class T> struct type_identity;
   template<class T> struct remove_cvref;
   template<class T> struct decay;
   template<bool, class T = void> struct enable_if;
   template<bool, class T, class F> struct conditional;
   template<class... T> struct common_type;
   template<class T> struct unwrap_reference;
   template<class T> struct unwrap_ref_decay;
   template<class T>
     using type_identity_t    = typename type_identity<T>::type;
   template<class T>
     using remove_cvref_t     = typename remove_cvref<T>::type;
   template<class T>
     using decay_t            = typename decay<T>::type;
+  template<bool B, class T = void>
+    using enable_if_t        = typename enable_if<B, T>::type;
+  template<bool B, class T, class F>
+    using conditional_t      = typename conditional<B, T, F>::type;
   template<class... T>
     using common_type_t      = typename common_type<T...>::type;
   template<class... T>
     using common_reference_t = typename common_reference<T...>::type;
   template<class T>
   template<class... B> struct disjunction;
   template<class B> struct negation;
   // [meta.unary.cat], primary type categories
   template<class T>
+    constexpr bool is_void_v = is_void<T>::value;
   template<class T>
+    constexpr bool is_null_pointer_v = is_null_pointer<T>::value;
   template<class T>
+    constexpr bool is_integral_v = is_integral<T>::value;
   template<class T>
+    constexpr bool is_floating_point_v = is_floating_point<T>::value;
   template<class T>
+    constexpr bool is_array_v = is_array<T>::value;
   template<class T>
+    constexpr bool is_pointer_v = is_pointer<T>::value;
   template<class T>
+    constexpr bool is_lvalue_reference_v = is_lvalue_reference<T>::value;
   template<class T>
+    constexpr bool is_rvalue_reference_v = is_rvalue_reference<T>::value;
   template<class T>
+    constexpr bool is_member_object_pointer_v = is_member_object_pointer<T>::value;
   template<class T>
+    constexpr bool is_member_function_pointer_v = is_member_function_pointer<T>::value;
   template<class T>
+    constexpr bool is_enum_v = is_enum<T>::value;
   template<class T>
+    constexpr bool is_union_v = is_union<T>::value;
   template<class T>
+    constexpr bool is_class_v = is_class<T>::value;
   template<class T>
+    constexpr bool is_function_v = is_function<T>::value;
   // [meta.unary.comp], composite type categories
   template<class T>
+    constexpr bool is_reference_v = is_reference<T>::value;
   template<class T>
+    constexpr bool is_arithmetic_v = is_arithmetic<T>::value;
   template<class T>
+    constexpr bool is_fundamental_v = is_fundamental<T>::value;
   template<class T>
+    constexpr bool is_object_v = is_object<T>::value;
   template<class T>
+    constexpr bool is_scalar_v = is_scalar<T>::value;
   template<class T>
+    constexpr bool is_compound_v = is_compound<T>::value;
   template<class T>
+    constexpr bool is_member_pointer_v = is_member_pointer<T>::value;
   // [meta.unary.prop], type properties
   template<class T>
+    constexpr bool is_const_v = is_const<T>::value;
   template<class T>
+    constexpr bool is_volatile_v = is_volatile<T>::value;
   template<class T>
+    constexpr bool is_trivial_v = is_trivial<T>::value;
   template<class T>
+    constexpr bool is_trivially_copyable_v = is_trivially_copyable<T>::value;
   template<class T>
+    constexpr bool is_standard_layout_v = is_standard_layout<T>::value;
   template<class T>
+    constexpr bool is_empty_v = is_empty<T>::value;
   template<class T>
+    constexpr bool is_polymorphic_v = is_polymorphic<T>::value;
   template<class T>
+    constexpr bool is_abstract_v = is_abstract<T>::value;
   template<class T>
+    constexpr bool is_final_v = is_final<T>::value;
   template<class T>
+    constexpr bool is_aggregate_v = is_aggregate<T>::value;
   template<class T>
+    constexpr bool is_signed_v = is_signed<T>::value;
   template<class T>
+    constexpr bool is_unsigned_v = is_unsigned<T>::value;
   template<class T>
+    constexpr bool is_bounded_array_v = is_bounded_array<T>::value;
   template<class T>
+    constexpr bool is_unbounded_array_v = is_unbounded_array<T>::value;
+  template<class T>
+    constexpr bool is_scoped_enum_v = is_scoped_enum<T>::value;
   template<class T, class... Args>
+    constexpr bool is_constructible_v = is_constructible<T, Args...>::value;
   template<class T>
+    constexpr bool is_default_constructible_v = is_default_constructible<T>::value;
   template<class T>
+    constexpr bool is_copy_constructible_v = is_copy_constructible<T>::value;
   template<class T>
+    constexpr bool is_move_constructible_v = is_move_constructible<T>::value;
   template<class T, class U>
+    constexpr bool is_assignable_v = is_assignable<T, U>::value;
   template<class T>
+    constexpr bool is_copy_assignable_v = is_copy_assignable<T>::value;
   template<class T>
+    constexpr bool is_move_assignable_v = is_move_assignable<T>::value;
   template<class T, class U>
+    constexpr bool is_swappable_with_v = is_swappable_with<T, U>::value;
   template<class T>
+    constexpr bool is_swappable_v = is_swappable<T>::value;
   template<class T>
+    constexpr bool is_destructible_v = is_destructible<T>::value;
   template<class T, class... Args>
+    constexpr bool is_trivially_constructible_v
       = is_trivially_constructible<T, Args...>::value;
   template<class T>
+    constexpr bool is_trivially_default_constructible_v
       = is_trivially_default_constructible<T>::value;
   template<class T>
+    constexpr bool is_trivially_copy_constructible_v
       = is_trivially_copy_constructible<T>::value;
   template<class T>
+    constexpr bool is_trivially_move_constructible_v
       = is_trivially_move_constructible<T>::value;
   template<class T, class U>
+    constexpr bool is_trivially_assignable_v = is_trivially_assignable<T, U>::value;
   template<class T>
+    constexpr bool is_trivially_copy_assignable_v
       = is_trivially_copy_assignable<T>::value;
   template<class T>
+    constexpr bool is_trivially_move_assignable_v
       = is_trivially_move_assignable<T>::value;
   template<class T>
+    constexpr bool is_trivially_destructible_v = is_trivially_destructible<T>::value;
   template<class T, class... Args>
+    constexpr bool is_nothrow_constructible_v
       = is_nothrow_constructible<T, Args...>::value;
   template<class T>
+    constexpr bool is_nothrow_default_constructible_v
       = is_nothrow_default_constructible<T>::value;
   template<class T>
+    constexpr bool is_nothrow_copy_constructible_v
       = is_nothrow_copy_constructible<T>::value;
   template<class T>
+    constexpr bool is_nothrow_move_constructible_v
       = is_nothrow_move_constructible<T>::value;
   template<class T, class U>
+    constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<T, U>::value;
   template<class T>
+    constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<T>::value;
   template<class T>
+    constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<T>::value;
   template<class T, class U>
+    constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with<T, U>::value;
   template<class T>
+    constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<T>::value;
   template<class T>
+    constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<T>::value;
   template<class T>
+    constexpr bool is_implicit_lifetime_v = is_implicit_lifetime<T>::value;
   template<class T>
+    constexpr bool has_virtual_destructor_v = has_virtual_destructor<T>::value;
+  template<class T>
+    constexpr bool has_unique_object_representations_v
       = has_unique_object_representations<T>::value;
+  template<class T, class U>
+    constexpr bool reference_constructs_from_temporary_v
+      = reference_constructs_from_temporary<T, U>::value;
+  template<class T, class U>
+    constexpr bool reference_converts_from_temporary_v
+      = reference_converts_from_temporary<T, U>::value;
   // [meta.unary.prop.query], type property queries
   template<class T>
+    constexpr size_t alignment_of_v = alignment_of<T>::value;
   template<class T>
+    constexpr size_t rank_v = rank<T>::value;
   template<class T, unsigned I = 0>
+    constexpr size_t extent_v = extent<T, I>::value;
   // [meta.rel], type relations
   template<class T, class U>
+    constexpr bool is_same_v = is_same<T, U>::value;
   template<class Base, class Derived>
+    constexpr bool is_base_of_v = is_base_of<Base, Derived>::value;
   template<class From, class To>
+    constexpr bool is_convertible_v = is_convertible<From, To>::value;
   template<class From, class To>
+    constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<From, To>::value;
   template<class T, class U>
+    constexpr bool is_layout_compatible_v = is_layout_compatible<T, U>::value;
   template<class Base, class Derived>
+    constexpr bool is_pointer_interconvertible_base_of_v
       = is_pointer_interconvertible_base_of<Base, Derived>::value;
   template<class Fn, class... ArgTypes>
+    constexpr bool is_invocable_v = is_invocable<Fn, ArgTypes...>::value;
   template<class R, class Fn, class... ArgTypes>
+    constexpr bool is_invocable_r_v = is_invocable_r<R, Fn, ArgTypes...>::value;
   template<class Fn, class... ArgTypes>
+    constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<Fn, ArgTypes...>::value;
   template<class R, class Fn, class... ArgTypes>
+    constexpr bool is_nothrow_invocable_r_v
       = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;
   // [meta.logical], logical operator traits
   template<class... B>
+    constexpr bool conjunction_v = conjunction<B...>::value;
   template<class... B>
+    constexpr bool disjunction_v = disjunction<B...>::value;
   template<class B>
+    constexpr bool negation_v = negation<B>::value;
   // [meta.member], member relationships
   template<class S, class M>
     constexpr bool is_pointer_interconvertible_with_class(M S::*m) noexcept;
   template<class S1, class S2, class M1, class M2>
 and its associated *typedef-name*s `true_type` and `false_type` are used
 as base classes to define the interface for various type traits.
 ### Unary type traits <a id="meta.unary">[[meta.unary]]</a>
+#### General <a id="meta.unary.general">[[meta.unary.general]]</a>
+Subclause [[meta.unary]] contains templates that may be used to query
+the properties of a type at compile time.
 Each of these templates shall be a *Cpp17UnaryTypeTrait* [[meta.rqmts]]
 with a base characteristic of `true_type` if the corresponding condition
 is `true`, otherwise `false_type`.
 template argument if and only if the semantics of `X` require that the
 argument is a complete type.
 For the purpose of defining the templates in this subclause, a function
 call expression `declval<T>()` for any type `T` is considered to be a
+trivial [[term.trivial.type]], [[special]] function call that is not an
+odr-use [[term.odr.use]] of `declval` in the context of the
 corresponding definition notwithstanding the restrictions of
 [[declval]].
+For the purpose of defining the templates in this subclause, let
+`VAL<T>` for some type `T` be an expression defined as follows:
+- If `T` is a reference or function type, `VAL<T>` is an expression with
+  the same type and value category as `declval<T>()`.
+- Otherwise, `VAL<T>` is a prvalue that initially has type `T`.
+  \[*Note 1*: If `T` is cv-qualified, the cv-qualification is subject to
+  adjustment [[expr.type]]. — *end note*]
 [*Example 1*:
 ``` cpp
 is_const_v<const volatile int>      // true
 Each of these templates shall be a *Cpp17BinaryTypeTrait* [[meta.rqmts]]
 with a base characteristic of `true_type` if the corresponding condition
 is true, otherwise `false_type`.
 For the purpose of defining the templates in this subclause, a function
 call expression `declval<T>()` for any type `T` is considered to be a
+trivial [[term.trivial.type]], [[special]] function call that is not an
+odr-use [[term.odr.use]] of `declval` in the context of the
 corresponding definition notwithstanding the restrictions of
 [[declval]].
 [*Example 1*:
 To test() {
   return declval<From>();
 }
 ```
+[*Note 1*: This requirement gives well-defined results for reference
+types, array types, function types, and cv `void`. — *end note*]
 Access checking is performed in a context unrelated to `To` and `From`.
 Only the validity of the immediate context of the *expression* of the
 `return` statement [[stmt.return]] (including initialization of the
 returned object or reference) is considered.
+[*Note 2*: The initialization can result in side effects such as the
 instantiation of class template specializations and function template
 specializations, the generation of implicitly-defined functions, and so
 on. Such side effects are not in the “immediate context” and can result
 in the program being ill-formed. — *end note*]
 ### Transformations between types <a id="meta.trans">[[meta.trans]]</a>
+#### General <a id="meta.trans.general">[[meta.trans.general]]</a>
+Subclause [[meta.trans]] contains templates that may be used to
+transform one type to another following some predefined rule.
+Each of the templates in [[meta.trans]] shall be a
 *Cpp17TransformationTrait* [[meta.rqmts]].
 #### Const-volatile modifications <a id="meta.trans.cv">[[meta.trans.cv]]</a>
 #### Reference modifications <a id="meta.trans.ref">[[meta.trans.ref]]</a>
 #### Sign modifications <a id="meta.trans.sign">[[meta.trans.sign]]</a>
 #### Array modifications <a id="meta.trans.arr">[[meta.trans.arr]]</a>
 [*Example 1*:
 ``` cpp
 // the following assertions hold:
 assert((is_same_v<remove_extent_t<int>, int>));
 #### Pointer modifications <a id="meta.trans.ptr">[[meta.trans.ptr]]</a>
 #### Other transformations <a id="meta.trans.other">[[meta.trans.other]]</a>
+[*Note 1*: The compilation of the expression can result in side effects
+such as the instantiation of class template specializations and function
+template specializations, the generation of implicitly-defined
+functions, and so on. Such side effects are not in the “immediate
+context” and can result in the program being ill-formed. — *end note*]
 In addition to being available via inclusion of the `<type_traits>`
 header, the templates `unwrap_reference`, `unwrap_ref_decay`,
 `unwrap_reference_t`, and `unwrap_ref_decay_t` are available when the
 header `<functional>` [[functional.syn]] is included.
   `T` be denoted by `T1` and `T2`, respectively, and let `D1` and `D2`
   denote the same types as `decay_t<T1>` and `decay_t<T2>`,
   respectively.
   - If `is_same_v<T1, D1>` is `false` or `is_same_v<T2, D2>` is `false`,
     let `C` denote the same type, if any, as `common_type_t<D1, D2>`.
+  - \[*Note 2*: None of the following will apply if there is a
     specialization `common_type<D1, D2>`. — *end note*]
   - Otherwise, if
     ``` cpp
     decay_t<decltype(false ? declval<D1>() : declval<D2>())>
     ```
 pursuant to [[namespace.std]], a program may specialize
 `common_type<T1, T2>` for types `T1` and `T2` such that
 `is_same_v<T1, decay_t<T1>>` and `is_same_v<T2, decay_t<T2>>` are each
 `true`.
+[*Note 3*: Such specializations are needed when only explicit
 conversions are desired between the template arguments. — *end note*]
 Such a specialization need not have a member named `type`, but if it
+does, the *qualified-id* `common_type<T1, T2>::type` shall denote a
+cv-unqualified non-reference type to which each of the types `T1` and
+`T2` is explicitly convertible. Moreover, `common_type_t<T1, T2>` shall
+denote the same type, if any, as does `common_type_t<T2, T1>`. No
+diagnostic is required for a violation of this Note’s rules.
 Note C: For the `common_reference` trait applied to a parameter pack `T`
 of types, the member `type` shall be either defined or not present as
 follows:
 - Otherwise, if `sizeof...(T)` is one, let `T0` denote the sole type in
   the pack `T`. The member typedef `type` shall denote the same type as
   `T0`.
 - Otherwise, if `sizeof...(T)` is two, let `T1` and `T2` denote the two
   types in the pack `T`. Then
+  - Let `R` be `COMMON-REF(T1, T2)`. If `T1` and `T2` are reference
+ types, `R` is well-formed, and
+    `is_convertible_v<add_pointer_t<T1>, add_pointer_t<R>> && is_convertible_v<add_poin{}ter_t<T2>, add_pointer_t<R>>`
+    is `true`, then the member typedef `type` denotes `R`.
   - Otherwise, if
     `basic_common_reference<remove_cvref_t<T1>, remove_cvref_t<T2>,
           {}XREF({}T1), XREF(T2)>::type` is well-formed, then the member
     typedef `type` denotes that type.
   - Otherwise, if `COND-RES(T1, T2)` is well-formed, then the member
   - Otherwise, there shall be no member `type`.
 Note D: Notwithstanding the provisions of [[meta.type.synop]], and
 pursuant to [[namespace.std]], a program may partially specialize
 `basic_common_reference<T, U, TQual, UQual>` for types `T` and `U` such
+that `is_same_v<T, decay_t<T>>` and `is_same_v<U, decay_t<U>>` are each
+`true`.
+[*Note 4*: Such specializations can be used to influence the result of
 `common_reference`, and are needed when only explicit conversions are
 desired between the template arguments. — *end note*]
 Such a specialization need not have a member named `type`, but if it
+does, the *qualified-id*
+`basic_common_reference<T, U, TQual, UQual>::type` shall denote a type
+to which each of the types `TQual<T>` and `UQual<U>` is convertible.
+Moreover, `basic_common_reference<T, U, TQual, UQual>::type` shall
+denote the same type, if any, as does
 `basic_common_reference<U, T, UQual, TQual>::type`. No diagnostic is
 required for a violation of these rules.
 [*Example 2*:
 ```
 *Mandates:* `S1` and `S2` are complete types.
 *Returns:* `true` if and only if `S1` and `S2` are standard-layout
+struct [[class.prop]] types, `M1` and `M2` are object types, `m1` and
+`m2` are not null, and `m1` and `m2` point to corresponding members of
+the common initial sequence [[class.mem]] of `S1` and `S2`.
 [*Note 1*:
 The type of a pointer-to-member expression `&C::b` is not always a
 pointer to member of `C`, leading to potentially surprising results when
 ``` cpp
 constexpr bool is_constant_evaluated() noexcept;
 ```
+*Effects:* Equivalent to:
+``` cpp
+if consteval {
+  return true;
+} else {
+  return false;
+}
+```
 [*Example 1*:
 ``` cpp
 constexpr void f(unsigned char *p, int n) {
 }
 ```
 — *end example*]
+## Compile-time rational arithmetic <a id="ratio">[[ratio]]</a>
+### In general <a id="ratio.general">[[ratio.general]]</a>
+Subclause  [[ratio]] describes the ratio library. It provides a class
+template `ratio` which exactly represents any finite rational number
+with a numerator and denominator representable by compile-time constants
+of type `intmax_t`.
+Throughout subclause  [[ratio]], the names of template parameters are
+used to express type requirements. If a template parameter is named `R1`
+or `R2`, and the template argument is not a specialization of the
+`ratio` template, the program is ill-formed.
+### Header `<ratio>` synopsis <a id="ratio.syn">[[ratio.syn]]</a>
+``` cpp
+// all freestanding
+namespace std {
+  // [ratio.ratio], class template ratio
+  template<intmax_t N, intmax_t D = 1> class ratio;
+  // [ratio.arithmetic], ratio arithmetic
+  template<class R1, class R2> using ratio_add = see below;
+  template<class R1, class R2> using ratio_subtract = see below;
+  template<class R1, class R2> using ratio_multiply = see below;
+  template<class R1, class R2> using ratio_divide = see below;
+  // [ratio.comparison], ratio comparison
+  template<class R1, class R2> struct ratio_equal;
+  template<class R1, class R2> struct ratio_not_equal;
+  template<class R1, class R2> struct ratio_less;
+  template<class R1, class R2> struct ratio_less_equal;
+  template<class R1, class R2> struct ratio_greater;
+  template<class R1, class R2> struct ratio_greater_equal;
+  template<class R1, class R2>
+    constexpr bool ratio_equal_v = ratio_equal<R1, R2>::value;
+  template<class R1, class R2>
+    constexpr bool ratio_not_equal_v = ratio_not_equal<R1, R2>::value;
+  template<class R1, class R2>
+    constexpr bool ratio_less_v = ratio_less<R1, R2>::value;
+  template<class R1, class R2>
+    constexpr bool ratio_less_equal_v = ratio_less_equal<R1, R2>::value;
+  template<class R1, class R2>
+    constexpr bool ratio_greater_v = ratio_greater<R1, R2>::value;
+  template<class R1, class R2>
+    constexpr bool ratio_greater_equal_v = ratio_greater_equal<R1, R2>::value;
+  // [ratio.si], convenience SI typedefs
+  using yocto = ratio<1, 1'000'000'000'000'000'000'000'000>;  // see below
+  using zepto = ratio<1,     1'000'000'000'000'000'000'000>;  // see below
+  using atto  = ratio<1,         1'000'000'000'000'000'000>;
+  using femto = ratio<1,             1'000'000'000'000'000>;
+  using pico  = ratio<1,                 1'000'000'000'000>;
+  using nano  = ratio<1,                     1'000'000'000>;
+  using micro = ratio<1,                         1'000'000>;
+  using milli = ratio<1,                             1'000>;
+  using centi = ratio<1,                               100>;
+  using deci  = ratio<1,                                10>;
+  using deca  = ratio<                               10, 1>;
+  using hecto = ratio<                              100, 1>;
+  using kilo  = ratio<                            1'000, 1>;
+  using mega  = ratio<                        1'000'000, 1>;
+  using giga  = ratio<                    1'000'000'000, 1>;
+  using tera  = ratio<                1'000'000'000'000, 1>;
+  using peta  = ratio<            1'000'000'000'000'000, 1>;
+  using exa   = ratio<        1'000'000'000'000'000'000, 1>;
+  using zetta = ratio<    1'000'000'000'000'000'000'000, 1>;  // see below
+  using yotta = ratio<1'000'000'000'000'000'000'000'000, 1>;  // see below
+}
+```
+### Class template `ratio` <a id="ratio.ratio">[[ratio.ratio]]</a>
+``` cpp
+namespace std {
+  template<intmax_t N, intmax_t D = 1> class ratio {
+  public:
+    static constexpr intmax_t num;
+    static constexpr intmax_t den;
+    using type = ratio<num, den>;
+  };
+}
+```
+If the template argument `D` is zero or the absolute values of either of
+the template arguments `N` and `D` is not representable by type
+`intmax_t`, the program is ill-formed.
+[*Note 1*: These rules ensure that infinite ratios are avoided and that
+for any negative input, there exists a representable value of its
+absolute value which is positive. This excludes the most negative
+value. — *end note*]
+The static data members `num` and `den` shall have the following values,
+where `gcd` represents the greatest common divisor of the absolute
+values of `N` and `D`:
+- `num` shall have the value
+  `\operatorname{sgn}(N) * \operatorname{sgn}(D) * abs(N) / gcd`.
+- `den` shall have the value `abs(D) / gcd`.
+### Arithmetic on `ratio`s <a id="ratio.arithmetic">[[ratio.arithmetic]]</a>
+Each of the alias templates `ratio_add`, `ratio_subtract`,
+`ratio_multiply`, and `ratio_divide` denotes the result of an arithmetic
+computation on two `ratio`s `R1` and `R2`. With `X` and `Y` computed (in
+the absence of arithmetic overflow) as specified by
+[[ratio.arithmetic]], each alias denotes a `ratio<U, V>` such that `U`
+is the same as `ratio<X, Y>::num` and `V` is the same as
+`ratio<X, Y>::den`.
+If it is not possible to represent `U` or `V` with `intmax_t`, the
+program is ill-formed. Otherwise, an implementation should yield correct
+values of `U` and `V`. If it is not possible to represent `X` or `Y`
+with `intmax_t`, the program is ill-formed unless the implementation
+yields correct values of `U` and `V`.
+**Table: Expressions used to perform ratio arithmetic** <a id="ratio.arithmetic">[ratio.arithmetic]</a>
+| Type                     | Value of `X`          | Value of `Y`        |
+| ------------------------ | --------------------- | ------------------- |
+| `ratio_add<R1, R2>`      | `R1::num * R2::den +` | `R1::den * R2::den` |
+|                          | `R2::num * R1::den`   |                     |
+| `ratio_subtract<R1, R2>` | `R1::num * R2::den -` | `R1::den * R2::den` |
+|                          | `R2::num * R1::den`   |                     |
+| `ratio_multiply<R1, R2>` | `R1::num * R2::num`   | `R1::den * R2::den` |
+| `ratio_divide<R1, R2>`   | `R1::num * R2::den`   | `R1::den * R2::num` |
+[*Example 1*:
+``` cpp
+static_assert(ratio_add<ratio<1, 3>, ratio<1, 6>>::num == 1, "1/3+1/6 == 1/2");
+static_assert(ratio_add<ratio<1, 3>, ratio<1, 6>>::den == 2, "1/3+1/6 == 1/2");
+static_assert(ratio_multiply<ratio<1, 3>, ratio<3, 2>>::num == 1, "1/3*3/2 == 1/2");
+static_assert(ratio_multiply<ratio<1, 3>, ratio<3, 2>>::den == 2, "1/3*3/2 == 1/2");
+// The following cases may cause the program to be ill-formed under some implementations
+static_assert(ratio_add<ratio<1, INT_MAX>, ratio<1, INT_MAX>>::num == 2,
+  "1/MAX+1/MAX == 2/MAX");
+static_assert(ratio_add<ratio<1, INT_MAX>, ratio<1, INT_MAX>>::den == INT_MAX,
+  "1/MAX+1/MAX == 2/MAX");
+static_assert(ratio_multiply<ratio<1, INT_MAX>, ratio<INT_MAX, 2>>::num == 1,
+  "1/MAX * MAX/2 == 1/2");
+static_assert(ratio_multiply<ratio<1, INT_MAX>, ratio<INT_MAX, 2>>::den == 2,
+  "1/MAX * MAX/2 == 1/2");
+```
+— *end example*]
+### Comparison of `ratio`s <a id="ratio.comparison">[[ratio.comparison]]</a>
+``` cpp
+template<class R1, class R2>
+  struct ratio_equal : bool_constant<R1::num == R2::num && R1::den == R2::den> { };
+```
+``` cpp
+template<class R1, class R2>
+  struct ratio_not_equal : bool_constant<!ratio_equal_v<R1, R2>> { };
+```
+``` cpp
+template<class R1, class R2>
+  struct ratio_less : bool_constant<see below> { };
+```
+If `R1::num` × `R2::den` is less than `R2::num` × `R1::den`,
+`ratio_less<R1, R2>` shall be derived from `bool_constant<true>`;
+otherwise it shall be derived from `bool_constant<false>`.
+Implementations may use other algorithms to compute this relationship to
+avoid overflow. If overflow occurs, the program is ill-formed.
+``` cpp
+template<class R1, class R2>
+  struct ratio_less_equal : bool_constant<!ratio_less_v<R2, R1>> { };
+```
+``` cpp
+template<class R1, class R2>
+  struct ratio_greater : bool_constant<ratio_less_v<R2, R1>> { };
+```
+``` cpp
+template<class R1, class R2>
+  struct ratio_greater_equal : bool_constant<!ratio_less_v<R1, R2>> { };
+```
+### SI types for `ratio` <a id="ratio.si">[[ratio.si]]</a>
+For each of the *typedef-name*s `yocto`, `zepto`, `zetta`, and `yotta`,
+if both of the constants used in its specification are representable by
+`intmax_t`, the typedef is defined; if either of the constants is not
+representable by `intmax_t`, the typedef is not defined.
+<!-- Link reference definitions -->
+[array]: containers.md#array
+[basic.compound]: basic.md#basic.compound
+[basic.fundamental]: basic.md#basic.fundamental
+[basic.type.qualifier]: basic.md#basic.type.qualifier
+[basic.types]: basic.md#basic.types
+[basic.types.general]: basic.md#basic.types.general
+[class.abstract]: class.md#class.abstract
+[class.derived]: class.md#class.derived
+[class.dtor]: class.md#class.dtor
+[class.mem]: class.md#class.mem
+[class.pre]: class.md#class.pre
+[class.prop]: class.md#class.prop
+[class.temporary]: basic.md#class.temporary
+[class.virtual]: class.md#class.virtual
+[conv.rank]: basic.md#conv.rank
+[dcl.array]: dcl.md#dcl.array
+[dcl.enum]: dcl.md#dcl.enum
+[dcl.init.aggr]: dcl.md#dcl.init.aggr
+[dcl.ref]: dcl.md#dcl.ref
+[declval]: utilities.md#declval
+[defns.referenceable]: intro.md#defns.referenceable
+[expr.alignof]: expr.md#expr.alignof
+[expr.type]: expr.md#expr.type
+[expr.unary.noexcept]: expr.md#expr.unary.noexcept
+[func.require]: utilities.md#func.require
+[functional.syn]: utilities.md#functional.syn
+[intseq]: #intseq
+[intseq.general]: #intseq.general
+[intseq.intseq]: #intseq.intseq
+[intseq.make]: #intseq.make
+[meta]: #meta
+[meta.const.eval]: #meta.const.eval
+[meta.general]: #meta.general
+[meta.help]: #meta.help
+[meta.logical]: #meta.logical
+[meta.member]: #meta.member
+[meta.rel]: #meta.rel
+[meta.rqmts]: #meta.rqmts
+[meta.summary]: #meta.summary
+[meta.trans]: #meta.trans
+[meta.trans.arr]: #meta.trans.arr
+[meta.trans.cv]: #meta.trans.cv
+[meta.trans.general]: #meta.trans.general
+[meta.trans.other]: #meta.trans.other
+[meta.trans.ptr]: #meta.trans.ptr
+[meta.trans.ref]: #meta.trans.ref
+[meta.trans.sign]: #meta.trans.sign
+[meta.type.synop]: #meta.type.synop
+[meta.unary]: #meta.unary
+[meta.unary.cat]: #meta.unary.cat
+[meta.unary.comp]: #meta.unary.comp
+[meta.unary.general]: #meta.unary.general
+[meta.unary.prop]: #meta.unary.prop
+[meta.unary.prop.query]: #meta.unary.prop.query
+[namespace.std]: library.md#namespace.std
+[ratio]: #ratio
+[ratio.arithmetic]: #ratio.arithmetic
+[ratio.comparison]: #ratio.comparison
+[ratio.general]: #ratio.general
+[ratio.ratio]: #ratio.ratio
+[ratio.si]: #ratio.si
+[ratio.syn]: #ratio.syn
+[special]: class.md#special
+[stmt.return]: stmt.md#stmt.return
+[support.signal]: support.md#support.signal
+[swappable.requirements]: library.md#swappable.requirements
+[term.layout.compatible.type]: basic.md#term.layout.compatible.type
+[term.object.type]: basic.md#term.object.type
+[term.odr.use]: basic.md#term.odr.use
+[term.scalar.type]: basic.md#term.scalar.type
+[term.standard.layout.type]: basic.md#term.standard.layout.type
+[term.trivial.type]: basic.md#term.trivial.type
+[term.trivially.copyable.type]: basic.md#term.trivially.copyable.type
+[term.unevaluated.operand]: expr.md#term.unevaluated.operand
+[tuple.apply]: utilities.md#tuple.apply
+[type.traits]: #type.traits
+[type.traits.general]: #type.traits.general

Diff to HTML by rtfpessoa