[requirements] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp3y0bhdd2/{from.md → to.md} +257 -209

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

@@ -1,11 +1,11 @@
 ## Library-wide requirements <a id="requirements">[[requirements]]</a>
 ### General <a id="requirements.general">[[requirements.general]]</a>
 Subclause [[requirements]] specifies requirements that apply to the
-entire C++ standard library. [[support]] through [[thread]] and [[depr]]
 specify the requirements of individual entities within the library.
 Requirements specified in terms of interactions between threads do not
 apply to programs having only a single thread of execution.
@@ -37,15 +37,15 @@ defined within the namespace `std` or namespaces nested within namespace
 It is unspecified whether names declared in a specific namespace are
 declared directly in that namespace or in an inline namespace inside
 that namespace.[^13]
-Whenever an unqualified name other than `swap`, `make_error_code`, or
-`make_error_condition` is used in the specification of a declaration `D`
-in [[support]] through [[thread]] or [[depr]], its meaning is
-established as-if by performing unqualified name lookup
-[[basic.lookup.unqual]] in the context of `D`.
 [*Note 1*: Argument-dependent lookup is not performed. — *end note*]
 Similarly, the meaning of a *qualified-id* is established as-if by
 performing qualified name lookup [[basic.lookup.qual]] in the context of
@@ -58,13 +58,14 @@ performing qualified name lookup [[basic.lookup.qual]] in the context of
 [*Note 2*: Operators in expressions [[over.match.oper]] are not so
 constrained; see [[global.functions]]. — *end note*]
 The meaning of the unqualified name `swap` is established in an overload
 resolution context for swappable values [[swappable.requirements]]. The
-meanings of the unqualified names `make_error_code` and
-`make_error_condition` are established as-if by performing
-argument-dependent lookup [[basic.lookup.argdep]].
 #### Headers <a id="headers">[[headers]]</a>
 Each element of the C++ standard library is declared or defined (as
 appropriate) in a *header*.[^14]
@@ -90,18 +91,18 @@ import <vector>;                // imports the <vector> header unit
 std::vector<int> vi;            // OK
 ```
 — *end example*]
-Except as noted in [[library]] through [[thread]] and [[depr]], the
 contents of each header `cname` is the same as that of the corresponding
 header `name.h` as specified in the C standard library [[intro.refs]].
 In the C++ standard library, however, the declarations (except for names
 which are defined as macros in C) are within namespace scope
 [[basic.scope.namespace]] of the namespace `std`. It is unspecified
 whether these names (including any overloads added in [[support]]
-through [[thread]] and [[depr]]) are first declared within the global
 namespace scope and are then injected into namespace `std` by explicit
 *using-declaration*s [[namespace.udecl]].
 Names which are defined as macros in C shall be defined as macros in the
 C++ standard library, even if C grants license for implementation as
@@ -115,15 +116,15 @@ Names that are defined as functions in C shall be defined as functions
 in the C++ standard library.[^16]
 Identifiers that are keywords or operators in C++ shall not be defined
 as macros in C++ standard library headers.[^17]
-[[support.c.headers]], C standard library headers, describes the effects
-of using the `name.h` (C header) form in a C++ program.[^18]
-Annex K of the C standard describes a large number of functions, with
-associated types and macros, which “promote safer, more secure
 programming” than many of the traditional C library functions. The names
 of the functions have a suffix of `_s`; most of them provide the same
 service as the C library function with the unsuffixed name, but
 generally take an additional argument whose value is the size of the
 result array. If any C++ header is included, it is
@@ -144,21 +145,23 @@ subset provided by a freestanding implementation) and the C++ headers
 for C library facilities ([[headers.cpp.c]]). It additionally exports
 declarations in the global namespace for the storage allocation and
 deallocation functions that are provided by `<new>`.
 The named module `std.compat` exports the same declarations as the named
-module `std`, and additionally exports declarations in the global
-namespace corresponding to the declarations in namespace `std` that are
-provided by the C++ headers for C library facilities (
-[[headers.cpp.c]]), except the explicitly excluded declarations
-described in [[support.c.headers.other]].
 It is unspecified to which module a declaration in the standard library
 is attached.
-[*Note 1*: Implementations are required to ensure that mixing
-`#include` and `import` does not result in conflicting attachments
 [[basic.link]]. — *end note*]
 *Recommended practice:* Implementations should ensure such attachments
 do not preclude further evolution or decomposition of the standard
 library modules.
@@ -187,40 +190,80 @@ headers. This set shall include at least the headers shown in
 [[headers.cpp.fs]].
 **Table: C++ headers for freestanding implementations** <a id="headers.cpp.fs">[headers.cpp.fs]</a>
 | Subclause             |                                                 | Header                               |
-| ---------------------- | -------------------------------- | ------------------------------------------------ |
 | [[support.types]]     | Common definitions                              | `<cstddef>`                          |
-| [[support.limits]] | Implementation properties        | `<cfloat>`, `<climits>`, `<limits>`, `<version>` |
 | [[cstdint.syn]]       | Integer types                                   | `<cstdint>`                          |
-| [[support.start.term]] | Start and termination            | `<cstdlib>`                                      |
 | [[support.dynamic]]   | Dynamic memory management                       | `<new>`                              |
 | [[support.rtti]]      | Type identification                             | `<typeinfo>`                         |
 | [[support.srcloc]]    | Source location                                 | `<source_location>`                  |
 | [[support.exception]] | Exception handling                              | `<exception>`                        |
 | [[support.initlist]]  | Initializer lists                               | `<initializer_list>`                 |
 | [[cmp]]               | Comparisons                                     | `<compare>`                          |
 | [[support.coroutine]] | Coroutines support                              | `<coroutine>`                        |
 | [[support.runtime]]   | Other runtime support                           | `<cstdarg>`                          |
 | [[concepts]]          | Concepts library                                | `<concepts>`                         |
 | [[type.traits]]       | Type traits                                     | `<type_traits>`                      |
-| [[bit]] | Bit manipulation                 | `<bit>` |
-| [[atomics]]            | Atomics                          | `<atomic>`                                       |
 | [[utility]]           | Utility components                              | `<utility>`                          |
 | [[tuple]]             | Tuples                                          | `<tuple>`                            |
-| [[memory]] | Memory                           | `<memory>` |
 | [[function.objects]]  | Function objects                                | `<functional>`                       |
-| [[ratio]] | Compile-time rational arithmetic | `<ratio>` |
 | [[iterators]]         | Iterators library                               | `<iterator>`                         |
 | [[ranges]]            | Ranges library                                  | `<ranges>`                           |
 For each of the headers listed in [[headers.cpp.fs]], a freestanding
 implementation provides at least the freestanding items
 [[freestanding.item]] declared in the header.
 ### Using the library <a id="using">[[using]]</a>
 #### Overview <a id="using.overview">[[using.overview]]</a>
 Subclause [[using]] describes how a C++ program gains access to the
