[library] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp4kkflxbp/{from.md → to.md} +464 -290

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

@@ -6,17 +6,16 @@ This Clause describes the contents of the *C++ standard library*, how a
 well-formed C++ program makes use of the library, and how a conforming
 implementation may provide the entities in the library.
 The following subclauses describe the method of description
 [[description]] and organization [[organization]] of the library.
-[[requirements]], [[support]] through [[thread]], and [[depr]] specify
-the contents of the library, as well as library requirements and
-constraints on both well-formed C++ programs and conforming
-implementations.
 Detailed specifications for each of the components in the library are in
-[[support]]– [[thread]], as shown in [[library.categories]].
 **Table: Library categories** <a id="library.categories">[library.categories]</a>
 | Clause           | Category                    |
 | ---------------- | --------------------------- |
@@ -24,23 +23,26 @@ Detailed specifications for each of the components in the library are in
 | [[concepts]]     | Concepts library            |
 | [[diagnostics]]  | Diagnostics library         |
 | [[mem]]          | Memory management library   |
 | [[meta]]         | Metaprogramming library     |
 | [[utilities]]    | General utilities library   |
-| [[strings]]      | Strings library             |
 | [[containers]]   | Containers library          |
 | [[iterators]]    | Iterators library           |
 | [[ranges]]       | Ranges library              |
 | [[algorithms]]   | Algorithms library          |
 | [[numerics]]     | Numerics library            |
 | [[time]]         | Time library                |
-| [[localization]] | Localization library        |
 | [[input.output]] | Input/output library        |
-| [[re]]           | Regular expressions library |
 | [[thread]]       | Concurrency support library |
 The language support library [[support]] provides components that are
 required by certain parts of the C++ language, such as memory allocation
 [[expr.new]], [[expr.delete]] and exception processing [[except]].
 The concepts library [[concepts]] describes library components that C++
@@ -61,69 +63,70 @@ sequences, and rational arithmetic.
 The general utilities library [[utilities]] includes components used by
 other library elements, such as a predefined storage allocator for
 dynamic storage management [[basic.stc.dynamic]], and components used as
 infrastructure in C++ programs, such as tuples and function wrappers.
-The strings library [[strings]] provides support for manipulating text
-represented as sequences of type `char`, sequences of type `char8_t`,
-sequences of type `char16_t`, sequences of type `char32_t`, sequences of
-type `wchar_t`, and sequences of any other character-like type.
 The containers [[containers]], iterators [[iterators]], ranges
 [[ranges]], and algorithms [[algorithms]] libraries provide a C++
 program with access to a subset of the most widely used algorithms and
 data structures.
 The numerics library [[numerics]] provides numeric algorithms and
 complex number components that extend support for numeric processing.
 The `valarray` component provides support for *n*-at-a-time processing,
 potentially implemented as parallel operations on platforms that support
 such processing. The random number component provides facilities for
 generating pseudo-random numbers.
 The time library [[time]] provides generally useful time utilities.
-The localization library [[localization]] provides extended
-internationalization support for text processing.
 The input/output library [[input.output]] provides the `iostream`
 components that are the primary mechanism for C++ program input and
 output. They can be used with other elements of the library,
 particularly strings, locales, and iterators.
-The regular expressions library [[re]] provides regular expression
-matching and searching.
 The concurrency support library [[thread]] provides components to create
 and manage threads, including atomic operations, mutual exclusion, and
 interthread communication.
 ## The C standard library <a id="library.c">[[library.c]]</a>
 The C++ standard library also makes available the facilities of the C
 standard library, suitably adjusted to ensure static type safety.
 The descriptions of many library functions rely on the C standard
 library for the semantics of those functions. In some cases, the
 signatures specified in this document may be different from the
 signatures in the C standard library, and additional overloads may be
 declared in this document, but the behavior and the preconditions
-(including any preconditions implied by the use of an ISO C `restrict`
 qualifier) are the same unless otherwise stated.
 A call to a C standard library function is a non-constant library call
 [[defns.nonconst.libcall]] if it raises a floating-point exception other
 than `FE_INEXACT`. The semantics of a call to a C standard library
 function evaluated as a core constant expression are those specified in
