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

Files changed (1) hide show

tmp/tmp27by8emx/{from.md → to.md} +234 -200

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

@@ -25,15 +25,15 @@ for internal types used by the container.
 [*Note 1*: This means, for example, that a node-based container would
 need to construct nodes containing aligned buffers and call `construct`
 to place the element into the buffer. — *end note*]
-### General containers <a id="container.gen.reqmts">[[container.gen.reqmts]]</a>
-#### General <a id="container.requirements.general">[[container.requirements.general]]</a>
-In subclause [[container.gen.reqmts]],
 - `X` denotes a container class containing objects of type `T`,
 - `a` denotes a value of type `X`,
 - `b` and `c` denote values of type (possibly const) `X`,
 - `i` and `j` denote values of type (possibly const) `X::iterator`,
@@ -50,11 +50,11 @@ containers:
 template<class R, class T>
 concept container-compatible-range =    // exposition only
   ranges::input_range<R> && convertible_to<ranges::range_reference_t<R>, T>;
 ```
-#### Containers <a id="container.reqmts">[[container.reqmts]]</a>
 A type `X` meets the *container* requirements if the following types,
 statements, and expressions are well-formed and have the specified
 semantics.
@@ -134,15 +134,15 @@ X u = rv;
 ```
 *Ensures:* `u` is equal to the value that `rv` had before this
 construction.
-*Complexity:* Linear for `array` and constant for all other standard
-containers.
 ``` cpp
-t = v;
 ```
 *Result:* `X&`.
 *Ensures:* `t == v`.
@@ -255,12 +255,12 @@ t.swap(s)
 *Result:* `void`.
 *Effects:* Exchanges the contents of `t` and `s`.
-*Complexity:* Linear for `array` and constant for all other standard
-containers.
 ``` cpp
 swap(t, s)
 ```
@@ -342,11 +342,11 @@ these container types take a `const allocator_type&` argument.
 [*Note 2*: If an invocation of a constructor uses the default value of
 an optional allocator argument, then the allocator type must support
 value-initialization. — *end note*]
 A copy of this allocator is used for any memory allocation and element
-construction performed, by these constructors and by all member
 functions, during the lifetime of each container object or until the
 allocator is replaced. The allocator may be replaced only via assignment
 or `swap()`. Allocator replacement is performed by copy assignment, move
 assignment, or swapping of the allocator only if
@@ -360,15 +360,15 @@ operation. In all container types defined in this Clause, the member
 `get_allocator()` returns a copy of the allocator used to construct the
 container or, if that allocator has been replaced, a copy of the most
 recent replacement.
 The expression `a.swap(b)`, for containers `a` and `b` of a standard
-container type other than `array`, shall exchange the values of `a` and
-`b` without invoking any move, copy, or swap operations on the
-individual container elements. Any `Compare`, `Pred`, or `Hash` types
-belonging to `a` and `b` shall meet the *Cpp17Swappable* requirements
-and shall be exchanged by calling `swap` as described in
 [[swappable.requirements]]. If
 `allocator_traits<allocator_type>::propagate_on_container_swap::value`
 is `true`, then `allocator_type` shall meet the *Cpp17Swappable*
 requirements and the allocators of `a` and `b` shall also be exchanged
 by calling `swap` as described in  [[swappable.requirements]].
@@ -378,13 +378,13 @@ iterator referring to an element in one container before the swap shall
 refer to the same element in the other container after the swap. It is
 unspecified whether an iterator with value `a.end()` before the swap
 will have value `b.end()` after the swap.
 Unless otherwise specified (see  [[associative.reqmts.except]],
-[[unord.req.except]], [[deque.modifiers]], and [[vector.modifiers]]) all
-container types defined in this Clause meet the following additional
-requirements:
 - If an exception is thrown by an `insert()` or `emplace()` function
   while inserting a single element, that function has no effects.
 - If an exception is thrown by a `push_back()`, `push_front()`,
   `emplace_back()`, or `emplace_front()` function, that function has no
@@ -500,13 +500,13 @@ are implemented by constexpr functions.
 a <=> b
 ```
 *Result:* *`synth-three-way-result`*`<X::value_type>`.
-*Preconditions:* Either `<=>` is defined for values of type (possibly
-const) `T`, or `<` is defined for values of type (possibly const) `T`
-and `<` is a total ordering relationship.
 *Returns:*
 `lexicographical_compare_three_way(a.begin(), a.end(), b.begin(), b.end(), `*`synth-three-way`*`)`
 [*Note 1*: The algorithm `lexicographical_compare_three_way` is defined
@@ -514,23 +514,25 @@ in [[algorithms]]. — *end note*]
 *Complexity:* Linear.
 #### Allocator-aware containers <a id="container.alloc.reqmts">[[container.alloc.reqmts]]</a>
-All of the containers defined in [[containers]] and in  [[basic.string]]
-except `array` meet the additional requirements of an
 *allocator-aware container*, as described below.
 Given an allocator type `A` and given a container type `X` having a
 `value_type` identical to `T` and an `allocator_type` identical to
 `allocator_traits<A>::rebind_alloc<T>` and given an lvalue `m` of type
-`A`, a pointer `p` of type `T*`, an expression `v` of type `T` or
-`const T`, and an rvalue `rv` of type `T`, the following terms are
-defined. If `X` is not allocator-aware or is a specialization of
-`basic_string`, the terms below are defined as if `A` were
-`allocator<T>` — no allocator object needs to be created and user
-specializations of `allocator<T>` are not instantiated:
 - `T` is **Cpp17DefaultInsertable* into `X`* means that the following
   expression is well-formed:
   ``` cpp
   allocator_traits<A>::construct(m, p)
@@ -551,11 +553,11 @@ specializations of `allocator<T>` are not instantiated:
   and its evaluation causes the following postcondition to hold: The
   value of `*p` is equivalent to the value of `rv` before the
   evaluation.
   \[*Note 1*: `rv` remains a valid object. Its state is
-  unspecified — *end note*]
 - `T` is **Cpp17CopyInsertable* into `X`* means that, in addition to `T`
   being *Cpp17MoveInsertable* into `X`, the following expression is
   well-formed:
   ``` cpp
   allocator_traits<A>::construct(m, p, v)
@@ -635,11 +637,11 @@ X u(m);
 X u(t, m);
 ```
 *Preconditions:* `T` is *Cpp17CopyInsertable* into `X`.
-*Ensures:* `u == t`, `u.get_allocator() == m`
 *Complexity:* Linear.
 ``` cpp
 X u(rv);
@@ -725,29 +727,22 @@ can result in a data race. As an exception to the general rule, for a
 `y[1] = true`. — *end note*]
 ### Sequence containers <a id="sequence.reqmts">[[sequence.reqmts]]</a>
 A sequence container organizes a finite set of objects, all of the same
-type, into a strictly linear arrangement. The library provides four
-basic kinds of sequence containers: `vector`, `forward_list`, `list`,
-and `deque`. In addition, `array` is provided as a sequence container
-which provides limited sequence operations because it has a fixed number
-of elements. The library also provides container adaptors that make it
 easy to construct abstract data types, such as `stack`s, `queue`s,
 `flat_map`s, `flat_multimap`s, `flat_set`s, or `flat_multiset`s, out of
 the basic sequence container kinds (or out of other program-defined
 sequence containers).
-[*Note 1*: The sequence containers offer the programmer different
-complexity trade-offs. `vector` is appropriate in most circumstances.
-`array` has a fixed size known during translation. `list` or
-`forward_list` support frequent insertions and deletions from the middle
-of the sequence. `deque` supports efficient insertions and deletions
-taking place at the beginning or at the end of the sequence. When
-choosing a container, remember `vector` is best; leave a comment to
-explain if you choose from the rest! — *end note*]
 In this subclause,
 - `X` denotes a sequence container class,
 - `a` denotes a value of type `X` containing elements of type `T`,
 - `u` denotes the name of a variable being declared,
@@ -755,18 +750,18 @@ In this subclause,
   `X::allocator_type` is valid and denotes a type [[temp.deduct]] and
   `allocator<T>` if it doesn’t,
 - `i` and `j` denote iterators that meet the *Cpp17InputIterator*
   requirements and refer to elements implicitly convertible to
   `value_type`,
-- `[i, j)` denotes a valid range,
 - `rg` denotes a value of a type `R` that models
   `container-compatible-range<T>`,
 - `il` designates an object of type `initializer_list<value_type>`,
 - `n` denotes a value of type `X::size_type`,
 - `p` denotes a valid constant iterator to `a`,
 - `q` denotes a valid dereferenceable constant iterator to `a`,
-- `[q1, q2)` denotes a valid range of constant iterators in `a`,
 - `t` denotes an lvalue or a const rvalue of `X::value_type`, and
 - `rv` denotes a non-const rvalue of `X::value_type`.
 - `Args` denotes a template parameter pack;
 - `args` denotes a function parameter pack with the pattern `Args&&`.
@@ -793,27 +788,34 @@ X u(i, j);
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from `*i`.
 For `vector`, if the iterator does not meet the *Cpp17ForwardIterator*
 requirements [[forward.iterators]], `T` is also *Cpp17MoveInsertable*
 into `X`.
-*Effects:* Constructs a sequence container equal to the range `[i, j)`.
-Each iterator in the range \[`i`, `j`) is dereferenced exactly once.
 *Ensures:* `distance(u.begin(), u.end()) == distance(i, j)` is `true`.
 ``` cpp
 X(from_range, rg)
 ```
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from
-`*ranges::begin(rg)`. For `vector`, if `R` models neither
-`ranges::sized_range` nor `ranges::forward_range`, `T` is also
-*Cpp17MoveInsertable* into `X`.
 *Effects:* Constructs a sequence container equal to the range `rg`. Each
 iterator in the range `rg` is dereferenced exactly once.
 *Ensures:* `distance(begin(), end()) == ranges::distance(rg)` is `true`.
 ``` cpp
 X(il)
 ```
@@ -839,30 +841,29 @@ a.emplace(p, args)
 ```
 *Result:* `iterator`.
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from
-`args`. For `vector` and `deque`, `T` is also *Cpp17MoveInsertable* into
-`X` and *Cpp17MoveAssignable*.
 *Effects:* Inserts an object of type `T` constructed with
 `std::forward<Args>(args)...` before `p`.
 [*Note 1*: `args` can directly or indirectly refer to a value in
 `a`. — *end note*]
