[type.descriptions] - C++17 → C++20

Files changed (1) hide show

tmp/tmp9vkdvp0b/{from.md → to.md} +76 -43

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

@@ -2,23 +2,21 @@
 ##### General <a id="type.descriptions.general">[[type.descriptions.general]]</a>
 The Requirements subclauses may describe names that are used to specify
 constraints on template arguments.[^6] These names are used in library
-Clauses to describe the types that may be supplied as arguments by a
-C++program when instantiating template components from the library.
-Certain types defined in Clause  [[input.output]] are used to describe
 implementation-defined types. They are based on other types, but with
 added constraints.
 ##### Exposition-only types <a id="expos.only.types">[[expos.only.types]]</a>
-Several types defined in Clauses  [[language.support]] through
-[[thread]] and Annex  [[depr]] that are used as function parameter or
-return types are defined for the purpose of exposition only in order to
-capture their language linkage. The declarations of such types are
 followed by a comment ending in *exposition only*.
 [*Example 1*:
 ``` cpp
@@ -32,73 +30,73 @@ function that takes a callback parameter with C language linkage.
 — *end example*]
 ##### Enumerated types <a id="enumerated.types">[[enumerated.types]]</a>
-Several types defined in Clause  [[input.output]] are *enumerated
-types*. Each enumerated type may be implemented as an enumeration or as
-a synonym for an enumeration.[^7]
 The enumerated type `enumerated` can be written:
 ``` cpp
-enum enumerated { V₀, V₁, V₂, V₃, ..... };
 inline const enumerated C₀(V₀);
 inline const enumerated C₁(V₁);
 inline const enumerated C₂(V₂);
 inline const enumerated C₃(V₃);
- .....
 ```
 Here, the names `C₀`, `C₁`, etc. represent *enumerated elements* for
 this particular enumerated type. All such elements have distinct values.
 ##### Bitmask types <a id="bitmask.types">[[bitmask.types]]</a>
-Several types defined in Clauses  [[language.support]] through
-[[thread]] and Annex  [[depr]] are *bitmask types*. Each bitmask type
-can be implemented as an enumerated type that overloads certain
-operators, as an integer type, or as a `bitset` ([[template.bitset]]).
-The bitmask type *bitmask* can be written:
 ``` cpp
 // For exposition only.
 // int_type is an integral type capable of representing all values of the bitmask type.
 enum bitmask : int_type {
-  V₀ = 1 << 0, V₁ = 1 << 1, V₂ = 1 << 2, V₃ = 1 << 3, .....
 };
 inline constexpr bitmask C₀(V₀{});
 inline constexpr bitmask C₁(V₁{});
 inline constexpr bitmask C₂(V₂{});
 inline constexpr bitmask C₃(V₃{});
- .....
-constexpr bitmask{} operator&(bitmask{} X, bitmask{} Y) {
-  return static_cast<bitmask{}>(
     static_cast<int_type>(X) & static_cast<int_type>(Y));
 }
-constexpr bitmask{} operator|(bitmask{} X, bitmask{} Y) {
-  return static_cast<bitmask{}>(
     static_cast<int_type>(X) | static_cast<int_type>(Y));
 }
-constexpr bitmask{} operator^(bitmask{} X, bitmask{} Y){
-  return static_cast<bitmask{}>(
     static_cast<int_type>(X) ^ static_cast<int_type>(Y));
 }
-constexpr bitmask{} operator~(bitmask{} X){
-  return static_cast<bitmask{}>(~static_cast<int_type>(X));
 }
-bitmask{}& operator&=(bitmask{}& X, bitmask{} Y){
   X = X & Y; return X;
 }
-bitmask{}& operator|=(bitmask{}& X, bitmask{} Y) {
   X = X | Y; return X;
 }
-bitmask{}& operator^=(bitmask{}& X, bitmask{} Y) {
   X = X ^ Y; return X;
 }
 ```
 Here, the names `C₀`, `C₁`, etc. represent *bitmask elements* for this
@@ -125,41 +123,76 @@ sequences that follow a few uniform conventions:
   basic execution character set.
 - The *decimal-point character* is the (single-byte) character used by
   functions that convert between a (single-byte) character sequence and
   a value of one of the floating-point types. It is used in the
   character sequence to denote the beginning of a fractional part. It is
-  represented in Clauses  [[language.support]] through  [[thread]] and
- Annex  [[depr]] by a period, `'.'`, which is also its value in the
- `"C"` locale, but may change during program execution by a call to
   `setlocale(int, const char*)`,[^8] or by a change to a `locale`
-  object, as described in Clauses  [[locales]] and  [[input.output]].
-- A *character sequence* is an array object ([[dcl.array]]) `A` that
- can be declared as `T A[N]`, where `T` is any of the types `char`,
-  `unsigned char`, or `signed char` ([[basic.fundamental]]), optionally
   qualified by any combination of `const` or `volatile`. The initial
   elements of the array have defined contents up to and including an
   element determined by some predicate. A character sequence can be
   designated by a pointer value `S` that points to its first element.
 ###### Byte strings <a id="byte.strings">[[byte.strings]]</a>
 A *null-terminated byte string*, or NTBS, is a character sequence whose
 highest-addressed element with defined content has the value zero (the
-*terminating null* character); no other element in the sequence has the
 value zero. [^9]
-The *length* of an NTBS is the number of elements that precede the
-terminating null character. An *empty* NTBS has a length of zero.
-The *value* of an NTBS is the sequence of values of the elements up to
 and including the terminating null character.
-A *static* NTBS is an NTBSwith static storage duration.[^10]
 ###### Multibyte strings <a id="multibyte.strings">[[multibyte.strings]]</a>
 A *null-terminated multibyte string*, or NTMBS, is an NTBS that
 constitutes a sequence of valid multibyte characters, beginning and
 ending in the initial shift state.[^11]
-A *static* NTMBS is an NTMBSwith static storage duration.

 ##### General <a id="type.descriptions.general">[[type.descriptions.general]]</a>
 The Requirements subclauses may describe names that are used to specify
 constraints on template arguments.[^6] These names are used in library
+Clauses to describe the types that may be supplied as arguments by a C++
+program when instantiating template components from the library.
+Certain types defined in [[input.output]] are used to describe
 implementation-defined types. They are based on other types, but with
 added constraints.
 ##### Exposition-only types <a id="expos.only.types">[[expos.only.types]]</a>
+Several types defined in [[support]] through [[thread]] and [[depr]] are
+defined for the purpose of exposition. The declaration of such a type is
 followed by a comment ending in *exposition only*.
 [*Example 1*:
 ``` cpp
 — *end example*]
 ##### Enumerated types <a id="enumerated.types">[[enumerated.types]]</a>