-Annex F of the C standard[^1]
 to the extent applicable to the floating-point types
 [[basic.fundamental]] that are parameter types of the called function.
-[*Note 1*: Annex F specifies the conditions under which floating-point
-exceptions are raised and the behavior when NaNs and/or infinities are
-passed as arguments. — *end note*]
 [*Note 2*: Equivalently, a call to a C standard library function is a
 non-constant library call if `errno` is set when
 `math_errhandling & MATH_ERRNO` is `true`. — *end note*]
@@ -131,11 +134,11 @@ non-constant library call if `errno` is set when
 ### General <a id="description.general">[[description.general]]</a>
 Subclause [[description]] describes the conventions used to specify the
 C++ standard library. [[structure]] describes the structure of
-[[support]] through [[thread]] and [[depr]]. [[conventions]] describes
 other editorial conventions.
 ### Structure of each clause <a id="structure">[[structure]]</a>
 #### Elements <a id="structure.elements">[[structure.elements]]</a>
@@ -253,54 +256,85 @@ appropriate):[^5]
   overload resolution [[over.match]]. \[*Note 1*: Failure to meet such a
   condition results in the function’s silent
   non-viability. — *end note*] \[*Example 1*: An implementation can
   express such a condition via a *constraint-expression*
   [[temp.constr.decl]]. — *end example*]
 - *Mandates:* the conditions that, if not met, render the program
   ill-formed. \[*Example 2*: An implementation can express such a
   condition via the *constant-expression* in a
   *static_assert-declaration* [[dcl.pre]]. If the diagnostic is to be
   emitted only after the function has been selected by overload
   resolution, an implementation can express such a condition via a
   *constraint-expression* [[temp.constr.decl]] and also define the
   function as deleted. — *end example*]
-- *Preconditions:* the conditions that the function assumes to hold
- whenever it is called; violation of any preconditions results in
- undefined behavior.
 - *Effects:* the actions performed by the function.
 - *Synchronization:* the synchronization operations
   [[intro.multithread]] applicable to the function.
 - *Ensures:* the conditions (sometimes termed observable results)
-  established by the function.
 - *Result:* for a *typename-specifier*, a description of the named type;
-  for an *expression*, a description of the type of the expression; the
-  expression is an lvalue if the type is an lvalue reference type, an
-  xvalue if the type is an rvalue reference type, and a prvalue
-  otherwise.
 - *Returns:* a description of the value(s) returned by the function.
 - *Throws:* any exceptions thrown by the function, and the conditions
   that would cause the exception.
 - *Complexity:* the time and/or space complexity of the function.
 - *Remarks:* additional semantic constraints on the function.
 - *Error conditions:* the error conditions for error codes reported by
   the function.
 Whenever the *Effects* element specifies that the semantics of some
 function `F` are *Equivalent to* some code sequence, then the various
 elements are interpreted as follows. If `F`’s semantics specifies any
 *Constraints* or *Mandates* elements, then those requirements are
 logically imposed prior to the *equivalent-to* semantics. Next, the
 semantics of the code sequence are determined by the *Constraints*,
-*Mandates*, *Preconditions*, *Effects*, *Synchronization*,
-*Postconditions*, *Returns*, *Throws*, *Complexity*, *Remarks*, and
-*Error conditions* specified for the function invocations contained in
-the code sequence. The value returned from `F` is specified by `F`’s
-*Returns* element, or if `F` has no *Returns* element, a non-`void`
-return from `F` is specified by the `return` statements [[stmt.return]]
-in the code sequence. If `F`’s semantics contains a *Throws*,
-*Postconditions*, or *Complexity* element, then that supersedes any
-occurrences of that element in the code sequence.
 For non-reserved replacement and handler functions, [[support]]
 specifies two behaviors for the functions in question: their required
 and default behavior. The *default behavior* describes a function
 definition provided by the implementation. The *required behavior*
@@ -334,27 +368,26 @@ to describe the contents of the C++ standard library. These conventions
 are for describing implementation-defined types [[type.descriptions]],
 and member functions [[functions.within.classes]].
 #### Exposition-only entities, etc. <a id="expos.only.entity">[[expos.only.entity]]</a>