-*Returns:* An iterator that points to the new element constructed from
-`args` into `a`.
 ``` cpp
 a.insert(p, t)
 ```
 *Result:* `iterator`.
-*Preconditions:* `T` is *Cpp17CopyInsertable* into `X`. For `vector` and
-`deque`, `T` is also *Cpp17CopyAssignable*.
 *Effects:* Inserts a copy of `t` before `p`.
 *Returns:* An iterator that points to the copy of `t` inserted into `a`.
@@ -870,12 +871,12 @@ a.insert(p, t)
 a.insert(p, rv)
 ```
 *Result:* `iterator`.
-*Preconditions:* `T` is *Cpp17MoveInsertable* into `X`. For `vector` and
-`deque`, `T` is also *Cpp17MoveAssignable*.
 *Effects:* Inserts a copy of `rv` before `p`.
 *Returns:* An iterator that points to the copy of `rv` inserted into
 `a`.
@@ -899,16 +900,17 @@ a.insert(p, i, j)
 ```
 *Result:* `iterator`.
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from `*i`.
-For `vector` and `deque`, `T` is also *Cpp17MoveInsertable* into `X`,
-and `T` meets the *Cpp17MoveConstructible*, *Cpp17MoveAssignable*, and
 *Cpp17Swappable*[[swappable.requirements]] requirements. Neither `i` nor
 `j` are iterators into `a`.
-*Effects:* Inserts copies of elements in `[i, j)` before `p`. Each
 iterator in the range \[`i`, `j`) shall be dereferenced exactly once.
 *Returns:* An iterator that points to the copy of the first element
 inserted into `a`, or `p` if `i == j`.
@@ -917,12 +919,12 @@ a.insert_range(p, rg)
 ```
 *Result:* `iterator`.
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from
-`*ranges::begin(rg)`. For `vector` and `deque`, `T` is also
-*Cpp17MoveInsertable* into `X`, and `T` meets the
 *Cpp17MoveConstructible*, *Cpp17MoveAssignable*, and
 *Cpp17Swappable*[[swappable.requirements]] requirements. `rg` and `a` do
 not overlap.
 *Effects:* Inserts copies of elements in `rg` before `p`. Each iterator
@@ -941,11 +943,12 @@ a.insert(p, il)
 a.erase(q)
 ```
 *Result:* `iterator`.
-*Preconditions:* For `vector` and `deque`, `T` is *Cpp17MoveAssignable*.
 *Effects:* Erases the element pointed to by `q`.
 *Returns:* An iterator that points to the element immediately following
 `q` prior to the element being erased. If no such element exists,
@@ -955,13 +958,14 @@ a.erase(q)
 a.erase(q1, q2)
 ```
 *Result:* `iterator`.
-*Preconditions:* For `vector` and `deque`, `T` is *Cpp17MoveAssignable*.
-*Effects:* Erases the elements in the range `[q1, q2)`.
 *Returns:* An iterator that points to the element pointed to by `q2`
 prior to any elements being erased. If no such element exists, `a.end()`
 is returned.
@@ -989,14 +993,15 @@ a.assign(i, j)
 and assignable from `*i`. For `vector`, if the iterator does not meet
 the forward iterator requirements [[forward.iterators]], `T` is also
 *Cpp17MoveInsertable* into `X`. Neither `i` nor `j` are iterators into
 `a`.
-*Effects:* Replaces elements in `a` with a copy of `[i, j)`. Invalidates
-all references, pointers and iterators referring to the elements of `a`.
-For `vector` and `deque`, also invalidates the past-the-end iterator.
-Each iterator in the range \[`i`, `j`) is dereferenced exactly once.
 ``` cpp
 a.assign_range(rg)
 ```
@@ -1004,20 +1009,26 @@ a.assign_range(rg)
 *Mandates:* `assignable_from<T&, ranges::range_reference_t<R>>` is
 modeled.
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from
-`*ranges::begin(rg)`. For `vector`, if `R` models neither
-`ranges::sized_range` nor `ranges::forward_range`, `T` is also
-*Cpp17MoveInsertable* into `X`. `rg` and `a` do not overlap.
 *Effects:* Replaces elements in `a` with a copy of each element in `rg`.
 Invalidates all references, pointers, and iterators referring to the
 elements of `a`. For `vector` and `deque`, also invalidates the
 past-the-end iterator. Each iterator in the range `rg` is dereferenced
 exactly once.
 ``` cpp
 a.assign(il)
 ```
 *Effects:* Equivalent to `a.assign(il.begin(), il.end())`.
@@ -1079,31 +1090,35 @@ containers but not others. Operations other than `prepend_range` and
 a.front()
 ```
 *Result:* `reference; const_reference` for constant `a`.
 *Returns:* `*a.begin()`
 *Remarks:* Required for `basic_string`, `array`, `deque`,
-`forward_list`, `list`, and `vector`.
 ``` cpp
 a.back()
 ```
 *Result:* `reference; const_reference` for constant `a`.
 *Effects:* Equivalent to:
 ``` cpp
 auto tmp = a.end();
 --tmp;
 return *tmp;
 ```
-*Remarks:* Required for `basic_string`, `array`, `deque`, `list`, and
-`vector`.
 ``` cpp
 a.emplace_front(args)
 ```
@@ -1131,11 +1146,11 @@ a.emplace_back(args)
 *Effects:* Appends an object of type `T` constructed with
 `std::forward<Args>(args)...`.
 *Returns:* `a.back()`.
-*Remarks:* Required for `deque`, `list`, and `vector`.
 ``` cpp
 a.push_front(t)
 ```
@@ -1187,11 +1202,12 @@ a.push_back(t)
 *Preconditions:* `T` is *Cpp17CopyInsertable* into `X`.
 *Effects:* Appends a copy of `t`.
-*Remarks:* Required for `basic_string`, `deque`, `list`, and `vector`.
 ``` cpp
 a.push_back(rv)
 ```
@@ -1199,11 +1215,12 @@ a.push_back(rv)
 *Preconditions:* `T` is *Cpp17MoveInsertable* into `X`.
 *Effects:* Appends a copy of `rv`.
-*Remarks:* Required for `basic_string`, `deque`, `list`, and `vector`.
 ``` cpp
 a.append_range(rg)
 ```
@@ -1214,19 +1231,19 @@ a.append_range(rg)
 into `X`.
 *Effects:* Inserts copies of elements in `rg` before `end()`. Each
 iterator in the range `rg` is dereferenced exactly once.
-*Remarks:* Required for `deque`, `list`, and `vector`.
 ``` cpp
 a.pop_front()
 ```
 *Result:* `void`
