[containers] - C++11 → C++14

Files changed (1) hide show

tmp/tmpyqgk4xlt/{from.md → to.md} +583 -504

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

@@ -50,15 +50,16 @@ function and destroyed using the
 container’s element type, not for internal types used by the container.
 This means, for example, that a node-based container might need to
 construct nodes containing aligned buffers and call `construct` to place
 the element into the buffer.
-In Tables  [[tab:containers.container.requirements]] and
-[[tab:containers.reversible.requirements]], `X` denotes a container
-class containing objects of type `T`, `a` and `b` denote values of type
-`X`, `u` denotes an identifier, `r` denotes a non-const value of type
-`X`, and `rv` denotes a non-const rvalue of type `X`.
 Notes: the algorithm `equal()` is defined in Clause  [[algorithms]].
 Those entries marked “(Note A)” or “(Note B)” have linear complexity for
 `array` and have constant complexity for all other standard containers.
@@ -70,28 +71,44 @@ constructors, inserts, and erases.
 returns an iterator referring to the first element in the container.
 `end()` returns an iterator which is the past-the-end value for the
 container. If the container is empty, then `begin() == end()`;
 Unless otherwise specified, all containers defined in this clause obtain
 memory using an allocator (see  [[allocator.requirements]]). Copy
 constructors for these container types obtain an allocator by calling
 `allocator_traits<allocator_type>::select_on_container_copy_construction`
-on their first parameters. Move constructors obtain an allocator by move
-construction from the allocator belonging to the container being moved.
-Such move construction of the allocator shall not exit via an exception.
-All other constructors for these container types take an `Allocator&`
-argument ([[allocator.requirements]]), an allocator whose value type is
-the same as the container’s value type. If an invocation of a
-constructor uses the default value of an optional allocator argument,
-then the `Allocator` type must support value initialization. A copy of
-this allocator is used for any memory allocation 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
 `allocator_traits<allocator_type>::propagate_on_container_copy_assignment::value`,
 `allocator_traits<allocator_type>::propagate_on_container_move_assignment::value`,
 or
 `allocator_traits<allocator_type>::propagate_on_container_swap::value`
 is true within the implementation of the corresponding container