-Several entities and *typedef-name*s defined in [[support]] through
-[[thread]] and [[depr]] are only defined for the purpose of exposition.
-The declaration of such an entity or *typedef-name* is followed by a
-comment ending in *exposition only*.
 The following are defined for exposition only to aid in the
 specification of the library:
 ``` cpp
 namespace std {
   template<class T>
     requires convertible_to<T, decay_t<T>>
-      constexpr decay_t<T> decay-copy(T&& v)
-        noexcept(is_nothrow_convertible_v<T, decay_t<T>>)       // exposition only
       { return std::forward<T>(v); }
-  constexpr auto synth-three-way =
     []<class T, class U>(const T& t, const U& u)
       requires requires {
         { t < u } -> boolean-testable;
         { u < t } -> boolean-testable;
       }
@@ -367,14 +400,24 @@ namespace std {
         return weak_ordering::equivalent;
       }
     };
   template<class T, class U = T>
-  using synth-three-way-result = decltype(synth-three-way(declval<T&>(), declval<U&>()));
 }
 ```
 #### Type descriptions <a id="type.descriptions">[[type.descriptions]]</a>
 ##### General <a id="type.descriptions.general">[[type.descriptions.general]]</a>
 The Requirements subclauses may describe names that are used to specify
@@ -409,11 +452,11 @@ inline const enumerated C₃(V₃);
 Here, the names `C₀`, `C₁`, etc. represent *enumerated elements* for
 this particular enumerated type. All such elements have distinct values.
 ##### Bitmask types <a id="bitmask.types">[[bitmask.types]]</a>
-Several types defined in [[support]] through [[thread]] and [[depr]] are
 *bitmask types*. Each bitmask type can be implemented as an enumerated
 type that overloads certain operators, as an integer type, or as a
 `bitset` [[template.bitset]].
 The bitmask type `bitmask` can be written:
@@ -495,20 +538,22 @@ sequences that follow a few uniform conventions:
   basic character set.
 - The *decimal-point character* is the locale-specific (single-byte)
   character used by functions that convert between a (single-byte)
   character sequence and a value of one of the floating-point types. It
   is used in the character sequence to denote the beginning of a