-*Preconditions:* `a.empty()` is `false`.
 *Effects:* Destroys the first element.
 *Remarks:* Required for `deque`, `forward_list`, and `list`.
@@ -1234,37 +1251,42 @@ a.pop_front()
 a.pop_back()
 ```
 *Result:* `void`
-*Preconditions:* `a.empty()` is `false`.
 *Effects:* Destroys the last element.
-*Remarks:* Required for `basic_string`, `deque`, `list`, and `vector`.
 ``` cpp
 a[n]
 ```
-*Result:* `reference; const_reference` for constant `a`
-*Returns:* `*(a.begin() + n)`
-*Remarks:* Required for `basic_string`, `array`, `deque`, and `vector`.
 ``` cpp
 a.at(n)
 ```
-*Result:* `reference; const_reference` for constant `a`
 *Returns:* `*(a.begin() + n)`
 *Throws:* `out_of_range` if `n >= a.size()`.
-*Remarks:* Required for `basic_string`, `array`, `deque`, and `vector`.
 ### Node handles <a id="container.node">[[container.node]]</a>
 #### Overview <a id="container.node.overview">[[container.node.overview]]</a>
@@ -1310,167 +1332,170 @@ public:
   using key_type       = see below;     // not present for set containers
   using mapped_type    = see below;     // not present for set containers
   using allocator_type = see below;
 private:
-  using container_node_type = unspecified;                  // exposition only
-  using ator_traits = allocator_traits<allocator_type>;     // exposition only
-  typename ator_traits::template
-    rebind_traits<container_node_type>::pointer ptr_;       // exposition only
   optional<allocator_type> alloc_;                          // exposition only
 public:
   // [container.node.cons], constructors, copy, and assignment
   constexpr node-handle() noexcept : ptr_(), alloc_() {}
-  node-handle(node-handle&&) noexcept;
-  node-handle& operator=(node-handle&&);
   // [container.node.dtor], destructor
-  ~node-handle();
   // [container.node.observers], observers
-  value_type& value() const; // not present for map containers
   key_type& key() const;                        // not present for set containers
-  mapped_type& mapped() const; // not present for set containers
-  allocator_type get_allocator() const;
-  explicit operator bool() const noexcept;
- [[nodiscard]] bool empty() const noexcept;
   // [container.node.modifiers], modifiers
-  void swap(node-handle&)
-    noexcept(ator_traits::propagate_on_container_swap::value ||
- ator_traits::is_always_equal::value);
-  friend void swap(node-handle& x, node-handle& y) noexcept(noexcept(x.swap(y))) {
     x.swap(y);
   }
 };
 ```
 #### Constructors, copy, and assignment <a id="container.node.cons">[[container.node.cons]]</a>
 ``` cpp
-node-handle(node-handle&& nh) noexcept;
 ```
-*Effects:* Constructs a *node-handle* object initializing `ptr_` with
-`nh.ptr_`. Move constructs `alloc_` with `nh.alloc_`. Assigns `nullptr`
-to `nh.ptr_` and assigns `nullopt` to `nh.alloc_`.
 ``` cpp
-node-handle& operator=(node-handle&& nh);
 ```
-*Preconditions:* Either `!alloc_`, or
-`ator_traits::propagate_on_container_move_assignment::value` is `true`,
-or `alloc_ == nh.alloc_`.
 *Effects:*
-- If `ptr_ != nullptr`, destroys the `value_type` subobject in the
- `container_node_type` object pointed to by `ptr_` by calling
-  `ator_traits::destroy`, then deallocates `ptr_` by calling
- `ator_traits::template rebind_traits<container_node_type>::deallocate`.
-- Assigns `nh.ptr_` to `ptr_`.
-- If `!alloc` or
- `ator_traits::propagate_on_container_move_assignment::value` is
-  `true`, move assigns `nh.alloc_` to `alloc_`.
-- Assigns `nullptr` to `nh.ptr_` and assigns `nullopt` to `nh.alloc_`.
 *Returns:* `*this`.
 *Throws:* Nothing.
 #### Destructor <a id="container.node.dtor">[[container.node.dtor]]</a>
 ``` cpp
-~node-handle();
 ```
-*Effects:* If `ptr_ != nullptr`, destroys the `value_type` subobject in
-the `container_node_type` object pointed to by `ptr_` by calling
-`ator_traits::destroy`, then deallocates `ptr_` by calling
-`ator_traits::template rebind_traits<container_node_type>::deallocate`.
 #### Observers <a id="container.node.observers">[[container.node.observers]]</a>
 ``` cpp
-value_type& value() const;
 ```
 *Preconditions:* `empty() == false`.
 *Returns:* A reference to the `value_type` subobject in the
-`container_node_type` object pointed to by `ptr_`.
 *Throws:* Nothing.
 ``` cpp
 key_type& key() const;
 ```
 *Preconditions:* `empty() == false`.
 *Returns:* A non-const reference to the `key_type` member of the
-`value_type` subobject in the `container_node_type` object pointed to by
-`ptr_`.
 *Throws:* Nothing.
 *Remarks:* Modifying the key through the returned reference is
 permitted.
 ``` cpp
-mapped_type& mapped() const;
 ```
 *Preconditions:* `empty() == false`.
 *Returns:* A reference to the `mapped_type` member of the `value_type`
-subobject in the `container_node_type` object pointed to by `ptr_`.
 *Throws:* Nothing.
 ``` cpp
-allocator_type get_allocator() const;
 ```
 *Preconditions:* `empty() == false`.
-*Returns:* `*alloc_`.
 *Throws:* Nothing.
 ``` cpp
-explicit operator bool() const noexcept;
 ```
-*Returns:* `ptr_ != nullptr`.
 ``` cpp
-[[nodiscard]] bool empty() const noexcept;
 ```
-*Returns:* `ptr_ == nullptr`.
 #### Modifiers <a id="container.node.modifiers">[[container.node.modifiers]]</a>
 ``` cpp
-void swap(node-handle& nh)
-  noexcept(ator_traits::propagate_on_container_swap::value ||
- ator_traits::is_always_equal::value);
 ```
-*Preconditions:* `!alloc_`, or `!nh.alloc_`, or
-`ator_traits::propagate_on_container_swap::value` is `true`, or
-`alloc_ == nh.alloc_`.
-*Effects:* Calls `swap(ptr_, nh.ptr_)`. If `!alloc_`, or `!nh.alloc_`,
-or `ator_traits::propagate_on_container_swap::value` is `true` calls
-`swap(alloc_, nh.alloc_)`.
 ### Insert return type <a id="container.insert.return">[[container.insert.return]]</a>
 The associative containers with unique keys and the unordered containers
 with unique keys have a member function `insert` that returns a nested
@@ -1485,11 +1510,11 @@ struct insert-return-type
   bool     inserted;
   NodeType node;
 };
 ```
-The name *`insert-return-type`* is exposition only.
 *`insert-return-type`* has the template parameters, data members, and
 special members specified above. It has no base classes or members other
 than those specified.
 ### Associative containers <a id="associative.reqmts">[[associative.reqmts]]</a>
@@ -1548,14 +1573,14 @@ In this subclause,
 - `X` denotes an associative container class,
 - `a` denotes a value of type `X`,
 - `a2` denotes a value of a type with nodes compatible with type `X` (
   [[container.node.compat]]),
-- `b` denotes a value or type `X` or `const X`,
 - `u` denotes the name of a variable being declared,
 - `a_uniq` denotes a value of type `X` when `X` supports unique keys,
-- `a_eq` denotes a value of type `X` when `X` supports multiple keys,
 - `a_tran` denotes a value of type `X` or `const X` when the
   *qualified-id* `X::key_compare::is_transparent` is valid and denotes a
   type [[temp.deduct]],
 - `i` and `j` meet the *Cpp17InputIterator* requirements and refer to
   elements implicitly convertible to `value_type`,
@@ -1563,11 +1588,11 @@ In this subclause,
 - `rg` denotes a value of a type `R` that models
   `container-compatible-range<value_type>`,
 - `p` denotes a valid constant iterator to `a`,
 - `q` denotes a valid dereferenceable constant iterator to `a`,
 - `r` denotes a valid dereferenceable iterator to `a`,
-- `[q1, q2)` denotes a valid range of constant iterators in `a`,
 - `il` designates an object of type `initializer_list<value_type>`,
 - `t` denotes a value of type `X::value_type`,
 - `k` denotes a value of type `X::key_type`, and
 - `c` denotes a value of type `X::key_compare` or
   `const X::key_compare`;
@@ -1589,19 +1614,18 @@ In this subclause,
 - `m` denotes an allocator of a type convertible to `A`, and `nh`
   denotes a non-const rvalue of type `X::node_type`.
 A type `X` meets the *associative container* requirements if `X` meets
 all the requirements of an allocator-aware container
-[[container.requirements.general]] and the following types, statements,
-and expressions are well-formed and have the specified semantics, except
 that for `map` and `multimap`, the requirements placed on `value_type`
-in [[container.alloc.reqmts]] apply instead to `key_type` and
-`mapped_type`.
-[*Note 3*: For example, in some cases `key_type` and `mapped_type` are
-required to be *Cpp17CopyAssignable* even though the associated
-`value_type`, `pair<const key_type, mapped_type>`, is not
 *Cpp17CopyAssignable*. — *end note*]
 ``` cpp
 typename X::key_type
 ```
@@ -1820,12 +1844,11 @@ a.emplace_hint(p, args)
 *Effects:* Equivalent to `a.emplace(std::forward<Args>(args)...)`,
 except that the element is inserted as close as possible to the position
 just prior to `p`.
-*Returns:* An iterator pointing to the element with the key equivalent
-to the newly inserted element.
 *Complexity:* Logarithmic in general, but amortized constant if the
 element is inserted right before `p`.
 ``` cpp