@@ -357,21 +400,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`
@@ -397,16 +440,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:
@@ -456,25 +498,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`.
@@ -501,11 +545,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
@@ -528,15 +572,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`,
@@ -632,11 +676,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`.
@@ -863,11 +907,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`.
@@ -1032,10 +1076,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:
@@ -1065,13 +1128,16 @@ Unless otherwise specified, the behavior of a C++ program is undefined
 if it adds declarations or definitions to namespace `std` or to a
 namespace within namespace `std`.
 Unless explicitly prohibited, a program may add a template
 specialization for any standard library class template to namespace
-`std` provided that (a) the added declaration depends on at least one
-program-defined type and (b) the specialization meets the standard
-library requirements for the original template.[^21]
 The behavior of a C++ program is undefined if it declares an explicit or
 partial specialization of any standard library variable template, except
 where explicitly permitted by the specification of that variable
 template.
@@ -1089,13 +1155,15 @@ The behavior of a C++ program is undefined if it declares
 - an explicit or partial specialization of any member class template of
   a standard library class or class template, or
 - a deduction guide for any standard library class template.
 A program may explicitly instantiate a class template defined in the
-standard library only if the declaration (a) depends on the name of at
-least one program-defined type and (b) the instantiation meets the
-standard library requirements for the original template.
 Let `F` denote a standard library function [[global.functions]], a
 standard library static member function, or an instantiation of a
 standard library function template. Unless `F` is designated an
 *addressable function*, the behavior of a C++ program is unspecified
@@ -1111,19 +1179,33 @@ Moreover, the behavior of a C++ program is unspecified (possibly
 ill-formed) if it attempts to form a reference to `F` or if it attempts
 to form a pointer-to-member designating either a standard library
 non-static member function [[member.functions]] or an instantiation of a
 standard library member function template.
 A translation unit shall not declare namespace `std` to be an inline
 namespace [[namespace.def]].
 ##### Namespace `posix` <a id="namespace.posix">[[namespace.posix]]</a>
 The behavior of a C++ program is undefined if it adds declarations or
 definitions to namespace `posix` or to a namespace within namespace
 `posix` unless otherwise specified. The namespace `posix` is reserved
-for use by ISO/IEC/IEEE 9945 and other POSIX standards.
 ##### Namespaces for future standardization <a id="namespace.future">[[namespace.future]]</a>
 Top-level namespaces whose *namespace-name* consists of `std` followed
 by one or more *digit*s [[lex.name]] are reserved for future
@@ -1147,89 +1229,29 @@ If a program declares or defines a name in a context where it is
 reserved, other than as explicitly allowed by [[library]], its behavior
 is undefined.
 ##### Zombie names <a id="zombie.names">[[zombie.names]]</a>
-In namespace `std`, the following names are reserved for previous
-standardization:
-- `auto_ptr`,
-- `auto_ptr_ref`,
-- `binary_function`,
-- `binary_negate`,
-- `bind1st`,
-- `bind2nd`,
-- `binder1st`,
-- `binder2nd`,
-- `const_mem_fun1_ref_t`,
-- `const_mem_fun1_t`,
-- `const_mem_fun_ref_t`,
-- `const_mem_fun_t`,
-- `declare_no_pointers`,
-- `declare_reachable`,
-- `get_pointer_safety`,
-- `get_temporary_buffer`,
-- `get_unexpected`,
-- `gets`,
-- `is_literal_type`,
-- `is_literal_type_v`,
-- `mem_fun1_ref_t`,
-- `mem_fun1_t`,
-- `mem_fun_ref_t`,
-- `mem_fun_ref`,
-- `mem_fun_t`,
-- `mem_fun`,
-- `not1`,
-- `not2`,
-- `pointer_safety`,
-- `pointer_to_binary_function`,
-- `pointer_to_unary_function`,
-- `ptr_fun`,
-- `random_shuffle`,
-- `raw_storage_iterator`,
-- `result_of`,
-- `result_of_t`,
-- `return_temporary_buffer`,
-- `set_unexpected`,
-- `unary_function`,
-- `unary_negate`,
-- `uncaught_exception`,
-- `undeclare_no_pointers`,
-- `undeclare_reachable`, and
-- `unexpected_handler`.
-The following names are reserved as members for previous
-standardization, and may not be used as a name for object-like macros in
-portable code:
-- `argument_type`,
-- `first_argument_type`,
-- `io_state`,
-- `open_mode`,
-- `preferred`,
-- `second_argument_type`,
-- `seek_dir`, and.
-- `strict`.
-The name `stossc` is reserved as a member function for previous
-standardization, and may not be used as a name for function-like macros
-in portable code.
-The header names `<ccomplex>`, `<ciso646>`, `<cstdalign>`, `<cstdbool>`,
-and `<ctgmath>` are reserved for previous standardization.
 ##### Macro names <a id="macro.names">[[macro.names]]</a>
 A translation unit that includes a standard library header shall not
 `#define` or `#undef` names declared in any standard library header.
-A translation unit shall not `#define` or `#undef` names lexically
-identical to keywords, to the identifiers listed in
-[[lex.name.special]], or to the *attribute-token*s described in
-[[dcl.attr]], except that the names `likely` and `unlikely` may be
-defined as function-like macros  [[cpp.replace]].
 ##### External linkage <a id="extern.names">[[extern.names]]</a>
 Each name declared as an object with external linkage in a header is
 reserved to the implementation to designate that library object with
 external linkage, [^22]
@@ -1277,56 +1299,15 @@ Virtual member function signatures defined for a base class in the C++
 standard library may be overridden in a derived class defined in the
 program [[class.virtual]].
 #### Replacement functions <a id="replacement.functions">[[replacement.functions]]</a>
-[[support]] through [[thread]] and [[depr]] describe the behavior of
-numerous functions defined by the C++ standard library. Under some
-circumstances, however, certain of these function descriptions also
-apply to replacement functions defined in the program.
-A C++ program may provide the definition for any of the following
-dynamic memory allocation function signatures declared in header `<new>`
-[[basic.stc.dynamic]], [[new.syn]]:
-``` cpp
-operator new(std::size_t)
-operator new(std::size_t, std::align_val_t)
-operator new(std::size_t, const std::nothrow_t&)
-operator new(std::size_t, std::align_val_t, const std::nothrow_t&)
-```
-``` cpp
-operator delete(void*)
-operator delete(void*, std::size_t)
-operator delete(void*, std::align_val_t)
-operator delete(void*, std::size_t, std::align_val_t)
-operator delete(void*, const std::nothrow_t&)
-operator delete(void*, std::align_val_t, const std::nothrow_t&)
-```
-``` cpp
-operator new[](std::size_t)
-operator new[](std::size_t, std::align_val_t)
-operator new[](std::size_t, const std::nothrow_t&)
-operator new[](std::size_t, std::align_val_t, const std::nothrow_t&)
-```
-``` cpp
-operator delete[](void*)
-operator delete[](void*, std::size_t)
-operator delete[](void*, std::align_val_t)
-operator delete[](void*, std::size_t, std::align_val_t)
-operator delete[](void*, const std::nothrow_t&)
-operator delete[](void*, std::align_val_t, const std::nothrow_t&)
-```
-The program’s definitions are used instead of the default versions
-supplied by the implementation [[new.delete]]. Such replacement occurs
-prior to program startup [[basic.def.odr]], [[basic.start]]. The
-program’s declarations shall not be specified as `inline`. No diagnostic
-is required.
 #### Handler functions <a id="handler.functions">[[handler.functions]]</a>
 The C++ standard library provides a default version of the following
 handler function [[support]]:
@@ -1347,14 +1328,14 @@ A C++ program can get a pointer to the current handler function by
 calling the following functions:
 - `get_new_handler`
 - `get_terminate`
-Calling the `set_*` and `get_*` functions shall not incur a data race. A
-call to any of the `set_*` functions shall synchronize with subsequent
-calls to the same `set_*` function and to the corresponding `get_*`
-function.
 #### Other functions <a id="res.on.functions">[[res.on.functions]]</a>
 In certain cases (replacement functions, handler functions, operations
 on types used to instantiate standard library template components), the
@@ -1362,13 +1343,13 @@ C++ standard library depends on components supplied by a C++ program. If
 these components do not meet their requirements, this document places no
 requirements on the implementation.
 In particular, the behavior is undefined in the following cases:
-- For replacement functions [[new.delete]], if the installed replacement
-  function does not implement the semantics of the applicable *Required
-  behavior:* paragraph.
 - For handler functions [[new.handler]], [[terminate.handler]], if the
   installed handler function does not implement the semantics of the
   applicable *Required behavior:* paragraph.
 - For types used as template arguments when instantiating a template
   component, if the operations on the type do not implement the
@@ -1396,11 +1377,11 @@ the C++ standard library, unless explicitly stated otherwise.
   address computations and accesses to objects (that would be valid if
   the pointer did point to the first element of such an array) are in
   fact valid.
 - If a function argument is bound to an rvalue reference parameter, the
   implementation may assume that this parameter is a unique reference to