+Several types defined in [[input.output]] are *enumerated types*. Each
+enumerated type may be implemented as an enumeration or as a synonym for
+an enumeration.[^7]
 The enumerated type `enumerated` can be written:
 ``` cpp
+enum enumerated { V₀, V₁, V₂, V₃, … };
 inline const enumerated C₀(V₀);
 inline const enumerated C₁(V₁);
 inline const enumerated C₂(V₂);
 inline const enumerated C₃(V₃);
+ ⋮
 ```
 Here, the names `C₀`, `C₁`, etc. represent *enumerated elements* for
 this particular enumerated type. All such elements have distinct values.
 ##### Bitmask types <a id="bitmask.types">[[bitmask.types]]</a>
+Several types defined in [[support]] through [[thread]] and [[depr]] are
+*bitmask types*. Each bitmask type can be implemented as an enumerated
+type that overloads certain operators, as an integer type, or as a
+`bitset` [[template.bitset]].
+The bitmask type `bitmask` can be written:
 ``` cpp
 // For exposition only.
 // int_type is an integral type capable of representing all values of the bitmask type.
 enum bitmask : int_type {
+  V₀ = 1 << 0, V₁ = 1 << 1, V₂ = 1 << 2, V₃ = 1 << 3, …
 };
 inline constexpr bitmask C₀(V₀{});
 inline constexpr bitmask C₁(V₁{});
 inline constexpr bitmask C₂(V₂{});
 inline constexpr bitmask C₃(V₃{});
+ ⋮
+constexpr bitmask operator&(bitmask X, bitmask Y) {
+  return static_cast<bitmask>(
     static_cast<int_type>(X) & static_cast<int_type>(Y));
 }
+constexpr bitmask operator|(bitmask X, bitmask Y) {
+  return static_cast<bitmask>(
     static_cast<int_type>(X) | static_cast<int_type>(Y));
 }
+constexpr bitmask operator^(bitmask X, bitmask Y){
+  return static_cast<bitmask>(
     static_cast<int_type>(X) ^ static_cast<int_type>(Y));
 }
+constexpr bitmask operator~(bitmask X){
+  return static_cast<bitmask>(~static_cast<int_type>(X));
 }
+bitmask& operator&=(bitmask& X, bitmask Y){
   X = X & Y; return X;
 }
+bitmask& operator|=(bitmask& X, bitmask Y) {
   X = X | Y; return X;
 }
+bitmask& operator^=(bitmask& X, bitmask Y) {
   X = X ^ Y; return X;
 }
 ```
 Here, the names `C₀`, `C₁`, etc. represent *bitmask elements* for this
   basic execution character set.
 - The *decimal-point character* is the (single-byte) character used by
   functions that convert between a (single-byte) character sequence and
   a value of one of the floating-point types. It is used in the
   character sequence to denote the beginning of a fractional part. It is