@@ -2034,21 +2057,22 @@ a.extract(q)
 a.merge(a2)
 ```
 *Result:* `void`
-*Preconditions:* `a.get_allocator() == a2.get_allocator()`.
 *Effects:* Attempts to extract each element in `a2` and insert it into
 `a` using the comparison object of `a`. In containers with unique keys,
 if there is an element in `a` with key equivalent to the key of an
 element from `a2`, then that element is not extracted from `a2`.
 *Ensures:* Pointers and references to the transferred elements of `a2`
-refer to those same elements but as members of `a`. Iterators referring
-to the transferred elements will continue to refer to their elements,
-but they now behave as iterators into `a`, not into `a2`.
 *Throws:* Nothing unless the comparison object throws.
 *Complexity:* N log(`a.size()+` N), where N has the value `a2.size()`.
@@ -2220,11 +2244,11 @@ b.upper_bound(k)
 *Result:* `iterator`; `const_iterator` for constant `b`.
 *Returns:* An iterator pointing to the first element with key greater
 than `k`, or `b.end()` if such an element is not found.
-*Complexity:* Logarithmic,
 ``` cpp
 a_tran.upper_bound(ku)
 ```
@@ -2422,17 +2446,17 @@ In this subclause,
 - `a_tran` denotes a value of type `X` or `const X` when the
   *qualified-id*s `X::key_equal::is_transparent` and
   `X::hasher::is_transparent` are both valid and denote types
   [[temp.deduct]],
 - `i` and `j` denote input iterators that refer to `value_type`,
-- `[i, j)` denotes a valid range,
 - `rg` denotes a value of a type `R` that models
   `container-compatible-range<value_type>`,
 - `p` and `q2` denote valid constant iterators to `a`,
 - `q` and `q1` denote valid dereferenceable constant iterators to `a`,
 - `r` denotes a valid dereferenceable iterator to `a`,
-- `[q1, q2)` denotes a valid range in `a`,
 - `il` denotes a value of type `initializer_list<value_type>`,
 - `t` denotes a value of type `X::value_type`,
 - `k` denotes a value of type `key_type`,
 - `hf` denotes a value of type `hasher` or `const hasher`,
 - `eq` denotes a value of type `key_equal` or `const key_equal`,
@@ -2455,19 +2479,19 @@ In this subclause,
 - `z` denotes a value of type `float`, and
 - `nh` denotes an rvalue of type `X::node_type`.
 A type `X` meets the *unordered associative container* requirements if
 `X` meets all the requirements of an allocator-aware container
-[[container.requirements.general]] and the following types, statements,
-and expressions are well-formed and have the specified semantics, except
 that for `unordered_map` and `unordered_multimap`, the requirements
-placed on `value_type` in [[container.alloc.reqmts]] apply instead to
 `key_type` and `mapped_type`.
-[*Note 3*: For example, `key_type` and `mapped_type` are sometimes
-required to be *Cpp17CopyAssignable* even though the associated
-`value_type`, `pair<const key_type, mapped_type>`, is not
 *Cpp17CopyAssignable*. — *end note*]
 ``` cpp
 typename X::key_type
 ```
@@ -2734,12 +2758,12 @@ X(il, n, hf, eq)
 ``` cpp
 X(b)
 ```
 *Effects:* In addition to the container
-requirements [[container.requirements.general]], copies the hash
-function, predicate, and maximum load factor.
 *Complexity:* Average case linear in `b.size()`, worst case quadratic.
 ``` cpp
 a = b
@@ -2825,21 +2849,15 @@ from `args`.
 a.emplace_hint(p, args)
 ```
 *Result:* `iterator`
-*Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `X`
-from `args`.
-*Effects:* Equivalent to `a.emplace(std::forward<Args>(args)...)`.
-*Returns:* An iterator pointing to the element with the key equivalent
-to the newly inserted element. The `const_iterator` `p` is a hint
-pointing to where the search should start. Implementations are permitted
-to ignore the hint.
-*Complexity:* Average case 𝑂(1), worst case 𝑂(`a.size()`).
 ``` cpp
 a_uniq.insert(t)
 ```
@@ -2900,11 +2918,11 @@ a.insert(i, j)
 *Result:* `void`
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `X`
 from `*i`. Neither `i` nor `j` are iterators into `a`.
-*Effects:* Equivalent to `a.insert(t)` for each element in `[i,j)`.
 *Complexity:* Average case 𝑂(N), where N is `distance(i, j)`, worst case
 𝑂(N(`a.size()` + 1)).
 ``` cpp
@@ -3106,11 +3124,11 @@ a.erase(r)
 a.erase(q1, q2)
 ```
 *Result:* `iterator`
-*Effects:* Erases all elements in the range `[q1, q2)`.
 *Returns:* The iterator immediately following the erased elements prior
 to the erasure.
 *Complexity:* Average case linear in `distance(q1, q2)`, worst case
@@ -3238,21 +3256,37 @@ b.bucket(k)
 *Preconditions:* `b.bucket_count() > 0`.
 *Returns:* The index of the bucket in which elements with keys
 equivalent to `k` would be found, if any such element existed. The
-return value is in the range `[0, b.bucket_count())`.
 *Complexity:* Constant.
 ``` cpp
 b.bucket_size(n)
 ```
 *Result:* `size_type`
-*Preconditions:* `n` shall be in the range `[0, b.bucket_count())`.
 *Returns:* The number of elements in the `n`ᵗʰ bucket.
 *Complexity:* 𝑂(`b.bucket_size(n)`)
@@ -3260,11 +3294,11 @@ b.bucket_size(n)
 b.begin(n)
 ```
 *Result:* `local_iterator`; `const_local_iterator` for constant `b`.
-*Preconditions:* `n` is in the range `[0, b.bucket_count())`.
 *Returns:* An iterator referring to the first element in the bucket. If
 the bucket is empty, then `b.begin(n) == b.end(n)`.
 *Complexity:* Constant.
@@ -3273,11 +3307,11 @@ the bucket is empty, then `b.begin(n) == b.end(n)`.
 b.end(n)
 ```
 *Result:* `local_iterator`; `const_local_iterator` for constant `b`.
-*Preconditions:* `n` is in the range `[0, b.bucket_count())`.
 *Returns:* An iterator which is the past-the-end value for the bucket.
 *Complexity:* Constant.
@@ -3285,11 +3319,11 @@ b.end(n)
 b.cbegin(n)
 ```
 *Result:* `const_local_iterator`
-*Preconditions:* `n` shall be in the range `[0, b.bucket_count())`.
 *Returns:* An iterator referring to the first element in the bucket. If
 the bucket is empty, then `b.cbegin(n) == b.cend(n)`.
 *Complexity:* Constant.
