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

Files changed (1) hide show

tmp/tmpcj9j6rtp/{from.md → to.md} +53 -53

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

@@ -1,42 +1,25 @@
 #### Type descriptions <a id="type.descriptions">[[type.descriptions]]</a>
 ##### 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
-namespace std {
-  extern "C" using some-handler = int(int, void*, double);  // exposition only
-}
-```
-The type placeholder `some-handler` can now be used to specify a
-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 [[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₃, … };
@@ -114,24 +97,36 @@ The following terms apply to objects and values of bitmask types:
 - The value *Y* *is set* in the object *X* if the expression *X* `&` *Y*
   is nonzero.
 ##### Character sequences <a id="character.seq">[[character.seq]]</a>
 The C standard library makes widespread use of characters and character
 sequences that follow a few uniform conventions:
 - A *letter* is any of the 26 lowercase or 26 uppercase letters in the
-  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
@@ -153,10 +148,14 @@ 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.
@@ -169,30 +168,31 @@ 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*]

 #### Type descriptions <a id="type.descriptions">[[type.descriptions]]</a>
 ##### 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.[^7]
+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.
 ##### 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.[^8]
 The enumerated type `enumerated` can be written:
 ``` cpp
 enum enumerated { V₀, V₁, V₂, V₃, … };
 - The value *Y* *is set* in the object *X* if the expression *X* `&` *Y*
   is nonzero.
 ##### Character sequences <a id="character.seq">[[character.seq]]</a>
+###### General <a id="character.seq.general">[[character.seq.general]]</a>
 The C standard library makes widespread use of characters and character
 sequences that follow a few uniform conventions:
+- Properties specified as *locale-specific* may change during program
+  execution by a call to `setlocale(int, const char*)` [[clocale.syn]],
+  or by a change to a `locale` object, as described in [[locales]] and
+  [[input.output]].
+- The *execution character set* and the *execution wide-character set*
+  are supersets of the basic literal character set [[lex.charset]]. The
+  encodings of the execution character sets and the sets of additional
+  elements (if any) are locale-specific. Each element of the execution
+  wide-character set is encoded as a single code unit representable by a
+  value of type `wchar_t`. \[*Note 1*: The encodings of the execution
+  character sets can be unrelated to any literal
+  encoding. — *end note*]
 - A *letter* is any of the 26 lowercase or 26 uppercase letters in the
+  basic character set.
+- The *decimal-point character* is the locale-specific (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.
 - 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
 A *static NTBS* is an NTBS with static storage duration.[^10]
 ###### Multibyte strings <a id="multibyte.strings">[[multibyte.strings]]</a>
+A *multibyte character* is a sequence of one or more bytes representing
+the code unit sequence for an encoded character of the execution
+character set.
 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.
 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 effects of invoking different instances
+of a specific customization point object type on the same arguments are
+equivalent.
+The type `T` of a customization point object, ignoring *cv-qualifier*s,
+shall model `invocable<T&, Args...>`, `invocable<const T&, Args...>`,
+`invocable<T, Args...>`, and `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.
+For a given customization point object `o`, let `p` be a variable
+initialized as if by `auto p = o;`. Then for any sequence of arguments
+`args...`, the following expressions have effects equivalent to
+`o(args...)`:
+- `p(args...)`
+- `as_const(p)(args...)`
+- `std::move(p)(args...)`
+- `std::move(as_const(p))(args...)`
 Each customization point object type constrains its return type to model
 a particular concept.

Diff to HTML by rtfpessoa