-  this argument, except that the argument passed to a move-assignment
   operator may be a reference to `*this` [[lib.types.movedfrom]].
   \[*Note 1*: If the type of a parameter is a forwarding reference
   [[temp.deduct.call]] that is deduced to an lvalue reference type, then
   the argument is not bound to an rvalue reference. — *end note*]
   \[*Note 2*: If a program casts an lvalue to an xvalue while passing
@@ -1449,16 +1430,21 @@ program is ill-formed, no diagnostic required.
 #### Overview <a id="conforming.overview">[[conforming.overview]]</a>
 Subclause [[conforming]] describes the constraints upon, and latitude
 of, implementations of the C++ standard library.
-An implementation’s use of headers is discussed in  [[res.on.headers]],
-its use of macros in  [[res.on.macro.definitions]], non-member functions
-in  [[global.functions]], member functions in  [[member.functions]],
-data race avoidance in  [[res.on.data.races]], access specifiers in
-[[protection.within.classes]], class derivation in  [[derivation]], and
-exceptions in  [[res.on.exception.handling]].
 #### Headers <a id="res.on.headers">[[res.on.headers]]</a>
 A C++ header may include other C++ headers. A C++ header shall provide
 the declarations and definitions that appear in its synopsis. A C++
@@ -1488,11 +1474,11 @@ stated otherwise.
 It is unspecified whether any non-member functions in the C++ standard
 library are defined as inline [[dcl.inline]].
 A call to a non-member function signature described in [[support]]
-through [[thread]] and [[depr]] shall behave as if the implementation
 declared no additional non-member function signatures.[^25]
 An implementation shall not declare a non-member function signature with
 additional default arguments.
@@ -1540,12 +1526,12 @@ signatures for a member function name. — *end note*]
 Whenever this document specifies a friend declaration of a function or
 function template within a class or class template definition, that
 declaration shall be the only declaration of that function or function
 template provided by an implementation.
-[*Note 1*: In particular, an implementation is not allowed to provide
-an additional declaration of that function or function template at
 namespace scope. — *end note*]
 [*Note 2*: Such a friend function or function template declaration is
 known as a hidden friend, as it is visible neither to ordinary
 unqualified lookup [[basic.lookup.unqual]] nor to qualified lookup
@@ -1555,12 +1541,12 @@ unqualified lookup [[basic.lookup.unqual]] nor to qualified lookup
 This document explicitly requires that certain standard library
 functions are `constexpr` [[dcl.constexpr]]. An implementation shall not
 declare any standard library function signature as `constexpr` except
 for those where it is explicitly required. Within any header that
-provides any non-defining declarations of constexpr functions or
-constructors an implementation shall provide corresponding definitions.
 #### Requirements for stable algorithms <a id="algorithm.stable">[[algorithm.stable]]</a>
 When the requirements for an algorithm state that it is “stable” without
 further elaboration, it means:
@@ -1625,14 +1611,32 @@ all operations solely within the current thread if those operations have
 effects that are visible [[intro.multithread]] to users.
 [*Note 3*: This allows implementations to parallelize operations if
 there are no visible side effects. — *end note*]
 #### Protection within classes <a id="protection.within.classes">[[protection.within.classes]]</a>
 It is unspecified whether any function signature or class described in
-[[support]] through [[thread]] and [[depr]] is a friend of another class
 in the C++ standard library.
 #### Derived classes <a id="derivation">[[derivation]]</a>
 An implementation may derive any class in the C++ standard library from
@@ -1660,21 +1664,22 @@ types unless otherwise specified.
 #### Restrictions on exception handling <a id="res.on.exception.handling">[[res.on.exception.handling]]</a>
 Any of the functions defined in the C++ standard library can report a
 failure by throwing an exception of a type described in its *Throws:*
 paragraph, or of a type derived from a type named in the *Throws:*
-paragraph that would be caught by an exception handler for the base
-type.
 Functions from the C standard library shall not throw exceptions [^26]
 except when such a function calls a program-supplied function that
 throws an exception.[^27]
 Destructor operations defined in the C++ standard library shall not
 throw exceptions. Every destructor in the C++ standard library shall
-behave as if it had a non-throwing exception specification.
 Functions defined in the C++ standard library that do not have a
 *Throws:* paragraph but do have a potentially-throwing exception
 specification may throw *implementation-defined* exceptions.[^28]
@@ -1683,15 +1688,22 @@ derived from the standard exception classes
 [[bad.alloc]], [[support.exception]], [[std.exceptions]].
 An implementation may strengthen the exception specification for a
 non-virtual function by adding a non-throwing exception specification.
 #### Value of error codes <a id="value.error.codes">[[value.error.codes]]</a>
 Certain functions in the C++ standard library report errors via a
-`std::error_code` [[syserr.errcode.overview]] object. That object’s
-`category()` member shall return `std::system_category()` for errors
 originating from the operating system, or a reference to an
 *implementation-defined* `error_category` object for errors originating
 elsewhere. The implementation shall define the possible values of
 `value()` for each of these error categories.
@@ -1707,56 +1719,65 @@ associated values. — *end example*]
 #### Moved-from state of library types <a id="lib.types.movedfrom">[[lib.types.movedfrom]]</a>
 Objects of types defined in the C++ standard library may be moved from
 [[class.copy.ctor]]. Move operations may be explicitly specified or
 implicitly generated. Unless otherwise specified, such moved-from
-objects shall be placed in a valid but unspecified state.
 An object of a type defined in the C++ standard library may be
 move-assigned [[class.copy.assign]] to itself. Unless otherwise
 specified, such an assignment places the object in a valid but
 unspecified state.
 <!-- Link reference definitions -->
 [alg.c.library]: algorithms.md#alg.c.library
 [alg.sorting]: algorithms.md#alg.sorting
 [algorithm.stable]: #algorithm.stable
 [algorithms]: algorithms.md#algorithms
 [algorithms.requirements]: algorithms.md#algorithms.requirements
 [alloc.errors]: support.md#alloc.errors
 [allocator.requirements]: #allocator.requirements
 [allocator.requirements.completeness]: #allocator.requirements.completeness
 [allocator.requirements.general]: #allocator.requirements.general
 [allocator.traits]: mem.md#allocator.traits
 [alt.headers]: #alt.headers
 [array.creation]: containers.md#array.creation
 [atomics]: thread.md#atomics
 [bad.alloc]: support.md#bad.alloc
 [basic.def.odr]: basic.md#basic.def.odr
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.life]: basic.md#basic.life
 [basic.link]: basic.md#basic.link
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lookup.qual]: basic.md#basic.lookup.qual
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.scope.namespace]: basic.md#basic.scope.namespace
-[basic.start]: basic.md#basic.start
 [basic.stc.dynamic]: basic.md#basic.stc.dynamic
 [bit]: utilities.md#bit
 [bitmask.types]: #bitmask.types
 [byte.strings]: #byte.strings
 [c.annex.k.names]: #c.annex.k.names
 [cassert.syn]: diagnostics.md#cassert.syn
 [cerrno.syn]: diagnostics.md#cerrno.syn
 [character.seq]: #character.seq
 [character.seq.general]: #character.seq.general
 [class.copy.assign]: class.md#class.copy.assign
 [class.copy.ctor]: class.md#class.copy.ctor
 [class.dtor]: class.md#class.dtor
 [class.mem]: class.md#class.mem
 [class.virtual]: class.md#class.virtual
-[clocale.syn]: localization.md#clocale.syn
 [cmp]: support.md#cmp
 [compliance]: #compliance
 [concept.destructible]: concepts.md#concept.destructible
 [concept.invocable]: concepts.md#concept.invocable
 [concept.totallyordered]: concepts.md#concept.totallyordered
@@ -1774,40 +1795,51 @@ unspecified state.
 [conv]: expr.md#conv
 [conv.func]: expr.md#conv.func
 [conventions]: #conventions
 [conventions.general]: #conventions.general
 [cpp.include]: cpp.md#cpp.include