@@ -3298,11 +3332,11 @@ the bucket is empty, then `b.cbegin(n) == b.cend(n)`.
 b.cend(n)
 ```
 *Result:* `const_local_iterator`
-*Preconditions:* `n` is in the range `[0, b.bucket_count())`.
 *Returns:* An iterator which is the past-the-end value for the bucket.
 *Complexity:* Constant.
@@ -3407,15 +3441,15 @@ accessing the element through such pointers and references while the
 element is owned by a `node_type` is undefined behavior. References and
 pointers to an element obtained while it is owned by a `node_type` are
 invalidated if the element is successfully inserted.
 The member function templates `find`, `count`, `equal_range`,
-`contains`, `extract`, and `erase` shall not participate in overload
-resolution unless the *qualified-id*s `Pred::is_transparent` and
-`Hash::is_transparent` are both valid and denote types [[temp.deduct]].
-Additionally, the member function templates `extract` and `erase` shall
-not participate in overload resolution if
 `is_convertible_v<K&&, iterator> || is_convertible_v<K&&, const_iterator>`
 is `true`, where `K` is the type substituted as the first template
 argument.
 A deduction guide for an unordered associative container shall not

 [*Note 1*: This means, for example, that a node-based container would
 need to construct nodes containing aligned buffers and call `construct`
 to place the element into the buffer. — *end note*]
+### General containers <a id="container.requirements.general">[[container.requirements.general]]</a>
+#### Introduction <a id="container.intro.reqmts">[[container.intro.reqmts]]</a>
+In [[container.requirements.general]],
 - `X` denotes a container class containing objects of type `T`,
 - `a` denotes a value of type `X`,
 - `b` and `c` denote values of type (possibly const) `X`,
 - `i` and `j` denote values of type (possibly const) `X::iterator`,
 template<class R, class T>
 concept container-compatible-range =    // exposition only
   ranges::input_range<R> && convertible_to<ranges::range_reference_t<R>, T>;
 ```
+#### Container requirements <a id="container.reqmts">[[container.reqmts]]</a>
 A type `X` meets the *container* requirements if the following types,
 statements, and expressions are well-formed and have the specified
 semantics.
 ```
 *Ensures:* `u` is equal to the value that `rv` had before this
 construction.
+*Complexity:* Linear for `array` and `inplace_vector` and constant for
+all other standard containers.
 ``` cpp
+t = v
 ```
 *Result:* `X&`.
 *Ensures:* `t == v`.
 *Result:* `void`.
 *Effects:* Exchanges the contents of `t` and `s`.
+*Complexity:* Linear for `array` and `inplace_vector`, and constant for
+all other standard containers.
 ``` cpp
 swap(t, s)
 ```
 [*Note 2*: If an invocation of a constructor uses the default value of
 an optional allocator argument, then the allocator type must support
 value-initialization. — *end note*]
 A copy of this allocator is used for any memory allocation and element
+construction performed, by these constructors and by all other member
 functions, during the lifetime of each container object or until the
 allocator is replaced. The allocator may be replaced only via assignment
 or `swap()`. Allocator replacement is performed by copy assignment, move
 assignment, or swapping of the allocator only if
 `get_allocator()` returns a copy of the allocator used to construct the
 container or, if that allocator has been replaced, a copy of the most
 recent replacement.
 The expression `a.swap(b)`, for containers `a` and `b` of a standard
+container type other than `array` and `inplace_vector`, shall exchange
+the values of `a` and `b` without invoking any move, copy, or swap
+operations on the individual container elements. Any `Compare`, `Pred`,
+or `Hash` types belonging to `a` and `b` shall meet the *Cpp17Swappable*
+requirements and shall be exchanged by calling `swap` as described in
 [[swappable.requirements]]. If
 `allocator_traits<allocator_type>::propagate_on_container_swap::value`
 is `true`, then `allocator_type` shall meet the *Cpp17Swappable*
 requirements and the allocators of `a` and `b` shall also be exchanged
 by calling `swap` as described in  [[swappable.requirements]].
 refer to the same element in the other container after the swap. It is
 unspecified whether an iterator with value `a.end()` before the swap
 will have value `b.end()` after the swap.
 Unless otherwise specified (see  [[associative.reqmts.except]],
+[[unord.req.except]], [[deque.modifiers]], [[inplace.vector.modifiers]],
+and [[vector.modifiers]]) all container types defined in this Clause
+meet the following additional requirements:
 - If an exception is thrown by an `insert()` or `emplace()` function
   while inserting a single element, that function has no effects.
 - If an exception is thrown by a `push_back()`, `push_front()`,
   `emplace_back()`, or `emplace_front()` function, that function has no
 a <=> b
 ```
 *Result:* *`synth-three-way-result`*`<X::value_type>`.
+*Preconditions:* Either `T` models `three_way_comparable`, or `<` is
+defined for values of type (possibly const) `T` and `<` is a total
+ordering relationship.
 *Returns:*
 `lexicographical_compare_three_way(a.begin(), a.end(), b.begin(), b.end(), `*`synth-three-way`*`)`
 [*Note 1*: The algorithm `lexicographical_compare_three_way` is defined
 *Complexity:* Linear.
 #### Allocator-aware containers <a id="container.alloc.reqmts">[[container.alloc.reqmts]]</a>
+Except for `array` and `inplace_vector`, all of the containers defined
+in [[containers]], [[stacktrace.basic]], [[basic.string]], and
+[[re.results]] meet the additional requirements of an
 *allocator-aware container*, as described below.
 Given an allocator type `A` and given a container type `X` having a
 `value_type` identical to `T` and an `allocator_type` identical to
 `allocator_traits<A>::rebind_alloc<T>` and given an lvalue `m` of type
+`A`, a pointer `p` of type `T*`, an expression `v` that denotes an
+lvalue of type `T` or `const T` or an rvalue of type `const T`, and an
+rvalue `rv` of type `T`, the following terms are defined. If `X` is not
+allocator-aware or is a specialization of `basic_string`, the terms
+below are defined as if `A` were `allocator<T>` — no allocator object
+needs to be created and user specializations of `allocator<T>` are not
+instantiated:
 - `T` is **Cpp17DefaultInsertable* into `X`* means that the following
   expression is well-formed:
   ``` cpp
   allocator_traits<A>::construct(m, p)
   and its evaluation causes the following postcondition to hold: The
   value of `*p` is equivalent to the value of `rv` before the
   evaluation.
   \[*Note 1*: `rv` remains a valid object. Its state is
+  unspecified. — *end note*]
 - `T` is **Cpp17CopyInsertable* into `X`* means that, in addition to `T`
   being *Cpp17MoveInsertable* into `X`, the following expression is
   well-formed:
   ``` cpp
   allocator_traits<A>::construct(m, p, v)
 X u(t, m);
 ```
 *Preconditions:* `T` is *Cpp17CopyInsertable* into `X`.
+*Ensures:* `u == t`, `u.get_allocator() == m`.
 *Complexity:* Linear.
 ``` cpp
 X u(rv);
 `y[1] = true`. — *end note*]
 ### Sequence containers <a id="sequence.reqmts">[[sequence.reqmts]]</a>
 A sequence container organizes a finite set of objects, all of the same
+type, into a strictly linear arrangement. The library provides the
+following basic kinds of sequence containers: `vector`,
+`inplace_vector`, `forward_list`, `list`, and `deque`. In addition,
+`array` and `hive` are provided as sequence containers which provide
+limited sequence operations, in `array`’s case because it has a fixed
+number of elements, and in `hive`’s case because insertion order is
+unspecified. The library also provides container adaptors that make it
 easy to construct abstract data types, such as `stack`s, `queue`s,
 `flat_map`s, `flat_multimap`s, `flat_set`s, or `flat_multiset`s, out of
 the basic sequence container kinds (or out of other program-defined
 sequence containers).
 In this subclause,
 - `X` denotes a sequence container class,
 - `a` denotes a value of type `X` containing elements of type `T`,
 - `u` denotes the name of a variable being declared,
   `X::allocator_type` is valid and denotes a type [[temp.deduct]] and
   `allocator<T>` if it doesn’t,
 - `i` and `j` denote iterators that meet the *Cpp17InputIterator*
   requirements and refer to elements implicitly convertible to
   `value_type`,
+- \[`i`, `j`) denotes a valid range,
 - `rg` denotes a value of a type `R` that models
   `container-compatible-range<T>`,
 - `il` designates an object of type `initializer_list<value_type>`,
 - `n` denotes a value of type `X::size_type`,
 - `p` denotes a valid constant iterator to `a`,
 - `q` denotes a valid dereferenceable constant iterator to `a`,
