[concepts.lang] - C++20 → C++23

Files changed (1) hide show

tmp/tmp2f6mv8k3/{from.md → to.md} +25 -21

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

@@ -33,22 +33,22 @@ template<class Derived, class Base>
 `Derived` and `Base` are the same class type ignoring
 cv-qualifiers. — *end note*]
 ### Concept  <a id="concept.convertible">[[concept.convertible]]</a>
-Given types `From` and `To` and an expression `E` such that
-`decltype((E))` is `add_rvalue_reference_t<From>`,
 `convertible_to<From, To>` requires `E` to be both implicitly and
 explicitly convertible to type `To`. The implicit and explicit
 conversions are required to produce equal results.
 ``` cpp
 template<class From, class To>
   concept convertible_to =
     is_convertible_v<From, To> &&
-    requires(add_rvalue_reference_t<From> (&f)()) {
-      static_cast<To>(f());
     };
 ```
 Let `FromR` be `add_rvalue_reference_t<From>` and `test` be the invented
 function:
@@ -77,12 +77,12 @@ that `f()` is equality-preserving. Types `From` and `To` model
 For two types `T` and `U`, if `common_reference_t<T, U>` is well-formed
 and denotes a type `C` such that both `convertible_to<T, C>` and
 `convertible_to<U, C>` are modeled, then `T` and `U` share a *common
 reference type*, `C`.
-[*Note 1*: `C` could be the same as `T`, or `U`, or it could be a
-different type. `C` may be a reference type. — *end note*]
 ``` cpp
 template<class T, class U>
   concept common_reference_with =
     same_as<common_reference_t<T, U>, common_reference_t<U, T>> &&
@@ -107,12 +107,12 @@ template [[meta.trans.other]]. — *end note*]
 ### Concept  <a id="concept.common">[[concept.common]]</a>
 If `T` and `U` can both be explicitly converted to some third type, `C`,
 then `T` and `U` share a *common type*, `C`.
-[*Note 1*: `C` could be the same as `T`, or `U`, or it could be a
-different type. `C` might not be unique. — *end note*]
 ``` cpp
 template<class T, class U>
   concept common_with =
     same_as<common_type_t<T, U>, common_type_t<U, T>> &&
@@ -223,31 +223,35 @@ if the operation modifies neither `t2` nor `u2` and:
 The name `ranges::swap` denotes a customization point object
 [[customization.point.object]]. The expression `ranges::swap(E1, E2)`
 for subexpressions `E1` and `E2` is expression-equivalent to an
 expression `S` determined as follows:
-- `S` is `(void)swap(E1, E2)`[^1] if `E1` or `E2` has class or
-  enumeration type [[basic.compound]] and that expression is valid, with
-  overload resolution performed in a context that includes the
-  declaration
   ``` cpp
   template<class T>
     void swap(T&, T&) = delete;
   ```
   and does not include a declaration of `ranges::swap`. If the function
   selected by overload resolution does not exchange the values denoted
   by `E1` and `E2`, the program is ill-formed, no diagnostic required.
 - Otherwise, if `E1` and `E2` are lvalues of array types
   [[basic.compound]] with equal extent and `ranges::swap(*E1, *E2)` is a
   valid expression, `S` is `(void)ranges::swap_ranges(E1, E2)`, except
   that `noexcept(S)` is equal to `noexcept({}ranges::swap(*E1, *E2))`.
 - Otherwise, if `E1` and `E2` are lvalues of the same type `T` that
   models `move_constructible<T>` and `assignable_from<T&, T>`, `S` is an
   expression that exchanges the denoted values. `S` is a constant
   expression if