-[cpp.replace]: cpp.md#cpp.replace
 [cpp17.copyassignable]: #cpp17.copyassignable
 [cpp17.copyconstructible]: #cpp17.copyconstructible
 [cpp17.destructible]: #cpp17.destructible
 [cpp17.hash]: #cpp17.hash
 [cpp17.moveassignable]: #cpp17.moveassignable
 [cpp17.nullablepointer]: #cpp17.nullablepointer
 [cstdarg.syn]: support.md#cstdarg.syn
 [cstddef.syn]: support.md#cstddef.syn
 [cstdint.syn]: support.md#cstdint.syn
 [customization.point.object]: #customization.point.object
 [dcl.array]: dcl.md#dcl.array
-[dcl.attr]: dcl.md#dcl.attr
 [dcl.constexpr]: dcl.md#dcl.constexpr
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init]: dcl.md#dcl.init
 [dcl.inline]: dcl.md#dcl.inline
 [dcl.link]: dcl.md#dcl.link
 [dcl.pre]: dcl.md#dcl.pre
 [dcl.typedef]: dcl.md#dcl.typedef
 [defns.nonconst.libcall]: intro.md#defns.nonconst.libcall
 [depr]: future.md#depr
 [derivation]: #derivation
 [derived.classes]: #derived.classes
 [description]: #description
 [description.general]: #description.general
 [diagnostics]: diagnostics.md#diagnostics
 [enumerated.types]: #enumerated.types
 [except]: except.md#except
 [expos.only.entity]: #expos.only.entity
 [expr.delete]: expr.md#expr.delete
 [expr.new]: expr.md#expr.new
 [expr.unary.op]: expr.md#expr.unary.op
 [extern.names]: #extern.names
 [extern.types]: #extern.types
@@ -1820,28 +1852,29 @@ unspecified state.
 [headers]: #headers
 [headers.cpp]: #headers.cpp
 [headers.cpp.c]: #headers.cpp.c
 [headers.cpp.fs]: #headers.cpp.fs
 [hidden.friends]: #hidden.friends
 [input.output]: input.md#input.output
 [intro.compliance]: intro.md#intro.compliance
 [intro.multithread]: basic.md#intro.multithread
 [intro.refs]: intro.md#intro.refs
 [iterator.requirements]: iterators.md#iterator.requirements
 [iterators]: iterators.md#iterators
 [lex.charset]: lex.md#lex.charset
 [lex.name]: lex.md#lex.name
-[lex.name.special]: #lex.name.special
 [lex.phases]: lex.md#lex.phases
 [lex.separate]: lex.md#lex.separate
 [lib.types.movedfrom]: #lib.types.movedfrom
 [library]: #library
 [library.c]: #library.c
 [library.categories]: #library.categories
 [library.general]: #library.general
-[locales]: localization.md#locales
-[localization]: localization.md#localization
 [macro.names]: #macro.names
 [mem]: mem.md#mem
 [member.functions]: #member.functions
 [memory]: mem.md#memory
 [meta]: meta.md#meta
@@ -1851,32 +1884,34 @@ unspecified state.
 [namespace.def]: dcl.md#namespace.def
 [namespace.future]: #namespace.future
 [namespace.posix]: #namespace.posix
 [namespace.std]: #namespace.std
 [namespace.udecl]: dcl.md#namespace.udecl
-[new.delete]: support.md#new.delete
 [new.handler]: support.md#new.handler
-[new.syn]: support.md#new.syn
 [nullablepointer.requirements]: #nullablepointer.requirements
 [numeric.requirements]: numerics.md#numeric.requirements
 [numerics]: numerics.md#numerics
 [objects.within.classes]: #objects.within.classes
 [organization]: #organization
 [organization.general]: #organization.general
 [ostream.iterator.ops]: iterators.md#ostream.iterator.ops
 [over.literal]: over.md#over.literal
 [over.match]: over.md#over.match
 [over.match.oper]: over.md#over.match.oper
 [protection.within.classes]: #protection.within.classes
 [random.access.iterators]: iterators.md#random.access.iterators
 [ranges]: ranges.md#ranges
 [ratio]: meta.md#ratio
-[re]: re.md#re
 [reentrancy]: #reentrancy
 [replacement.functions]: #replacement.functions
 [requirements]: #requirements
 [requirements.general]: #requirements.general
 [res.on.arguments]: #res.on.arguments
 [res.on.data.races]: #res.on.data.races
 [res.on.exception.handling]: #res.on.exception.handling
 [res.on.functions]: #res.on.functions
 [res.on.headers]: #res.on.headers
@@ -1886,31 +1921,34 @@ unspecified state.
 [reserved.names]: #reserved.names
 [reserved.names.general]: #reserved.names.general
 [specialized.addressof]: mem.md#specialized.addressof
 [std.exceptions]: diagnostics.md#std.exceptions
 [std.modules]: #std.modules
 [stmt.return]: stmt.md#stmt.return
 [stream.types]: input.md#stream.types
 [strings]: strings.md#strings
 [structure]: #structure
 [structure.elements]: #structure.elements
 [structure.requirements]: #structure.requirements
 [structure.see.also]: #structure.see.also
 [structure.specifications]: #structure.specifications
 [structure.summary]: #structure.summary
 [support]: support.md#support
 [support.c.headers]: support.md#support.c.headers
 [support.c.headers.other]: support.md#support.c.headers.other
 [support.coroutine]: support.md#support.coroutine
 [support.dynamic]: support.md#support.dynamic
 [support.exception]: support.md#support.exception
 [support.initlist]: support.md#support.initlist
 [support.limits]: support.md#support.limits
 [support.rtti]: support.md#support.rtti
 [support.runtime]: support.md#support.runtime
 [support.srcloc]: support.md#support.srcloc
-[support.start.term]: support.md#support.start.term
 [support.types]: support.md#support.types
 [swappable.requirements]: #swappable.requirements
 [syserr]: diagnostics.md#syserr
 [syserr.errcode.overview]: diagnostics.md#syserr.errcode.overview
 [tab:cpp17.destructible]: #tab:cpp17.destructible
@@ -1920,11 +1958,13 @@ unspecified state.
 [temp.constr.decl]: temp.md#temp.constr.decl
 [temp.deduct.call]: temp.md#temp.deduct.call
 [template.bitset]: utilities.md#template.bitset
 [term.incomplete.type]: basic.md#term.incomplete.type
 [term.object.type]: basic.md#term.object.type
 [terminate.handler]: support.md#terminate.handler
 [thread]: thread.md#thread
 [time]: time.md#time
 [tuple]: utilities.md#tuple
 [type.descriptions]: #type.descriptions
 [type.descriptions.general]: #type.descriptions.general
@@ -1938,13 +1978,20 @@ unspecified state.
 [utility]: utilities.md#utility
 [utility.arg.requirements]: #utility.arg.requirements
 [utility.requirements]: #utility.requirements
 [utility.requirements.general]: #utility.requirements.general
 [value.error.codes]: #value.error.codes
 [zombie.names]: #zombie.names
-[^1]: See also ISO/IEC 9899:2018 section 7.6.
 [^2]: To save space, items that do not apply to a Clause are omitted.
     For example, if a Clause does not specify any requirements, there
     will be no “Requirements” subclause.
@@ -2013,11 +2060,12 @@ unspecified state.
 [^19]: This is the same as the C standard library.
 [^20]: The only reliable way to declare an object or function signature
     from the C standard library is by including the header that declares
-    it, notwithstanding the latitude granted in 7.1.4 of the C Standard.
 [^21]: Any library code that instantiates other library templates must
     be prepared to work adequately with any user-supplied specialization
     that meets the minimum requirements of this document.
@@ -2036,12 +2084,12 @@ unspecified state.
 [^25]: A valid C++ program always calls the expected library non-member
     function. An implementation can also define additional non-member
     functions that would otherwise not be called by a valid C++ program.
-[^26]: That is, the C library functions can all be treated as if they
-    are marked `noexcept`. This allows implementations to make
     performance optimizations based on the absence of exceptions at
     runtime.
 [^27]: The functions `qsort()` and `bsearch()` [[alg.c.library]] meet
     this condition.

 ## Library-wide requirements <a id="requirements">[[requirements]]</a>
 ### General <a id="requirements.general">[[requirements.general]]</a>
 Subclause [[requirements]] specifies requirements that apply to the