+- \[`q1`, `q2`) denotes a valid range of constant iterators in `a`,
 - `t` denotes an lvalue or a const rvalue of `X::value_type`, and
 - `rv` denotes a non-const rvalue of `X::value_type`.
 - `Args` denotes a template parameter pack;
 - `args` denotes a function parameter pack with the pattern `Args&&`.
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from `*i`.
 For `vector`, if the iterator does not meet the *Cpp17ForwardIterator*
 requirements [[forward.iterators]], `T` is also *Cpp17MoveInsertable*
 into `X`.
+*Effects:* Constructs a sequence container equal to the range \[`i`,
+`j`). Each iterator in the range \[`i`, `j`) is dereferenced exactly
+once.
 *Ensures:* `distance(u.begin(), u.end()) == distance(i, j)` is `true`.
 ``` cpp
 X(from_range, rg)
 ```
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from
+`*ranges::begin(rg)`. For `vector`, if `R` models
+`ranges::approximately_sized_range` but not `ranges::sized_range` or
+models `ranges::input_range` but not `ranges::forward_range`, `T` is
+also *Cpp17MoveInsertable* into `X`.
 *Effects:* Constructs a sequence container equal to the range `rg`. Each
 iterator in the range `rg` is dereferenced exactly once.
+*Recommended practice:* If `R` models
+`ranges::approximately_sized_range` and
+`ranges::distance(rg) <= ranges::reserve_hint(rg)` is `true`, an
+implementation should not perform more than a single reallocation.
 *Ensures:* `distance(begin(), end()) == ranges::distance(rg)` is `true`.
 ``` cpp
 X(il)
 ```
 ```
 *Result:* `iterator`.
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from
+`args`. For `vector`, `inplace_vector`, and `deque`, `T` is also
+*Cpp17MoveInsertable* into `X` and *Cpp17MoveAssignable*.
 *Effects:* Inserts an object of type `T` constructed with
 `std::forward<Args>(args)...` before `p`.
 [*Note 1*: `args` can directly or indirectly refer to a value in
 `a`. — *end note*]
+*Returns:* An iterator that points to the new element.
 ``` cpp
 a.insert(p, t)
 ```
 *Result:* `iterator`.
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `X`. For `vector`,
+`inplace_vector`, and `deque`, `T` is also *Cpp17CopyAssignable*.
 *Effects:* Inserts a copy of `t` before `p`.
 *Returns:* An iterator that points to the copy of `t` inserted into `a`.
 a.insert(p, rv)
 ```
 *Result:* `iterator`.
+*Preconditions:* `T` is *Cpp17MoveInsertable* into `X`. For `vector`,
+`inplace_vector`, and `deque`, `T` is also *Cpp17MoveAssignable*.
 *Effects:* Inserts a copy of `rv` before `p`.
 *Returns:* An iterator that points to the copy of `rv` inserted into
 `a`.
 ```
 *Result:* `iterator`.
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from `*i`.
+For `vector`, `inplace_vector`, and `deque`, `T` is also
+*Cpp17MoveInsertable* into `X`, and `T` meets the
+*Cpp17MoveConstructible*, *Cpp17MoveAssignable*, and
 *Cpp17Swappable*[[swappable.requirements]] requirements. Neither `i` nor
 `j` are iterators into `a`.
+*Effects:* Inserts copies of elements in \[`i`, `j`) before `p`. Each
 iterator in the range \[`i`, `j`) shall be dereferenced exactly once.
 *Returns:* An iterator that points to the copy of the first element
 inserted into `a`, or `p` if `i == j`.
 ```
 *Result:* `iterator`.
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from
+`*ranges::begin(rg)`. For `vector`, `inplace_vector`, and `deque`, `T`
+is also *Cpp17MoveInsertable* into `X`, and `T` meets the
 *Cpp17MoveConstructible*, *Cpp17MoveAssignable*, and
 *Cpp17Swappable*[[swappable.requirements]] requirements. `rg` and `a` do
 not overlap.
 *Effects:* Inserts copies of elements in `rg` before `p`. Each iterator
 a.erase(q)
 ```
 *Result:* `iterator`.
+*Preconditions:* For `vector`, `inplace_vector`, and `deque`, `T` is
+*Cpp17MoveAssignable*.
 *Effects:* Erases the element pointed to by `q`.
 *Returns:* An iterator that points to the element immediately following
 `q` prior to the element being erased. If no such element exists,
 a.erase(q1, q2)
 ```
 *Result:* `iterator`.
+*Preconditions:* For `vector`, `inplace_vector`, and `deque`, `T` is
+*Cpp17MoveAssignable*.
+*Effects:* Erases the elements in the range \[`q1`, `q2`).
 *Returns:* An iterator that points to the element pointed to by `q2`
 prior to any elements being erased. If no such element exists, `a.end()`
 is returned.
 and assignable from `*i`. For `vector`, if the iterator does not meet
 the forward iterator requirements [[forward.iterators]], `T` is also
 *Cpp17MoveInsertable* into `X`. Neither `i` nor `j` are iterators into
 `a`.
+*Effects:* Replaces elements in `a` with a copy of \[`i`, `j`).
+Invalidates all references, pointers and iterators referring to the
+elements of `a`. For `vector` and `deque`, also invalidates the
+past-the-end iterator. Each iterator in the range \[`i`, `j`) is
+dereferenced exactly once.
 ``` cpp
 a.assign_range(rg)
 ```
 *Mandates:* `assignable_from<T&, ranges::range_reference_t<R>>` is
 modeled.
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from
+`*ranges::begin(rg)`. For `vector`, if `R` models
+`ranges::approximately_sized_range` but not `ranges::sized_range` or
+models `ranges::input_range` but not `ranges::forward_range`, `T` is
+also *Cpp17MoveInsertable* into `X`. `rg` and `a` do not overlap.
 *Effects:* Replaces elements in `a` with a copy of each element in `rg`.
 Invalidates all references, pointers, and iterators referring to the
 elements of `a`. For `vector` and `deque`, also invalidates the
 past-the-end iterator. Each iterator in the range `rg` is dereferenced
 exactly once.
+*Recommended practice:* If `R` models
+`ranges::approximately_sized_range` and
+`ranges::distance(rg) <= ranges::reserve_hint(rg)` is `true`, an
+implementation should not perform any reallocation.
 ``` cpp
 a.assign(il)
 ```
 *Effects:* Equivalent to `a.assign(il.begin(), il.end())`.
 a.front()
 ```
 *Result:* `reference; const_reference` for constant `a`.
+`a.empty()` is `false`.
 *Returns:* `*a.begin()`
 *Remarks:* Required for `basic_string`, `array`, `deque`,
+`forward_list`, `inplace_vector`, `list`, and `vector`.
 ``` cpp
 a.back()
 ```
 *Result:* `reference; const_reference` for constant `a`.
+`a.empty()` is `false`.
 *Effects:* Equivalent to:
 ``` cpp
 auto tmp = a.end();
 --tmp;
 return *tmp;
 ```
+*Remarks:* Required for `basic_string`, `array`, `deque`,
+`inplace_vector`, `list`, and `vector`.
 ``` cpp
 a.emplace_front(args)
 ```
 *Effects:* Appends an object of type `T` constructed with
 `std::forward<Args>(args)...`.
 *Returns:* `a.back()`.
+*Remarks:* Required for `deque`, `inplace_vector`, `list`, and `vector`.
 ``` cpp
 a.push_front(t)
 ```
 *Preconditions:* `T` is *Cpp17CopyInsertable* into `X`.
 *Effects:* Appends a copy of `t`.
+*Remarks:* Required for `basic_string`, `deque`, `inplace_vector`,
+`list`, and `vector`.
 ``` cpp
 a.push_back(rv)
 ```
 *Preconditions:* `T` is *Cpp17MoveInsertable* into `X`.
 *Effects:* Appends a copy of `rv`.
+*Remarks:* Required for `basic_string`, `deque`, `inplace_vector`,
+`list`, and `vector`.
 ``` cpp
 a.append_range(rg)
 ```
 into `X`.
 *Effects:* Inserts copies of elements in `rg` before `end()`. Each
 iterator in the range `rg` is dereferenced exactly once.
+*Remarks:* Required for `deque`, `inplace_vector`, `list`, and `vector`.
 ``` cpp
 a.pop_front()
 ```
 *Result:* `void`
+`a.empty()` is `false`.
 *Effects:* Destroys the first element.
 *Remarks:* Required for `deque`, `forward_list`, and `list`.
 a.pop_back()
 ```
 *Result:* `void`
+`a.empty()` is `false`.
 *Effects:* Destroys the last element.
+*Remarks:* Required for `basic_string`, `deque`, `inplace_vector`,
+`list`, and `vector`.
 ``` cpp
 a[n]
 ```