-  - `T` is a literal type [[basic.types]],
   - both `E1 = std::move(E2)` and `E2 = std::move(E1)` are constant
     subexpressions [[defns.const.subexpr]], and
   - the full-expressions of the initializers in the declarations
     ``` cpp
     T t1(std::move(E1));
@@ -256,15 +260,15 @@ expression `S` determined as follows:
     are constant subexpressions.
   `noexcept(S)` is equal to
   `is_nothrow_move_constructible_v<T> && is_nothrow_move_assignable_v<T>`.
-- Otherwise, `ranges::swap(E1, E2)` is ill-formed. \[*Note 2*: This case
   can result in substitution failure when `ranges::swap(E1, E2)` appears
   in the immediate context of a template instantiation. — *end note*]
-[*Note 3*: Whenever `ranges::swap(E1, E2)` is a valid expression, it
 exchanges the values denoted by `E1` and `E2` and has type
 `void`. — *end note*]
 ``` cpp
 template<class T>
@@ -281,13 +285,13 @@ template<class T, class U>
       ranges::swap(std::forward<T>(t), std::forward<U>(u));
       ranges::swap(std::forward<U>(u), std::forward<T>(t));
     };
 ```
-[*Note 4*: The semantics of the `swappable` and `swappable_with`
-concepts are fully defined by the `ranges::swap` customization
-point. — *end note*]
 [*Example 1*:
 User code can ensure that the evaluation of `swap` calls is performed in
 an appropriate context under the various conditions as follows:
@@ -362,11 +366,11 @@ template<class T, class... Args>
 ### Concept  <a id="concept.default.init">[[concept.default.init]]</a>
 ``` cpp
 template<class T>
- inline constexpr bool is-default-initializable = see below; // exposition only
 template<class T>
   concept default_initializable = constructible_from<T> &&
                                   requires { T{}; } &&
                                   is-default-initializable<T>;
@@ -409,12 +413,12 @@ template<class T>
     constructible_from<T, T&> && convertible_to<T&, T> &&
     constructible_from<T, const T&> && convertible_to<const T&, T> &&
     constructible_from<T, const T> && convertible_to<const T, T>;
 ```
-If `T` is an object type, then let `v` be an lvalue of type (possibly
-`const`) `T` or an rvalue of type `const T`. `T` models
 `copy_constructible` only if
 - After the definition `T u = v;`, `u` is equal to `v`
   [[concepts.equality]] and `v` is not modified.
 - `T(v)` is equal to `v` and does not modify `v`.

 `Derived` and `Base` are the same class type ignoring
 cv-qualifiers. — *end note*]
 ### Concept  <a id="concept.convertible">[[concept.convertible]]</a>
+Given types `From` and `To` and an expression `E` whose type and value
+category are the same as those of `declval<From>()`,
 `convertible_to<From, To>` requires `E` to be both implicitly and
 explicitly convertible to type `To`. The implicit and explicit
 conversions are required to produce equal results.
 ``` cpp
 template<class From, class To>
   concept convertible_to =
     is_convertible_v<From, To> &&
+    requires {
+      static_cast<To>(declval<From>());
     };
 ```
 Let `FromR` be `add_rvalue_reference_t<From>` and `test` be the invented
 function:
 For two types `T` and `U`, if `common_reference_t<T, U>` is well-formed
 and denotes a type `C` such that both `convertible_to<T, C>` and
 `convertible_to<U, C>` are modeled, then `T` and `U` share a *common
 reference type*, `C`.
+[*Note 1*: `C` can be the same as `T` or `U`, or can be a different
+type. `C` can be a reference type. — *end note*]
 ``` cpp
 template<class T, class U>
   concept common_reference_with =
     same_as<common_reference_t<T, U>, common_reference_t<U, T>> &&
 ### Concept  <a id="concept.common">[[concept.common]]</a>
 If `T` and `U` can both be explicitly converted to some third type, `C`,
 then `T` and `U` share a *common type*, `C`.