+  represented in [[support]] through [[thread]] and [[depr]] by a
+  period, `'.'`, which is also its value in the `"C"` locale, but may
+  change during program execution by a call to
   `setlocale(int, const char*)`,[^8] or by a change to a `locale`
+  object, as described in [[locales]] and [[input.output]].
+- A *character sequence* is an array object [[dcl.array]] `A` that can
+  be declared as `T A[N]`, where `T` is any of the types `char`,
+  `unsigned char`, or `signed char` [[basic.fundamental]], optionally
   qualified by any combination of `const` or `volatile`. The initial
   elements of the array have defined contents up to and including an
   element determined by some predicate. A character sequence can be
   designated by a pointer value `S` that points to its first element.
 ###### Byte strings <a id="byte.strings">[[byte.strings]]</a>
 A *null-terminated byte string*, or NTBS, is a character sequence whose
 highest-addressed element with defined content has the value zero (the
+*terminating null character*); no other element in the sequence has the
 value zero. [^9]
+The *length of an NTBS* is the number of elements that precede the
+terminating null character. An *empty NTBS* has a length of zero.
+The *value of an NTBS* is the sequence of values of the elements up to
 and including the terminating null character.
+A *static NTBS* is an NTBS with static storage duration.[^10]
 ###### Multibyte strings <a id="multibyte.strings">[[multibyte.strings]]</a>
 A *null-terminated multibyte string*, or NTMBS, is an NTBS that
 constitutes a sequence of valid multibyte characters, beginning and
 ending in the initial shift state.[^11]
+A *static NTMBS* is an NTMBS with static storage duration.
+##### Customization Point Object types <a id="customization.point.object">[[customization.point.object]]</a>
+A *customization point object* is a function object [[function.objects]]
+with a literal class type that interacts with program-defined types
+while enforcing semantic requirements on that interaction.
+The type of a customization point object, ignoring cv-qualifiers, shall
+model `semiregular` [[concepts.object]].
+All instances of a specific customization point object type shall be
+equal [[concepts.equality]].
+The type `T` of a customization point object shall model
+`invocable<const T&, Args...>` [[concept.invocable]] when the types in
+`Args...` meet the requirements specified in that customization point
+object’s definition. When the types of `Args...` do not meet the
+customization point object’s requirements, `T` shall not have a function
+call operator that participates in overload resolution.
+Each customization point object type constrains its return type to model
+a particular concept.
+[*Note 1*: Many of the customization point objects in the library
+evaluate function call expressions with an unqualified name which
+results in a call to a program-defined function found by argument
+dependent name lookup [[basic.lookup.argdep]]. To preclude such an
+expression resulting in a call to unconstrained functions with the same
+name in namespace `std`, customization point objects specify that lookup
+for these expressions is performed in a context that includes deleted
+overloads matching the signatures of overloads defined in namespace
+`std`. When the deleted overloads are viable, program-defined overloads
+need be more specialized [[temp.func.order]] or more constrained
+[[temp.constr.order]] to be used by a customization point
+object. — *end note*]

Diff to HTML by rtfpessoa