+entire C++ standard library. [[support]] through [[exec]] and [[depr]]
 specify the requirements of individual entities within the library.
 Requirements specified in terms of interactions between threads do not
 apply to programs having only a single thread of execution.
 It is unspecified whether names declared in a specific namespace are
 declared directly in that namespace or in an inline namespace inside
 that namespace.[^13]
+Whenever an unqualified name other than `swap`, `make_error_code`,
+`make_error_condition`, `from_stream`, or `submdspan_mapping` is used in
+the specification of a declaration `D` in [[support]] through [[exec]]
+or [[depr]], its meaning is established as-if by performing unqualified
+name lookup [[basic.lookup.unqual]] in the context of `D`.
 [*Note 1*: Argument-dependent lookup is not performed. — *end note*]
 Similarly, the meaning of a *qualified-id* is established as-if by
 performing qualified name lookup [[basic.lookup.qual]] in the context of
 [*Note 2*: Operators in expressions [[over.match.oper]] are not so
 constrained; see [[global.functions]]. — *end note*]
 The meaning of the unqualified name `swap` is established in an overload
 resolution context for swappable values [[swappable.requirements]]. The
+meanings of the unqualified names `make_error_code`,
+`make_error_condition`, `from_stream`, and `submdspan_mapping` are
+established as-if by performing argument-dependent lookup
+[[basic.lookup.argdep]].
 #### Headers <a id="headers">[[headers]]</a>
 Each element of the C++ standard library is declared or defined (as
 appropriate) in a *header*.[^14]
 std::vector<int> vi;            // OK
 ```
 — *end example*]
+Except as noted in [[library]] through [[exec]] and [[depr]], the
 contents of each header `cname` is the same as that of the corresponding
 header `name.h` as specified in the C standard library [[intro.refs]].
 In the C++ standard library, however, the declarations (except for names
 which are defined as macros in C) are within namespace scope
 [[basic.scope.namespace]] of the namespace `std`. It is unspecified
 whether these names (including any overloads added in [[support]]
+through [[exec]] and [[depr]]) are first declared within the global
 namespace scope and are then injected into namespace `std` by explicit
 *using-declaration*s [[namespace.udecl]].
 Names which are defined as macros in C shall be defined as macros in the
 C++ standard library, even if C grants license for implementation as
 in the C++ standard library.[^16]
 Identifiers that are keywords or operators in C++ shall not be defined
 as macros in C++ standard library headers.[^17]
+Subclause [[support.c.headers]] describes the effects of using the
+`name.h` (C header) form in a C++ program.[^18]
+ISO/IEC 9899:2018 (C), Annex K describes a large number of functions,
+with associated types and macros, which “promote safer, more secure
 programming” than many of the traditional C library functions. The names
 of the functions have a suffix of `_s`; most of them provide the same
 service as the C library function with the unsuffixed name, but
 generally take an additional argument whose value is the size of the
 result array. If any C++ header is included, it is
 for C library facilities ([[headers.cpp.c]]). It additionally exports
 declarations in the global namespace for the storage allocation and
 deallocation functions that are provided by `<new>`.
 The named module `std.compat` exports the same declarations as the named
+module `std`, and additionally exports
+- declarations in the global namespace corresponding to the declarations
+  in namespace `std` that are provided by the C++ headers for C library
+  facilities ([[headers.cpp.c]]), except the explicitly excluded
+  declarations described in [[support.c.headers.other]] and
+- declarations provided by the headers `<stdbit.h>` and `<stdckdint.h>`.
 It is unspecified to which module a declaration in the standard library
 is attached.
+[*Note 1*: Conforming implementations ensure that mixing `#include` and
+`import` does not result in conflicting attachments
 [[basic.link]]. — *end note*]
 *Recommended practice:* Implementations should ensure such attachments
 do not preclude further evolution or decomposition of the standard
 library modules.
 [[headers.cpp.fs]].
 **Table: C++ headers for freestanding implementations** <a id="headers.cpp.fs">[headers.cpp.fs]</a>
 | Subclause             |                                                 | Header                               |
+| --------------------- | ----------------------------------------------- | ------------------------------------ |
 | [[support.types]]     | Common definitions                              | `<cstddef>`                          |
+| [[cstdlib.syn]] | C standard library                              | `<cstdlib>` |
+| [[support.limits]]    | Implementation properties                       | `<cfloat>`, `<climits>`, `<limits>`, |
+|                       |                                                 | `<version>`                          |
 | [[cstdint.syn]]       | Integer types                                   | `<cstdint>`                          |
 | [[support.dynamic]]   | Dynamic memory management                       | `<new>`                              |
 | [[support.rtti]]      | Type identification                             | `<typeinfo>`                         |
 | [[support.srcloc]]    | Source location                                 | `<source_location>`                  |
 | [[support.exception]] | Exception handling                              | `<exception>`                        |
 | [[support.initlist]]  | Initializer lists                               | `<initializer_list>`                 |
 | [[cmp]]               | Comparisons                                     | `<compare>`                          |
+| [[support.contract]]  | Contract-violation handling                     | `<contracts>`                        |
 | [[support.coroutine]] | Coroutines support                              | `<coroutine>`                        |
 | [[support.runtime]]   | Other runtime support                           | `<cstdarg>`                          |
 | [[concepts]]          | Concepts library                                | `<concepts>`                         |
+| [[errno]]             | Error numbers                                   | `<cerrno>`                           |
+| [[syserr]]            | System error support                            | `<system_error>`                     |
+| [[debugging]]         | Debugging                                       | `<debugging>`                        |
+| [[memory]]            | Memory                                          | `<memory>`                           |
 | [[type.traits]]       | Type traits                                     | `<type_traits>`                      |
+| [[ratio]] | Compile-time rational arithmetic                | `<ratio>` |
 | [[utility]]           | Utility components                              | `<utility>`                          |
 | [[tuple]]             | Tuples                                          | `<tuple>`                            |
+| [[optional]] | Optional objects                                | `<optional>` |
+| [[variant]]           | Variants                                        | `<variant>`                          |
+| [[expected]]          | Expected objects                                | `<expected>`                         |
 | [[function.objects]]  | Function objects                                | `<functional>`                       |
+| [[bit]] | Bit manipulation                                | `<bit>` |
+| [[stdbit.h.syn]]      | C-compatible bit manipulation                   | `<stdbit.h>`                         |
+| [[array]]             | Class template `array`                          | `<array>`                            |
+| [[inplace.vector]]    | Class template `inplace_vector`                 | `<inplace_vector>`                   |
+| [[views.contiguous]]  | Contiguous access                               | `<span>`                             |
+| [[views.multidim]]    | Multidimensional access                         | `<mdspan>`                           |
 | [[iterators]]         | Iterators library                               | `<iterator>`                         |
 | [[ranges]]            | Ranges library                                  | `<ranges>`                           |
+| [[algorithms]]        | Algorithms library                              | `<algorithm>`, `<numeric>`           |
+| [[execpol]]           | Execution policies                              | `<execution>`                        |
+| [[string.view]]       | String view classes                             | `<string_view>`                      |
+| [[string.classes]]    | String classes                                  | `<string>`                           |
+| [[c.strings]]         | Null-terminated sequence utilities              | `<cstring>`, `<cwchar>`              |
+| [[charconv]]          | Primitive numeric conversions                   | `<charconv>`                         |
+| [[rand]]              | Random number generation                        | `<random>`                           |
+| [[c.math]]            | Mathematical functions for floating-point types | `<cmath>`                            |
+| [[atomics]]           | Atomics                                         | `<atomic>`                           |
 For each of the headers listed in [[headers.cpp.fs]], a freestanding
 implementation provides at least the freestanding items
 [[freestanding.item]] declared in the header.