+*Result:* `reference; const_reference` for constant `a`.
+`n < a.size()` is `true`.
+*Effects:* Equivalent to: `return *(a.begin() + n);`
+*Remarks:* Required for `basic_string`, `array`, `deque`,
+`inplace_vector`, and `vector`.
 ``` cpp
 a.at(n)
 ```
+*Result:* `reference; const_reference` for constant `a`.
 *Returns:* `*(a.begin() + n)`
 *Throws:* `out_of_range` if `n >= a.size()`.
+*Remarks:* Required for `basic_string`, `array`, `deque`,
+`inplace_vector`, and `vector`.
 ### Node handles <a id="container.node">[[container.node]]</a>
 #### Overview <a id="container.node.overview">[[container.node.overview]]</a>
   using key_type       = see below;     // not present for set containers
   using mapped_type    = see below;     // not present for set containers
   using allocator_type = see below;
 private:
+  using container-node-type = unspecified;                  // exposition only
+  using ator-traits = allocator_traits<allocator_type>;     // exposition only
+  typename ator-traits::template
+    rebind_traits<container-node-type>::pointer ptr_;       // exposition only
   optional<allocator_type> alloc_;                          // exposition only
 public:
   // [container.node.cons], constructors, copy, and assignment
   constexpr node-handle() noexcept : ptr_(), alloc_() {}
+ constexpr node-handle(node-handle&&) noexcept;
+ constexpr node-handle& operator=(node-handle&&);
   // [container.node.dtor], destructor
+ constexpr ~node-handle();
   // [container.node.observers], observers
+ constexpr value_type& value() const; // not present for map containers
   key_type& key() const;                        // not present for set containers
+ constexpr mapped_type& mapped() const; // not present for set containers
+ constexpr allocator_type get_allocator() const;
+ constexpr explicit operator bool() const noexcept;
+ constexpr bool empty() const noexcept;
   // [container.node.modifiers], modifiers
+ constexpr void swap(node-handle&)
+    noexcept(ator-traits::propagate_on_container_swap::value ||
+ ator-traits::is_always_equal::value);
+  friend constexpr void swap(node-handle& x, node-handle& y) noexcept(noexcept(x.swap(y))) {
     x.swap(y);
   }
 };
 ```
 #### Constructors, copy, and assignment <a id="container.node.cons">[[container.node.cons]]</a>
 ``` cpp
+constexpr node-handle(node-handle&& nh) noexcept;
 ```
+*Effects:* Constructs a *node-handle* object initializing *ptr\_* with
+`nh.`*`ptr_`*. Move constructs *alloc\_* with `nh.`*`alloc_`*. Assigns
+`nullptr` to `nh.`*`ptr_`* and assigns `nullopt` to `nh.`*`alloc_`*.
 ``` cpp
+constexpr node-handle& operator=(node-handle&& nh);
 ```
+*Preconditions:* Either `!`*`alloc_`* is `true`, or
+*`ator-traits`*`::propagate_on_container_move_assignment::value` is
+`true`, or *`alloc_`*` == nh.`*`alloc_`* is `true`.
 *Effects:*
+- If *`ptr_`*` != nullptr` is `true`, destroys the `value_type`
+ subobject in the *container-node-type* object pointed to by *ptr\_* by
+ calling *`ator-traits`*`::destroy`, then deallocates *ptr\_* by
+ calling
+  *`ator-traits`*`::template rebind_traits<`*`container-node-type`*`>::deallocate`.
+- Assigns `nh.`*`ptr_`* to *ptr\_*.
+- If `!`*`alloc_`* is `true` or
+ *`ator-traits`*`::propagate_on_container_move_assignment::value` is
+ `true`, move assigns `nh.`*`alloc_`* to *alloc\_*.
+- Assigns `nullptr` to `nh.`*`ptr_`* and assigns `nullopt` to
+  `nh.`*`alloc_`*.
 *Returns:* `*this`.
 *Throws:* Nothing.
 #### Destructor <a id="container.node.dtor">[[container.node.dtor]]</a>
 ``` cpp
+constexpr ~node-handle();
 ```
+*Effects:* If *`ptr_`*` != nullptr` is `true`, destroys the `value_type`
+subobject in the *container-node-type* object pointed to by *ptr\_* by
+calling *`ator-traits`*`::destroy`, then deallocates *ptr\_* by calling
+*`ator-traits`*`::template rebind_traits<`*`container-node-type`*`>::deallocate`.
 #### Observers <a id="container.node.observers">[[container.node.observers]]</a>
 ``` cpp
+constexpr value_type& value() const;
 ```
 *Preconditions:* `empty() == false`.
 *Returns:* A reference to the `value_type` subobject in the
+*container-node-type* object pointed to by *ptr\_*.
 *Throws:* Nothing.
 ``` cpp
 key_type& key() const;
 ```
 *Preconditions:* `empty() == false`.
 *Returns:* A non-const reference to the `key_type` member of the
+`value_type` subobject in the *container-node-type* object pointed to by
+*ptr\_*.
 *Throws:* Nothing.
 *Remarks:* Modifying the key through the returned reference is
 permitted.
 ``` cpp
+constexpr mapped_type& mapped() const;
 ```
 *Preconditions:* `empty() == false`.
 *Returns:* A reference to the `mapped_type` member of the `value_type`
+subobject in the *container-node-type* object pointed to by *ptr\_*.
 *Throws:* Nothing.
 ``` cpp
+constexpr allocator_type get_allocator() const;
 ```
 *Preconditions:* `empty() == false`.
+*Returns:* `*`*`alloc_`*.
 *Throws:* Nothing.
 ``` cpp
+constexpr explicit operator bool() const noexcept;
 ```
+*Returns:* *`ptr_`*` != nullptr`.
 ``` cpp
+constexpr bool empty() const noexcept;
 ```
+*Returns:* *`ptr_`*` == nullptr`.
 #### Modifiers <a id="container.node.modifiers">[[container.node.modifiers]]</a>
 ``` cpp
+constexpr void swap(node-handle& nh)
+  noexcept(ator-traits::propagate_on_container_swap::value ||
+ ator-traits::is_always_equal::value);
 ```
+*Preconditions:* `!`*`alloc_`* is `true`, or `!nh.`*`alloc_`*, or
+*`ator-traits`*`::propagate_on_container_swap::value` is `true`, or
+*`alloc_`*` == nh.`*`alloc_`* is `true`.
+*Effects:* Calls `swap(`*`ptr_`*`, nh.`*`ptr_`*`)`. If `!`*`alloc_`* is
+`true`, or `!nh.`*`alloc_`* is `true`, or
+*`ator-traits`*`::propagate_on_container_swap::value` is `true` calls
+`swap(`*`alloc_`*`, nh.`*`alloc_`*`)`.
 ### Insert return type <a id="container.insert.return">[[container.insert.return]]</a>
 The associative containers with unique keys and the unordered containers
 with unique keys have a member function `insert` that returns a nested
   bool     inserted;
   NodeType node;
 };
 ```
+The name *`insert-return-type`* is for exposition only.
 *`insert-return-type`* has the template parameters, data members, and
 special members specified above. It has no base classes or members other
 than those specified.
 ### Associative containers <a id="associative.reqmts">[[associative.reqmts]]</a>
 - `X` denotes an associative container class,
 - `a` denotes a value of type `X`,
 - `a2` denotes a value of a type with nodes compatible with type `X` (
   [[container.node.compat]]),
+- `b` denotes a value of type `X` or `const X`,
 - `u` denotes the name of a variable being declared,
 - `a_uniq` denotes a value of type `X` when `X` supports unique keys,
+- `a_eq` denotes a value of type `X` when `X` supports equivalent keys,
 - `a_tran` denotes a value of type `X` or `const X` when the
   *qualified-id* `X::key_compare::is_transparent` is valid and denotes a
   type [[temp.deduct]],
 - `i` and `j` meet the *Cpp17InputIterator* requirements and refer to
   elements implicitly convertible to `value_type`,
 - `rg` denotes a value of a type `R` that models
   `container-compatible-range<value_type>`,
 - `p` denotes a valid constant iterator to `a`,
 - `q` denotes a valid dereferenceable constant iterator to `a`,
 - `r` denotes a valid dereferenceable iterator to `a`,