-  fractional part. It is represented in [[support]] through [[thread]]
- and [[depr]] by a period, `'.'`, which is also its value in the `"C"`
   locale.
 - A *character sequence* is an array object [[dcl.array]] `A` that can
   be declared as `T A[N]`, where `T` is any of the types `char`,
   `unsigned char`, or `signed char` [[basic.fundamental]], optionally
   qualified by any combination of `const` or `volatile`. The initial
   elements of the array have defined contents up to and including an
   element determined by some predicate. A character sequence can be
   designated by a pointer value `S` that points to its first element.
 ###### Byte strings <a id="byte.strings">[[byte.strings]]</a>
 A *null-terminated byte string*, or NTBS, is a character sequence whose
 highest-addressed element with defined content has the value zero (the
@@ -566,32 +611,64 @@ initialized as if by `auto p = o;`. Then for any sequence of arguments
 - `p(args...)`
 - `as_const(p)(args...)`
 - `std::move(p)(args...)`
 - `std::move(as_const(p))(args...)`
-Each customization point object type constrains its return type to model
-a particular concept.
 #### Functions within classes <a id="functions.within.classes">[[functions.within.classes]]</a>
-For the sake of exposition, [[support]] through [[thread]] and [[depr]]
-do not describe copy/move constructors, assignment operators, or
 (non-virtual) destructors with the same apparent semantics as those that
 can be generated by default
 [[class.copy.ctor]], [[class.copy.assign]], [[class.dtor]]. It is
 unspecified whether the implementation provides explicit definitions for
 such member function signatures, or for virtual destructors that can be
 generated by default.
 #### Private members <a id="objects.within.classes">[[objects.within.classes]]</a>
-[[support]] through [[thread]] and [[depr]] do not specify the
 representation of classes, and intentionally omit specification of class
 members [[class.mem]]. An implementation may define static or non-static
 class members, or both, as needed to implement the semantics of the
-member functions specified in [[support]] through [[thread]] and
-[[depr]].
 For the sake of exposition, some subclauses provide representative
 declarations, and semantic requirements, for private members of classes
 that meet the external specifications of the classes. The declarations
 for such members are followed by a comment that ends with *exposition
@@ -604,69 +681,118 @@ streambuf* sb;      // exposition only
 An implementation may use any technique that provides equivalent
 observable behavior.
 #### Freestanding items <a id="freestanding.item">[[freestanding.item]]</a>
-A *freestanding item* is a declaration, entity, *typedef-name*, or macro
-that is required to be present in a freestanding implementation and a
-hosted implementation.
 Unless otherwise specified, the requirements on freestanding items for a
 freestanding implementation 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.
-[*Note 1*: This implies that freestanding item enumerations have the
-same enumerators on freestanding implementations and hosted
-implementations. Furthermore, class types have the same members and
-class templates have the same deduction guides on freestanding
-implementations and hosted implementations. — *end note*]
-A declaration in a header synopsis is a freestanding item if
-- it is followed by a comment that includes *freestanding*, or
-- the header synopsis begins with a comment that includes *all
-  freestanding*.
-An entity or *typedef-name* is a freestanding item if it is:
 - introduced by a declaration that is a freestanding item,
 - an enclosing namespace of a freestanding item,
 - a friend of a freestanding item,
-- denoted by a *typedef-name* that is a freestanding item, or
 - denoted by an alias template that is a freestanding item.
 A macro is a freestanding item if it is defined in a header synopsis and
 - the definition is followed by a comment that includes *freestanding*,
   or
-- the header synopsis begins with a comment that includes *all
- freestanding*.
-[*Example 1*:
 ``` cpp
 #define NULL see below      // freestanding
 ```
 — *end example*]
-[*Example 2*:
 ``` cpp
-// all freestanding
-namespace std {
 ```
 — *end example*]
 ## 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.
@@ -698,15 +824,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
@@ -719,13 +845,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]
@@ -751,18 +878,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
@@ -776,15 +903,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
@@ -805,21 +932,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.
@@ -848,40 +977,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
@@ -1018,21 +1187,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`
@@ -1058,16 +1227,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:
@@ -1117,25 +1285,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`.
@@ -1162,11 +1332,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
@@ -1189,15 +1359,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`,
@@ -1293,11 +1463,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`.
@@ -1524,11 +1694,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`.
@@ -1693,10 +1863,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:
@@ -1726,13 +1915,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.
@@ -1750,13 +1942,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
@@ -1772,19 +1966,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
@@ -1808,89 +2016,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]
@@ -1938,56 +2086,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]]:
@@ -2008,14 +2115,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
@@ -2023,13 +2130,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
@@ -2057,11 +2164,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
@@ -2110,16 +2217,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++
@@ -2149,11 +2261,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.
@@ -2201,12 +2313,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
@@ -2216,12 +2328,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:
@@ -2286,14 +2398,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
@@ -2321,21 +2451,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]
@@ -2344,15 +2475,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.
@@ -2368,56 +2506,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
@@ -2435,40 +2582,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
@@ -2481,28 +2639,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
@@ -2512,32 +2671,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
@@ -2547,31 +2708,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
@@ -2581,11 +2745,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
@@ -2599,13 +2765,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.
@@ -2674,11 +2847,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.
@@ -2697,12 +2871,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.

 well-formed C++ program makes use of the library, and how a conforming
 implementation may provide the entities in the library.
 The following subclauses describe the method of description
 [[description]] and organization [[organization]] of the library.
+[[requirements]], [[support]] through [[exec]], and [[depr]] specify the
+contents of the library, as well as library requirements and constraints
+on both well-formed C++ programs and conforming implementations.
 Detailed specifications for each of the components in the library are in
+[[support]]– [[exec]], as shown in [[library.categories]].
 **Table: Library categories** <a id="library.categories">[library.categories]</a>
 | Clause           | Category                    |
 | ---------------- | --------------------------- |
 | [[concepts]]     | Concepts library            |
 | [[diagnostics]]  | Diagnostics library         |
 | [[mem]]          | Memory management library   |
 | [[meta]]         | Metaprogramming library     |
 | [[utilities]]    | General utilities library   |
 | [[containers]]   | Containers library          |
 | [[iterators]]    | Iterators library           |
 | [[ranges]]       | Ranges library              |
 | [[algorithms]]   | Algorithms library          |
+| [[strings]]      | Strings library             |
+| [[text]]         | Text processing library     |
 | [[numerics]]     | Numerics library            |
 | [[time]]         | Time library                |
 | [[input.output]] | Input/output library        |
 | [[thread]]       | Concurrency support library |
+| [[exec]]         | Execution control library   |
+The operating system interface described in IEEE 1003.1-2017 (POSIX) is
+hereinafter called *POSIX*.
 The language support library [[support]] provides components that are
 required by certain parts of the C++ language, such as memory allocation
 [[expr.new]], [[expr.delete]] and exception processing [[except]].
 The concepts library [[concepts]] describes library components that C++
 The general utilities library [[utilities]] includes components used by
 other library elements, such as a predefined storage allocator for
 dynamic storage management [[basic.stc.dynamic]], and components used as
 infrastructure in C++ programs, such as tuples and function wrappers.
 The containers [[containers]], iterators [[iterators]], ranges
 [[ranges]], and algorithms [[algorithms]] libraries provide a C++
 program with access to a subset of the most widely used algorithms and
 data structures.
+The strings library [[strings]] provides support for manipulating
+sequences of type `char`, sequences of type `char8_t`, sequences of type
+`char16_t`, sequences of type `char32_t`, sequences of type `wchar_t`,
+and sequences of any other character-like type.
+The text processing library [[text]] provides support for text
+processing, including formatting, internationalization support and
+regular expression matching and searching.
 The numerics library [[numerics]] provides numeric algorithms and
 complex number components that extend support for numeric processing.
 The `valarray` component provides support for *n*-at-a-time processing,
 potentially implemented as parallel operations on platforms that support
 such processing. The random number component provides facilities for
 generating pseudo-random numbers.
 The time library [[time]] provides generally useful time utilities.
 The input/output library [[input.output]] provides the `iostream`
 components that are the primary mechanism for C++ program input and
 output. They can be used with other elements of the library,
 particularly strings, locales, and iterators.
 The concurrency support library [[thread]] provides components to create
 and manage threads, including atomic operations, mutual exclusion, and
 interthread communication.
+The execution control library [[exec]] provides components supporting
+execution of function objects.
 ## The C standard library <a id="library.c">[[library.c]]</a>
 The C++ standard library also makes available the facilities of the C
 standard library, suitably adjusted to ensure static type safety.
 The descriptions of many library functions rely on the C standard
 library for the semantics of those functions. In some cases, the
 signatures specified in this document may be different from the
 signatures in the C standard library, and additional overloads may be
 declared in this document, but the behavior and the preconditions
+(including any preconditions implied by the use of a C `restrict`
 qualifier) are the same unless otherwise stated.
 A call to a C standard library function is a non-constant library call
 [[defns.nonconst.libcall]] if it raises a floating-point exception other
 than `FE_INEXACT`. The semantics of a call to a C standard library
 function evaluated as a core constant expression are those specified in
+ISO/IEC 9899:2018 (C), Annex F[^1]
 to the extent applicable to the floating-point types
 [[basic.fundamental]] that are parameter types of the called function.
+[*Note 1*: ISO/IEC 9899:2018 (C), Annex F specifies the conditions
+under which floating-point exceptions are raised and the behavior when
+NaNs and/or infinities are passed as arguments. — *end note*]
 [*Note 2*: Equivalently, a call to a C standard library function is a
 non-constant library call if `errno` is set when
 `math_errhandling & MATH_ERRNO` is `true`. — *end note*]
 ### General <a id="description.general">[[description.general]]</a>
 Subclause [[description]] describes the conventions used to specify the
 C++ standard library. [[structure]] describes the structure of
+[[support]] through [[exec]] and [[depr]]. [[conventions]] describes
 other editorial conventions.
 ### Structure of each clause <a id="structure">[[structure]]</a>
 #### Elements <a id="structure.elements">[[structure.elements]]</a>
   overload resolution [[over.match]]. \[*Note 1*: Failure to meet such a
   condition results in the function’s silent
   non-viability. — *end note*] \[*Example 1*: An implementation can
   express such a condition via a *constraint-expression*
   [[temp.constr.decl]]. — *end example*]
 - *Mandates:* the conditions that, if not met, render the program
   ill-formed. \[*Example 2*: An implementation can express such a
   condition via the *constant-expression* in a
   *static_assert-declaration* [[dcl.pre]]. If the diagnostic is to be
   emitted only after the function has been selected by overload
   resolution, an implementation can express such a condition via a
   *constraint-expression* [[temp.constr.decl]] and also define the
   function as deleted. — *end example*]
+- the conditions that are required for a call to the function to be a
+ constant subexpression [[defns.const.subexpr]].
+- *Preconditions:* conditions that the function assumes to hold whenever
+  it is called; violation of any preconditions results in undefined
+  behavior. \[*Example 3*: An implementation can express some such
+  conditions via the use of a contract assertion, such as a precondition
+  assertion [[dcl.contract.func]]. — *end example*]
+- conditions that the function assumes to hold whenever it is called.
+  - When invoking the function in a hardened implementation, prior to
+    any other observable side effects of the function, one or more
+    contract assertions whose predicates are as described in the
+    hardened precondition are evaluated with a checking semantic
+    [[basic.contract.eval]]. If any of these assertions is evaluated
+    with a non-terminating semantic and the contract-violation handler
+    returns, the program has undefined behavior.
+  - When invoking the function in a non-hardened implementation, if any
+    hardened precondition is violated, the program has undefined
+    behavior.
 - *Effects:* the actions performed by the function.
 - *Synchronization:* the synchronization operations
   [[intro.multithread]] applicable to the function.
 - *Ensures:* the conditions (sometimes termed observable results)
+  established by the function. \[*Example 4*: An implementation can
+  express some such conditions via the use of a contract assertion, such
+  as a postcondition assertion [[dcl.contract.func]]. — *end example*]
 - *Result:* for a *typename-specifier*, a description of the named type;
+  for an *expression*, a description of the type and value category of
+ the expression; the expression is an lvalue if the type is an lvalue
+ reference type, an xvalue if the type is an rvalue reference type, and
+ a prvalue otherwise.
 - *Returns:* a description of the value(s) returned by the function.
 - *Throws:* any exceptions thrown by the function, and the conditions
   that would cause the exception.
 - *Complexity:* the time and/or space complexity of the function.
 - *Remarks:* additional semantic constraints on the function.
 - *Error conditions:* the error conditions for error codes reported by
   the function.
 Whenever the *Effects* element specifies that the semantics of some
 function `F` are *Equivalent to* some code sequence, then the various
 elements are interpreted as follows. If `F`’s semantics specifies any
 *Constraints* or *Mandates* elements, then those requirements are
 logically imposed prior to the *equivalent-to* semantics. Next, the
 semantics of the code sequence are determined by the *Constraints*,
+*Mandates*, *Constant When*, *Preconditions*, *Hardened preconditions*,
+*Effects*, *Synchronization*, *Postconditions*, *Returns*, *Throws*,
+*Complexity*, *Remarks*, and *Error conditions* specified for the
+function invocations contained in the code sequence. The value returned
+from `F` is specified by `F`’s *Returns* element, or if `F` has no
+*Returns* element, a non-`void` return from `F` is specified by the
+`return` statements [[stmt.return]] in the code sequence. If `F`’s
+semantics contains a *Throws*, *Postconditions*, or *Complexity*
+element, then that supersedes any occurrences of that element in the
+code sequence.
 For non-reserved replacement and handler functions, [[support]]
 specifies two behaviors for the functions in question: their required
 and default behavior. The *default behavior* describes a function
 definition provided by the implementation. The *required behavior*
 are for describing implementation-defined types [[type.descriptions]],
 and member functions [[functions.within.classes]].
 #### Exposition-only entities, etc. <a id="expos.only.entity">[[expos.only.entity]]</a>
+Several entities defined in [[support]] through [[exec]] and [[depr]]
+are only defined for the purpose of exposition. The declaration of such
+an entity is followed by a comment ending in *exposition only*.
 The following are defined for exposition only to aid in the
 specification of the library:
 ``` cpp
 namespace std {
   template<class T>
     requires convertible_to<T, decay_t<T>>
+      constexpr decay_t<T> decay-copy(T&& v)       // exposition only
+        noexcept(is_nothrow_convertible_v<T, decay_t<T>>)
       { return std::forward<T>(v); }
+  constexpr auto synth-three-way =                 // exposition only
     []<class T, class U>(const T& t, const U& u)
       requires requires {
         { t < u } -> boolean-testable;
         { u < t } -> boolean-testable;
       }
         return weak_ordering::equivalent;
       }
     };
   template<class T, class U = T>