+The *hosted library facilities* are the set of facilities described in
+this document that are required for hosted implementations, but not
+required for freestanding implementations. A freestanding implementation
+provides a (possibly empty) implementation-defined subset of the hosted
+library facilities. Unless otherwise specified, the requirements on each
+declaration, entity, and macro provided in this way are the same as the
+corresponding requirements for a hosted implementation, except that not
+all of the members of the namespaces are required to be present.
+A freestanding implementation provides deleted definitions
+[[dcl.fct.def.delete]] for a (possibly empty) implementation-defined
+subset of the namespace-scope functions and function templates from the
+hosted library facilities.
+[*Note 1*: An implementation can provide a deleted definition so that
+the result of overload resolution does not silently change when
+migrating a program from a freestanding implementation to a hosted
+implementation. — *end note*]
 ### Using the library <a id="using">[[using]]</a>
 #### Overview <a id="using.overview">[[using.overview]]</a>
 Subclause [[using]] describes how a C++ program gains access to the
 **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:
 if it adds declarations or definitions to namespace `std` or to a
 namespace within namespace `std`.
 Unless explicitly prohibited, a program may add a template
 specialization for any standard library class template to namespace
+`std` provided that
+- the added declaration depends on at least one program-defined type,
+  and
+- the specialization meets the standard library requirements for the
+  original template.[^21]
 The behavior of a C++ program is undefined if it declares an explicit or
 partial specialization of any standard library variable template, except
 where explicitly permitted by the specification of that variable
 template.
 - an explicit or partial specialization of any member class template of
   a standard library class or class template, or
 - a deduction guide for any standard library class template.
 A program may explicitly instantiate a class template defined in the
+standard library only if the declaration
+- depends on the name of at least one program-defined type, and
+- the instantiation meets the standard library requirements for the
+  original template.
 Let `F` denote a standard library function [[global.functions]], a
 standard library static member function, or an instantiation of a
 standard library function template. Unless `F` is designated an
 *addressable function*, the behavior of a C++ program is unspecified
 ill-formed) if it attempts to form a reference to `F` or if it attempts
 to form a pointer-to-member designating either a standard library
 non-static member function [[member.functions]] or an instantiation of a
 standard library member function template.
+Let `F` denote a standard library function or function template. Unless
+`F` is designated an addressable function, it is unspecified if or how a
+reflection value designating the associated entity can be formed.
+[*Note 3*: For example, it is possible that `std::meta::members_of`
+will not return reflections of standard library functions that an
+implementation handles through an extra-linguistic
+mechanism. — *end note*]
+Let `C` denote a standard library class or class template
+specialization. It is unspecified if or how a reflection value can be
+formed to any private member of `C`, or what the names of such members
+may be.
 A translation unit shall not declare namespace `std` to be an inline
 namespace [[namespace.def]].
 ##### Namespace `posix` <a id="namespace.posix">[[namespace.posix]]</a>
 The behavior of a C++ program is undefined if it adds declarations or
 definitions to namespace `posix` or to a namespace within namespace
 `posix` unless otherwise specified. The namespace `posix` is reserved
+for use by \IsoPosixUndated and other POSIX standards.
 ##### Namespaces for future standardization <a id="namespace.future">[[namespace.future]]</a>
 Top-level namespaces whose *namespace-name* consists of `std` followed
 by one or more *digit*s [[lex.name]] are reserved for future
 reserved, other than as explicitly allowed by [[library]], its behavior
 is undefined.
 ##### Zombie names <a id="zombie.names">[[zombie.names]]</a>
+In namespace `std`, the names shown in [[zombie.names.std]] are reserved
+for previous standardization:
+The names shown in [[zombie.names.objmacro]] are reserved as members for
+previous standardization, and may not be used as a name for object-like
+macros in portable code:
+The names shown in [[zombie.names.fnmacro]] are reserved as member
+functions for previous standardization, and may not be used as a name
+for function-like macros in portable code:
+The header names shown in [[zombie.names.header]] are reserved for
+previous standardization:
 ##### Macro names <a id="macro.names">[[macro.names]]</a>
 A translation unit that includes a standard library header shall not
 `#define` or `#undef` names declared in any standard library header.
 ##### External linkage <a id="extern.names">[[extern.names]]</a>
 Each name declared as an object with external linkage in a header is
 reserved to the implementation to designate that library object with
 external linkage, [^22]
 standard library may be overridden in a derived class defined in the
 program [[class.virtual]].
 #### Replacement functions <a id="replacement.functions">[[replacement.functions]]</a>
+If a function defined in [[support]] through [[exec]] and [[depr]] is
+specified as replaceable [[term.replaceable.function]], the description
+of function semantics apply to both the default version defined by the
+C++ standard library and the replacement function defined by the
+program.
 #### Handler functions <a id="handler.functions">[[handler.functions]]</a>
 The C++ standard library provides a default version of the following
 handler function [[support]]:
 calling the following functions:
 - `get_new_handler`
 - `get_terminate`
+Calling the `set_*` and `get_*` functions shall not incur a data race
+[[intro.races]]. A call to any of the `set_*` functions synchronizes
+with subsequent calls to the same `set_*` function and to the
+corresponding `get_*` function.
 #### Other functions <a id="res.on.functions">[[res.on.functions]]</a>
 In certain cases (replacement functions, handler functions, operations
 on types used to instantiate standard library template components), the
 these components do not meet their requirements, this document places no
 requirements on the implementation.
 In particular, the behavior is undefined in the following cases:
+- For replacement functions [[replacement.functions]], if the installed
+ replacement function does not implement the semantics of the
+ applicable *Required behavior:* paragraph.
 - For handler functions [[new.handler]], [[terminate.handler]], if the
   installed handler function does not implement the semantics of the
   applicable *Required behavior:* paragraph.
 - For types used as template arguments when instantiating a template
   component, if the operations on the type do not implement the
   address computations and accesses to objects (that would be valid if
   the pointer did point to the first element of such an array) are in
   fact valid.
 - If a function argument is bound to an rvalue reference parameter, the
   implementation may assume that this parameter is a unique reference to