+- \[`q1`, `q2`) denotes a valid range of constant iterators in `a`,
 - `il` designates an object of type `initializer_list<value_type>`,
 - `t` denotes a value of type `X::value_type`,
 - `k` denotes a value of type `X::key_type`, and
 - `c` denotes a value of type `X::key_compare` or
   `const X::key_compare`;
 - `m` denotes an allocator of a type convertible to `A`, and `nh`
   denotes a non-const rvalue of type `X::node_type`.
 A type `X` meets the *associative container* requirements if `X` meets
 all the requirements of an allocator-aware container
+[[container.alloc.reqmts]] and the following types, statements, and
+expressions are well-formed and have the specified semantics, except
 that for `map` and `multimap`, the requirements placed on `value_type`
+in [[container.reqmts]] apply instead to `key_type` and `mapped_type`.
+[*Note 3*: For example, in some cases `key_type` and `mapped_type` need
+to be *Cpp17CopyAssignable* even though the associated `value_type`,
+`pair<const key_type, mapped_type>`, is not
 *Cpp17CopyAssignable*. — *end note*]
 ``` cpp
 typename X::key_type
 ```
 *Effects:* Equivalent to `a.emplace(std::forward<Args>(args)...)`,
 except that the element is inserted as close as possible to the position
 just prior to `p`.
+*Returns:* The iterator returned by `emplace`.
 *Complexity:* Logarithmic in general, but amortized constant if the
 element is inserted right before `p`.
 ``` cpp
 a.merge(a2)
 ```
 *Result:* `void`
+*Preconditions:* `a.get_allocator() == a2.get_allocator()` is `true`.
 *Effects:* Attempts to extract each element in `a2` and insert it into
 `a` using the comparison object of `a`. In containers with unique keys,
 if there is an element in `a` with key equivalent to the key of an
 element from `a2`, then that element is not extracted from `a2`.
 *Ensures:* Pointers and references to the transferred elements of `a2`
+refer to those same elements but as members of `a`. If `a.begin()` and
+`a2.begin()` have the same type, iterators referring to the transferred
+elements will continue to refer to their elements, but they now behave
+as iterators into `a`, not into `a2`.
 *Throws:* Nothing unless the comparison object throws.
 *Complexity:* N log(`a.size()+` N), where N has the value `a2.size()`.
 *Result:* `iterator`; `const_iterator` for constant `b`.
 *Returns:* An iterator pointing to the first element with key greater
 than `k`, or `b.end()` if such an element is not found.
+*Complexity:* Logarithmic.
 ``` cpp
 a_tran.upper_bound(ku)
 ```
 - `a_tran` denotes a value of type `X` or `const X` when the
   *qualified-id*s `X::key_equal::is_transparent` and
   `X::hasher::is_transparent` are both valid and denote types
   [[temp.deduct]],
 - `i` and `j` denote input iterators that refer to `value_type`,
+- \[`i`, `j`) denotes a valid range,
 - `rg` denotes a value of a type `R` that models
   `container-compatible-range<value_type>`,
 - `p` and `q2` denote valid constant iterators to `a`,
 - `q` and `q1` denote valid dereferenceable constant iterators to `a`,
 - `r` denotes a valid dereferenceable iterator to `a`,
+- \[`q1`, `q2`) denotes a valid range in `a`,
 - `il` denotes a value of type `initializer_list<value_type>`,
 - `t` denotes a value of type `X::value_type`,
 - `k` denotes a value of type `key_type`,
 - `hf` denotes a value of type `hasher` or `const hasher`,
 - `eq` denotes a value of type `key_equal` or `const key_equal`,
 - `z` denotes a value of type `float`, and
 - `nh` denotes an rvalue of type `X::node_type`.
 A type `X` meets the *unordered associative container* requirements if
 `X` meets all the requirements of an allocator-aware container
+[[container.alloc.reqmts]] and the following types, statements, and
+expressions are well-formed and have the specified semantics, except
 that for `unordered_map` and `unordered_multimap`, the requirements
+placed on `value_type` in [[container.reqmts]] apply instead to
 `key_type` and `mapped_type`.
+[*Note 3*: For example, `key_type` and `mapped_type` sometimes need to
+be *Cpp17CopyAssignable* even though the associated `value_type`,
+`pair<const key_type, mapped_type>`, is not
 *Cpp17CopyAssignable*. — *end note*]
 ``` cpp
 typename X::key_type
 ```
 ``` cpp
 X(b)
 ```
 *Effects:* In addition to the container
+requirements [[container.reqmts]], copies the hash function, predicate,
+and maximum load factor.
 *Complexity:* Average case linear in `b.size()`, worst case quadratic.
 ``` cpp
 a = b
 a.emplace_hint(p, args)
 ```
 *Result:* `iterator`
+*Effects:* Equivalent to `a.emplace(std::forward<Args>(args)...)`,
+except that the `const_iterator` `p` is a hint pointing to where the
+search should start. Implementations are permitted to ignore the hint.
+*Returns:* The iterator returned by `emplace`.
 ``` cpp
 a_uniq.insert(t)
 ```
 *Result:* `void`
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `X`
 from `*i`. Neither `i` nor `j` are iterators into `a`.
+*Effects:* Equivalent to `a.insert(t)` for each element in \[`i`, `j`).
 *Complexity:* Average case 𝑂(N), where N is `distance(i, j)`, worst case
 𝑂(N(`a.size()` + 1)).
 ``` cpp
 a.erase(q1, q2)
 ```
 *Result:* `iterator`
+*Effects:* Erases all elements in the range \[`q1`, `q2`).
 *Returns:* The iterator immediately following the erased elements prior
 to the erasure.
 *Complexity:* Average case linear in `distance(q1, q2)`, worst case
 *Preconditions:* `b.bucket_count() > 0`.
 *Returns:* The index of the bucket in which elements with keys
 equivalent to `k` would be found, if any such element existed. The
+return value is in the range \[`0`, `b.bucket_count()`).
+*Complexity:* Constant.
+``` cpp
+a_tran.bucket(ke)
+```
+*Result:* `size_type`
+*Preconditions:* `a_tran.bucket_count() > 0`.
+*Ensures:* The return value is in the range \[`0`,
+`a_tran.bucket_count()`).
+*Returns:* The index of the bucket in which elements with keys
+equivalent to `ke` would be found, if any such element existed.
 *Complexity:* Constant.
 ``` cpp
 b.bucket_size(n)
 ```
 *Result:* `size_type`
+*Preconditions:* `n` shall be in the range \[`0`, `b.bucket_count()`).
 *Returns:* The number of elements in the `n`ᵗʰ bucket.
 *Complexity:* 𝑂(`b.bucket_size(n)`)
 b.begin(n)
 ```
 *Result:* `local_iterator`; `const_local_iterator` for constant `b`.
+*Preconditions:* `n` is in the range \[`0`, `b.bucket_count()`).
 *Returns:* An iterator referring to the first element in the bucket. If
 the bucket is empty, then `b.begin(n) == b.end(n)`.
 *Complexity:* Constant.
 b.end(n)
 ```
 *Result:* `local_iterator`; `const_local_iterator` for constant `b`.
+*Preconditions:* `n` is in the range \[`0`, `b.bucket_count()`).
 *Returns:* An iterator which is the past-the-end value for the bucket.
 *Complexity:* Constant.
 b.cbegin(n)
 ```
 *Result:* `const_local_iterator`
+*Preconditions:* `n` shall be in the range \[`0`, `b.bucket_count()`).
 *Returns:* An iterator referring to the first element in the bucket. If
 the bucket is empty, then `b.cbegin(n) == b.cend(n)`.
 *Complexity:* Constant.
 b.cend(n)
 ```
 *Result:* `const_local_iterator`
+*Preconditions:* `n` is in the range \[`0`, `b.bucket_count()`).
 *Returns:* An iterator which is the past-the-end value for the bucket.
 *Complexity:* Constant.
 element is owned by a `node_type` is undefined behavior. References and
 pointers to an element obtained while it is owned by a `node_type` are
 invalidated if the element is successfully inserted.
 The member function templates `find`, `count`, `equal_range`,
+`contains`, `extract`, `erase`, and `bucket` shall not participate in
+overload resolution unless the *qualified-id*s `Pred::is_transparent`
+and `Hash::is_transparent` are both valid and denote types
+[[temp.deduct]]. Additionally, the member function templates `extract`
+and `erase` shall not participate in overload resolution if
 `is_convertible_v<K&&, iterator> || is_convertible_v<K&&, const_iterator>`
 is `true`, where `K` is the type substituted as the first template
 argument.
 A deduction guide for an unordered associative container shall not

Diff to HTML by rtfpessoa