@@ -130,12 +147,13 @@ Unless otherwise specified (see  [[associative.reqmts.except]],
 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()` or `push_front()`
-  function, that function has no effects.
 - no `erase()`, `clear()`, `pop_back()` or `pop_front()` function throws
   an exception.
 - no copy constructor or assignment operator of a returned iterator
   throws an exception.
 - no `swap()` function throws an exception.
@@ -163,29 +181,56 @@ All of the containers defined in this Clause and in ([[basic.string]])
 except `array` meet the additional requirements of an allocator-aware
 container, as described in Table  [[tab:containers.allocatoraware]].
 Given a container type `X` having an `allocator_type` identical to `A`
 and a `value_type` identical to `T` and given an lvalue `m` of type `A`,
-a pointer `p` of type `T*`, an expression `v` of type `T`, and an rvalue
-`rv` of type `T`, the following terms are defined. (If `X` is not
-allocator-aware, the terms below are defined as if `A` were
-`std::allocator<T>`.)
-- `T` is *`CopyInsertable` into `X`* means that the following expression
-  is well-formed:
   ``` cpp
-  allocator_traits<A>::construct(m, p, v);
   ```
 - `T` is *`MoveInsertable` into `X`* means that the following expression
   is well-formed:
   ``` cpp
-  allocator_traits<A>::construct(m, p, rv);
   ```
 - `T` is *`EmplaceConstructible` into `X` from `args`*, for zero or more
   arguments `args`, means that the following expression is well-formed:
   ``` cpp
-  allocator_traits<A>::construct(m, p, args);
   ```
 A container calls `allocator_traits<A>::construct(m, p, args)` to
 construct an element at `p` using `args`. The default `construct` in
 `std::allocator` will call `::new((void*)p) T(args)`, but specialized
@@ -193,12 +238,12 @@ allocators may choose a different definition.
 In Table  [[tab:containers.allocatoraware]], `X` denotes an
 allocator-aware container class with a `value_type` of `T` using
 allocator of type `A`, `u` denotes a variable, `a` and `b` denote
 non-const lvalues of type `X`, `t` denotes an lvalue or a const rvalue
-of type X``, `rv` denotes a non-const rvalue of type `X`, `m` is a value
-of type `A`, and `Q` is an allocator type.
 ### Container data races <a id="container.requirements.dataraces">[[container.requirements.dataraces]]</a>
 For purposes of avoiding data races ([[res.on.data.races]]),
 implementations shall consider the following functions to be `const`:
@@ -206,11 +251,11 @@ implementations shall consider the following functions to be `const`:
 `lower_bound`, `upper_bound`, `equal_range`, `at` and, except in
 associative or unordered associative containers, `operator[]`.
 Notwithstanding ([[res.on.data.races]]), implementations are required
 to avoid data races when the contents of the contained object in
-different elements in the same sequence, excepting `vector<bool>`, are
 modified concurrently.
 For a `vector<int> x` with a size greater than one, `x[1] = 5` and
 `*x.begin() = 10` can be executed concurrently without a data race, but
 `x[0] = 5` and `*x.begin() = 10` executed concurrently may result in a
@@ -269,12 +314,12 @@ The iterator returned from `a.insert(p, n, t)` points to the copy of the
 first element inserted into `a`, or `p` if `n == 0`.
 The iterator returned from `a.insert(p, i, j)` points to the copy of the
 first element inserted into `a`, or `p` if `i == j`.
-The iterator returned from `a.insert(p, i1)` points to the copy of the
-first element inserted into `a`, or `p` if `i1` is empty.
 The iterator returned from `a.emplace(p, args)` points to the new
 element constructed from `args` into `a`.
 The iterator returned from `a.erase(q)` points to the element
@@ -334,12 +379,12 @@ library provides four basic kinds of associative containers: `set`,
 `multiset`, `map` and `multimap`.
 Each associative container is parameterized on `Key` and an ordering
 relation `Compare` that induces a strict weak ordering (
 [[alg.sorting]]) on elements of `Key`. In addition, `map` and `multimap`
-associate an arbitrary type `T` with the `Key`. The object of type
-`Compare` is called the *comparison object* of a container.
 The phrase “equivalence of keys” means the equivalence relation imposed
 by the comparison and *not* the `operator==` on keys. That is, two keys
 `k1` and `k2` are considered to be equivalent if for the comparison
 object `comp`, `comp(k1, k2) == false && comp(k2, k1) == false`. For any
@@ -352,12 +397,11 @@ The `set` and `map` classes support unique keys; the `multiset` and
 `multimap` classes support equivalent keys. For `multiset` and
 `multimap`, `insert`, `emplace`, and `erase` preserve the relative
 ordering of equivalent elements.
 For `set` and `multiset` the value type is the same as the key type. For
-`map` and `multimap` it is equal to `pair<const Key, T>`. Keys in an
-associative container are immutable.
 `iterator`
 of an associative container is of the bidirectional iterator category.
 For associative containers where the value type is the same as the key
@@ -378,24 +422,31 @@ associated `value_type`, `pair<const key_type, mapped_type>`, is not
 `CopyAssignable`.
 In Table  [[tab:containers.associative.requirements]], `X` denotes an
 associative container class, `a` denotes a value of `X`, `a_uniq`
 denotes a value of `X` when `X` supports unique keys, `a_eq` denotes a
-value of `X` when `X` supports multiple keys, `u` denotes an identifier,
-`i` and `j` satisfy input iterator requirements and refer to elements
-implicitly convertible to `value_type`, \[`i`, `j`) denotes a valid
-range, `p` denotes a valid const iterator to `a`, `q` denotes a valid
-dereferenceable const iterator to `a`, `[q1, q2)` denotes a valid range
-of const iterators in `a`, `il` designates an object of type
-`initializer_list<value_type>`, `t` denotes a value of `X::value_type`,
-`k` denotes a value of `X::key_type` and `c` denotes a value of type
-`X::key_compare`. `A` denotes the storage allocator used by `X`, if any,
-or `std::allocator<X::value_type>` otherwise, and `m` denotes an
-allocator of a type convertible to `A`.
 The `insert` and `emplace` members shall not affect the validity of
-iterators and references to the container, and the erase members shall
 invalidate only iterators and references to the erased elements.
 The fundamental property of iterators of associative containers is that
 they iterate through the containers in the non-descending order of keys
 where non-descending is defined by the comparison that was used to
@@ -419,10 +470,15 @@ passed object, even if that object is passed by reference. When an
 associative container is copied, either through a copy constructor or an
 assignment operator, the target container shall then use the comparison
 object from the container being copied, as if that comparison object had
 been passed to the target container in its constructor.
 #### Exception safety guarantees <a id="associative.reqmts.except">[[associative.reqmts.except]]</a>
 For associative containers, no `clear()` function throws an exception.
 `erase(k)` does not throw an exception unless that exception is thrown
 by the container’s `Compare` object (if any).
@@ -454,19 +510,24 @@ function object type `Hash` that meets the `Hash` requirements (
 of type `Key`, and by a binary predicate `Pred` that induces an
 equivalence relation on values of type `Key`. Additionally,
 `unordered_map` and `unordered_multimap` associate an arbitrary *mapped
 type* `T` with the `Key`.
-A hash function is a function object that takes a single argument of
-type `Key` and returns a value of type `std::size_t`.
 Two values `k1` and `k2` of type `Key` are considered equivalent if the
-container’s `key_equal` function object returns `true` when passed those
-values. If `k1` and `k2` are equivalent, the hash function shall return
-the same value for both. Thus, when an unordered associative container
-is instantiated with a non-default `Pred` parameter it usually needs a
-non-default `Hash` parameter as well.
 An unordered associative container supports *unique keys* if it may
 contain at most one element for each key. Otherwise, it supports
 *equivalent keys*. `unordered_set` and `unordered_map` support unique
 keys. `unordered_multiset` and `unordered_multimap` support equivalent
@@ -482,10 +543,18 @@ unless otherwise specified.
 For `unordered_set` and `unordered_multiset` the value type is the same
 as the key type. For `unordered_map` and `unordered_multimap` it is
 `std::pair<const Key,
 T>`.
 The elements of an unordered associative container are organized into
 *buckets*. Keys with the same hash code appear in the same bucket. The
 number of buckets is automatically increased as elements are added to an
 unordered associative container, so that the average number of elements
 per bucket is kept below a bound. Rehashing invalidates iterators,
@@ -520,15 +589,14 @@ type `float`.
 Two unordered containers `a` and `b` compare equal if
 `a.size() == b.size()` and, for every equivalent-key group \[`Ea1`,
 `Ea2`) obtained from `a.equal_range(Ea1)`, there exists an
 equivalent-key group \[`Eb1`, `Eb2`) obtained from `b.equal_range(Ea1)`,
-such that `distance(Ea1, Ea2) == distance(Eb1, Eb2)` and
-`is_permutation(Ea1, Ea2, Eb1)` returns `true`. For `unordered_set` and
-`unordered_map`, the complexity of `operator==` (i.e., the number of
-calls to the `==` operator of the `value_type`, to the predicate
-returned by `key_equal()`, and to the hasher returned by
 `hash_function()`) is proportional to N in the average case and to N² in
 the worst case, where N is a.size(). For `unordered_multiset` and
 `unordered_multimap`, the complexity of `operator==` is proportional to
 $\sum E_i^2$ in the average case and to N² in the worst case, where N is
 `a.size()`, and Eᵢ is the size of the iᵗʰ equivalent-key group in `a`.
@@ -550,12 +618,13 @@ associative container are of at least the forward iterator category. For
 unordered associative containers where the key type and value type are
 the same, both `iterator` and `const_iterator` are const iterators.
 The `insert` and `emplace` members shall not affect the validity of
 references to container elements, but may invalidate all iterators to
-the container. The erase members shall invalidate only iterators and
-references to the erased elements.
 The `insert` and `emplace` members shall not affect the validity of
 iterators if `(N+n) < z * B`, where `N` is the number of elements in the
 container prior to the insert operation, `n` is the number of elements
 inserted, `B` is the container’s bucket count, and `z` is the
@@ -619,15 +688,15 @@ namespace std {
   template <class T, size_t N>
     struct tuple_size<array<T, N> >;
   template <size_t I, class T, size_t N>
     struct tuple_element<I, array<T, N> >;
   template <size_t I, class T, size_t N>
-    T& get(array<T, N>&) noexcept;
   template <size_t I, class T, size_t N>
-    T&& get(array<T, N>&&) noexcept;
   template <size_t I, class T, size_t N>
-    const T& get(const array<T, N>&) noexcept;
 }
 ```
 \synopsis{Header \texttt{\<deque\>} synopsis}
@@ -726,10 +795,11 @@ namespace std {
   template <class Allocator> class vector<bool,Allocator>;
   // hash support
   template <class T> struct hash;
   template <class Allocator> struct hash<vector<bool, Allocator> >;
 ```
 ### Class template `array` <a id="array">[[array]]</a>
 #### Class template `array` overview <a id="array.overview">[[array.overview]]</a>
@@ -772,12 +842,12 @@ namespace std {
     typedef size_t                                size_type;
     typedef ptrdiff_t                             difference_type;
     typedef T                                     value_type;
     typedef T*                                    pointer;
     typedef const T*                              const_pointer;
-    typedef reverse_iterator<iterator> reverse_iterator;
-    typedef reverse_iterator<const_iterator> const_reverse_iterator;
     T       elems[N];           // exposition only
     // no explicit construct/copy/destroy for aggregate type
@@ -799,23 +869,23 @@ namespace std {
     const_iterator         cend() const noexcept;
     const_reverse_iterator crbegin() const noexcept;
     const_reverse_iterator crend() const noexcept;
     // capacity:
-    constexpr size_type size() noexcept;
-    constexpr size_type max_size() noexcept;
-    constexpr bool      empty() noexcept;
     // element access:
     reference                 operator[](size_type n);
-    const_reference operator[](size_type n) const;
-    const_reference at(size_type n) const;
     reference                 at(size_type n);
     reference                 front();
-    const_reference front() const;
     reference                 back();
-    const_reference back() const;
     T *       data() noexcept;
     const T * data() const noexcept;
   };
 }
@@ -846,16 +916,16 @@ template <class T, size_t N> void swap(array<T,N>& x, array<T,N>& y) noexcept(no
 ``` cpp
 x.swap(y);
 ```
-*Complexity:* linear in `N`.
 #### `array::size` <a id="array.size">[[array.size]]</a>
 ``` cpp
-template <class T, size_t N> constexpr size_type array<T,N>::size() noexcept;
 ```
 *Returns:* `N`
 #### `array::data` <a id="array.data">[[array.data]]</a>
@@ -884,11 +954,11 @@ void swap(array& y) noexcept(noexcept(swap(declval<T&>(), declval<T&>())));
 *Effects:* `swap_ranges(begin(), end(), y.begin())`
 *Throws:* Nothing unless one of the element-wise swap calls throws an
 exception.
-*Note:* Unlike the `swap` function for other containers, array::swap
 takes linear time, may exit via an exception, and does not cause
 iterators to become associated with the other container.
 #### Zero sized arrays <a id="array.zero">[[array.zero]]</a>
@@ -904,42 +974,43 @@ Member function `swap()` shall have a *noexcept-specification* which is
 equivalent to `noexcept(true)`.
 #### Tuple interface to class template `array` <a id="array.tuple">[[array.tuple]]</a>
 ``` cpp
-tuple_size<array<T, N> >::value
 ```
-*Return type:* integral constant expression.
-*Value:* `N`
 ``` cpp
 tuple_element<I, array<T, N> >::type
 ```
 *Requires:* `I < N`. The program is ill-formed if `I` is out of bounds.
 *Value:* The type T.
 ``` cpp
-template <size_t I, class T, size_t N> T& get(array<T, N>& a) noexcept;
 ```
 *Requires:* `I < N`. The program is ill-formed if `I` is out of bounds.
 *Returns:* A reference to the `I`th element of `a`, where indexing is
 zero-based.
 ``` cpp
-template <size_t I, class T, size_t N> T&& get(array<T, N>&& a) noexcept;
 ```
 *Effects:* Equivalent to `return std::move(get<I>(a));`
 ``` cpp
-template <size_t I, class T, size_t N> const T& get(const array<T, N>& a) noexcept;
 ```
 *Requires:* `I < N`. The program is ill-formed if `I` is out of bounds.
 *Returns:* A const reference to the `I`th element of `a`, where indexing
@@ -983,12 +1054,13 @@ namespace std {
     typedef typename allocator_traits<Allocator>::const_pointer     const_pointer;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
     // [deque.cons], construct/copy/destroy:
- explicit deque(const Allocator& = Allocator());
-    explicit deque(size_type n);
     deque(size_type n, const T& value, const Allocator& = Allocator());
     template <class InputIterator>
       deque(InputIterator first, InputIterator last, const Allocator& = Allocator());
     deque(const deque& x);
     deque(deque&&);
@@ -1085,24 +1157,25 @@ namespace std {
 ```
 #### `deque` constructors, copy, and assignment <a id="deque.cons">[[deque.cons]]</a>
 ``` cpp
-explicit deque(const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `deque`, using the specified allocator.
 *Complexity:* Constant.
 ``` cpp
-explicit deque(size_type n);
 ```
-*Effects:* Constructs a `deque` with `n` value-initialized elements.
-*Requires:* `T` shall be `DefaultConstructible`.
 *Complexity:* Linear in `n`.
 ``` cpp
 deque(size_type n, const T& value,
@@ -1123,71 +1196,46 @@ template <class InputIterator>
 ```
 *Effects:* Constructs a `deque` equal to the range \[`first`, `last`),
 using the specified allocator.
-*Complexity:* `distance(first, last)`.
-``` cpp
-template <class InputIterator>
-  void assign(InputIterator first, InputIterator last);
-```
-*Effects:*
-``` cpp
-erase(begin(), end());
-insert(begin(), first, last);
-```
-``` cpp
-void assign(size_type n, const T& t);
-```
-*Effects:*
-``` cpp
-erase(begin(), end());
-insert(begin(), n, t);
-```
 #### `deque` capacity <a id="deque.capacity">[[deque.capacity]]</a>
 ``` cpp
 void resize(size_type sz);
 ```
-*Effects:* If `sz <= size()`, equivalent to
-`erase(begin() + sz, end());`. If `size() < sz`, appends `sz - size()`
-value-initialized elements to the sequence.
-*Requires:* `T` shall be `DefaultConstructible`.
 ``` cpp
 void resize(size_type sz, const T& c);
 ```
-*Effects:*
-``` cpp
-if (sz > size())
-  insert(end(), sz-size(), c);
-else if (sz < size())
-  erase(begin()+sz, end());
-else
-  ;                 // do nothing
-```
 *Requires:* `T` shall be `CopyInsertable` into `*this`.
 ``` cpp
 void shrink_to_fit();
 ```
-*Remarks:* `shrink_to_fit` is a non-binding request to reduce memory
-use. The request is non-binding to allow latitude for
-implementation-specific optimizations.
 #### `deque` modifiers <a id="deque.modifiers">[[deque.modifiers]]</a>
 ``` cpp
 iterator insert(const_iterator position, const T& x);
@@ -1212,12 +1260,14 @@ iterators and references to elements of the deque. An insertion at
 either end of the deque invalidates all the iterators to the deque, but
 has no effect on the validity of references to elements of the deque.
 *Remarks:* If an exception is thrown other than by the copy constructor,
 move constructor, assignment operator, or move assignment operator of
-`T` there are no effects. If an exception is thrown by the move
-constructor of a non-`CopyInsertable` `T`, the effects are unspecified.
 *Complexity:* The complexity is linear in the number of elements
 inserted plus the lesser of the distances to the beginning and end of
 the deque. Inserting a single element either at the beginning or end of
 a deque always takes constant time and causes a single call to a
@@ -1271,23 +1321,23 @@ access to list elements is not supported. It is intended that
 hand-written C-style singly linked list. Features that would conflict
 with that goal have been omitted.
 A `forward_list` satisfies all of the requirements of a container
 (Table  [[tab:containers.container.requirements]]), except that the
-`size()` member function is not provided. A `forward_list` also
-satisfies all of the requirements for an allocator-aware container
-(Table  [[tab:containers.allocatoraware]]). In addition, a
-`forward_list` provides the `assign` member functions (Table
-[[tab:containers.sequence.requirements]]) and several of the optional
-container requirements (Table  [[tab:containers.sequence.optional]]).
-Descriptions are provided here only for operations on `forward_list`
-that are not described in that table or for operations where there is
-additional semantic information.
 Modifying any list requires access to the element preceding the first
 element of interest, but in a `forward_list` there is no constant-time
-way to acess a preceding element. For this reason, ranges that are
 modified, such as those supplied to `erase` and `splice`, must be open
 at the beginning.
 ``` cpp
 namespace std {
@@ -1305,12 +1355,13 @@ namespace std {
     typedef Allocator allocator_type;
     typedef typename allocator_traits<Allocator>::pointer         pointer;
     typedef typename allocator_traits<Allocator>::const_pointer   const_pointer;
     // [forwardlist.cons], construct/copy/destroy:
- explicit forward_list(const Allocator& = Allocator());
-    explicit forward_list(size_type n);
     forward_list(size_type n, const T& value,
                  const Allocator& = Allocator());
     template <class InputIterator>
       forward_list(InputIterator first, InputIterator last,
                    const Allocator& = Allocator());
@@ -1422,26 +1473,26 @@ namespace std {
 ```
 #### `forward_list` constructors, copy, assignment <a id="forwardlist.cons">[[forwardlist.cons]]</a>
 ``` cpp
-explicit forward_list(const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `forward_list` object using the specified
 allocator.
 *Complexity:* Constant.
 ``` cpp
-explicit forward_list(size_type n);
 ```
-*Effects:* Constructs a `forward_list` object with `n` value-initialized
-elements.
-*Requires:* `T` shall be `DefaultConstructible`.
 *Complexity:* Linear in `n`.
 ``` cpp
 forward_list(size_type n, const T& value, const Allocator& = Allocator());
@@ -1462,23 +1513,10 @@ template <class InputIterator>
 *Effects:* Constructs a `forward_list` object equal to the range
 \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
-``` cpp
-template <class InputIterator>
-  void assign(InputIterator first, InputIterator last);
-```
-*Effects:* `clear(); insert_after(before_begin(), first, last);`
-``` cpp
-void assign(size_type n, const T& t);
-```
-*Effects:* `clear(); insert_after(before_begin(), n, t);`
 #### `forward_list` iterators <a id="forwardlist.iter">[[forwardlist.iter]]</a>
 ``` cpp
 iterator before_begin() noexcept;
 const_iterator before_begin() const noexcept;
@@ -1577,11 +1615,11 @@ iterator insert_after(const_iterator position, initializer_list<T> il);
 ```
 *Effects:* `insert_after(p, il.begin(), il.end())`.
 *Returns:* An iterator pointing to the last inserted element or
-`position` if `i1` is empty.
 ``` cpp
 template <class... Args>
   iterator emplace_after(const_iterator position, Args&&... args);
 ```
@@ -1621,21 +1659,31 @@ dereferenceable.
 *Throws:* Nothing.
 ``` cpp
 void resize(size_type sz);
 void resize(size_type sz, const value_type& c);
 ```
 *Effects:* If `sz < distance(begin(), end())`, erases the last
 `distance(begin(), end()) - sz` elements from the list. Otherwise,
-inserts `sz - distance(begin(), end())` elements at the end of the list.
-For the first signature the inserted elements are value-initialized, and
-for the second signature they are copies of `c`.
-*Requires:* `T` shall be `DefaultConstructible` for the first form and
-it shall be `CopyInsertable` into `*this` for the second form.
 ``` cpp
 void clear() noexcept;
 ```
@@ -1649,11 +1697,12 @@ void clear() noexcept;
 void splice_after(const_iterator position, forward_list& x);
 void splice_after(const_iterator position, forward_list&& x);
 ```
 *Requires:* `position` is `before_begin()` or is a dereferenceable
-iterator in the range \[`begin()`, `end()`). `&x != this`.
 *Effects:* Inserts the contents of `x` after `position`, and `x` becomes
 empty. Pointers and references to the moved elements of `x` now refer to
 those same elements but as members of `*this`. Iterators referring to
 the moved elements will continue to refer to their elements, but they
@@ -1669,17 +1718,18 @@ void splice_after(const_iterator position, forward_list&& x, const_iterator i);
 ```
 *Requires:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). The iterator following `i`
 is a dereferenceable iterator in `x`.
 *Effects:* Inserts the element following `i` into `*this`, following
 `position`, and removes it from `x`. The result is unchanged if
-`position == i` or `position == ++i`. Pointers and references to `*i`
 continue to refer to the same element but as a member of `*this`.
-Iterators to `*i` (including `i` itself) continue to refer to the same
-element, but now behave as iterators into `*this`, not into `x`.
 *Throws:* Nothing.
 *Complexity:* 𝑂(1)
@@ -1692,11 +1742,11 @@ void splice_after(const_iterator position, forward_list&& x,
 *Requires:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). (`first`, `last`) is a
 valid range in `x`, and all iterators in the range (`first`, `last`) are
 dereferenceable. `position` is not an iterator in the range (`first`,
-`last`).
 *Effects:* Inserts elements in the range (`first`, `last`) after
 `position` and removes the elements from `x`. Pointers and references to
 the moved elements of `x` now refer to those same elements but as
 members of `*this`. Iterators referring to the moved elements will
@@ -1710,18 +1760,18 @@ void remove(const T& value);
 template <class Predicate> void remove_if(Predicate pred);
 ```
 *Effects:* Erases all the elements in the list referred by a list
 iterator `i` for which the following conditions hold: `*i == value` (for
-`remove()`), `pred(*i)` is true (for `remove_if()`). This operation
-shall be stable: the relative order of the elements that are not removed
-is the same as their relative order in the original list. Invalidates
-only the iterators and references to the erased elements.
 *Throws:* Nothing unless an exception is thrown by the equality
 comparison or the predicate.
 *Complexity:* Exactly `distance(begin(), end())` applications of the
 corresponding predicate.
 ``` cpp
 void unique();
@@ -1743,28 +1793,32 @@ comparison or the predicate.
 otherwise no applications of the predicate.
 ``` cpp
 void merge(forward_list& x);
 void merge(forward_list&& x);
-template <class Compare> void merge(forward_list& x, Compare comp)
-template <class Compare> void merge(forward_list&& x, Compare comp)
 ```
 *Requires:* `comp` defines a strict weak ordering ([[alg.sorting]]),
 and `*this` and `x` are both sorted according to this ordering.
-*Effects:* Merges `x` into `*this`. This operation shall be stable: for
-equivalent elements in the two lists, the elements from `*this` shall
-always precede the elements from `x`. `x` is empty after the merge. If
-an exception is thrown other than by a comparison there are no effects.
-Pointers and references to the moved elements of `x` now refer to those
-same elements but as members of `*this`. Iterators referring to the
-moved elements will continue to refer to their elements, but they now
-behave as iterators into `*this`, not into `x`.
-*Complexity:* At most distance(begin(), end()) + distance(x.begin(),
-x.end()) - 1 comparisons.
 ``` cpp
 void sort();
 template <class Compare> void sort(Compare comp);
 ```
@@ -1772,14 +1826,15 @@ template <class Compare> void sort(Compare comp);
 *Requires:* `operator<` (for the version with no arguments) or `comp`
 (for the version with a comparison argument) defines a strict weak
 ordering ([[alg.sorting]]).
 *Effects:* Sorts the list according to the `operator<` or the `comp`
-function object. This operation shall be stable: the relative order of
-the equivalent elements is preserved. If an exception is thrown the
-order of the elements in `*this` is unspecified. Does not affect the
-validity of iterators and references.
 *Complexity:* Approximately N log N comparisons, where N is
 `distance(begin(), end())`.
 ``` cpp
@@ -1840,12 +1895,13 @@ namespace std {
     typedef typename allocator_traits<Allocator>::const_pointer     const_pointer;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
     // [list.cons], construct/copy/destroy:
- explicit list(const Allocator& = Allocator());
-    explicit list(size_type n);
     list(size_type n, const T& value, const Allocator& = Allocator());
     template <class InputIterator>
       list(InputIterator first, InputIterator last, const Allocator& = Allocator());
     list(const list& x);
     list(list&& x);
@@ -1962,24 +2018,25 @@ namespace std {
 ```
 #### `list` constructors, copy, and assignment <a id="list.cons">[[list.cons]]</a>
 ``` cpp
-explicit list(const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty list, using the specified allocator.
 *Complexity:* Constant.
 ``` cpp
-explicit list(size_type n);
 ```
-*Effects:* Constructs a `list` with `n` value-initialized elements.
-*Requires:* `T` shall be `DefaultConstructible`.
 *Complexity:* Linear in `n`.
 ``` cpp
 list(size_type n, const T& value,
@@ -2001,40 +2058,26 @@ list(InputIterator first, InputIterator last,
 *Effects:* Constructs a `list` equal to the range \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
-``` cpp
-template <class InputIterator>
-  void assign(InputIterator first, InputIterator last);
-```
-*Effects:* Replaces the contents of the list with the range
-`[first, last)`.
-``` cpp
-void assign(size_type n, const T& t);
-```
-*Effects:* Replaces the contents of the list with `n` copies of `t`.
 #### `list` capacity <a id="list.capacity">[[list.capacity]]</a>
 ``` cpp
 void resize(size_type sz);
 ```
-*Effects:* If `size() < sz`, appends `sz - size()` value-initialized
 elements to the sequence. If `sz <= size()`, equivalent to
 ``` cpp
 list<T>::iterator it = begin();
 advance(it, sz);
 erase(it, end());
 ```
-*Requires:* `T` shall be `DefaultConstructible`.
 ``` cpp
 void resize(size_type sz, const T& c);
 ```
@@ -2179,11 +2222,11 @@ iterator `i` for which the following conditions hold:
 references to the erased elements.
 *Throws:* Nothing unless an exception is thrown by `*i == value` or
 `pred(*i) != false`.
-*Remarks:* Stable.
 *Complexity:* Exactly `size()` applications of the corresponding
 predicate.
 ``` cpp
@@ -2196,11 +2239,11 @@ of equal elements referred to by the iterator `i` in the range
 \[`first + 1`, `last`) for which `*i == *(i-1)` (for the version of
 `unique` with no arguments) or `pred(*i, *(i - 1))` (for the version of
 `unique` with a predicate argument) holds. Invalidates only the
 iterators and references to the erased elements.
-*Throws:* Nothing unless an exception in thrown by `*i == *(i-1)` or
 `pred(*i, *(i - 1))`
 *Complexity:* If the range `[first, last)` is not empty, exactly
 `(last - first) - 1` applications of the corresponding predicate,
 otherwise no applications of the predicate.
@@ -2225,13 +2268,14 @@ according to the ordering defined by `comp`; that is, for every iterator
 elements of `x` now refer to those same elements but as members of
 `*this`. Iterators referring to the moved elements will continue to
 refer to their elements, but they now behave as iterators into `*this`,
 not into `x`.
-*Remarks:* Stable. If `(&x != this)` the range `[x.begin(), x.end())` is
-empty after the merge. No elements are copied by this operation. The
-behavior is undefined if `this->get_allocator() != x.get_allocator()`.
 *Complexity:* At most `size() + x.size() - 1` applications of `comp` if
 `(&x != this)`; otherwise, no applications of `comp` are performed. If
 an exception is thrown other than by a comparison there are no effects.
@@ -2254,11 +2298,11 @@ second version) shall define a strict weak ordering ([[alg.sorting]]).
 *Effects:* Sorts the list according to the `operator<` or a `Compare`
 function object. Does not affect the validity of iterators and
 references.
-*Remarks:* Stable.
 *Complexity:* Approximately N log(N) comparisons, where `N == size()`.
 #### `list` specialized algorithms <a id="list.special">[[list.special]]</a>
@@ -2315,12 +2359,13 @@ namespace std {
     typedef typename allocator_traits<Allocator>::const_pointer     const_pointer;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
     // [vector.cons], construct/copy/destroy:
- explicit vector(const Allocator& = Allocator());
-    explicit vector(size_type n);
     vector(size_type n, const T& value, const Allocator& = Allocator());
     template <class InputIterator>
       vector(InputIterator first, InputIterator last,
              const Allocator& = Allocator());
     vector(const vector& x);
@@ -2417,24 +2462,25 @@ namespace std {
 ```
 #### `vector` constructors, copy, and assignment <a id="vector.cons">[[vector.cons]]</a>
 ``` cpp
-explicit vector(const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `vector`, using the specified allocator.
 *Complexity:* Constant.
 ``` cpp
-explicit vector(size_type n);
 ```
-*Effects:* Constructs a `vector` with `n` value-initialized elements.
-*Requires:* `T` shall be `DefaultConstructible`.
 *Complexity:* Linear in `n`.
 ``` cpp
 vector(size_type n, const T& value,
@@ -2461,33 +2507,10 @@ using the specified allocator.
 is the distance between `first` and `last`) and no reallocations if
 iterators first and last are of forward, bidirectional, or random access
 categories. It makes order `N` calls to the copy constructor of `T` and
 order log(N) reallocations if they are just input iterators.
-``` cpp
-template <class InputIterator>
-  void assign(InputIterator first, InputIterator last);
-```
-*Effects:*
-``` cpp
-erase(begin(), end());
-insert(begin(), first, last);
-```
-``` cpp
-void assign(size_type n, const T& t);
-```
-*Effects:*
-``` cpp
-erase(begin(), end());
-insert(begin(), n, t);
-```
 #### `vector` capacity <a id="vector.capacity">[[vector.capacity]]</a>
 ``` cpp
 size_type capacity() const noexcept;
 ```
@@ -2497,10 +2520,12 @@ requiring reallocation.
 ``` cpp
 void reserve(size_type n);
 ```
 *Effects:* A directive that informs a `vector` of a planned change in
 size, so that it can manage the storage allocation accordingly. After
 `reserve()`, `capacity()` is greater or equal to the argument of
 `reserve` if reallocation happens; and equal to the previous value of
 `capacity()` otherwise. Reallocation happens at this point if and only
@@ -2512,22 +2537,28 @@ non-`CopyInsertable` type, there are no effects.
 most linear time in the size of the sequence.
 *Throws:* `length_error` if `n > max_size()`.[^4]
 *Remarks:* Reallocation invalidates all the references, pointers, and
-iterators referring to the elements in the sequence. It is guaranteed
-that no reallocation takes place during insertions that happen after a
-call to `reserve()` until the time when an insertion would make the size
-of the vector greater than the value of `capacity()`.
 ``` cpp
 void shrink_to_fit();
 ```
 *Remarks:* `shrink_to_fit` is a non-binding request to reduce
 `capacity()` to `size()`. The request is non-binding to allow latitude
-for implementation-specific optimizations.
 ``` cpp
 void swap(vector& x);
 ```
@@ -2538,34 +2569,32 @@ of `x`.
 ``` cpp
 void resize(size_type sz);
 ```
-*Effects:* If `sz <= size()`, equivalent to
-`erase(begin() + sz, end());`. If `size() < sz`, appends `sz - size()`
-value-initialized elements to the sequence.
-*Requires:* `T` shall be `CopyInsertable` into `*this`.
-``` cpp
-void resize(size_type sz, const T& c);
-```
-*Effects:*
-``` cpp
-if (sz > size())
-  insert(end(), sz-size(), c);
-else if (sz < size())
-  erase(begin()+sz, end());
-else
-  ;                 // do nothing
-```
-*Requires:* If an exception is thrown other than by the move constructor
 of a non-`CopyInsertable` `T` there are no effects.
 #### `vector` data <a id="vector.data">[[vector.data]]</a>
 ``` cpp
 T*         data() noexcept;
 const T*   data() const noexcept;
@@ -2595,12 +2624,15 @@ void push_back(T&& x);
 *Remarks:* Causes reallocation if the new size is greater than the old
 capacity. If no reallocation happens, all the iterators and references
 before the insertion point remain valid. If an exception is thrown other
 than by the copy constructor, move constructor, assignment operator, or
 move assignment operator of `T` or by any `InputIterator` operation
-there are no effects. If an exception is thrown by the move constructor
-of a non-`CopyInsertable` `T`, the effects are unspecified.
 *Complexity:* The complexity is linear in the number of elements
 inserted plus the distance to the end of the vector.
 ``` cpp
@@ -2666,12 +2698,14 @@ namespace std {
       reference& operator=(const reference& x) noexcept;
       void flip() noexcept;     // flips the bit
     };
     // construct/copy/destroy:
- explicit vector(const Allocator& = Allocator());
-    explicit vector(size_type n, const bool& value = bool(),
            const Allocator& = Allocator());
     template <class InputIterator>
       vector(InputIterator first, InputIterator last,
              const Allocator& = Allocator());
     vector(const vector<bool,Allocator>& x);
@@ -2680,15 +2714,15 @@ namespace std {
     vector(vector&&, const Allocator&);
     vector(initializer_list<bool>, const Allocator& = Allocator()));
    ~vector();
     vector<bool,Allocator>& operator=(const vector<bool,Allocator>& x);
     vector<bool,Allocator>& operator=(vector<bool,Allocator>&& x);
-    vector operator=(initializer_list<bool>);
     template <class InputIterator>
       void assign(InputIterator first, InputIterator last);
     void assign(size_type n, const bool& t);
-    void assign(initializer_list<bool>;
     allocator_type get_allocator() const noexcept;
     // iterators:
     iterator               begin() noexcept;
     const_iterator         begin() const noexcept;
@@ -2722,12 +2756,14 @@ namespace std {
     const_reference front() const;
     reference       back();
     const_reference back() const;
     // modifiers:
     void push_back(const bool& x);
     void pop_back();
     iterator insert(const_iterator position, const bool& x);
     iterator insert (const_iterator position, size_type n, const bool& x);
     template <class InputIterator>
         iterator insert(const_iterator position,
                         InputIterator first, InputIterator last);
@@ -2781,12 +2817,12 @@ y = b;
 ``` cpp
 template <class Allocator> struct hash<vector<bool, Allocator> >;
 ```
-*Requires:* the template specialization shall meet the requirements of
-class template `hash` ([[unord.hash]]).
 ## Associative containers <a id="associative">[[associative]]</a>
 ### In general <a id="associative.general">[[associative.general]]</a>
@@ -2968,28 +3004,32 @@ namespace std {
         return comp(x.first, y.first);
       }
     };
     // [map.cons], construct/copy/destroy:
- explicit map(const Compare& comp = Compare(),
                  const Allocator& = Allocator());
     template <class InputIterator>
       map(InputIterator first, InputIterator last,
           const Compare& comp = Compare(), const Allocator& = Allocator());
-    map(const map<Key,T,Compare,Allocator>& x);
-    map(map<Key,T,Compare,Allocator>&& x);
     explicit map(const Allocator&);
     map(const map&, const Allocator&);
     map(map&&, const Allocator&);
     map(initializer_list<value_type>,
       const Compare& = Compare(),
       const Allocator& = Allocator());
    ~map();
-    map<Key,T,Compare,Allocator>&
- operator=(const map<Key,T,Compare,Allocator>& x);
-    map<Key,T,Compare,Allocator>&
-      operator=(map<Key,T,Compare,Allocator>&& x);
     map& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
     // iterators:
     iterator               begin() noexcept;
@@ -3031,31 +3071,44 @@ namespace std {
     void insert(initializer_list<value_type>);
     iterator  erase(const_iterator position);
     size_type erase(const key_type& x);
     iterator  erase(const_iterator first, const_iterator last);
-    void swap(map<Key,T,Compare,Allocator>&);
     void clear() noexcept;
     // observers:
     key_compare   key_comp() const;
     value_compare value_comp() const;
-    // [map.ops], map operations:
     iterator       find(const key_type& x);
     const_iterator find(const key_type& x) const;
     size_type      count(const key_type& x) const;
     iterator       lower_bound(const key_type& x);
     const_iterator lower_bound(const key_type& x) const;
     iterator       upper_bound(const key_type& x);
     const_iterator upper_bound(const key_type& x) const;
     pair<iterator,iterator>
       equal_range(const key_type& x);
     pair<const_iterator,const_iterator>
       equal_range(const key_type& x) const;
   };
   template <class Key, class T, class Compare, class Allocator>
     bool operator==(const map<Key,T,Compare,Allocator>& x,
                     const map<Key,T,Compare,Allocator>& y);
@@ -3083,11 +3136,11 @@ namespace std {
 ```
 #### `map` constructors, copy, and assignment <a id="map.cons">[[map.cons]]</a>
 ``` cpp
-explicit map(const Compare& comp = Compare(),
              const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `map` using the specified comparison
 object and allocator.
@@ -3098,13 +3151,13 @@ object and allocator.
 template <class InputIterator>
   map(InputIterator first, InputIterator last,
       const Compare& comp = Compare(), const Allocator& = Allocator());
 ```
-*Requires:* If the iterator’s dereference operator returns an lvalue or
 a const rvalue `pair<key_type, mapped_type>`, then both `key_type` and
-`mapped_type` shall be `CopyConstructible`.
 *Effects:* Constructs an empty `map` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
 `last`).
@@ -3118,31 +3171,31 @@ T& operator[](const key_type& x);
 ```
 *Effects:* If there is no key equivalent to `x` in the map, inserts
 `value_type(x, T())` into the map.
-*Requires:* `key_type` shall be `CopyConstructible` and `mapped_type`
-shall be `DefaultConstructible`.
 *Returns:* A reference to the `mapped_type` corresponding to `x` in
 `*this`.
-*Complexity:* logarithmic.
 ``` cpp
 T& operator[](key_type&& x);
 ```
 *Effects:* If there is no key equivalent to `x` in the map, inserts
 `value_type(std::move(x), T())` into the map.
-*Requires:* `mapped_type` shall be `DefaultConstructible`.
 *Returns:* A reference to the `mapped_type` corresponding to `x` in
 `*this`.
-*Complexity:* logarithmic.
 ``` cpp
 T&       at(const key_type& x);
 const T& at(const key_type& x) const;
 ```
@@ -3151,58 +3204,27 @@ const T& at(const key_type& x) const;
 `*this`.
 *Throws:* An exception object of type `out_of_range` if no such element
 is present.
-*Complexity:* logarithmic.
 #### `map` modifiers <a id="map.modifiers">[[map.modifiers]]</a>
 ``` cpp
 template <class P> pair<iterator, bool> insert(P&& x);
-template <class P> pair<iterator, bool> insert(const_iterator position, P&& x);
 template <class InputIterator>
   void insert(InputIterator first, InputIterator last);
 ```
-*Requires:* `P` shall be convertible to `value_type`.
-If `P` is instantiated as a reference type, then the argument `x` is
-copied from. Otherwise `x` is considered to be an rvalue as it is
-converted to `value_type` and inserted into the `map`. Specifically, in
-such cases `CopyConstructible` is not required of `key_type` or
-`mapped_type` unless the conversion from `P` specifically requires it
-(e.g., if `P` is a `tuple<const key_type, mapped_type>`, then `key_type`
-must be `CopyConstructible`). The signature taking `InputIterator`
-parameters does not require `CopyConstructible` of either `key_type` or
-`mapped_type` if the dereferenced `InputIterator` returns a non-const
-rvalue `pair<key_type,mapped_type>`. Otherwise `CopyConstructible` is
-required for both `key_type` and `mapped_type`.
-#### `map` operations <a id="map.ops">[[map.ops]]</a>
-``` cpp
-iterator       find(const key_type& x);
-const_iterator find(const key_type& x) const;
-iterator       lower_bound(const key_type& x);
-const_iterator lower_bound(const key_type& x) const;
-iterator       upper_bound(const key_type& x);
-const_iterator upper_bound(const key_type &x) const;
-pair<iterator, iterator>
-  equal_range(const key_type &x);
-pair<const_iterator, const_iterator>
-  equal_range(const key_type& x) const;
-```
-The `find`, `lower_bound`, `upper_bound` and `equal_range` member
-functions each have two versions, one const and the other non-const. In
-each case the behavior of the two functions is identical except that the
-const version returns a `const_iterator` and the non-const version an
-`iterator` ([[associative.reqmts]]).
 #### `map` specialized algorithms <a id="map.special">[[map.special]]</a>
 ``` cpp
 template <class Key, class T, class Compare, class Allocator>
@@ -3273,29 +3295,33 @@ namespace std {
         return comp(x.first, y.first);
       }
     };
     // construct/copy/destroy:
- explicit multimap(const Compare& comp = Compare(),
                       const Allocator& = Allocator());
     template <class InputIterator>
       multimap(InputIterator first, InputIterator last,
                const Compare& comp = Compare(),
                const Allocator& = Allocator());
-    multimap(const multimap<Key,T,Compare,Allocator>& x);
-    multimap(multimap<Key,T,Compare,Allocator>&& x);
     explicit multimap(const Allocator&);
     multimap(const multimap&, const Allocator&);
     multimap(multimap&&, const Allocator&);
     multimap(initializer_list<value_type>,
       const Compare& = Compare(),
       const Allocator& = Allocator());
    ~multimap();
-    multimap<Key,T,Compare,Allocator>&
- operator=(const multimap<Key,T,Compare,Allocator>& x);
-    multimap<Key,T,Compare,Allocator>&
-      operator=(multimap<Key,T,Compare,Allocator>&& x);
     multimap& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
     // iterators:
     iterator               begin() noexcept;
@@ -3330,31 +3356,44 @@ namespace std {
     void insert(initializer_list<value_type>);
     iterator  erase(const_iterator position);
     size_type erase(const key_type& x);
     iterator  erase(const_iterator first, const_iterator last);
-    void swap(multimap<Key,T,Compare,Allocator>&);
     void clear() noexcept;
     // observers:
     key_compare    key_comp() const;
     value_compare  value_comp() const;
     // map operations:
     iterator       find(const key_type& x);
     const_iterator find(const key_type& x) const;
     size_type      count(const key_type& x) const;
     iterator       lower_bound(const key_type& x);
     const_iterator lower_bound(const key_type& x) const;
     iterator       upper_bound(const key_type& x);
     const_iterator upper_bound(const key_type& x) const;
     pair<iterator,iterator>
       equal_range(const key_type& x);
     pair<const_iterator,const_iterator>
       equal_range(const key_type& x) const;
   };
   template <class Key, class T, class Compare, class Allocator>
     bool operator==(const multimap<Key,T,Compare,Allocator>& x,
                     const multimap<Key,T,Compare,Allocator>& y);
@@ -3382,11 +3421,11 @@ namespace std {
 ```
 #### `multimap` constructors <a id="multimap.cons">[[multimap.cons]]</a>
 ``` cpp
-explicit multimap(const Compare& comp = Compare(),
                   const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `multimap` using the specified comparison
 object and allocator.
@@ -3398,13 +3437,13 @@ template <class InputIterator>
   multimap(InputIterator first, InputIterator last,
            const Compare& comp = Compare(),
            const Allocator& = Allocator());
 ```
-*Requires:* If the iterator’s dereference operator returns an lvalue or
 a const rvalue `pair<key_type, mapped_type>`, then both `key_type` and
-`mapped_type` shall be `CopyConstructible`.
 *Effects:* Constructs an empty `multimap` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
 `last`).
@@ -3416,44 +3455,16 @@ sorted using `comp` and otherwise N log N, where N is `last - first`.
 ``` cpp
 template <class P> iterator insert(P&& x);
 template <class P> iterator insert(const_iterator position, P&& x);
 ```
-*Requires:* `P` shall be convertible to `value_type`.
-If `P` is instantiated as a reference type, then the argument `x` is
-copied from. Otherwise `x` is considered to be an rvalue as it is
-converted to `value_type` and inserted into the `map`. Specifically, in
-such cases `CopyConstructible` is not required of `key_type` or
-`mapped_type` unless the conversion from `P` specifically requires it
-(e.g., if `P` is a `tuple<const key_type, mapped_type>`, then `key_type`
-must be `CopyConstructible`). The signature taking `InputIterator`
-parameters does not require `CopyConstructible` of either `key_type` or
-`mapped_type` if the dereferenced `InputIterator` returns a non-const
-rvalue `pair<key_type, mapped_type>`. Otherwise `CopyConstructible` is
-required for both `key_type` and `mapped_type`.
-#### `multimap` operations <a id="multimap.ops">[[multimap.ops]]</a>
-``` cpp
-iterator       find(const key_type &x);
-const_iterator find(const key_type& x) const;
-iterator       lower_bound(const key_type& x);
-const_iterator lower_bound(const key_type& x) const;
-pair<iterator, iterator>
-  equal_range(const key_type& x);
-pair<const_iterator, const_iterator>
-  equal_range(const key_type& x) const;
-```
-The `find`, `lower_bound`, `upper_bound`, and `equal_range` member
-functions each have two versions, one const and one non-const. In each
-case the behavior of the two versions is identical except that the const
-version returns a `const_iterator` and the non-const version an
-`iterator` ([[associative.reqmts]]).
 #### `multimap` specialized algorithms <a id="multimap.special">[[multimap.special]]</a>
 ``` cpp
 template <class Key, class T, class Compare, class Allocator>
@@ -3509,28 +3520,32 @@ namespace std {
     typedef typename allocator_traits<Allocator>::const_pointer     const_pointer;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
     // [set.cons], construct/copy/destroy:
- explicit set(const Compare& comp = Compare(),
                  const Allocator& = Allocator());
     template <class InputIterator>
       set(InputIterator first, InputIterator last,
           const Compare& comp = Compare(), const Allocator& = Allocator());
-    set(const set<Key,Compare,Allocator>& x);
-    set(set<Key,Compare,Allocator>&& x);
     explicit set(const Allocator&);
     set(const set&, const Allocator&);
     set(set&&, const Allocator&);
     set(initializer_list<value_type>,
       const Compare& = Compare(),
       const Allocator& = Allocator());
    ~set();
-    set<Key,Compare,Allocator>& operator=
-      (const set<Key,Compare,Allocator>& x);
-    set<Key,Compare,Allocator>& operator=
-      (set<Key,Compare,Allocator>&& x);
     set& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
     // iterators:
     iterator               begin() noexcept;
@@ -3565,31 +3580,42 @@ namespace std {
     void insert(initializer_list<value_type>);
     iterator  erase(const_iterator position);
     size_type erase(const key_type& x);
     iterator  erase(const_iterator first, const_iterator last);
-    void swap(set<Key,Compare,Allocator>&);
     void clear() noexcept;
     // observers:
     key_compare   key_comp() const;
     value_compare value_comp() const;
     // set operations:
     iterator        find(const key_type& x);
     const_iterator  find(const key_type& x) const;
     size_type count(const key_type& x) const;
     iterator        lower_bound(const key_type& x);
     const_iterator  lower_bound(const key_type& x) const;
     iterator        upper_bound(const key_type& x);
     const_iterator  upper_bound(const key_type& x) const;
     pair<iterator,iterator>             equal_range(const key_type& x);
     pair<const_iterator,const_iterator> equal_range(const key_type& x) const;
   };
   template <class Key, class Compare, class Allocator>
     bool operator==(const set<Key,Compare,Allocator>& x,
                     const set<Key,Compare,Allocator>& y);
@@ -3617,11 +3643,11 @@ namespace std {
 ```
 #### `set` constructors, copy, and assignment <a id="set.cons">[[set.cons]]</a>
 ``` cpp
-explicit set(const Compare& comp = Compare(),
              const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty set using the specified comparison
 objects and allocator.
@@ -3636,12 +3662,12 @@ template <class InputIterator>
 *Effects:* Constructs an empty `set` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
 `last`).
-*Requires:* If the iterator’s dereference operator returns an lvalue or
-a non-const rvalue, then `Key` shall be `CopyConstructible`.
 *Complexity:* Linear in N if the range \[`first`, `last`) is already
 sorted using `comp` and otherwise N log N, where N is `last - first`.
 #### `set` specialized algorithms <a id="set.special">[[set.special]]</a>
@@ -3701,29 +3727,33 @@ namespace std {
     typedef typename allocator_traits<Allocator>::const_pointer     const_pointer;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
     // construct/copy/destroy:
- explicit multiset(const Compare& comp = Compare(),
                       const Allocator& = Allocator());
     template <class InputIterator>
       multiset(InputIterator first, InputIterator last,
                const Compare& comp = Compare(),
                const Allocator& = Allocator());
-    multiset(const multiset<Key,Compare,Allocator>& x);
-    multiset(multiset<Key,Compare,Allocator>&& x);
     explicit multiset(const Allocator&);
     multiset(const multiset&, const Allocator&);
     multiset(multiset&&, const Allocator&);
     multiset(initializer_list<value_type>,
       const Compare& = Compare(),
       const Allocator& = Allocator());
    ~multiset();
-    multiset<Key,Compare,Allocator>&
- operator=(const multiset<Key,Compare,Allocator>& x);
-    multiset<Key,Compare,Allocator>&
-        operator=(multiset<Key,Compare,Allocator>&& x);
     multiset& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
     // iterators:
     iterator               begin() noexcept;
@@ -3758,31 +3788,42 @@ namespace std {
     void insert(initializer_list<value_type>);
     iterator  erase(const_iterator position);
     size_type erase(const key_type& x);
     iterator  erase(const_iterator first, const_iterator last);
-    void swap(multiset<Key,Compare,Allocator>&);
     void clear() noexcept;
     // observers:
     key_compare   key_comp() const;
     value_compare value_comp() const;
     // set operations:
     iterator        find(const key_type& x);
     const_iterator  find(const key_type& x) const;
     size_type count(const key_type& x) const;
     iterator        lower_bound(const key_type& x);
     const_iterator  lower_bound(const key_type& x) const;
     iterator        upper_bound(const key_type& x);
     const_iterator  upper_bound(const key_type& x) const;
     pair<iterator,iterator>             equal_range(const key_type& x);
     pair<const_iterator,const_iterator> equal_range(const key_type& x) const;
   };
   template <class Key, class Compare, class Allocator>
     bool operator==(const multiset<Key,Compare,Allocator>& x,
                     const multiset<Key,Compare,Allocator>& y);
@@ -3810,27 +3851,27 @@ namespace std {
 ```
 #### `multiset` constructors <a id="multiset.cons">[[multiset.cons]]</a>
 ``` cpp
-explicit multiset(const Compare& comp = Compare(),
                   const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty set using the specified comparison object
 and allocator.
 *Complexity:* Constant.
 ``` cpp
 template <class InputIterator>
-  multiset(InputIterator first, last,
            const Compare& comp = Compare(), const Allocator& = Allocator());
 ```
-*Requires:* If the iterator’s dereference operator returns an lvalue or
-a const rvalue, then `Key` shall be `CopyConstructible`.
 *Effects:* Constructs an empty `multiset` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
 `last`).
@@ -3986,24 +4027,25 @@ namespace std {
     typedef std::pair<const Key, T>                             value_type;
     typedef T                                                   mapped_type;
     typedef Hash                                                hasher;
     typedef Pred                                                key_equal;
     typedef Allocator                                           allocator_type;
-    typedef typename allocator_type::pointer pointer;
-    typedef typename allocator_type::const_pointer const_pointer;
-    typedef typename allocator_type::reference       reference;
-    typedef typename allocator_type::const_reference const_reference;
     typedef implementation-defined                              size_type;
     typedef implementation-defined                              difference_type;
     typedef implementation-defined                              iterator;
     typedef implementation-defined                              const_iterator;
     typedef implementation-defined                              local_iterator;
     typedef implementation-defined                              const_local_iterator;
     // construct/destroy/copy
- explicit unordered_map(size_type n = see below,
                            const hasher& hf = hasher(),
                            const key_equal& eql = key_equal(),
                            const allocator_type& a = allocator_type());
     template <class InputIterator>
       unordered_map(InputIterator f, InputIterator l,
@@ -4019,10 +4061,26 @@ namespace std {
     unordered_map(initializer_list<value_type>,
       size_type = see below,
       const hasher& hf = hasher(),
       const key_equal& eql = key_equal(),
       const allocator_type& a = allocator_type());
     ~unordered_map();
     unordered_map& operator=(const unordered_map&);
     unordered_map& operator=(unordered_map&&);
     unordered_map& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
@@ -4107,19 +4165,20 @@ namespace std {
 ```
 #### `unordered_map` constructors <a id="unord.map.cnstr">[[unord.map.cnstr]]</a>
 ``` cpp
-explicit unordered_map(size_type n = see below,
                        const hasher& hf = hasher(),
                        const key_equal& eql = key_equal(),
                        const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_map` using the specified hash
 function, key equality function, and allocator, and using at least *`n`*
-buckets. If *`n`* is not provided, the number of buckets is
 *implementation-defined*. `max_load_factor()` returns 1.0.
 *Complexity:* Constant.
 ``` cpp
@@ -4144,13 +4203,13 @@ buckets. If *`n`* is not provided, the number of buckets is
 ``` cpp
 mapped_type& operator[](const key_type& k);
 mapped_type& operator[](key_type&& k);
 ```
-*Requires:* `mapped_type` shall be `DefaultConstructible`. For the first
-operator, `key_type` shall be `CopyConstructible`. For the second
-operator, `key_type` shall be `MoveConstructible`.
 *Effects:* If the `unordered_map` does not already contain an element
 whose key is equivalent to *`k`*, the first operator inserts the value
 `value_type(k, mapped_type())` and the second operator inserts the value
 `value_type(std::move(k), mapped_type())`.
@@ -4176,44 +4235,25 @@ is present.
 ``` cpp
 template <class P>
   pair<iterator, bool> insert(P&& obj);
 ```
-*Requires:* `value_type` is constructible from `std::forward<P>(obj)`.
-*Effects:* Inserts `obj` converted to `value_type` if and only if there
-is no element in the container with key equivalent to the key of
-`value_type(obj)`.
-*Returns:* The `bool` component of the returned `pair` object indicates
-whether the insertion took place and the iterator component points to
-the element with key equivalent to the key of `value_type(obj)`.
-*Complexity:* Average case 𝑂(1), worst case 𝑂(`size()`).
 *Remarks:* This signature shall not participate in overload resolution
-unless `P` is implicitly convertible to `value_type`.
 ``` cpp
 template <class P>
   iterator insert(const_iterator hint, P&& obj);
 ```
-*Requires:* `value_type` is constructible from `std::forward<P>(obj)`.
-*Effects:* Inserts `obj` converted to `value_type` if and only if there
-is no element in the container with key equivalent to the key of
-`value_type(obj)`. The iterator `hint` is a hint pointing to where the
-search should start.
-*Returns:* An iterator that points to the element with key equivalent to
-the key of `value_type(obj)`.
-*Complexity:* Average case 𝑂(1), worst case 𝑂(`size()`).
 *Remarks:* This signature shall not participate in overload resolution
-unless `P` is implicitly convertible to `value_type`.
 #### `unordered_map` swap <a id="unord.map.swap">[[unord.map.swap]]</a>
 ``` cpp
 template <class Key, class T, class Hash, class Pred, class Alloc>
@@ -4261,24 +4301,25 @@ namespace std {
     typedef std::pair<const Key, T>                             value_type;
     typedef T                                                   mapped_type;
     typedef Hash                                                hasher;
     typedef Pred                                                key_equal;
     typedef Allocator                                           allocator_type;
-    typedef typename allocator_type::pointer pointer;
-    typedef typename allocator_type::const_pointer const_pointer;
-    typedef typename allocator_type::reference       reference;
-    typedef typename allocator_type::const_reference const_reference;
     typedef implementation-defined                              size_type;
     typedef implementation-defined                              difference_type;
     typedef implementation-defined                              iterator;
     typedef implementation-defined                              const_iterator;
     typedef implementation-defined                              local_iterator;
     typedef implementation-defined                              const_local_iterator;
     // construct/destroy/copy
- explicit unordered_multimap(size_type n = see below,
                                 const hasher& hf = hasher(),
                                 const key_equal& eql = key_equal(),
                                 const allocator_type& a = allocator_type());
     template <class InputIterator>
       unordered_multimap(InputIterator f, InputIterator l,
@@ -4294,10 +4335,26 @@ namespace std {
     unordered_multimap(initializer_list<value_type>,
       size_type = see below,
       const hasher& hf = hasher(),
       const key_equal& eql = key_equal(),
       const allocator_type& a = allocator_type());
     ~unordered_multimap();
     unordered_multimap& operator=(const unordered_multimap&);
     unordered_multimap& operator=(unordered_multimap&&);
     unordered_multimap& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
@@ -4377,19 +4434,20 @@ namespace std {
 ```
 #### `unordered_multimap` constructors <a id="unord.multimap.cnstr">[[unord.multimap.cnstr]]</a>
 ``` cpp
-explicit unordered_multimap(size_type n = see below,
                             const hasher& hf = hasher(),
                             const key_equal& eql = key_equal(),
                             const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_multimap` using the specified
 hash function, key equality function, and allocator, and using at least
-*`n`* buckets. If *`n`* is not provided, the number of buckets is
 *implementation-defined*. `max_load_factor()` returns 1.0.
 *Complexity:* Constant.
 ``` cpp
@@ -4414,39 +4472,25 @@ hash function, key equality function, and allocator, and using at least
 ``` cpp
 template <class P>
   iterator insert(P&& obj);
 ```
-*Requires:* `value_type` is constructible from `std::forward<P>(obj)`.
-*Effects:* Inserts `obj` converted to `value_type`.
-*Returns:* An iterator that points to the element with key equivalent to
-the key of `value_type(obj)`.
-*Complexity:* Average case 𝑂(1), worst case 𝑂(`size()`).
 *Remarks:* This signature shall not participate in overload resolution
-unless `P` is implicitly convertible to `value_type`.
 ``` cpp
 template <class P>
   iterator insert(const_iterator hint, P&& obj);
 ```
-*Requires:* `value_type` is constructible from `std::forward<P>(obj)`.
-*Effects:* Inserts `obj` converted to `value_type`. The iterator `hint`
-is a hint pointing to where the search should start.
-*Returns:* An iterator that points to the element with key equivalent to
-the key of `value_type(obj)`.
-*Complexity:* Average case 𝑂(1), worst case 𝑂(`size()`).
 *Remarks:* This signature shall not participate in overload resolution
-unless `P` is implicitly convertible to `value_type`.
 #### `unordered_multimap` swap <a id="unord.multimap.swap">[[unord.multimap.swap]]</a>
 ``` cpp
 template <class Key, class T, class Hash, class Pred, class Alloc>
@@ -4492,24 +4536,25 @@ namespace std {
     typedef Key                                                 key_type;
     typedef Key                                                 value_type;
     typedef Hash                                                hasher;
     typedef Pred                                                key_equal;
     typedef Allocator                                           allocator_type;
-    typedef typename allocator_type::pointer pointer;
-    typedef typename allocator_type::const_pointer const_pointer;
-    typedef typename allocator_type::reference       reference;
-    typedef typename allocator_type::const_reference const_reference;
     typedef implementation-defined                              size_type;
     typedef implementation-defined                              difference_type;
     typedef implementation-defined                              iterator;
     typedef implementation-defined                              const_iterator;
     typedef implementation-defined                              local_iterator;
     typedef implementation-defined                              const_local_iterator;
     // construct/destroy/copy
- explicit unordered_set(size_type n = see below,
                            const hasher& hf = hasher(),
                            const key_equal& eql = key_equal(),
                            const allocator_type& a = allocator_type());
     template <class InputIterator>
       unordered_set(InputIterator f, InputIterator l,
@@ -4525,10 +4570,26 @@ namespace std {
     unordered_set(initializer_list<value_type>,
       size_type = see below,
       const hasher& hf = hasher(),
       const key_equal& eql = key_equal(),
       const allocator_type& a = allocator_type());
     ~unordered_set();
     unordered_set& operator=(const unordered_set&);
     unordered_set& operator=(unordered_set&&);
     unordered_set& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
@@ -4596,31 +4657,32 @@ namespace std {
   template <class Key, class Hash, class Pred, class Alloc>
     void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
               unordered_set<Key, Hash, Pred, Alloc>& y);
-  template <class Key, class T, class Hash, class Pred, class Alloc>
-    bool operator==(const unordered_set<Key, T, Hash, Pred, Alloc>& a,
-                    const unordered_set<Key, T, Hash, Pred, Alloc>& b);
-  template <class Key, class T, class Hash, class Pred, class Alloc>
-    bool operator!=(const unordered_set<Key, T, Hash, Pred, Alloc>& a,
-                    const unordered_set<Key, T, Hash, Pred, Alloc>& b);
 }
 ```
 #### `unordered_set` constructors <a id="unord.set.cnstr">[[unord.set.cnstr]]</a>
 ``` cpp
-explicit unordered_set(size_type n = see below,
                        const hasher& hf = hasher(),
                        const key_equal& eql = key_equal(),
                        const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_set` using the specified hash
 function, key equality function, and allocator, and using at least *`n`*
-buckets. If *`n`* is not provided, the number of buckets is
 *implementation-defined*. `max_load_factor()` returns 1.0.
 *Complexity:* Constant.
 ``` cpp
@@ -4687,24 +4749,25 @@ namespace std {
     typedef Key                                                 key_type;
     typedef Key                                                 value_type;
     typedef Hash                                                hasher;
     typedef Pred                                                key_equal;
     typedef Allocator                                           allocator_type;
-    typedef typename allocator_type::pointer pointer;
-    typedef typename allocator_type::const_pointer const_pointer;
-    typedef typename allocator_type::reference       reference;
-    typedef typename allocator_type::const_reference const_reference;
     typedef implementation-defined                              size_type;
     typedef implementation-defined                              difference_type;
     typedef implementation-defined                              iterator;
     typedef implementation-defined                              const_iterator;
     typedef implementation-defined                              local_iterator;
     typedef implementation-defined                              const_local_iterator;
     // construct/destroy/copy
- explicit unordered_multiset(size_type n = see below,
                                 const hasher& hf = hasher(),
                                 const key_equal& eql = key_equal(),
                                 const allocator_type& a = allocator_type());
     template <class InputIterator>
       unordered_multiset(InputIterator f, InputIterator l,
@@ -4720,13 +4783,29 @@ namespace std {
     unordered_multiset(initializer_list<value_type>,
       size_type = see below,
       const hasher& hf = hasher(),
       const key_equal& eql = key_equal(),
       const allocator_type& a = allocator_type());
     ~unordered_multiset();
     unordered_multiset& operator=(const unordered_multiset&);
-    unordered_multiset operator=(unordered_multiset&&);
     unordered_multiset& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
     // size and capacity
     bool empty() const noexcept;
@@ -4790,31 +4869,32 @@ namespace std {
   };
   template <class Key, class Hash, class Pred, class Alloc>
     void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
               unordered_multiset<Key, Hash, Pred, Alloc>& y);
-    template <class Key, class T, class Hash, class Pred, class Alloc>
-      bool operator==(const unordered_multiset<Key, T, Hash, Pred, Alloc>& a,
-                      const unordered_multiset<Key, T, Hash, Pred, Alloc>& b);
-    template <class Key, class T, class Hash, class Pred, class Alloc>
-      bool operator!=(const unordered_multiset<Key, T, Hash, Pred, Alloc>& a,
-                      const unordered_multiset<Key, T, Hash, Pred, Alloc>& b);
 }
 ```
 #### `unordered_multiset` constructors <a id="unord.multiset.cnstr">[[unord.multiset.cnstr]]</a>
 ``` cpp
-explicit unordered_multiset(size_type n = see below,
                             const hasher& hf = hasher(),
                             const key_equal& eql = key_equal(),
                             const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_multiset` using the specified
 hash function, key equality function, and allocator, and using at least
-*`n`* buckets. If *`n`* is not provided, the number of buckets is
 *implementation-defined*. `max_load_factor()` returns 1.0.
 *Complexity:* Constant.
 ``` cpp
@@ -4847,12 +4927,11 @@ template <class Key, class Hash, class Pred, class Alloc>
 ## Container adaptors <a id="container.adaptors">[[container.adaptors]]</a>
 ### In general <a id="container.adaptors.general">[[container.adaptors.general]]</a>
 The headers `<queue>` and `<stack>` define the container adaptors
-`queue`, `priority_queue`, and `stack`. These container adaptors meet
-the requirements for sequence containers.
 The container adaptors each take a `Container` template parameter, and
 each constructor takes a `Container` reference argument. This container
 is copied into the `Container` member of each adaptor. If the container
 takes an allocator, then a compatible allocator may be passed in to the
@@ -5368,12 +5447,12 @@ namespace std {
     bool operator> (const stack<T, Container>& x, const stack<T, Container>& y);
   template <class T, class Container>
     bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y);
   template <class T, class Container>
     bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);
-  template <class T, class Allocator>
-    void swap(stack<T,Allocator>& x, stack<T,Allocator>& y);
   template <class T, class Container, class Alloc>
     struct uses_allocator<stack<T, Container>, Alloc>
       : uses_allocator<Container, Alloc>::type { };
 }
@@ -5386,11 +5465,11 @@ explicit stack(const Container& cont);
 ```
 *Effects:* Initializes `c` with `cont`.
 ``` cpp
-explicit stack(Container&& const = Container());
 ```
 *Effects:* Initializes `c` with `std::move(cont)`.
 #### `stack` constructors with allocators <a id="stack.cons.alloc">[[stack.cons.alloc]]</a>
@@ -5497,10 +5576,11 @@ template <class T, class Container>
 *Effects:* `x.swap(y)`.
 <!-- Link reference definitions -->
 [alg.sorting]: algorithms.md#alg.sorting
 [algorithms]: algorithms.md#algorithms
 [allocator.requirements]: library.md#allocator.requirements
 [allocator.traits.members]: utilities.md#allocator.traits.members
 [array]: #array
 [array.cons]: #array.cons
@@ -5556,17 +5636,15 @@ template <class T, class Container>
 [list.special]: #list.special
 [map]: #map
 [map.access]: #map.access
 [map.cons]: #map.cons
 [map.modifiers]: #map.modifiers
-[map.ops]: #map.ops
 [map.overview]: #map.overview
 [map.special]: #map.special
 [multimap]: #multimap
 [multimap.cons]: #multimap.cons
 [multimap.modifiers]: #multimap.modifiers
-[multimap.ops]: #multimap.ops
 [multimap.overview]: #multimap.overview
 [multimap.special]: #multimap.special
 [multiset]: #multiset
 [multiset.cons]: #multiset.cons
 [multiset.overview]: #multiset.overview
@@ -5606,10 +5684,11 @@ template <class T, class Container>
 [tab:containers.lib.summary]: #tab:containers.lib.summary
 [tab:containers.optional.operations]: #tab:containers.optional.operations
 [tab:containers.reversible.requirements]: #tab:containers.reversible.requirements
 [tab:containers.sequence.optional]: #tab:containers.sequence.optional
 [tab:containers.sequence.requirements]: #tab:containers.sequence.requirements
 [unord]: #unord
 [unord.general]: #unord.general
 [unord.hash]: utilities.md#unord.hash
 [unord.map]: #unord.map
 [unord.map.cnstr]: #unord.map.cnstr

 container’s element type, not for internal types used by the container.
 This means, for example, that a node-based container might need to
 construct nodes containing aligned buffers and call `construct` to place
 the element into the buffer.
+In Tables  [[tab:containers.container.requirements]],
+[[tab:containers.reversible.requirements]], and
+[[tab:containers.optional.operations]] `X` denotes a container class
+containing objects of type `T`, `a` and `b` denote values of type `X`,
+`u` denotes an identifier, `r` denotes a non-const value of type `X`,
+and `rv` denotes a non-const rvalue of type `X`.
 Notes: the algorithm `equal()` is defined in Clause  [[algorithms]].
 Those entries marked “(Note A)” or “(Note B)” have linear complexity for
 `array` and have constant complexity for all other standard containers.
 returns an iterator referring to the first element in the container.
 `end()` returns an iterator which is the past-the-end value for the
 container. If the container is empty, then `begin() == end()`;
+In the expressions
+``` cpp
+i == j
+i != j
+i < j
+i <= j
+i >= j
+i > j
+i - j
+```
+where `i` and `j` denote objects of a container’s `iterator` type,
+either or both may be replaced by an object of the container’s
+`const_iterator` type referring to the same element with no change in
+semantics.
 Unless otherwise specified, all containers defined in this clause obtain
 memory using an allocator (see  [[allocator.requirements]]). Copy
 constructors for these container types obtain an allocator by calling
 `allocator_traits<allocator_type>::select_on_container_copy_construction`
+on the allocator belonging to the container being copied. Move
+constructors obtain an allocator by move construction from the allocator
+belonging to the container being moved. Such move construction of the
+allocator shall not exit via an exception. All other constructors for
+these container types take a `const allocator_type&` argument. If an
+invocation of a constructor uses the default value of an optional
+allocator argument, then the `Allocator` type must support value
+initialization. A copy of this allocator is used for any memory
+allocation 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
 `allocator_traits<allocator_type>::propagate_on_container_copy_assignment::value`,
 `allocator_traits<allocator_type>::propagate_on_container_move_assignment::value`,
 or
 `allocator_traits<allocator_type>::propagate_on_container_swap::value`
 is true within the implementation of the corresponding container
 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
+  effects.
 - no `erase()`, `clear()`, `pop_back()` or `pop_front()` function throws
   an exception.
 - no copy constructor or assignment operator of a returned iterator
   throws an exception.
 - no `swap()` function throws an exception.
 except `array` meet the additional requirements of an allocator-aware
 container, as described in Table  [[tab:containers.allocatoraware]].
 Given a container type `X` having an `allocator_type` identical to `A`
 and a `value_type` identical to `T` and given an lvalue `m` of type `A`,
+a pointer `p` of type `T*`, an expression `v` of type (possibly const)
+`T`, and an rvalue `rv` of type `T`, the following terms are defined. If
+`X` is not allocator-aware, the terms below are defined as if `A` were
+`std::allocator<T>` — no allocator object needs to be created and user
+specializations of `std::allocator<T>` are not instantiated:
+- `T` is *`DefaultInsertable` into `X`* means that the following
+ expression is well-formed:
   ``` cpp
+  allocator_traits<A>::construct(m, p)
   ```
+- An element of `X` is *default-inserted* if it is initialized by
+  evaluation of the expression
+  ``` cpp
+  allocator_traits<A>::construct(m, p)
+  ```
+  where `p` is the address of the uninitialized storage for the element
+  allocated within `X`.
 - `T` is *`MoveInsertable` into `X`* means that the following expression
   is well-formed:
   ``` cpp
+  allocator_traits<A>::construct(m, p, rv)
   ```
+  and its evaluation causes the following postcondition to hold: The
+  value of `*p` is equivalent to the value of `rv` before the
+  evaluation. rv remains a valid object. Its state is unspecified
+- `T` is *`CopyInsertable` into `X`* means that, in addition to `T`
+  being `MoveInsertable` into `X`, the following expression is
+  well-formed:
+  ``` cpp
+  allocator_traits<A>::construct(m, p, v)
+  ```
+  and its evaluation causes the following postcondition to hold: The
+  value of `v` is unchanged and is equivalent to `*p`.
 - `T` is *`EmplaceConstructible` into `X` from `args`*, for zero or more
   arguments `args`, means that the following expression is well-formed:
   ``` cpp
+  allocator_traits<A>::construct(m, p, args)
+  ```
+- `T` is *`Erasable` from `X`* means that the following expression is
+  well-formed:
+  ``` cpp
+  allocator_traits<A>::destroy(m, p)
   ```
 A container calls `allocator_traits<A>::construct(m, p, args)` to
 construct an element at `p` using `args`. The default `construct` in
 `std::allocator` will call `::new((void*)p) T(args)`, but specialized
 In Table  [[tab:containers.allocatoraware]], `X` denotes an
 allocator-aware container class with a `value_type` of `T` using
 allocator of type `A`, `u` denotes a variable, `a` and `b` denote
 non-const lvalues of type `X`, `t` denotes an lvalue or a const rvalue
+of type `X`, `rv` denotes a non-const rvalue of type `X`, and `m` is a
+value of type `A`.
 ### Container data races <a id="container.requirements.dataraces">[[container.requirements.dataraces]]</a>
 For purposes of avoiding data races ([[res.on.data.races]]),
 implementations shall consider the following functions to be `const`:
 `lower_bound`, `upper_bound`, `equal_range`, `at` and, except in
 associative or unordered associative containers, `operator[]`.
 Notwithstanding ([[res.on.data.races]]), implementations are required
 to avoid data races when the contents of the contained object in
+different elements in the same container, excepting `vector<bool>`, are
 modified concurrently.
 For a `vector<int> x` with a size greater than one, `x[1] = 5` and
 `*x.begin() = 10` can be executed concurrently without a data race, but
 `x[0] = 5` and `*x.begin() = 10` executed concurrently may result in a
 first element inserted into `a`, or `p` if `n == 0`.
 The iterator returned from `a.insert(p, i, j)` points to the copy of the
 first element inserted into `a`, or `p` if `i == j`.
+The iterator returned from `a.insert(p, il)` points to the copy of the
+first element inserted into `a`, or `p` if `il` is empty.
 The iterator returned from `a.emplace(p, args)` points to the new
 element constructed from `args` into `a`.
 The iterator returned from `a.erase(q)` points to the element
 `multiset`, `map` and `multimap`.
 Each associative container is parameterized on `Key` and an ordering
 relation `Compare` that induces a strict weak ordering (
 [[alg.sorting]]) on elements of `Key`. In addition, `map` and `multimap`
+associate an arbitrary *mapped type* `T` with the `Key`. The object of
+type `Compare` is called the *comparison object* of a container.
 The phrase “equivalence of keys” means the equivalence relation imposed
 by the comparison and *not* the `operator==` on keys. That is, two keys
 `k1` and `k2` are considered to be equivalent if for the comparison
 object `comp`, `comp(k1, k2) == false && comp(k2, k1) == false`. For any
 `multimap` classes support equivalent keys. For `multiset` and
 `multimap`, `insert`, `emplace`, and `erase` preserve the relative
 ordering of equivalent elements.
 For `set` and `multiset` the value type is the same as the key type. For
+`map` and `multimap` it is equal to `pair<const Key, T>`.
 `iterator`
 of an associative container is of the bidirectional iterator category.
 For associative containers where the value type is the same as the key
 `CopyAssignable`.
 In Table  [[tab:containers.associative.requirements]], `X` denotes an
 associative container class, `a` denotes a value of `X`, `a_uniq`
 denotes a value of `X` when `X` supports unique keys, `a_eq` denotes a
+value of `X` when `X` supports multiple keys, `a_tran` denotes a value
+of `X` when the qualified-id `X::key_compare::is_transparent` is valid
+and denotes a type ([[temp.deduct]]), `i` and `j` satisfy input
+iterator requirements and refer to elements implicitly convertible to
+`value_type`, \[`i`, `j`) denotes a valid range, `p` denotes a valid
+const iterator to `a`, `q` denotes a valid dereferenceable const
+iterator to `a`, `[q1, q2)` denotes a valid range of const iterators in
+`a`, `il` designates an object of type `initializer_list<value_type>`,
+`t` denotes a value of `X::value_type`, `k` denotes a value of
+`X::key_type` and `c` denotes a value of type `X::key_compare`; `kl` is
+a value such that `a` is partitioned ([[alg.sorting]]) with respect to
+`c(r, kl)`, with `r` the key value of `e` and `e` in `a`; `ku` is a
+value such that `a` is partitioned with respect to `!c(ku, r)`; `ke` is
+a value such that `a` is partitioned with respect to `c(r, ke)` and
+`!c(ke, r)`, with `c(r, ke)` implying `!c(ke, r)`. `A` denotes the
+storage allocator used by `X`, if any, or
+`std::allocator<X::value_type>` otherwise, and `m` denotes an allocator
+of a type convertible to `A`.
 The `insert` and `emplace` members shall not affect the validity of
+iterators and references to the container, and the `erase` members shall
 invalidate only iterators and references to the erased elements.
 The fundamental property of iterators of associative containers is that
 they iterate through the containers in the non-descending order of keys
 where non-descending is defined by the comparison that was used to
 associative container is copied, either through a copy constructor or an
 assignment operator, the target container shall then use the comparison
 object from the container being copied, as if that comparison object had
 been passed to the target container in its constructor.
+The member function templates `find`, `count`, `lower_bound`,
+`upper_bound`, and `equal_range` shall not participate in overload
+resolution unless the qualified-id `Compare::is_transparent` is valid
+and denotes a type ([[temp.deduct]]).
 #### Exception safety guarantees <a id="associative.reqmts.except">[[associative.reqmts.except]]</a>
 For associative containers, no `clear()` function throws an exception.
 `erase(k)` does not throw an exception unless that exception is thrown
 by the container’s `Compare` object (if any).
 of type `Key`, and by a binary predicate `Pred` that induces an
 equivalence relation on values of type `Key`. Additionally,
 `unordered_map` and `unordered_multimap` associate an arbitrary *mapped
 type* `T` with the `Key`.
+The container’s object of type `Hash` — denoted by `hash` — is called
+the *hash function* of the container. The container’s object of type
+`Pred` — denoted by `pred` — is called the *key equality predicate* of
+the container.
 Two values `k1` and `k2` of type `Key` are considered equivalent if the
+container’s key equality predicate returns `true` when passed those
+values. If `k1` and `k2` are equivalent, the container’s hash function
+shall return the same value for both. Thus, when an unordered
+associative container is instantiated with a non-default `Pred`
+parameter it usually needs a non-default `Hash` parameter as well. For
+any two keys `k1` and `k2` in the same container, calling `pred(k1, k2)`
+shall always return the same value. For any key `k` in a container,
+calling `hash(k)` shall always return the same value.
 An unordered associative container supports *unique keys* if it may
 contain at most one element for each key. Otherwise, it supports
 *equivalent keys*. `unordered_set` and `unordered_map` support unique
 keys. `unordered_multiset` and `unordered_multimap` support equivalent
 For `unordered_set` and `unordered_multiset` the value type is the same
 as the key type. For `unordered_map` and `unordered_multimap` it is
 `std::pair<const Key,
 T>`.
+For unordered containers where the value type is the same as the key
+type, both `iterator` and `const_iterator` are constant iterators. It is
+unspecified whether or not `iterator` and `const_iterator` are the same
+type. `iterator` and `const_iterator` have identical semantics in this
+case, and `iterator` is convertible to `const_iterator`. Users can avoid
+violating the One Definition Rule by always using `const_iterator` in
+their function parameter lists.
 The elements of an unordered associative container are organized into
 *buckets*. Keys with the same hash code appear in the same bucket. The
 number of buckets is automatically increased as elements are added to an
 unordered associative container, so that the average number of elements
 per bucket is kept below a bound. Rehashing invalidates iterators,
 Two unordered containers `a` and `b` compare equal if
 `a.size() == b.size()` and, for every equivalent-key group \[`Ea1`,
 `Ea2`) obtained from `a.equal_range(Ea1)`, there exists an
 equivalent-key group \[`Eb1`, `Eb2`) obtained from `b.equal_range(Ea1)`,
+such that `is_permutation(Ea1, Ea2, Eb1, Eb2)` returns `true`. For
+`unordered_set` and `unordered_map`, the complexity of `operator==`
+(i.e., the number of calls to the `==` operator of the `value_type`, to
+the predicate returned by `key_equal()`, and to the hasher returned by
 `hash_function()`) is proportional to N in the average case and to N² in
 the worst case, where N is a.size(). For `unordered_multiset` and
 `unordered_multimap`, the complexity of `operator==` is proportional to
 $\sum E_i^2$ in the average case and to N² in the worst case, where N is
 `a.size()`, and Eᵢ is the size of the iᵗʰ equivalent-key group in `a`.
 unordered associative containers where the key type and value type are
 the same, both `iterator` and `const_iterator` are const iterators.
 The `insert` and `emplace` members shall not affect the validity of
 references to container elements, but may invalidate all iterators to
+the container. The `erase` members shall invalidate only iterators and
+references to the erased elements, and preserve the relative order of
+the elements that are not erased.
 The `insert` and `emplace` members shall not affect the validity of
 iterators if `(N+n) < z * B`, where `N` is the number of elements in the
 container prior to the insert operation, `n` is the number of elements
 inserted, `B` is the container’s bucket count, and `z` is the
   template <class T, size_t N>
     struct tuple_size<array<T, N> >;
   template <size_t I, class T, size_t N>
     struct tuple_element<I, array<T, N> >;
   template <size_t I, class T, size_t N>
+ constexpr T& get(array<T, N>&) noexcept;
   template <size_t I, class T, size_t N>
+ constexpr T&& get(array<T, N>&&) noexcept;
   template <size_t I, class T, size_t N>
+ constexpr const T& get(const array<T, N>&) noexcept;
 }
 ```
 \synopsis{Header \texttt{\<deque\>} synopsis}
   template <class Allocator> class vector<bool,Allocator>;
   // hash support
   template <class T> struct hash;
   template <class Allocator> struct hash<vector<bool, Allocator> >;
+}
 ```
 ### Class template `array` <a id="array">[[array]]</a>
 #### Class template `array` overview <a id="array.overview">[[array.overview]]</a>
     typedef size_t                                size_type;
     typedef ptrdiff_t                             difference_type;
     typedef T                                     value_type;
     typedef T*                                    pointer;
     typedef const T*                              const_pointer;
+    typedef std::reverse_iterator<iterator> reverse_iterator;
+    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
     T       elems[N];           // exposition only
     // no explicit construct/copy/destroy for aggregate type
     const_iterator         cend() const noexcept;
     const_reverse_iterator crbegin() const noexcept;
     const_reverse_iterator crend() const noexcept;
     // capacity:
+    constexpr size_type size() const noexcept;
+    constexpr size_type max_size() const noexcept;
+    constexpr bool      empty() const noexcept;
     // element access:
     reference                 operator[](size_type n);
+ constexpr const_reference operator[](size_type n) const;
     reference                 at(size_type n);
+    constexpr const_reference at(size_type n) const;
     reference                 front();
+ constexpr const_reference front() const;
     reference                 back();
+ constexpr const_reference back() const;
     T *       data() noexcept;
     const T * data() const noexcept;
   };
 }
 ``` cpp
 x.swap(y);
 ```
+*Complexity:* Linear in `N`.
 #### `array::size` <a id="array.size">[[array.size]]</a>
 ``` cpp
+template <class T, size_t N> constexpr size_type array<T,N>::size() const noexcept;
 ```
 *Returns:* `N`
 #### `array::data` <a id="array.data">[[array.data]]</a>
 *Effects:* `swap_ranges(begin(), end(), y.begin())`
 *Throws:* Nothing unless one of the element-wise swap calls throws an
 exception.
+*Note:* Unlike the `swap` function for other containers, `array::swap`
 takes linear time, may exit via an exception, and does not cause
 iterators to become associated with the other container.
 #### Zero sized arrays <a id="array.zero">[[array.zero]]</a>
 equivalent to `noexcept(true)`.
 #### Tuple interface to class template `array` <a id="array.tuple">[[array.tuple]]</a>
 ``` cpp
+template <class T, size_t N>
+struct tuple_size<array<T, N>>
+  : integral_constant<size_t, N> { };
 ```
 ``` cpp
 tuple_element<I, array<T, N> >::type
 ```
 *Requires:* `I < N`. The program is ill-formed if `I` is out of bounds.
 *Value:* The type T.
 ``` cpp
+template <size_t I, class T, size_t N>
+constexpr T& get(array<T, N>& a) noexcept;
 ```
 *Requires:* `I < N`. The program is ill-formed if `I` is out of bounds.
 *Returns:* A reference to the `I`th element of `a`, where indexing is
 zero-based.
 ``` cpp
+template <size_t I, class T, size_t N>
+constexpr T&& get(array<T, N>&& a) noexcept;
 ```
 *Effects:* Equivalent to `return std::move(get<I>(a));`
 ``` cpp
+template <size_t I, class T, size_t N>
+constexpr const T& get(const array<T, N>& a) noexcept;
 ```
 *Requires:* `I < N`. The program is ill-formed if `I` is out of bounds.
 *Returns:* A const reference to the `I`th element of `a`, where indexing
     typedef typename allocator_traits<Allocator>::const_pointer     const_pointer;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
     // [deque.cons], construct/copy/destroy:
+    deque() : deque(Allocator()) { }
+    explicit deque(const Allocator&);
+    explicit deque(size_type n, const Allocator& = Allocator());
     deque(size_type n, const T& value, const Allocator& = Allocator());
     template <class InputIterator>
       deque(InputIterator first, InputIterator last, const Allocator& = Allocator());
     deque(const deque& x);
     deque(deque&&);
 ```
 #### `deque` constructors, copy, and assignment <a id="deque.cons">[[deque.cons]]</a>
 ``` cpp
+explicit deque(const Allocator&);
 ```
 *Effects:* Constructs an empty `deque`, using the specified allocator.
 *Complexity:* Constant.
 ``` cpp
+explicit deque(size_type n, const Allocator& = Allocator());
 ```
+*Effects:* Constructs a `deque` with `n` default-inserted elements using
+the specified allocator.
+*Requires:* `T` shall be `DefaultInsertable` into `*this`.
 *Complexity:* Linear in `n`.
 ``` cpp
 deque(size_type n, const T& value,
 ```
 *Effects:* Constructs a `deque` equal to the range \[`first`, `last`),
 using the specified allocator.
+*Complexity:* Linear in `distance(first, last)`.
 #### `deque` capacity <a id="deque.capacity">[[deque.capacity]]</a>
 ``` cpp
 void resize(size_type sz);
 ```
+*Effects:* If `sz <= size()`, equivalent to calling `pop_back()`
+`size() - sz` times. If `size() < sz`, appends `sz - size()`
+default-inserted elements to the sequence.
+*Requires:* `T` shall be `MoveInsertable` and `DefaultInsertable` into
+`*this`.
 ``` cpp
 void resize(size_type sz, const T& c);
 ```
+*Effects:* If `sz <= size()`, equivalent to calling `pop_back()`
+`size() - sz` times. If `size() < sz`, appends `sz - size()` copies of
+`c` to the sequence.
 *Requires:* `T` shall be `CopyInsertable` into `*this`.
 ``` cpp
 void shrink_to_fit();
 ```
+*Requires:* `T` shall be `MoveInsertable` into `*this`.
+*Complexity:* Linear in the size of the sequence.
+*Remarks:* `shrink_to_fit` is a non-binding request to reduce memory use
+but does not change the size of the sequence. The request is non-binding
+to allow latitude for implementation-specific optimizations.
 #### `deque` modifiers <a id="deque.modifiers">[[deque.modifiers]]</a>
 ``` cpp
 iterator insert(const_iterator position, const T& x);
 either end of the deque invalidates all the iterators to the deque, but
 has no effect on the validity of references to elements of the deque.
 *Remarks:* If an exception is thrown other than by the copy constructor,
 move constructor, assignment operator, or move assignment operator of
+`T` there are no effects. If an exception is thrown while inserting a
+single element at either end, there are no effects. Otherwise, if an
+exception is thrown by the move constructor of a non-`CopyInsertable`
+`T`, the effects are unspecified.
 *Complexity:* The complexity is linear in the number of elements
 inserted plus the lesser of the distances to the beginning and end of
 the deque. Inserting a single element either at the beginning or end of
 a deque always takes constant time and causes a single call to a
 hand-written C-style singly linked list. Features that would conflict
 with that goal have been omitted.
 A `forward_list` satisfies all of the requirements of a container
 (Table  [[tab:containers.container.requirements]]), except that the
+`size()` member function is not provided and `operator==` has linear
+complexity. A `forward_list` also satisfies all of the requirements for
+an allocator-aware container (Table  [[tab:containers.allocatoraware]]).
+In addition, a `forward_list` provides the `assign` member functions
+(Table  [[tab:containers.sequence.requirements]]) and several of the
+optional container requirements (Table
+[[tab:containers.sequence.optional]]). Descriptions are provided here
+only for operations on `forward_list` that are not described in that
+table or for operations where there is additional semantic information.
 Modifying any list requires access to the element preceding the first
 element of interest, but in a `forward_list` there is no constant-time
+way to access a preceding element. For this reason, ranges that are
 modified, such as those supplied to `erase` and `splice`, must be open
 at the beginning.
 ``` cpp
 namespace std {
     typedef Allocator allocator_type;
     typedef typename allocator_traits<Allocator>::pointer         pointer;
     typedef typename allocator_traits<Allocator>::const_pointer   const_pointer;
     // [forwardlist.cons], construct/copy/destroy:
+    forward_list() : forward_list(Allocator()) { }
+    explicit forward_list(const Allocator&);
+    explicit forward_list(size_type n, const Allocator& = Allocator());
     forward_list(size_type n, const T& value,
                  const Allocator& = Allocator());
     template <class InputIterator>
       forward_list(InputIterator first, InputIterator last,
                    const Allocator& = Allocator());
 ```
 #### `forward_list` constructors, copy, assignment <a id="forwardlist.cons">[[forwardlist.cons]]</a>
 ``` cpp
+explicit forward_list(const Allocator&);
 ```
 *Effects:* Constructs an empty `forward_list` object using the specified
 allocator.
 *Complexity:* Constant.
 ``` cpp
+explicit forward_list(size_type n, const Allocator& = Allocator());
 ```
+*Effects:* Constructs a `forward_list` object with `n` default-inserted
+elements using the specified allocator.
+*Requires:* `T` shall be `DefaultInsertable` into `*this`.
 *Complexity:* Linear in `n`.
 ``` cpp
 forward_list(size_type n, const T& value, const Allocator& = Allocator());
 *Effects:* Constructs a `forward_list` object equal to the range
 \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
 #### `forward_list` iterators <a id="forwardlist.iter">[[forwardlist.iter]]</a>
 ``` cpp
 iterator before_begin() noexcept;
 const_iterator before_begin() const noexcept;
 ```
 *Effects:* `insert_after(p, il.begin(), il.end())`.
 *Returns:* An iterator pointing to the last inserted element or
+`position` if `il` is empty.
 ``` cpp
 template <class... Args>
   iterator emplace_after(const_iterator position, Args&&... args);
 ```
 *Throws:* Nothing.
 ``` cpp
 void resize(size_type sz);
+```
+*Effects:* If `sz < distance(begin(), end())`, erases the last
+`distance(begin(), end()) - sz` elements from the list. Otherwise,
+inserts `sz - distance(begin(), end())` default-inserted elements at the
+end of the list.
+*Requires:* `T` shall be `DefaultInsertable` into `*this`.
+``` cpp
 void resize(size_type sz, const value_type& c);
 ```
 *Effects:* If `sz < distance(begin(), end())`, erases the last
 `distance(begin(), end()) - sz` elements from the list. Otherwise,
+inserts `sz - distance(begin(), end())` elements at the end of the list
+such that each new element, `e`, is initialized by a method equivalent
+to calling
+`allocator_traits<allocator_type>::construct(get_allocator(), std::addressof(e), c)`.
+*Requires:* `T` shall be `CopyInsertable` into `*this`.
 ``` cpp
 void clear() noexcept;
 ```
 void splice_after(const_iterator position, forward_list& x);
 void splice_after(const_iterator position, forward_list&& x);
 ```
 *Requires:* `position` is `before_begin()` or is a dereferenceable
+iterator in the range \[`begin()`, `end()`).
+`get_allocator() == x.get_allocator()`. `&x != this`.
 *Effects:* Inserts the contents of `x` after `position`, and `x` becomes
 empty. Pointers and references to the moved elements of `x` now refer to
 those same elements but as members of `*this`. Iterators referring to
 the moved elements will continue to refer to their elements, but they
 ```
 *Requires:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). The iterator following `i`
 is a dereferenceable iterator in `x`.
+`get_allocator() == x.get_allocator()`.
 *Effects:* Inserts the element following `i` into `*this`, following
 `position`, and removes it from `x`. The result is unchanged if
+`position == i` or `position == ++i`. Pointers and references to `*++i`
 continue to refer to the same element but as a member of `*this`.
+Iterators to `*++i` continue to refer to the same element, but now
+behave as iterators into `*this`, not into `x`.
 *Throws:* Nothing.
 *Complexity:* 𝑂(1)
 *Requires:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). (`first`, `last`) is a
 valid range in `x`, and all iterators in the range (`first`, `last`) are
 dereferenceable. `position` is not an iterator in the range (`first`,
+`last`). `get_allocator() == x.get_allocator()`.
 *Effects:* Inserts elements in the range (`first`, `last`) after
 `position` and removes the elements from `x`. Pointers and references to
 the moved elements of `x` now refer to those same elements but as
 members of `*this`. Iterators referring to the moved elements will
 template <class Predicate> void remove_if(Predicate pred);
 ```
 *Effects:* Erases all the elements in the list referred by a list
 iterator `i` for which the following conditions hold: `*i == value` (for
+`remove()`), `pred(*i)` is true (for `remove_if()`). Invalidates only
+the iterators and references to the erased elements.
 *Throws:* Nothing unless an exception is thrown by the equality
 comparison or the predicate.
+*Remarks:* Stable ([[algorithm.stable]]).
 *Complexity:* Exactly `distance(begin(), end())` applications of the
 corresponding predicate.
 ``` cpp
 void unique();
 otherwise no applications of the predicate.
 ``` cpp
 void merge(forward_list& x);
 void merge(forward_list&& x);
+template <class Compare> void merge(forward_list& x, Compare comp);
+template <class Compare> void merge(forward_list&& x, Compare comp);
 ```
 *Requires:* `comp` defines a strict weak ordering ([[alg.sorting]]),
 and `*this` and `x` are both sorted according to this ordering.
+`get_allocator() == x.get_allocator()`.
+*Effects:* Merges the two sorted ranges `[begin(), end())` and
+`[x.begin(), x.end())`. `x` is empty after the merge. If an exception is
+thrown other than by a comparison there are no effects. Pointers and
+references to the moved elements of `x` now refer to those same elements
+but as members of `*this`. Iterators referring to the moved elements
+will continue to refer to their elements, but they now behave as
+iterators into `*this`, not into `x`.
+*Remarks:* Stable ([[algorithm.stable]]). The behavior is undefined if
+`this->get_allocator() != x.get_allocator()`.
+*Complexity:* At most
+`distance(begin(), end()) + distance(x.begin(), x.end()) - 1`
+comparisons.
 ``` cpp
 void sort();
 template <class Compare> void sort(Compare comp);
 ```
 *Requires:* `operator<` (for the version with no arguments) or `comp`
 (for the version with a comparison argument) defines a strict weak
 ordering ([[alg.sorting]]).
 *Effects:* Sorts the list according to the `operator<` or the `comp`
+function object. If an exception is thrown the order of the elements in
+`*this` is unspecified. Does not affect the validity of iterators and
+references.
+*Remarks:* Stable ([[algorithm.stable]]).
 *Complexity:* Approximately N log N comparisons, where N is
 `distance(begin(), end())`.
 ``` cpp
     typedef typename allocator_traits<Allocator>::const_pointer     const_pointer;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
     // [list.cons], construct/copy/destroy:
+    list() : list(Allocator()) { }
+    explicit list(const Allocator&);
+    explicit list(size_type n, const Allocator& = Allocator());
     list(size_type n, const T& value, const Allocator& = Allocator());
     template <class InputIterator>
       list(InputIterator first, InputIterator last, const Allocator& = Allocator());
     list(const list& x);
     list(list&& x);
 ```
 #### `list` constructors, copy, and assignment <a id="list.cons">[[list.cons]]</a>
 ``` cpp
+explicit list(const Allocator&);
 ```
 *Effects:* Constructs an empty list, using the specified allocator.
 *Complexity:* Constant.
 ``` cpp
+explicit list(size_type n, const Allocator& = Allocator());
 ```
+*Effects:* Constructs a `list` with `n` default-inserted elements using
+the specified allocator.
+*Requires:* `T` shall be `DefaultInsertable` into `*this`.
 *Complexity:* Linear in `n`.
 ``` cpp
 list(size_type n, const T& value,
 *Effects:* Constructs a `list` equal to the range \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
 #### `list` capacity <a id="list.capacity">[[list.capacity]]</a>
 ``` cpp
 void resize(size_type sz);
 ```
+*Effects:* If `size() < sz`, appends `sz - size()` default-inserted
 elements to the sequence. If `sz <= size()`, equivalent to
 ``` cpp
 list<T>::iterator it = begin();
 advance(it, sz);
 erase(it, end());
 ```
+*Requires:* `T` shall be `DefaultInsertable` into `*this`.
 ``` cpp
 void resize(size_type sz, const T& c);
 ```
 references to the erased elements.
 *Throws:* Nothing unless an exception is thrown by `*i == value` or
 `pred(*i) != false`.
+*Remarks:* Stable ([[algorithm.stable]]).
 *Complexity:* Exactly `size()` applications of the corresponding
 predicate.
 ``` cpp
 \[`first + 1`, `last`) for which `*i == *(i-1)` (for the version of
 `unique` with no arguments) or `pred(*i, *(i - 1))` (for the version of
 `unique` with a predicate argument) holds. Invalidates only the
 iterators and references to the erased elements.
+*Throws:* Nothing unless an exception is thrown by `*i == *(i-1)` or
 `pred(*i, *(i - 1))`
 *Complexity:* If the range `[first, last)` is not empty, exactly
 `(last - first) - 1` applications of the corresponding predicate,
 otherwise no applications of the predicate.
 elements of `x` now refer to those same elements but as members of
 `*this`. Iterators referring to the moved elements will continue to
 refer to their elements, but they now behave as iterators into `*this`,
 not into `x`.
+*Remarks:* Stable ([[algorithm.stable]]). If `(&x != this)` the range
+`[x.begin(), x.end())` is empty after the merge. No elements are copied
+by this operation. The behavior is undefined if
+`this->get_allocator() != x.get_allocator()`.
 *Complexity:* At most `size() + x.size() - 1` applications of `comp` if
 `(&x != this)`; otherwise, no applications of `comp` are performed. If
 an exception is thrown other than by a comparison there are no effects.
 *Effects:* Sorts the list according to the `operator<` or a `Compare`
 function object. Does not affect the validity of iterators and
 references.
+*Remarks:* Stable ([[algorithm.stable]]).
 *Complexity:* Approximately N log(N) comparisons, where `N == size()`.
 #### `list` specialized algorithms <a id="list.special">[[list.special]]</a>
     typedef typename allocator_traits<Allocator>::const_pointer     const_pointer;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
     // [vector.cons], construct/copy/destroy:
+    vector() : vector(Allocator()) { }
+    explicit vector(const Allocator&);
+    explicit vector(size_type n, const Allocator& = Allocator());
     vector(size_type n, const T& value, const Allocator& = Allocator());
     template <class InputIterator>
       vector(InputIterator first, InputIterator last,
              const Allocator& = Allocator());
     vector(const vector& x);
 ```
 #### `vector` constructors, copy, and assignment <a id="vector.cons">[[vector.cons]]</a>
 ``` cpp
+explicit vector(const Allocator&);
 ```
 *Effects:* Constructs an empty `vector`, using the specified allocator.
 *Complexity:* Constant.
 ``` cpp
+explicit vector(size_type n, const Allocator& = Allocator());
 ```
+*Effects:* Constructs a `vector` with `n` default-inserted elements
+using the specified allocator.
+*Requires:* `T` shall be `DefaultInsertable` into `*this`.
 *Complexity:* Linear in `n`.
 ``` cpp
 vector(size_type n, const T& value,
 is the distance between `first` and `last`) and no reallocations if
 iterators first and last are of forward, bidirectional, or random access
 categories. It makes order `N` calls to the copy constructor of `T` and
 order log(N) reallocations if they are just input iterators.
 #### `vector` capacity <a id="vector.capacity">[[vector.capacity]]</a>
 ``` cpp
 size_type capacity() const noexcept;
 ```
 ``` cpp
 void reserve(size_type n);
 ```
+*Requires:* `T` shall be `MoveInsertable` into `*this`.
 *Effects:* A directive that informs a `vector` of a planned change in
 size, so that it can manage the storage allocation accordingly. After
 `reserve()`, `capacity()` is greater or equal to the argument of
 `reserve` if reallocation happens; and equal to the previous value of
 `capacity()` otherwise. Reallocation happens at this point if and only
 most linear time in the size of the sequence.
 *Throws:* `length_error` if `n > max_size()`.[^4]
 *Remarks:* Reallocation invalidates all the references, pointers, and
+iterators referring to the elements in the sequence. No reallocation
+shall take place during insertions that happen after a call to
+`reserve()` until the time when an insertion would make the size of the
+vector greater than the value of `capacity()`.
 ``` cpp
 void shrink_to_fit();
 ```
+*Requires:* `T` shall be `MoveInsertable` into `*this`.
+*Complexity:* Linear in the size of the sequence.
 *Remarks:* `shrink_to_fit` is a non-binding request to reduce
 `capacity()` to `size()`. The request is non-binding to allow latitude
+for implementation-specific optimizations. If an exception is thrown
+other than by the move constructor of a non-`CopyInsertable` `T` there
+are no effects.
 ``` cpp
 void swap(vector& x);
 ```
 ``` cpp
 void resize(size_type sz);
 ```
+*Effects:* If `sz <= size()`, equivalent to calling `pop_back()`
+`size() - sz` times. If `size() < sz`, appends `sz - size()`
+default-inserted elements to the sequence.
+*Requires:* `T` shall be `MoveInsertable` and `DefaultInsertable` into
+`*this`.
+*Remarks:* If an exception is thrown other than by the move constructor
 of a non-`CopyInsertable` `T` there are no effects.
+``` cpp
+void resize(size_type sz, const T& c);
+```
+*Effects:* If `sz <= size()`, equivalent to calling `pop_back()`
+`size() - sz` times. If `size() < sz`, appends `sz - size()` copies of
+`c` to the sequence.
+*Requires:* `T` shall be `CopyInsertable` into `*this`.
+*Remarks:* If an exception is thrown there are no effects.
 #### `vector` data <a id="vector.data">[[vector.data]]</a>
 ``` cpp
 T*         data() noexcept;
 const T*   data() const noexcept;
 *Remarks:* Causes reallocation if the new size is greater than the old
 capacity. If no reallocation happens, all the iterators and references
 before the insertion point remain valid. If an exception is thrown other
 than by the copy constructor, move constructor, assignment operator, or
 move assignment operator of `T` or by any `InputIterator` operation
+there are no effects. If an exception is thrown while inserting a single
+element at the end and `T` is `CopyInsertable` or
+`is_nothrow_move_constructible<T>::value` is `true`, there are no
+effects. Otherwise, if an exception is thrown by the move constructor of
+a non-`CopyInsertable` `T`, the effects are unspecified.
 *Complexity:* The complexity is linear in the number of elements
 inserted plus the distance to the end of the vector.
 ``` cpp
       reference& operator=(const reference& x) noexcept;
       void flip() noexcept;     // flips the bit
     };
     // construct/copy/destroy:
+    vector() : vector(Allocator()) { }
+    explicit vector(const Allocator&);
+    explicit vector(size_type n, const Allocator& = Allocator());
+    vector(size_type n, const bool& value,
            const Allocator& = Allocator());
     template <class InputIterator>
       vector(InputIterator first, InputIterator last,
              const Allocator& = Allocator());
     vector(const vector<bool,Allocator>& x);
     vector(vector&&, const Allocator&);
     vector(initializer_list<bool>, const Allocator& = Allocator()));
    ~vector();
     vector<bool,Allocator>& operator=(const vector<bool,Allocator>& x);
     vector<bool,Allocator>& operator=(vector<bool,Allocator>&& x);
+    vector& operator=(initializer_list<bool>);
     template <class InputIterator>
       void assign(InputIterator first, InputIterator last);
     void assign(size_type n, const bool& t);
+    void assign(initializer_list<bool>);
     allocator_type get_allocator() const noexcept;
     // iterators:
     iterator               begin() noexcept;
     const_iterator         begin() const noexcept;
     const_reference front() const;
     reference       back();
     const_reference back() const;
     // modifiers:
+    template <class... Args> void emplace_back(Args&&... args);
     void push_back(const bool& x);
     void pop_back();
+    template <class... Args> iterator emplace(const_iterator position, Args&&... args);
     iterator insert(const_iterator position, const bool& x);
     iterator insert (const_iterator position, size_type n, const bool& x);
     template <class InputIterator>
         iterator insert(const_iterator position,
                         InputIterator first, InputIterator last);
 ``` cpp
 template <class Allocator> struct hash<vector<bool, Allocator> >;
 ```
+The template specialization shall meet the requirements of class
+template `hash` ([[unord.hash]]).
 ## Associative containers <a id="associative">[[associative]]</a>
 ### In general <a id="associative.general">[[associative.general]]</a>
         return comp(x.first, y.first);
       }
     };
     // [map.cons], construct/copy/destroy:
+    map() : map(Compare()) { }
+    explicit map(const Compare& comp,
                  const Allocator& = Allocator());
     template <class InputIterator>
       map(InputIterator first, InputIterator last,
           const Compare& comp = Compare(), const Allocator& = Allocator());
+    map(const map& x);
+    map(map&& x);
     explicit map(const Allocator&);
     map(const map&, const Allocator&);
     map(map&&, const Allocator&);
     map(initializer_list<value_type>,
       const Compare& = Compare(),
       const Allocator& = Allocator());
+    template <class InputIterator>
+    map(InputIterator first, InputIterator last, const Allocator& a)
+      : map(first, last, Compare(), a) { }
+    map(initializer_list<value_type> il, const Allocator& a)
+      : map(il, Compare(), a) { }
    ~map();
+    map& operator=(const map& x);
+    map& operator=(map&& x);
     map& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
     // iterators:
     iterator               begin() noexcept;
     void insert(initializer_list<value_type>);
     iterator  erase(const_iterator position);
     size_type erase(const key_type& x);
     iterator  erase(const_iterator first, const_iterator last);
+    void swap(map&);
     void clear() noexcept;
     // observers:
     key_compare   key_comp() const;
     value_compare value_comp() const;
+    // map operations:
     iterator       find(const key_type& x);
     const_iterator find(const key_type& x) const;
+    template <class K> iterator       find(const K& x);
+    template <class K> const_iterator find(const K& x) const;
     size_type      count(const key_type& x) const;
+    template <class K> size_type count(const K& x) const;
     iterator       lower_bound(const key_type& x);
     const_iterator lower_bound(const key_type& x) const;
+    template <class K> iterator       lower_bound(const K& x);
+    template <class K> const_iterator lower_bound(const K& x) const;
     iterator       upper_bound(const key_type& x);
     const_iterator upper_bound(const key_type& x) const;
+    template <class K> iterator       upper_bound(const K& x);
+    template <class K> const_iterator upper_bound(const K& x) const;
     pair<iterator,iterator>
       equal_range(const key_type& x);
     pair<const_iterator,const_iterator>
       equal_range(const key_type& x) const;
+    template <class K>
+      pair<iterator, iterator>             equal_range(const K& x);
+    template <class K>
+      pair<const_iterator, const_iterator> equal_range(const K& x) const;
   };
   template <class Key, class T, class Compare, class Allocator>
     bool operator==(const map<Key,T,Compare,Allocator>& x,
                     const map<Key,T,Compare,Allocator>& y);
 ```
 #### `map` constructors, copy, and assignment <a id="map.cons">[[map.cons]]</a>
 ``` cpp
+explicit map(const Compare& comp,
              const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `map` using the specified comparison
 object and allocator.
 template <class InputIterator>
   map(InputIterator first, InputIterator last,
       const Compare& comp = Compare(), const Allocator& = Allocator());
 ```
+*Requires:* If the iterator’s indirection operator returns an lvalue or
 a const rvalue `pair<key_type, mapped_type>`, then both `key_type` and
+`mapped_type` shall be `CopyInsertable` into `*this`.
 *Effects:* Constructs an empty `map` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
 `last`).
 ```
 *Effects:* If there is no key equivalent to `x` in the map, inserts
 `value_type(x, T())` into the map.
+*Requires:* `key_type` shall be `CopyInsertable` and `mapped_type` shall
+be `DefaultInsertable` into `*this`.
 *Returns:* A reference to the `mapped_type` corresponding to `x` in
 `*this`.
+*Complexity:* Logarithmic.
 ``` cpp
 T& operator[](key_type&& x);
 ```
 *Effects:* If there is no key equivalent to `x` in the map, inserts
 `value_type(std::move(x), T())` into the map.
+*Requires:* `mapped_type` shall be `DefaultInsertable` into `*this`.
 *Returns:* A reference to the `mapped_type` corresponding to `x` in
 `*this`.
+*Complexity:* Logarithmic.
 ``` cpp
 T&       at(const key_type& x);
 const T& at(const key_type& x) const;
 ```
 `*this`.
 *Throws:* An exception object of type `out_of_range` if no such element
 is present.
+*Complexity:* Logarithmic.
 #### `map` modifiers <a id="map.modifiers">[[map.modifiers]]</a>
 ``` cpp
 template <class P> pair<iterator, bool> insert(P&& x);
+template <class P> iterator insert(const_iterator position, P&& x);
 template <class InputIterator>
   void insert(InputIterator first, InputIterator last);
 ```
+*Effects:* The first form is equivalent to
+`return emplace(std::forward<P>(x))`. The second form is equivalent to
+`return emplace_hint(position, std::forward<P>(x))`.
+*Remarks:* These signatures shall not participate in overload resolution
+unless `std::is_constructible<value_type, P&&>::value` is `true`.
 #### `map` specialized algorithms <a id="map.special">[[map.special]]</a>
 ``` cpp
 template <class Key, class T, class Compare, class Allocator>
         return comp(x.first, y.first);
       }
     };
     // construct/copy/destroy:
+    multimap() : multimap(Compare()) { }
+    explicit multimap(const Compare& comp,
                       const Allocator& = Allocator());
     template <class InputIterator>
       multimap(InputIterator first, InputIterator last,
                const Compare& comp = Compare(),
                const Allocator& = Allocator());
+    multimap(const multimap& x);
+    multimap(multimap&& x);
     explicit multimap(const Allocator&);
     multimap(const multimap&, const Allocator&);
     multimap(multimap&&, const Allocator&);
     multimap(initializer_list<value_type>,
       const Compare& = Compare(),
       const Allocator& = Allocator());
+    template <class InputIterator>
+    multimap(InputIterator first, InputIterator last, const Allocator& a)
+      : multimap(first, last, Compare(), a) { }
+    multimap(initializer_list<value_type> il, const Allocator& a)
+      : multimap(il, Compare(), a) { }
    ~multimap();
+    multimap& operator=(const multimap& x);
+    multimap& operator=(multimap&& x);
     multimap& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
     // iterators:
     iterator               begin() noexcept;
     void insert(initializer_list<value_type>);
     iterator  erase(const_iterator position);
     size_type erase(const key_type& x);
     iterator  erase(const_iterator first, const_iterator last);
+    void swap(multimap&);
     void clear() noexcept;
     // observers:
     key_compare    key_comp() const;
     value_compare  value_comp() const;
     // map operations:
     iterator       find(const key_type& x);
     const_iterator find(const key_type& x) const;
+    template <class K> iterator       find(const K& x);
+    template <class K> const_iterator find(const K& x) const;
     size_type      count(const key_type& x) const;
+    template <class K> size_type count(const K& x) const;
     iterator       lower_bound(const key_type& x);
     const_iterator lower_bound(const key_type& x) const;
+    template <class K> iterator       lower_bound(const K& x);
+    template <class K> const_iterator lower_bound(const K& x) const;
     iterator       upper_bound(const key_type& x);
     const_iterator upper_bound(const key_type& x) const;
+    template <class K> iterator       upper_bound(const K& x);
+    template <class K> const_iterator upper_bound(const K& x) const;
     pair<iterator,iterator>
       equal_range(const key_type& x);
     pair<const_iterator,const_iterator>
       equal_range(const key_type& x) const;
+    template <class K>
+      pair<iterator, iterator>             equal_range(const K& x);
+    template <class K>
+      pair<const_iterator, const_iterator> equal_range(const K& x) const;
   };
   template <class Key, class T, class Compare, class Allocator>
     bool operator==(const multimap<Key,T,Compare,Allocator>& x,
                     const multimap<Key,T,Compare,Allocator>& y);
 ```
 #### `multimap` constructors <a id="multimap.cons">[[multimap.cons]]</a>
 ``` cpp
+explicit multimap(const Compare& comp,
                   const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `multimap` using the specified comparison
 object and allocator.
   multimap(InputIterator first, InputIterator last,
            const Compare& comp = Compare(),
            const Allocator& = Allocator());
 ```
+*Requires:* If the iterator’s indirection operator returns an lvalue or
 a const rvalue `pair<key_type, mapped_type>`, then both `key_type` and
+`mapped_type` shall be `CopyInsertable` into `*this`.
 *Effects:* Constructs an empty `multimap` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
 `last`).
 ``` cpp
 template <class P> iterator insert(P&& x);
 template <class P> iterator insert(const_iterator position, P&& x);
 ```
+*Effects:* The first form is equivalent to
+`return emplace(std::forward<P>(x))`. The second form is equivalent to
+`return emplace_hint(position, std::forward<P>(x))`.
+*Remarks:* These signatures shall not participate in overload resolution
+unless `std::is_constructible<value_type, P&&>::value` is `true`.
 #### `multimap` specialized algorithms <a id="multimap.special">[[multimap.special]]</a>
 ``` cpp
 template <class Key, class T, class Compare, class Allocator>
     typedef typename allocator_traits<Allocator>::const_pointer     const_pointer;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
     // [set.cons], construct/copy/destroy:
+    set() : set(Compare()) { }
+    explicit set(const Compare& comp,
                  const Allocator& = Allocator());
     template <class InputIterator>
       set(InputIterator first, InputIterator last,
           const Compare& comp = Compare(), const Allocator& = Allocator());
+    set(const set& x);
+    set(set&& x);
     explicit set(const Allocator&);
     set(const set&, const Allocator&);
     set(set&&, const Allocator&);
     set(initializer_list<value_type>,
       const Compare& = Compare(),
       const Allocator& = Allocator());
+    template <class InputIterator>
+    set(InputIterator first, InputIterator last, const Allocator& a)
+      : set(first, last, Compare(), a) { }
+    set(initializer_list<value_type> il, const Allocator& a)
+      : set(il, Compare(), a) { }
    ~set();
+    set& operator=(const set& x);
+    set& operator=(set&& x);
     set& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
     // iterators:
     iterator               begin() noexcept;
     void insert(initializer_list<value_type>);
     iterator  erase(const_iterator position);
     size_type erase(const key_type& x);
     iterator  erase(const_iterator first, const_iterator last);
+    void swap(set&);
     void clear() noexcept;
     // observers:
     key_compare   key_comp() const;
     value_compare value_comp() const;
     // set operations:
     iterator        find(const key_type& x);
     const_iterator  find(const key_type& x) const;
+    template <class K> iterator       find(const K& x);
+    template <class K> const_iterator find(const K& x) const;
     size_type count(const key_type& x) const;
+    template <class K> size_type count(const K& x) const;
     iterator        lower_bound(const key_type& x);
     const_iterator  lower_bound(const key_type& x) const;
+    template <class K> iterator       lower_bound(const K& x);
+    template <class K> const_iterator lower_bound(const K& x) const;
     iterator        upper_bound(const key_type& x);
     const_iterator  upper_bound(const key_type& x) const;
+    template <class K> iterator       upper_bound(const K& x);
+    template <class K> const_iterator upper_bound(const K& x) const;
     pair<iterator,iterator>             equal_range(const key_type& x);
     pair<const_iterator,const_iterator> equal_range(const key_type& x) const;
+    template <class K>
+      pair<iterator, iterator>             equal_range(const K& x);
+    template <class K>
+      pair<const_iterator, const_iterator> equal_range(const K& x) const;
   };
   template <class Key, class Compare, class Allocator>
     bool operator==(const set<Key,Compare,Allocator>& x,
                     const set<Key,Compare,Allocator>& y);
 ```
 #### `set` constructors, copy, and assignment <a id="set.cons">[[set.cons]]</a>
 ``` cpp
+explicit set(const Compare& comp,
              const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty set using the specified comparison
 objects and allocator.
 *Effects:* Constructs an empty `set` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
 `last`).
+*Requires:* If the iterator’s indirection operator returns an lvalue or
+a non-const rvalue, then `Key` shall be `CopyInsertable` into `*this`.
 *Complexity:* Linear in N if the range \[`first`, `last`) is already
 sorted using `comp` and otherwise N log N, where N is `last - first`.
 #### `set` specialized algorithms <a id="set.special">[[set.special]]</a>
     typedef typename allocator_traits<Allocator>::const_pointer     const_pointer;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
     // construct/copy/destroy:
+    multiset() : multiset(Compare()) { }
+    explicit multiset(const Compare& comp,
                       const Allocator& = Allocator());
     template <class InputIterator>
       multiset(InputIterator first, InputIterator last,
                const Compare& comp = Compare(),
                const Allocator& = Allocator());
+    multiset(const multiset& x);
+    multiset(multiset&& x);
     explicit multiset(const Allocator&);
     multiset(const multiset&, const Allocator&);
     multiset(multiset&&, const Allocator&);
     multiset(initializer_list<value_type>,
       const Compare& = Compare(),
       const Allocator& = Allocator());
+    template <class InputIterator>
+    multiset(InputIterator first, InputIterator last, const Allocator& a)
+      : multiset(first, last, Compare(), a) { }
+    multiset(initializer_list<value_type> il, const Allocator& a)
+      : multiset(il, Compare(), a) { }
    ~multiset();
+    multiset& operator=(const multiset& x);
+    multiset& operator=(multiset&& x);
     multiset& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
     // iterators:
     iterator               begin() noexcept;
     void insert(initializer_list<value_type>);
     iterator  erase(const_iterator position);
     size_type erase(const key_type& x);
     iterator  erase(const_iterator first, const_iterator last);
+    void swap(multiset&);
     void clear() noexcept;
     // observers:
     key_compare   key_comp() const;
     value_compare value_comp() const;
     // set operations:
     iterator        find(const key_type& x);
     const_iterator  find(const key_type& x) const;
+    template <class K> iterator       find(const K& x);
+    template <class K> const_iterator find(const K& x) const;
     size_type count(const key_type& x) const;
+    template <class K> size_type count(const K& x) const;
     iterator        lower_bound(const key_type& x);
     const_iterator  lower_bound(const key_type& x) const;
+    template <class K> iterator       lower_bound(const K& x);
+    template <class K> const_iterator lower_bound(const K& x) const;
     iterator        upper_bound(const key_type& x);
     const_iterator  upper_bound(const key_type& x) const;
+    template <class K> iterator       upper_bound(const K& x);
+    template <class K> const_iterator upper_bound(const K& x) const;
     pair<iterator,iterator>             equal_range(const key_type& x);
     pair<const_iterator,const_iterator> equal_range(const key_type& x) const;
+    template <class K>
+      pair<iterator, iterator>             equal_range(const K& x);
+    template <class K>
+      pair<const_iterator, const_iterator> equal_range(const K& x) const;
   };
   template <class Key, class Compare, class Allocator>
     bool operator==(const multiset<Key,Compare,Allocator>& x,
                     const multiset<Key,Compare,Allocator>& y);
 ```
 #### `multiset` constructors <a id="multiset.cons">[[multiset.cons]]</a>
 ``` cpp
+explicit multiset(const Compare& comp,
                   const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty set using the specified comparison object
 and allocator.
 *Complexity:* Constant.
 ``` cpp
 template <class InputIterator>
+  multiset(InputIterator first, InputIterator last,
            const Compare& comp = Compare(), const Allocator& = Allocator());
 ```
+*Requires:* If the iterator’s indirection operator returns an lvalue or
+a const rvalue, then `Key` shall be `CopyInsertable` into `*this`.
 *Effects:* Constructs an empty `multiset` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
 `last`).
     typedef std::pair<const Key, T>                             value_type;
     typedef T                                                   mapped_type;
     typedef Hash                                                hasher;
     typedef Pred                                                key_equal;
     typedef Allocator                                           allocator_type;
+    typedef typename allocator_traits<Allocator>::pointer pointer;
+    typedef typename allocator_traits<Allocator>::const_pointer const_pointer;
+    typedef value_type&                                         reference;
+    typedef const value_type&                                   const_reference;
     typedef implementation-defined                              size_type;
     typedef implementation-defined                              difference_type;
     typedef implementation-defined                              iterator;
     typedef implementation-defined                              const_iterator;
     typedef implementation-defined                              local_iterator;
     typedef implementation-defined                              const_local_iterator;
     // construct/destroy/copy
+    unordered_map();
+    explicit unordered_map(size_type n,
                            const hasher& hf = hasher(),
                            const key_equal& eql = key_equal(),
                            const allocator_type& a = allocator_type());
     template <class InputIterator>
       unordered_map(InputIterator f, InputIterator l,
     unordered_map(initializer_list<value_type>,
       size_type = see below,
       const hasher& hf = hasher(),
       const key_equal& eql = key_equal(),
       const allocator_type& a = allocator_type());
+    unordered_map(size_type n, const allocator_type& a)
+      : unordered_map(n, hasher(), key_equal(), a) { }
+    unordered_map(size_type n, const hasher& hf, const allocator_type& a)
+      : unordered_map(n, hf, key_equal(), a) { }
+    template <class InputIterator>
+      unordered_map(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
+      : unordered_map(f, l, n, hasher(), key_equal(), a) { }
+    template <class InputIterator>
+      unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf,
+      const allocator_type& a)
+      : unordered_map(f, l, n, hf, key_equal(), a) { }
+    unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& a)
+      : unordered_map(il, n, hasher(), key_equal(), a) { }
+    unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf,
+    const allocator_type& a)
+      : unordered_map(il, n, hf, key_equal(), a) { }
     ~unordered_map();
     unordered_map& operator=(const unordered_map&);
     unordered_map& operator=(unordered_map&&);
     unordered_map& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
 ```
 #### `unordered_map` constructors <a id="unord.map.cnstr">[[unord.map.cnstr]]</a>
 ``` cpp
+unordered_map() : unordered_map(size_type(see below)) { }
+explicit unordered_map(size_type n,
                        const hasher& hf = hasher(),
                        const key_equal& eql = key_equal(),
                        const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_map` using the specified hash
 function, key equality function, and allocator, and using at least *`n`*
+buckets. For the default constructor, the number of buckets is
 *implementation-defined*. `max_load_factor()` returns 1.0.
 *Complexity:* Constant.
 ``` cpp
 ``` cpp
 mapped_type& operator[](const key_type& k);
 mapped_type& operator[](key_type&& k);
 ```
+*Requires:* `mapped_type` shall be `DefaultInsertable` into `*this`. For
+the first operator, `key_type` shall be `CopyInsertable` into `*this`.
+For the second operator, `key_type` shall be `MoveConstructible`.
 *Effects:* If the `unordered_map` does not already contain an element
 whose key is equivalent to *`k`*, the first operator inserts the value
 `value_type(k, mapped_type())` and the second operator inserts the value
 `value_type(std::move(k), mapped_type())`.
 ``` cpp
 template <class P>
   pair<iterator, bool> insert(P&& obj);
 ```
+*Effects:* Equivalent to `return emplace(std::forward<P>(obj))`.
 *Remarks:* This signature shall not participate in overload resolution
+unless `std::is_constructible<value_type, P&&>::value` is `true`.
 ``` cpp
 template <class P>
   iterator insert(const_iterator hint, P&& obj);
 ```
+*Effects:* Equivalent to
+`return emplace_hint(hint, std::forward<P>(obj))`.
 *Remarks:* This signature shall not participate in overload resolution
+unless `std::is_constructible<value_type, P&&>::value` is `true`.
 #### `unordered_map` swap <a id="unord.map.swap">[[unord.map.swap]]</a>
 ``` cpp
 template <class Key, class T, class Hash, class Pred, class Alloc>
     typedef std::pair<const Key, T>                             value_type;
     typedef T                                                   mapped_type;
     typedef Hash                                                hasher;
     typedef Pred                                                key_equal;
     typedef Allocator                                           allocator_type;
+    typedef typename allocator_traits<Allocator>::pointer pointer;
+    typedef typename allocator_traits<Allocator>::const_pointer const_pointer;
+    typedef value_type&                                         reference;
+    typedef const value_type&                                   const_reference;
     typedef implementation-defined                              size_type;
     typedef implementation-defined                              difference_type;
     typedef implementation-defined                              iterator;
     typedef implementation-defined                              const_iterator;
     typedef implementation-defined                              local_iterator;
     typedef implementation-defined                              const_local_iterator;
     // construct/destroy/copy
+    unordered_multimap();
+    explicit unordered_multimap(size_type n,
                                 const hasher& hf = hasher(),
                                 const key_equal& eql = key_equal(),
                                 const allocator_type& a = allocator_type());
     template <class InputIterator>
       unordered_multimap(InputIterator f, InputIterator l,
     unordered_multimap(initializer_list<value_type>,
       size_type = see below,
       const hasher& hf = hasher(),
       const key_equal& eql = key_equal(),
       const allocator_type& a = allocator_type());
+    unordered_multimap(size_type n, const allocator_type& a)
+      : unordered_multimap(n, hasher(), key_equal(), a) { }
+    unordered_multimap(size_type n, const hasher& hf, const allocator_type& a)
+      : unordered_multimap(n, hf, key_equal(), a) { }
+    template <class InputIterator>
+      unordered_multimap(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
+      : unordered_multimap(f, l, n, hasher(), key_equal(), a) { }
+    template <class InputIterator>
+      unordered_multimap(InputIterator f, InputIterator l, size_type n, const hasher& hf,
+      const allocator_type& a)
+      : unordered_multimap(f, l, n, hf, key_equal(), a) { }
+    unordered_multimap(initializer_list<value_type> il, size_type n, const allocator_type& a)
+      : unordered_multimap(il, n, hasher(), key_equal(), a) { }
+    unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf,
+    const allocator_type& a)
+      : unordered_multimap(il, n, hf, key_equal(), a) { }
     ~unordered_multimap();
     unordered_multimap& operator=(const unordered_multimap&);
     unordered_multimap& operator=(unordered_multimap&&);
     unordered_multimap& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
 ```
 #### `unordered_multimap` constructors <a id="unord.multimap.cnstr">[[unord.multimap.cnstr]]</a>
 ``` cpp
+unordered_multimap() : unordered_multimap(size_type(see below)) { }
+explicit unordered_multimap(size_type n,
                             const hasher& hf = hasher(),
                             const key_equal& eql = key_equal(),
                             const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_multimap` using the specified
 hash function, key equality function, and allocator, and using at least
+*`n`* buckets. For the default constructor, the number of buckets is
 *implementation-defined*. `max_load_factor()` returns 1.0.
 *Complexity:* Constant.
 ``` cpp
 ``` cpp
 template <class P>
   iterator insert(P&& obj);
 ```
+*Effects:* Equivalent to `return emplace(std::forward<P>(obj))`.
 *Remarks:* This signature shall not participate in overload resolution
+unless `std::is_constructible<value_type, P&&>::value` is `true`.
 ``` cpp
 template <class P>
   iterator insert(const_iterator hint, P&& obj);
 ```
+*Effects:* Equivalent to
+`return emplace_hint(hint, std::forward<P>(obj))`.
 *Remarks:* This signature shall not participate in overload resolution
+unless `std::is_constructible<value_type, P&&>::value` is `true`.
 #### `unordered_multimap` swap <a id="unord.multimap.swap">[[unord.multimap.swap]]</a>
 ``` cpp
 template <class Key, class T, class Hash, class Pred, class Alloc>
     typedef Key                                                 key_type;
     typedef Key                                                 value_type;
     typedef Hash                                                hasher;
     typedef Pred                                                key_equal;
     typedef Allocator                                           allocator_type;
+    typedef typename allocator_traits<Allocator>::pointer pointer;
+    typedef typename allocator_traits<Allocator>::const_pointer const_pointer;
+    typedef value_type&                                         reference;
+    typedef const value_type&                                   const_reference;
     typedef implementation-defined                              size_type;
     typedef implementation-defined                              difference_type;
     typedef implementation-defined                              iterator;
     typedef implementation-defined                              const_iterator;
     typedef implementation-defined                              local_iterator;
     typedef implementation-defined                              const_local_iterator;
     // construct/destroy/copy
+    unordered_set();
+    explicit unordered_set(size_type n,
                            const hasher& hf = hasher(),
                            const key_equal& eql = key_equal(),
                            const allocator_type& a = allocator_type());
     template <class InputIterator>
       unordered_set(InputIterator f, InputIterator l,
     unordered_set(initializer_list<value_type>,
       size_type = see below,
       const hasher& hf = hasher(),
       const key_equal& eql = key_equal(),
       const allocator_type& a = allocator_type());
+    unordered_set(size_type n, const allocator_type& a)
+      : unordered_set(n, hasher(), key_equal(), a) { }
+    unordered_set(size_type n, const hasher& hf, const allocator_type& a)
+      : unordered_set(n, hf, key_equal(), a) { }
+    template <class InputIterator>
+      unordered_set(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
+      : unordered_set(f, l, n, hasher(), key_equal(), a) { }
+    template <class InputIterator>
+      unordered_set(InputIterator f, InputIterator l, size_type n, const hasher& hf,
+      const allocator_type& a)
+      : unordered_set(f, l, n, hf, key_equal(), a) { }
+    unordered_set(initializer_list<value_type> il, size_type n, const allocator_type& a)
+      : unordered_set(il, n, hasher(), key_equal(), a) { }
+    unordered_set(initializer_list<value_type> il, size_type n, const hasher& hf,
+    const allocator_type& a)
+      : unordered_set(il, n, hf, key_equal(), a) { }
     ~unordered_set();
     unordered_set& operator=(const unordered_set&);
     unordered_set& operator=(unordered_set&&);
     unordered_set& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
   template <class Key, class Hash, class Pred, class Alloc>
     void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
               unordered_set<Key, Hash, Pred, Alloc>& y);
+  template <class Key, class Hash, class Pred, class Alloc>
+    bool operator==(const unordered_set<Key, Hash, Pred, Alloc>& a,
+                    const unordered_set<Key, Hash, Pred, Alloc>& b);
+  template <class Key, class Hash, class Pred, class Alloc>
+    bool operator!=(const unordered_set<Key, Hash, Pred, Alloc>& a,
+                    const unordered_set<Key, Hash, Pred, Alloc>& b);
 }
 ```
 #### `unordered_set` constructors <a id="unord.set.cnstr">[[unord.set.cnstr]]</a>
 ``` cpp
+unordered_set() : unordered_set(size_type(see below)) { }
+explicit unordered_set(size_type n,
                        const hasher& hf = hasher(),
                        const key_equal& eql = key_equal(),
                        const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_set` using the specified hash
 function, key equality function, and allocator, and using at least *`n`*
+buckets. For the default constructor, the number of buckets is
 *implementation-defined*. `max_load_factor()` returns 1.0.
 *Complexity:* Constant.
 ``` cpp
     typedef Key                                                 key_type;
     typedef Key                                                 value_type;
     typedef Hash                                                hasher;
     typedef Pred                                                key_equal;
     typedef Allocator                                           allocator_type;
+    typedef typename allocator_traits<Allocator>::pointer pointer;
+    typedef typename allocator_traits<Allocator>::const_pointer const_pointer;
+    typedef value_type&                                         reference;
+    typedef const value_type&                                   const_reference;
     typedef implementation-defined                              size_type;
     typedef implementation-defined                              difference_type;
     typedef implementation-defined                              iterator;
     typedef implementation-defined                              const_iterator;
     typedef implementation-defined                              local_iterator;
     typedef implementation-defined                              const_local_iterator;
     // construct/destroy/copy
+    unordered_multiset();
+    explicit unordered_multiset(size_type n,
                                 const hasher& hf = hasher(),
                                 const key_equal& eql = key_equal(),
                                 const allocator_type& a = allocator_type());
     template <class InputIterator>
       unordered_multiset(InputIterator f, InputIterator l,
     unordered_multiset(initializer_list<value_type>,
       size_type = see below,
       const hasher& hf = hasher(),
       const key_equal& eql = key_equal(),
       const allocator_type& a = allocator_type());
+    unordered_multiset(size_type n, const allocator_type& a)
+      : unordered_multiset(n, hasher(), key_equal(), a) { }
+    unordered_multiset(size_type n, const hasher& hf, const allocator_type& a)
+      : unordered_multiset(n, hf, key_equal(), a) { }
+    template <class InputIterator>
+      unordered_multiset(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
+      : unordered_multiset(f, l, n, hasher(), key_equal(), a) { }
+    template <class InputIterator>
+      unordered_multiset(InputIterator f, InputIterator l, size_type n, const hasher& hf,
+      const allocator_type& a)
+      : unordered_multiset(f, l, n, hf, key_equal(), a) { }
+    unordered_multiset(initializer_list<value_type> il, size_type n, const allocator_type& a)
+      : unordered_multiset(il, n, hasher(), key_equal(), a) { }
+    unordered_multiset(initializer_list<value_type> il, size_type n, const hasher& hf,
+    const allocator_type& a)
+      : unordered_multiset(il, n, hf, key_equal(), a) { }
     ~unordered_multiset();
     unordered_multiset& operator=(const unordered_multiset&);
+    unordered_multiset& operator=(unordered_multiset&&);
     unordered_multiset& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
     // size and capacity
     bool empty() const noexcept;
   };
   template <class Key, class Hash, class Pred, class Alloc>
     void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
               unordered_multiset<Key, Hash, Pred, Alloc>& y);
+    template <class Key, class Hash, class Pred, class Alloc>
+      bool operator==(const unordered_multiset<Key, Hash, Pred, Alloc>& a,
+                      const unordered_multiset<Key, Hash, Pred, Alloc>& b);
+    template <class Key, class Hash, class Pred, class Alloc>
+      bool operator!=(const unordered_multiset<Key, Hash, Pred, Alloc>& a,
+                      const unordered_multiset<Key, Hash, Pred, Alloc>& b);
 }
 ```
 #### `unordered_multiset` constructors <a id="unord.multiset.cnstr">[[unord.multiset.cnstr]]</a>
 ``` cpp
+unordered_multiset() : unordered_multiset(size_type(see below)) { }
+explicit unordered_multiset(size_type n,
                             const hasher& hf = hasher(),
                             const key_equal& eql = key_equal(),
                             const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_multiset` using the specified
 hash function, key equality function, and allocator, and using at least
+*`n`* buckets. For the default constructor, the number of buckets is
 *implementation-defined*. `max_load_factor()` returns 1.0.
 *Complexity:* Constant.
 ``` cpp
 ## Container adaptors <a id="container.adaptors">[[container.adaptors]]</a>
 ### In general <a id="container.adaptors.general">[[container.adaptors.general]]</a>
 The headers `<queue>` and `<stack>` define the container adaptors
+`queue`, `priority_queue`, and `stack`.
 The container adaptors each take a `Container` template parameter, and
 each constructor takes a `Container` reference argument. This container
 is copied into the `Container` member of each adaptor. If the container
 takes an allocator, then a compatible allocator may be passed in to the
     bool operator> (const stack<T, Container>& x, const stack<T, Container>& y);
   template <class T, class Container>
     bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y);
   template <class T, class Container>
     bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);
+  template <class T, class Container>
+    void swap(stack<T, Container>& x, stack<T, Container>& y) noexcept(noexcept(x.swap(y)));
   template <class T, class Container, class Alloc>
     struct uses_allocator<stack<T, Container>, Alloc>
       : uses_allocator<Container, Alloc>::type { };
 }
 ```
 *Effects:* Initializes `c` with `cont`.
 ``` cpp
+explicit stack(Container&& cont = Container());
 ```
 *Effects:* Initializes `c` with `std::move(cont)`.
 #### `stack` constructors with allocators <a id="stack.cons.alloc">[[stack.cons.alloc]]</a>
 *Effects:* `x.swap(y)`.
 <!-- Link reference definitions -->
 [alg.sorting]: algorithms.md#alg.sorting
+[algorithm.stable]: library.md#algorithm.stable
 [algorithms]: algorithms.md#algorithms
 [allocator.requirements]: library.md#allocator.requirements
 [allocator.traits.members]: utilities.md#allocator.traits.members
 [array]: #array
 [array.cons]: #array.cons
 [list.special]: #list.special
 [map]: #map
 [map.access]: #map.access
 [map.cons]: #map.cons
 [map.modifiers]: #map.modifiers
 [map.overview]: #map.overview
 [map.special]: #map.special
 [multimap]: #multimap
 [multimap.cons]: #multimap.cons
 [multimap.modifiers]: #multimap.modifiers
 [multimap.overview]: #multimap.overview
 [multimap.special]: #multimap.special
 [multiset]: #multiset
 [multiset.cons]: #multiset.cons
 [multiset.overview]: #multiset.overview
 [tab:containers.lib.summary]: #tab:containers.lib.summary
 [tab:containers.optional.operations]: #tab:containers.optional.operations
 [tab:containers.reversible.requirements]: #tab:containers.reversible.requirements
 [tab:containers.sequence.optional]: #tab:containers.sequence.optional
 [tab:containers.sequence.requirements]: #tab:containers.sequence.requirements
+[temp.deduct]: temp.md#temp.deduct
 [unord]: #unord
 [unord.general]: #unord.general
 [unord.hash]: utilities.md#unord.hash
 [unord.map]: #unord.map
 [unord.map.cnstr]: #unord.map.cnstr

Diff to HTML by rtfpessoa