+  this argument, except that the argument passed to a move assignment
   operator may be a reference to `*this` [[lib.types.movedfrom]].
   \[*Note 1*: If the type of a parameter is a forwarding reference
   [[temp.deduct.call]] that is deduced to an lvalue reference type, then
   the argument is not bound to an rvalue reference. — *end note*]
   \[*Note 2*: If a program casts an lvalue to an xvalue while passing
 #### Overview <a id="conforming.overview">[[conforming.overview]]</a>
 Subclause [[conforming]] describes the constraints upon, and latitude
 of, implementations of the C++ standard library.
+An implementation’s use of
+- headers is discussed in  [[res.on.headers]],
+- macros in  [[res.on.macro.definitions]],
+- non-member functions in  [[global.functions]],
+- member functions in  [[member.functions]],
+- data race avoidance in  [[res.on.data.races]],
+- access specifiers in  [[protection.within.classes]],
+- class derivation in  [[derivation]],
+- exceptions in  [[res.on.exception.handling]], and
+- contract assertions in  [[res.contract.assertions]].
 #### Headers <a id="res.on.headers">[[res.on.headers]]</a>
 A C++ header may include other C++ headers. A C++ header shall provide
 the declarations and definitions that appear in its synopsis. A C++
 It is unspecified whether any non-member functions in the C++ standard
 library are defined as inline [[dcl.inline]].
 A call to a non-member function signature described in [[support]]
+through [[exec]] and [[depr]] shall behave as if the implementation
 declared no additional non-member function signatures.[^25]
 An implementation shall not declare a non-member function signature with
 additional default arguments.
 Whenever this document specifies a friend declaration of a function or
 function template within a class or class template definition, that
 declaration shall be the only declaration of that function or function
 template provided by an implementation.
+[*Note 1*: In particular, a conforming implementation does not provide
+any additional declarations of that function or function template at
 namespace scope. — *end note*]
 [*Note 2*: Such a friend function or function template declaration is
 known as a hidden friend, as it is visible neither to ordinary
 unqualified lookup [[basic.lookup.unqual]] nor to qualified lookup
 This document explicitly requires that certain standard library
 functions are `constexpr` [[dcl.constexpr]]. An implementation shall not
 declare any standard library function signature as `constexpr` except
 for those where it is explicitly required. Within any header that
+provides any non-defining declarations of constexpr functions an
+implementation shall provide corresponding definitions.
 #### Requirements for stable algorithms <a id="algorithm.stable">[[algorithm.stable]]</a>
 When the requirements for an algorithm state that it is “stable” without
 further elaboration, it means:
 effects that are visible [[intro.multithread]] to users.
 [*Note 3*: This allows implementations to parallelize operations if
 there are no visible side effects. — *end note*]
+#### Properties of library classes <a id="library.class.props">[[library.class.props]]</a>
+Unless explicitly stated otherwise, it is unspecified whether any class
+described in [[support]] through [[exec]] and [[depr]] is a trivially
+copyable class, a standard-layout class, or an implicit-lifetime class
+[[class.prop]].
+Unless explicitly stated otherwise, it is unspecified whether any class
+for which trivial relocation (i.e., the effects of `trivially_relocate`
+[[obj.lifetime]]) would be semantically equivalent to move-construction
+of the destination object followed by destruction of the source object
+is a trivially relocatable class [[class.prop]].
+Unless explicitly stated otherwise, it is unspecified whether a class
+`C` is a replaceable class [[class.prop]] if assigning an xvalue `a` of
+type `C` to an object `b` of type `C` is semantically equivalent to
+destroying `b` and then constructing from `a` in `b`’s place.
 #### Protection within classes <a id="protection.within.classes">[[protection.within.classes]]</a>
 It is unspecified whether any function signature or class described in
+[[support]] through [[exec]] and [[depr]] is a friend of another class
 in the C++ standard library.
 #### Derived classes <a id="derivation">[[derivation]]</a>
 An implementation may derive any class in the C++ standard library from
 #### Restrictions on exception handling <a id="res.on.exception.handling">[[res.on.exception.handling]]</a>
 Any of the functions defined in the C++ standard library can report a
 failure by throwing an exception of a type described in its *Throws:*
 paragraph, or of a type derived from a type named in the *Throws:*
+paragraph that would be caught by a *handler* [[except.handle]] for the
+base type.
 Functions from the C standard library shall not throw exceptions [^26]
 except when such a function calls a program-supplied function that
 throws an exception.[^27]
 Destructor operations defined in the C++ standard library shall not
 throw exceptions. Every destructor in the C++ standard library shall
+behave as if it had a non-throwing exception specification
+[[except.spec]].
 Functions defined in the C++ standard library that do not have a
 *Throws:* paragraph but do have a potentially-throwing exception
 specification may throw *implementation-defined* exceptions.[^28]
 [[bad.alloc]], [[support.exception]], [[std.exceptions]].
 An implementation may strengthen the exception specification for a
 non-virtual function by adding a non-throwing exception specification.
+#### Contract assertions <a id="res.contract.assertions">[[res.contract.assertions]]</a>
+Unless specified otherwise, an implementation may check the specified
+preconditions and postconditions of a function in the C++ standard
+library using contract assertions
+[[basic.contract]], [[structure.specifications]].
 #### Value of error codes <a id="value.error.codes">[[value.error.codes]]</a>
 Certain functions in the C++ standard library report errors via a
+`error_code` [[syserr.errcode.overview]] object. That object’s
+`category()` member shall return `system_category()` for errors
 originating from the operating system, or a reference to an
 *implementation-defined* `error_category` object for errors originating
 elsewhere. The implementation shall define the possible values of
 `value()` for each of these error categories.
 #### Moved-from state of library types <a id="lib.types.movedfrom">[[lib.types.movedfrom]]</a>
 Objects of types defined in the C++ standard library may be moved from
 [[class.copy.ctor]]. Move operations may be explicitly specified or
 implicitly generated. Unless otherwise specified, such moved-from
+objects shall be placed in a valid but unspecified state
+[[defns.valid]].
 An object of a type defined in the C++ standard library may be
 move-assigned [[class.copy.assign]] to itself. Unless otherwise
 specified, such an assignment places the object in a valid but
 unspecified state.
 <!-- Link reference definitions -->
 [alg.c.library]: algorithms.md#alg.c.library
+[alg.func.obj]: #alg.func.obj
 [alg.sorting]: algorithms.md#alg.sorting
 [algorithm.stable]: #algorithm.stable
 [algorithms]: algorithms.md#algorithms
 [algorithms.requirements]: algorithms.md#algorithms.requirements
 [alloc.errors]: support.md#alloc.errors
 [allocator.requirements]: #allocator.requirements
 [allocator.requirements.completeness]: #allocator.requirements.completeness
 [allocator.requirements.general]: #allocator.requirements.general
 [allocator.traits]: mem.md#allocator.traits
 [alt.headers]: #alt.headers
+[array]: containers.md#array
 [array.creation]: containers.md#array.creation
 [atomics]: thread.md#atomics
 [bad.alloc]: support.md#bad.alloc
+[basic.contract]: basic.md#basic.contract
+[basic.contract.eval]: basic.md#basic.contract.eval
 [basic.def.odr]: basic.md#basic.def.odr
 [basic.fundamental]: basic.md#basic.fundamental
+[basic.indet]: basic.md#basic.indet
 [basic.life]: basic.md#basic.life
 [basic.link]: basic.md#basic.link
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lookup.qual]: basic.md#basic.lookup.qual
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.scope.namespace]: basic.md#basic.scope.namespace
 [basic.stc.dynamic]: basic.md#basic.stc.dynamic
 [bit]: utilities.md#bit
 [bitmask.types]: #bitmask.types
 [byte.strings]: #byte.strings
 [c.annex.k.names]: #c.annex.k.names
+[c.math]: numerics.md#c.math
+[c.strings]: strings.md#c.strings
 [cassert.syn]: diagnostics.md#cassert.syn
 [cerrno.syn]: diagnostics.md#cerrno.syn
 [character.seq]: #character.seq
 [character.seq.general]: #character.seq.general
+[charconv]: text.md#charconv
 [class.copy.assign]: class.md#class.copy.assign
 [class.copy.ctor]: class.md#class.copy.ctor
 [class.dtor]: class.md#class.dtor
 [class.mem]: class.md#class.mem
+[class.prop]: class.md#class.prop
 [class.virtual]: class.md#class.virtual
+[clocale.syn]: text.md#clocale.syn
 [cmp]: support.md#cmp
 [compliance]: #compliance
 [concept.destructible]: concepts.md#concept.destructible
 [concept.invocable]: concepts.md#concept.invocable
 [concept.totallyordered]: concepts.md#concept.totallyordered
 [conv]: expr.md#conv
 [conv.func]: expr.md#conv.func
 [conventions]: #conventions
 [conventions.general]: #conventions.general
 [cpp.include]: cpp.md#cpp.include
 [cpp17.copyassignable]: #cpp17.copyassignable
 [cpp17.copyconstructible]: #cpp17.copyconstructible
 [cpp17.destructible]: #cpp17.destructible
 [cpp17.hash]: #cpp17.hash
 [cpp17.moveassignable]: #cpp17.moveassignable
 [cpp17.nullablepointer]: #cpp17.nullablepointer
 [cstdarg.syn]: support.md#cstdarg.syn
 [cstddef.syn]: support.md#cstddef.syn
 [cstdint.syn]: support.md#cstdint.syn
+[cstdlib.syn]: support.md#cstdlib.syn
 [customization.point.object]: #customization.point.object
 [dcl.array]: dcl.md#dcl.array
 [dcl.constexpr]: dcl.md#dcl.constexpr
+[dcl.contract.func]: dcl.md#dcl.contract.func
+[dcl.fct.def.delete]: dcl.md#dcl.fct.def.delete
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init]: dcl.md#dcl.init
 [dcl.inline]: dcl.md#dcl.inline
 [dcl.link]: dcl.md#dcl.link
 [dcl.pre]: dcl.md#dcl.pre
 [dcl.typedef]: dcl.md#dcl.typedef