+  using synth-three-way-result =                  // exposition only
+    decltype(synth-three-way(declval<T&>(), declval<U&>()));
 }
 ```
+An object `dst` is said to be *decay-copied from* a subexpression `src`
+if the type of `dst` is
+``` cpp
+decay_t<decltype((src))>
+```
+and `dst` is copy-initialized from `src`.
 #### Type descriptions <a id="type.descriptions">[[type.descriptions]]</a>
 ##### General <a id="type.descriptions.general">[[type.descriptions.general]]</a>
 The Requirements subclauses may describe names that are used to specify
 Here, the names `C₀`, `C₁`, etc. represent *enumerated elements* for
 this particular enumerated type. All such elements have distinct values.
 ##### Bitmask types <a id="bitmask.types">[[bitmask.types]]</a>
+Several types defined in [[support]] through [[exec]] and [[depr]] are
 *bitmask types*. Each bitmask type can be implemented as an enumerated
 type that overloads certain operators, as an integer type, or as a
 `bitset` [[template.bitset]].
 The bitmask type `bitmask` can be written:
   basic character set.
 - The *decimal-point character* is the locale-specific (single-byte)
   character used by functions that convert between a (single-byte)
   character sequence and a value of one of the floating-point types. It
   is used in the character sequence to denote the beginning of a
+  fractional part. It is represented in [[support]] through [[exec]] and
+  [[depr]] by a period, `'.'`, which is also its value in the `"C"`
   locale.
 - A *character sequence* is an array object [[dcl.array]] `A` that can
   be declared as `T A[N]`, where `T` is any of the types `char`,
   `unsigned char`, or `signed char` [[basic.fundamental]], optionally
   qualified by any combination of `const` or `volatile`. The initial
   elements of the array have defined contents up to and including an
   element determined by some predicate. A character sequence can be
   designated by a pointer value `S` that points to its first element.
+- Let *`STATICALLY-WIDEN`*`<charT>("...")` be `"..."` if `charT` is
+  `char` and `L"..."` if `charT` is `wchar_t`.
 ###### Byte strings <a id="byte.strings">[[byte.strings]]</a>
 A *null-terminated byte string*, or NTBS, is a character sequence whose
 highest-addressed element with defined content has the value zero (the
 - `p(args...)`
 - `as_const(p)(args...)`
 - `std::move(p)(args...)`
 - `std::move(as_const(p))(args...)`
+#### Algorithm function objects <a id="alg.func.obj">[[alg.func.obj]]</a>
+An *algorithm function object* is a customization point object
+[[customization.point.object]] that is specified as one or more
+overloaded function templates. The name of these function templates
+designates the corresponding algorithm function object.
+For an algorithm function object `o`, let S be the corresponding set of
+function templates. Then for any sequence of arguments `args` …,
+`o(args` … `)` is expression-equivalent to `s(args` … `)`, where the
+result of name lookup for `s` is the overload set S.
+[*Note 1*:
+Algorithm function objects are not found by argument-dependent name
+lookup [[basic.lookup.argdep]]. When found by unqualified name lookup
+[[basic.lookup.unqual]] for the *postfix-expression* in a function call
+[[expr.call]], they inhibit argument-dependent name lookup.
+[*Example 1*:
+``` cpp
+void foo() {
+  using namespace std::ranges;
+  std::vector<int> vec{1,2,3};
+  find(begin(vec), end(vec), 2);        // #1
+}
+```
+The function call expression at \#1 invokes `std::ranges::find`, not
+`std::find`.
+— *end example*]
+— *end note*]
 #### Functions within classes <a id="functions.within.classes">[[functions.within.classes]]</a>
+For the sake of exposition, [[support]] through [[exec]] and [[depr]] do
+not describe copy/move constructors, assignment operators, or
 (non-virtual) destructors with the same apparent semantics as those that
 can be generated by default
 [[class.copy.ctor]], [[class.copy.assign]], [[class.dtor]]. It is
 unspecified whether the implementation provides explicit definitions for
 such member function signatures, or for virtual destructors that can be
 generated by default.
 #### Private members <a id="objects.within.classes">[[objects.within.classes]]</a>
+[[support]] through [[exec]] and [[depr]] do not specify the
 representation of classes, and intentionally omit specification of class
 members [[class.mem]]. An implementation may define static or non-static
 class members, or both, as needed to implement the semantics of the
+member functions specified in [[support]] through [[exec]] and [[depr]].
 For the sake of exposition, some subclauses provide representative
 declarations, and semantic requirements, for private members of classes
 that meet the external specifications of the classes. The declarations
 for such members are followed by a comment that ends with *exposition
 An implementation may use any technique that provides equivalent
 observable behavior.
 #### Freestanding items <a id="freestanding.item">[[freestanding.item]]</a>
+A *freestanding item* is a declaration, entity, or macro that is
+required to be present in a freestanding implementation and a hosted
+implementation.
 Unless otherwise specified, the requirements on freestanding items for a
 freestanding implementation are the same as the corresponding
 requirements for a hosted implementation, except that not all of the
+members of those items are required to be present.
+Function declarations and function template declarations followed by a
+comment that include *freestanding-deleted* are *freestanding deleted
+functions*. On freestanding implementations, it is
+*implementation-defined* whether each entity introduced by a
+freestanding deleted function is a deleted function
+[[dcl.fct.def.delete]] or whether the requirements are the same as the
+corresponding requirements for a hosted implementation.
+[*Note 1*: Deleted definitions reduce the chance of overload resolution
+silently changing when migrating from a freestanding implementation to a
+hosted implementation. — *end note*]
+[*Example 1*:
+``` cpp
+double abs(double j);           // freestanding-deleted
+```
+— *end example*]
+A declaration in a synopsis is a freestanding item if
+- it is followed by a comment that includes *freestanding*,
+- it is followed by a comment that includes *freestanding-deleted*, or
+- the header synopsis begins with a comment that includes *freestanding*
+  and the declaration is not followed by a comment that includes
+  *hosted*. \[*Note 2*: Declarations followed by *hosted* in
+  freestanding headers are not freestanding items. As a result, looking
+  up the name of such functions can vary between hosted and freestanding
+  implementations. — *end note*]
+[*Example 2*:
+``` cpp
+// all freestanding
+namespace std {
+```
+— *end example*]
+An entity or deduction guide is a freestanding item if its introducing
+declaration is not followed by a comment that includes *hosted*, and is:
 - introduced by a declaration that is a freestanding item,
+- a member of a freestanding item other than a namespace,
+- an enumerator of a freestanding item,
+- a deduction guide of a freestanding item,
 - an enclosing namespace of a freestanding item,
 - a friend of a freestanding item,
+- denoted by a type alias that is a freestanding item, or
 - denoted by an alias template that is a freestanding item.
 A macro is a freestanding item if it is defined in a header synopsis and
 - the definition is followed by a comment that includes *freestanding*,
   or
+- the header synopsis begins with a comment that includes *freestanding*
+ and the definition is not followed by a comment that includes
+  *hosted*.
+[*Example 3*:
 ``` cpp
 #define NULL see below      // freestanding
 ```
 — *end example*]
+[*Note 3*: Freestanding annotations follow some additional exposition
+conventions that do not impose any additional normative requirements.
+Header synopses that begin with a comment containing "all freestanding"
+contain no hosted items and no freestanding deleted functions. Header
+synopses that begin with a comment containing "mostly freestanding"
+contain at least one hosted item or freestanding deleted function.
+Classes and class templates followed by a comment containing "partially
+freestanding" contain at least one hosted item or freestanding deleted
+function. — *end note*]
+[*Example 4*:
 ``` cpp
+template<class T, size_t N> struct array;               // partially freestanding
+template<class T, size_t N>
+struct array {
+  constexpr reference       operator[](size_type n);
+  constexpr const_reference operator[](size_type n) const;
+  constexpr reference       at(size_type n);            // freestanding-deleted
+  constexpr const_reference at(size_type n) const;      // freestanding-deleted
+};
 ```
 — *end example*]
 ## 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