[utility.requirements] - C++23 → Trunk

Files changed (1) hide show

tmp/tmptaonxtw9/{from.md → to.md} +36 -16

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

@@ -90,21 +90,21 @@ signatures is called using the default argument [[dcl.fct.default]].
 **Table: Cpp17Destructible requirements** <a id="cpp17.destructible">[cpp17.destructible]</a>
 | Expression | Post-condition                                                        |
 | ---------- | --------------------------------------------------------------------- |
-| `u.~T()`   | All resources owned by `u` are reclaimed, no exception is propagated. |
 | *[spans 2 columns]*  *Array types and non-object types are not Cpp17Destructible.* |
 #### Swappable requirements <a id="swappable.requirements">[[swappable.requirements]]</a>
 This subclause provides definitions for swappable types and expressions.
 In these definitions, let `t` denote an expression of type `T`, and let
 `u` denote an expression of type `U`.
-An object `t` is *swappable with* an object `u` if and only if:
 - the expressions `swap(t, u)` and `swap(u, t)` are valid when evaluated
   in the context described below, and
 - these expressions have the following effects:
   - the object referred to by `t` has the value originally held by `u`
@@ -130,16 +130,15 @@ swappable requirement includes the header `<utility>` to ensure an
 appropriate evaluation context. — *end note*]
 An rvalue or lvalue `t` is *swappable* if and only if `t` is swappable
 with any rvalue or lvalue, respectively, of type `T`.
-A type `X` meets the *Cpp17Swappable* requirements if lvalues of type
-`X` are swappable.
 A type `X` meeting any of the iterator requirements