+[debugging]: diagnostics.md#debugging
+[defns.const.subexpr]: intro.md#defns.const.subexpr
 [defns.nonconst.libcall]: intro.md#defns.nonconst.libcall
+[defns.valid]: intro.md#defns.valid
 [depr]: future.md#depr
 [derivation]: #derivation
 [derived.classes]: #derived.classes
 [description]: #description
 [description.general]: #description.general
 [diagnostics]: diagnostics.md#diagnostics
 [enumerated.types]: #enumerated.types
+[errno]: diagnostics.md#errno
 [except]: except.md#except
+[except.handle]: except.md#except.handle
+[except.spec]: except.md#except.spec
+[exec]: exec.md#exec
+[execpol]: algorithms.md#execpol
+[expected]: utilities.md#expected
 [expos.only.entity]: #expos.only.entity
+[expr.call]: expr.md#expr.call
 [expr.delete]: expr.md#expr.delete
 [expr.new]: expr.md#expr.new
 [expr.unary.op]: expr.md#expr.unary.op
 [extern.names]: #extern.names
 [extern.types]: #extern.types
 [headers]: #headers
 [headers.cpp]: #headers.cpp
 [headers.cpp.c]: #headers.cpp.c
 [headers.cpp.fs]: #headers.cpp.fs
 [hidden.friends]: #hidden.friends
+[inplace.vector]: containers.md#inplace.vector
 [input.output]: input.md#input.output
 [intro.compliance]: intro.md#intro.compliance
 [intro.multithread]: basic.md#intro.multithread
+[intro.races]: basic.md#intro.races
 [intro.refs]: intro.md#intro.refs
 [iterator.requirements]: iterators.md#iterator.requirements
 [iterators]: iterators.md#iterators
 [lex.charset]: lex.md#lex.charset
 [lex.name]: lex.md#lex.name
 [lex.phases]: lex.md#lex.phases
 [lex.separate]: lex.md#lex.separate
 [lib.types.movedfrom]: #lib.types.movedfrom
 [library]: #library
 [library.c]: #library.c
 [library.categories]: #library.categories
+[library.class.props]: #library.class.props
 [library.general]: #library.general
+[locales]: text.md#locales
 [macro.names]: #macro.names
 [mem]: mem.md#mem
 [member.functions]: #member.functions
 [memory]: mem.md#memory
 [meta]: meta.md#meta
 [namespace.def]: dcl.md#namespace.def
 [namespace.future]: #namespace.future
 [namespace.posix]: #namespace.posix
 [namespace.std]: #namespace.std
 [namespace.udecl]: dcl.md#namespace.udecl
 [new.handler]: support.md#new.handler
 [nullablepointer.requirements]: #nullablepointer.requirements
 [numeric.requirements]: numerics.md#numeric.requirements
 [numerics]: numerics.md#numerics
+[obj.lifetime]: mem.md#obj.lifetime
 [objects.within.classes]: #objects.within.classes
+[optional]: utilities.md#optional
 [organization]: #organization
 [organization.general]: #organization.general
 [ostream.iterator.ops]: iterators.md#ostream.iterator.ops
 [over.literal]: over.md#over.literal
 [over.match]: over.md#over.match
 [over.match.oper]: over.md#over.match.oper
 [protection.within.classes]: #protection.within.classes
+[rand]: numerics.md#rand
 [random.access.iterators]: iterators.md#random.access.iterators
 [ranges]: ranges.md#ranges
 [ratio]: meta.md#ratio
+[re]: text.md#re
 [reentrancy]: #reentrancy
 [replacement.functions]: #replacement.functions
 [requirements]: #requirements
 [requirements.general]: #requirements.general
+[res.contract.assertions]: #res.contract.assertions
 [res.on.arguments]: #res.on.arguments
 [res.on.data.races]: #res.on.data.races
 [res.on.exception.handling]: #res.on.exception.handling
 [res.on.functions]: #res.on.functions
 [res.on.headers]: #res.on.headers
 [reserved.names]: #reserved.names
 [reserved.names.general]: #reserved.names.general
 [specialized.addressof]: mem.md#specialized.addressof
 [std.exceptions]: diagnostics.md#std.exceptions
 [std.modules]: #std.modules
+[stdbit.h.syn]: utilities.md#stdbit.h.syn
 [stmt.return]: stmt.md#stmt.return
 [stream.types]: input.md#stream.types
+[string.classes]: strings.md#string.classes
+[string.view]: strings.md#string.view
 [strings]: strings.md#strings
 [structure]: #structure
 [structure.elements]: #structure.elements
 [structure.requirements]: #structure.requirements
 [structure.see.also]: #structure.see.also
 [structure.specifications]: #structure.specifications
 [structure.summary]: #structure.summary
 [support]: support.md#support
 [support.c.headers]: support.md#support.c.headers
 [support.c.headers.other]: support.md#support.c.headers.other
+[support.contract]: support.md#support.contract
 [support.coroutine]: support.md#support.coroutine
 [support.dynamic]: support.md#support.dynamic
 [support.exception]: support.md#support.exception
 [support.initlist]: support.md#support.initlist
 [support.limits]: support.md#support.limits
 [support.rtti]: support.md#support.rtti
 [support.runtime]: support.md#support.runtime
 [support.srcloc]: support.md#support.srcloc
 [support.types]: support.md#support.types
 [swappable.requirements]: #swappable.requirements
 [syserr]: diagnostics.md#syserr
 [syserr.errcode.overview]: diagnostics.md#syserr.errcode.overview
 [tab:cpp17.destructible]: #tab:cpp17.destructible
 [temp.constr.decl]: temp.md#temp.constr.decl
 [temp.deduct.call]: temp.md#temp.deduct.call
 [template.bitset]: utilities.md#template.bitset
 [term.incomplete.type]: basic.md#term.incomplete.type
 [term.object.type]: basic.md#term.object.type
+[term.replaceable.function]: dcl.md#term.replaceable.function
 [terminate.handler]: support.md#terminate.handler
+[text]: text.md#text
 [thread]: thread.md#thread
 [time]: time.md#time
 [tuple]: utilities.md#tuple
 [type.descriptions]: #type.descriptions
 [type.descriptions.general]: #type.descriptions.general
 [utility]: utilities.md#utility
 [utility.arg.requirements]: #utility.arg.requirements
 [utility.requirements]: #utility.requirements
 [utility.requirements.general]: #utility.requirements.general
 [value.error.codes]: #value.error.codes
+[variant]: utilities.md#variant
+[views.contiguous]: containers.md#views.contiguous
+[views.multidim]: containers.md#views.multidim
 [zombie.names]: #zombie.names
+[zombie.names.fnmacro]: #zombie.names.fnmacro
+[zombie.names.header]: #zombie.names.header
+[zombie.names.objmacro]: #zombie.names.objmacro
+[zombie.names.std]: #zombie.names.std
+[^1]: See also ISO/IEC 9899:2018 (C), 7.6.
 [^2]: To save space, items that do not apply to a Clause are omitted.
     For example, if a Clause does not specify any requirements, there
     will be no “Requirements” subclause.
 [^19]: This is the same as the C standard library.
 [^20]: The only reliable way to declare an object or function signature
     from the C standard library is by including the header that declares
+    it, notwithstanding the latitude granted in ISO/IEC 9899:2018 (C),
+    7.1.4.
 [^21]: Any library code that instantiates other library templates must
     be prepared to work adequately with any user-supplied specialization
     that meets the minimum requirements of this document.
 [^25]: A valid C++ program always calls the expected library non-member
     function. An implementation can also define additional non-member
     functions that would otherwise not be called by a valid C++ program.
+[^26]: That is, the C standard library functions can all be treated as
+ if they are marked `noexcept`. This allows implementations to make
     performance optimizations based on the absence of exceptions at
     runtime.
 [^27]: The functions `qsort()` and `bsearch()` [[alg.c.library]] meet
     this condition.

Diff to HTML by rtfpessoa