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

Files changed (1) hide show

tmp/tmpl91ihvl1/{from.md → to.md} +29 -52

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

@@ -1,32 +1,23 @@
 ### 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>));
@@ -51,30 +42,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.
@@ -125,11 +101,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>())>
     ```
@@ -153,20 +129,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:
@@ -174,12 +149,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
@@ -196,23 +173,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*:

 ### 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*:

Diff to HTML by rtfpessoa