-[[iterator.requirements]] meets the *Cpp17ValueSwappable* requirements
-if, for any dereferenceable object `x` of type `X`, `*x` is swappable.
 [*Example 1*:
 User code can ensure that the evaluation of `swap` calls is performed in
 an appropriate context under the various conditions as follows:
@@ -189,25 +188,27 @@ int main() {
 — *end example*]
 #### *Cpp17NullablePointer* requirements <a id="nullablepointer.requirements">[[nullablepointer.requirements]]</a>
 A *Cpp17NullablePointer* type is a pointer-like type that supports null
-values. A type `P` meets the *Cpp17NullablePointer* requirements if:
 - `P` meets the *Cpp17EqualityComparable*, *Cpp17DefaultConstructible*,
   *Cpp17CopyConstructible*, *Cpp17CopyAssignable*, *Cpp17Swappable*, and
   *Cpp17Destructible* requirements,
 - the expressions shown in [[cpp17.nullablepointer]] are valid and have
   the indicated semantics, and
 - `P` meets all the other requirements of this subclause.
 A value-initialized object of type `P` produces the null value of the
 type. The null value shall be equivalent only to itself. A
-default-initialized object of type `P` may have an indeterminate value.
 [*Note 1*: Operations involving indeterminate values can cause
-undefined behavior. — *end note*]
 An object `p` of type `P` can be contextually converted to `bool`
 [[conv]]. The effect shall be as if `p != nullptr` had been evaluated in
 place of `p`.
@@ -234,11 +235,11 @@ non-`const` lvalue of type `P`, `a` and `b` denote values of type
 | `np != a`      |                                                                           |                             |
 #### *Cpp17Hash* requirements <a id="hash.requirements">[[hash.requirements]]</a>
-A type `H` meets the requirements if:
 - it is a function object type [[function.objects]],
 - it meets the *Cpp17CopyConstructible* ([[cpp17.copyconstructible]])
   and *Cpp17Destructible* ([[cpp17.destructible]]) requirements, and
 - the expressions shown in [[cpp17.hash]] are valid and have the
@@ -261,15 +262,15 @@ The library describes a standard set of requirements for *allocators*,
 which are class-type objects that encapsulate the information about an
 allocation model. This information includes the knowledge of pointer
 types, the type of their difference, the type of the size of objects in
 this allocation model, as well as the memory allocation and deallocation
 primitives for it. All of the string types [[strings]], containers
-[[containers]] (except `array`), string buffers and string streams
-[[input.output]], and `match_results` [[re]] are parameterized in terms
-of allocators.
-In subclause [[allocator.requirements]],
 - `T`, `U`, `C` denote any cv-unqualified object type
   [[term.object.type]],
 - `X` denotes an allocator class for type `T`,
 - `Y` denotes the corresponding allocator class for type `U`,
@@ -365,11 +366,11 @@ typename X::difference_type
 between any two pointers in the allocation model.
 *Remarks:* Default: `pointer_traits<XX::pointer>::difference_type`
 ``` cpp
-typename X::template rebind<U>::other
 ```
 *Result:* `Y`
 *Ensures:* For all `U` (including `T`), `YY::rebind_alloc<T>` is `X`.
@@ -596,11 +597,11 @@ X u(std::move(b));
 *Ensures:* `u` is equal to the prior value of `X(b)`.
 *Throws:* Nothing.
 ``` cpp
-a.construct(c, args)
 ```
 *Result:* (not used)
 *Effects:* Constructs an object of type `C` at `c`.
@@ -765,10 +766,29 @@ struct SimpleAllocator {
 };
 ```
 — *end example*]
 ##### Allocator completeness requirements <a id="allocator.requirements.completeness">[[allocator.requirements.completeness]]</a>
 If `X` is an allocator class for type `T`, `X` additionally meets the
 allocator completeness requirements if, whether or not `T` is a complete
 type:

 **Table: Cpp17Destructible requirements** <a id="cpp17.destructible">[cpp17.destructible]</a>
 | Expression | Post-condition                                                        |
 | ---------- | --------------------------------------------------------------------- |
+| `a.~T()`   | All resources owned by `a` are reclaimed, no exception is propagated. |
 | *[spans 2 columns]*  *Array types and non-object types are not Cpp17Destructible.* |
 #### Swappable requirements <a id="swappable.requirements">[[swappable.requirements]]</a>
 This subclause provides definitions for swappable types and expressions.
 In these definitions, let `t` denote an expression of type `T`, and let
 `u` denote an expression of type `U`.
+An object `t` is *swappable with* an object `u` if and only if
 - the expressions `swap(t, u)` and `swap(u, t)` are valid when evaluated
   in the context described below, and
 - these expressions have the following effects:
   - the object referred to by `t` has the value originally held by `u`
 appropriate evaluation context. — *end note*]
 An rvalue or lvalue `t` is *swappable* if and only if `t` is swappable
 with any rvalue or lvalue, respectively, of type `T`.
+A type `X` meets the requirements if lvalues of type `X` are swappable.
 A type `X` meeting any of the iterator requirements
+[[iterator.requirements]] meets the requirements if, for any
+dereferenceable object `x` of type `X`, `*x` is swappable.
 [*Example 1*:
 User code can ensure that the evaluation of `swap` calls is performed in
 an appropriate context under the various conditions as follows:
 — *end example*]
 #### *Cpp17NullablePointer* requirements <a id="nullablepointer.requirements">[[nullablepointer.requirements]]</a>
 A *Cpp17NullablePointer* type is a pointer-like type that supports null
+values. A type `P` meets the *Cpp17NullablePointer* requirements if
 - `P` meets the *Cpp17EqualityComparable*, *Cpp17DefaultConstructible*,
   *Cpp17CopyConstructible*, *Cpp17CopyAssignable*, *Cpp17Swappable*, and
   *Cpp17Destructible* requirements,
 - the expressions shown in [[cpp17.nullablepointer]] are valid and have
   the indicated semantics, and
 - `P` meets all the other requirements of this subclause.
 A value-initialized object of type `P` produces the null value of the
 type. The null value shall be equivalent only to itself. A
+default-initialized object of type `P` may have an indeterminate or
+erroneous value.
 [*Note 1*: Operations involving indeterminate values can cause
+undefined behavior, and operations involving erroneous values can cause
+erroneous behavior [[basic.indet]]. — *end note*]
 An object `p` of type `P` can be contextually converted to `bool`
 [[conv]]. The effect shall be as if `p != nullptr` had been evaluated in
 place of `p`.
 | `np != a`      |                                                                           |                             |
 #### *Cpp17Hash* requirements <a id="hash.requirements">[[hash.requirements]]</a>
+A type `H` meets the requirements if
 - it is a function object type [[function.objects]],
 - it meets the *Cpp17CopyConstructible* ([[cpp17.copyconstructible]])
   and *Cpp17Destructible* ([[cpp17.destructible]]) requirements, and
 - the expressions shown in [[cpp17.hash]] are valid and have the
 which are class-type objects that encapsulate the information about an
 allocation model. This information includes the knowledge of pointer
 types, the type of their difference, the type of the size of objects in
 this allocation model, as well as the memory allocation and deallocation
 primitives for it. All of the string types [[strings]], containers
+[[containers]] (except `array` and `inplace_vector`), string buffers and
+string streams [[input.output]], and `match_results` [[re]] are
+parameterized in terms of allocators.
+In [[allocator.requirements]],
 - `T`, `U`, `C` denote any cv-unqualified object type
   [[term.object.type]],
 - `X` denotes an allocator class for type `T`,
 - `Y` denotes the corresponding allocator class for type `U`,
 between any two pointers in the allocation model.
 *Remarks:* Default: `pointer_traits<XX::pointer>::difference_type`
 ``` cpp
+typename X::rebind<U>::other
 ```
 *Result:* `Y`
 *Ensures:* For all `U` (including `T`), `YY::rebind_alloc<T>` is `X`.
 *Ensures:* `u` is equal to the prior value of `X(b)`.
 *Throws:* Nothing.
 ``` cpp
+a.construct(c, args...)
 ```
 *Result:* (not used)
 *Effects:* Constructs an object of type `C` at `c`.
 };
 ```
 — *end example*]
+The following exposition-only concept defines the minimal requirements
+on an Allocator type.
+``` cpp
+namespace std {
+  template<class Alloc>
+  concept simple-allocator =
+    requires(Alloc alloc, size_t n) {
+      { *alloc.allocate(n) } -> same_as<typename Alloc::value_type&>;
+      { alloc.deallocate(alloc.allocate(n), n) };
+    } &&
+    copy_constructible<Alloc> &&
+    equality_comparable<Alloc>;
+}
+```
+A type `Alloc` models `simple-allocator` if it meets the requirements of
+[[allocator.requirements.general]].
 ##### Allocator completeness requirements <a id="allocator.requirements.completeness">[[allocator.requirements.completeness]]</a>
 If `X` is an allocator class for type `T`, `X` additionally meets the
 allocator completeness requirements if, whether or not `T` is a complete
 type:

Diff to HTML by rtfpessoa