+[*Note 1*: `C` can be the same as `T` or `U`, or can be a different
+type. `C` is not necessarily unique. — *end note*]
 ``` cpp
 template<class T, class U>
   concept common_with =
     same_as<common_type_t<T, U>, common_type_t<U, T>> &&
 The name `ranges::swap` denotes a customization point object
 [[customization.point.object]]. The expression `ranges::swap(E1, E2)`
 for subexpressions `E1` and `E2` is expression-equivalent to an
 expression `S` determined as follows:
+- `S` is `(void)swap(E1, E2)`[^1]
+ if `E1` or `E2` has class or enumeration type [[basic.compound]] and
+ that expression is valid, with overload resolution performed in a
+ context that includes the declaration
   ``` cpp
   template<class T>
     void swap(T&, T&) = delete;
   ```
   and does not include a declaration of `ranges::swap`. If the function
   selected by overload resolution does not exchange the values denoted
   by `E1` and `E2`, the program is ill-formed, no diagnostic required.
+  \[*Note 2*: This precludes calling unconstrained program-defined
+  overloads of `swap`. When the deleted overload is viable,
+  program-defined overloads need to be more specialized
+  [[temp.func.order]] to be selected. — *end note*]
 - Otherwise, if `E1` and `E2` are lvalues of array types
   [[basic.compound]] with equal extent and `ranges::swap(*E1, *E2)` is a
   valid expression, `S` is `(void)ranges::swap_ranges(E1, E2)`, except
   that `noexcept(S)` is equal to `noexcept({}ranges::swap(*E1, *E2))`.
 - Otherwise, if `E1` and `E2` are lvalues of the same type `T` that
   models `move_constructible<T>` and `assignable_from<T&, T>`, `S` is an
   expression that exchanges the denoted values. `S` is a constant
   expression if
+  - `T` is a literal type [[term.literal.type]],
   - both `E1 = std::move(E2)` and `E2 = std::move(E1)` are constant
     subexpressions [[defns.const.subexpr]], and
   - the full-expressions of the initializers in the declarations
     ``` cpp
     T t1(std::move(E1));
     are constant subexpressions.
   `noexcept(S)` is equal to
   `is_nothrow_move_constructible_v<T> && is_nothrow_move_assignable_v<T>`.
+- Otherwise, `ranges::swap(E1, E2)` is ill-formed. \[*Note 3*: This case
   can result in substitution failure when `ranges::swap(E1, E2)` appears
   in the immediate context of a template instantiation. — *end note*]
+[*Note 4*: Whenever `ranges::swap(E1, E2)` is a valid expression, it
 exchanges the values denoted by `E1` and `E2` and has type
 `void`. — *end note*]
 ``` cpp
 template<class T>
       ranges::swap(std::forward<T>(t), std::forward<U>(u));
       ranges::swap(std::forward<U>(u), std::forward<T>(t));
     };
 ```
+[*Note 5*: The semantics of the `swappable` and `swappable_with`
+concepts are fully defined by the `ranges::swap` customization point
+object. — *end note*]
 [*Example 1*:
 User code can ensure that the evaluation of `swap` calls is performed in
 an appropriate context under the various conditions as follows:
 ### Concept  <a id="concept.default.init">[[concept.default.init]]</a>
 ``` cpp
 template<class T>
+  constexpr bool is-default-initializable = see below; // exposition only
 template<class T>
   concept default_initializable = constructible_from<T> &&
                                   requires { T{}; } &&
                                   is-default-initializable<T>;
     constructible_from<T, T&> && convertible_to<T&, T> &&
     constructible_from<T, const T&> && convertible_to<const T&, T> &&
     constructible_from<T, const T> && convertible_to<const T, T>;
 ```
+If `T` is an object type, then let `v` be an lvalue of type `T` or
+`const T` or an rvalue of type `const T`. `T` models
 `copy_constructible` only if
 - After the definition `T u = v;`, `u` is equal to `v`
   [[concepts.equality]] and `v` is not modified.
 - `T(v)` is equal to `v` and does not modify `v`.

Diff to HTML by rtfpessoa