[associative] - C++14 → C++17

Files changed (1) hide show

tmp/tmp8jlnrd3h/{from.md → to.md} +457 -208

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

@@ -3,17 +3,33 @@
 ### In general <a id="associative.general">[[associative.general]]</a>
 The header `<map>` defines the class templates `map` and `multimap`; the
 header `<set>` defines the class templates `set` and `multiset`.
 ### Header `<map>` synopsis <a id="associative.map.syn">[[associative.map.syn]]</a>
 ``` cpp
 #include <initializer_list>
 namespace std {
   template <class Key, class T, class Compare = less<Key>,
             class Allocator = allocator<pair<const Key, T>>>
     class map;
   template <class Key, class T, class Compare, class Allocator>
     bool operator==(const map<Key, T, Compare, Allocator>& x,
@@ -33,12 +49,14 @@ namespace std {
   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);
   template <class Key, class T, class Compare, class Allocator>
     void swap(map<Key, T, Compare, Allocator>& x,
-              map<Key,T,Compare,Allocator>& y);
   template <class Key, class T, class Compare = less<Key>,
             class Allocator = allocator<pair<const Key, T>>>
     class multimap;
   template <class Key, class T, class Compare, class Allocator>
     bool operator==(const multimap<Key, T, Compare, Allocator>& x,
@@ -58,21 +76,32 @@ namespace std {
   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);
   template <class Key, class T, class Compare, class Allocator>
     void swap(multimap<Key, T, Compare, Allocator>& x,
-              multimap<Key,T,Compare,Allocator>& y);
 }
 ```
 ### Header `<set>` synopsis <a id="associative.set.syn">[[associative.set.syn]]</a>
 ``` cpp
 #include <initializer_list>
 namespace std {
   template <class Key, class Compare = less<Key>,
             class Allocator = allocator<Key>>
     class set;
   template <class Key, class Compare, class Allocator>
     bool operator==(const set<Key, Compare, Allocator>& x,
@@ -92,12 +121,14 @@ namespace std {
   template <class Key, class Compare, class Allocator>
     bool operator<=(const set<Key, Compare, Allocator>& x,
                     const set<Key, Compare, Allocator>& y);
   template <class Key, class Compare, class Allocator>
     void swap(set<Key, Compare, Allocator>& x,
-              set<Key,Compare,Allocator>& y);
   template <class Key, class Compare = less<Key>,
             class Allocator = allocator<Key>>
     class multiset;
   template <class Key, class Compare, class Allocator>
     bool operator==(const multiset<Key, Compare, Allocator>& x,
@@ -117,11 +148,22 @@ namespace std {
   template <class Key, class Compare, class Allocator>
     bool operator<=(const multiset<Key, Compare, Allocator>& x,
                     const multiset<Key, Compare, Allocator>& y);
   template <class Key, class Compare, class Allocator>
     void swap(multiset<Key, Compare, Allocator>& x,
-              multiset<Key,Compare,Allocator>& y);
 }
 ```
 ### Class template `map` <a id="map">[[map]]</a>
@@ -134,59 +176,57 @@ bidirectional iterators.
 A `map` satisfies all of the requirements of a container, of a
 reversible container ([[container.requirements]]), of an associative
 container ([[associative.reqmts]]), and of an allocator-aware container
 (Table  [[tab:containers.allocatoraware]]). A `map` also provides most
-operations described in ([[associative.reqmts]]) for unique keys. This
-means that a `map` supports the `a_uniq` operations in (
-[[associative.reqmts]]) but not the `a_eq` operations. For a
-`map<Key,T>` the `key_type` is `Key` and the `value_type` is
-`pair<const Key,T>`. Descriptions are provided here only for operations
-on `map` that are not described in one of those tables or for operations
-where there is additional semantic information.
 ``` cpp
 namespace std {
   template <class Key, class T, class Compare = less<Key>,
             class Allocator = allocator<pair<const Key, T>>>
   class map {
   public:
     // types:
- typedef Key                                   key_type;
- typedef T                                     mapped_type;
- typedef pair<const Key, T>                    value_type;
- typedef Compare                               key_compare;
- typedef Allocator                             allocator_type;
- typedef value_type&                           reference;
- typedef const value_type&                     const_reference;
- typedef implementation-defined                iterator;       // see [container.requirements]
- typedef implementation-defined                const_iterator; // see [container.requirements]
- typedef implementation-defined                size_type; // see [container.requirements]
- typedef implementation-defined                difference_type;// see [container.requirements]
- typedef typename allocator_traits<Allocator>::pointer           pointer;
- 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;
     class value_compare {
       friend class map;
     protected:
       Compare comp;
       value_compare(Compare c) : comp(c) {}
     public:
-      typedef bool result_type;
-      typedef value_type first_argument_type;
-      typedef value_type second_argument_type;
       bool operator()(const value_type& x, const value_type& y) const {
         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);
@@ -201,11 +241,13 @@ namespace std {
         : 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;
@@ -226,34 +268,70 @@ namespace std {
     // capacity:
     bool      empty() const noexcept;
     size_type size() const noexcept;
     size_type max_size() const noexcept;
-    // [map.access], element access:
     T& operator[](const key_type& x);
     T& operator[](key_type&& x);
     T&       at(const key_type& x);
     const T& at(const key_type& x) const;
-    // [map.modifiers], modifiers:
     template <class... Args> pair<iterator, bool> emplace(Args&&... args);
     template <class... Args> iterator emplace_hint(const_iterator position, Args&&... args);
     pair<iterator, bool> insert(const value_type& x);
     template <class P> pair<iterator, bool> insert(P&& x);
     iterator insert(const_iterator position, const value_type& x);
     template <class P>
       iterator insert(const_iterator position, P&&);
     template <class InputIterator>
       void insert(InputIterator first, InputIterator last);
     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:
@@ -273,20 +351,36 @@ namespace std {
     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);
   template <class Key, class T, class Compare, class Allocator>
     bool operator< (const map<Key, T, Compare, Allocator>& x,
@@ -302,22 +396,22 @@ namespace std {
                     const map<Key, T, Compare, Allocator>& y);
   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);
-  // specialized algorithms:
   template <class Key, class T, class Compare, class Allocator>
     void swap(map<Key, T, Compare, Allocator>& x,
-              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.
@@ -327,51 +421,30 @@ 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`).
 *Complexity:* Linear in N if the range \[`first`, `last`) is already
-sorted using `comp` and otherwise N log N, where N is `last` - `first`.
 #### `map` element access <a id="map.access">[[map.access]]</a>
 ``` cpp
 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 `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;
 ```
@@ -385,36 +458,122 @@ 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>
   void swap(map<Key, T, Compare, Allocator>& x,
-            map<Key,T,Compare,Allocator>& y);
 ```
-*Effects:*
-``` cpp
-x.swap(y);
-```
 ### Class template `multimap` <a id="multimap">[[multimap]]</a>
 #### Class template `multimap` overview <a id="multimap.overview">[[multimap.overview]]</a>
@@ -425,13 +584,13 @@ for fast retrieval of values of another type `T` based on the keys. The
 A `multimap` satisfies all of the requirements of a container and of a
 reversible container ([[container.requirements]]), of an associative
 container ([[associative.reqmts]]), and of an allocator-aware container
 (Table  [[tab:containers.allocatoraware]]). A `multimap` also provides
-most operations described in ([[associative.reqmts]]) for equal keys.
-This means that a `multimap` supports the `a_eq` operations in (
-[[associative.reqmts]]) but not the `a_uniq` operations. For a
 `multimap<Key,T>` the `key_type` is `Key` and the `value_type` is
 `pair<const Key,T>`. Descriptions are provided here only for operations
 on `multimap` that are not described in one of those tables or for
 operations where there is additional semantic information.
@@ -440,44 +599,41 @@ namespace std {
   template <class Key, class T, class Compare = less<Key>,
             class Allocator = allocator<pair<const Key, T>>>
   class multimap {
   public:
     // types:
- typedef Key                                   key_type;
- typedef T                                     mapped_type;
- typedef pair<const Key,T>                     value_type;
- typedef Compare                               key_compare;
- typedef Allocator                             allocator_type;
- typedef value_type&                           reference;
- typedef const value_type&                     const_reference;
- typedef implementation-defined                iterator;       // see [container.requirements]
- typedef implementation-defined                const_iterator; // see [container.requirements]
- typedef implementation-defined                size_type; // see [container.requirements]
- typedef implementation-defined                difference_type;// see [container.requirements]
- typedef typename allocator_traits<Allocator>::pointer           pointer;
- 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;
     class value_compare {
       friend class multimap;
     protected:
       Compare comp;
       value_compare(Compare c) : comp(c) { }
     public:
-      typedef bool result_type;
-      typedef value_type first_argument_type;
-      typedef value_type second_argument_type;
       bool operator()(const value_type& x, const value_type& y) const {
         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);
@@ -493,11 +649,13 @@ namespace std {
         : 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;
@@ -518,27 +676,46 @@ namespace std {
     // capacity:
     bool      empty() const noexcept;
     size_type size() const noexcept;
     size_type max_size() const noexcept;
-    // modifiers:
     template <class... Args> iterator emplace(Args&&... args);
     template <class... Args> iterator emplace_hint(const_iterator position, Args&&... args);
     iterator insert(const value_type& x);
     template <class P> iterator insert(P&& x);
     iterator insert(const_iterator position, const value_type& x);
     template <class P> iterator insert(const_iterator position, P&& x);
     template <class InputIterator>
       void insert(InputIterator first, InputIterator last);
     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:
@@ -558,20 +735,37 @@ namespace std {
     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);
   template <class Key, class T, class Compare, class Allocator>
     bool operator< (const multimap<Key, T, Compare, Allocator>& x,
@@ -587,22 +781,22 @@ namespace std {
                     const multimap<Key, T, Compare, Allocator>& y);
   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);
-  // specialized algorithms:
   template <class Key, class T, class Compare, class Allocator>
     void swap(multimap<Key, T, Compare, Allocator>& x,
-              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.
@@ -613,14 +807,10 @@ template <class InputIterator>
   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`).
 *Complexity:* Linear in N if the range \[`first`, `last`) is already
@@ -636,25 +826,22 @@ 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>
   void swap(multimap<Key, T, Compare, Allocator>& x,
-            multimap<Key,T,Compare,Allocator>& y);
 ```
-*Effects:*
-``` cpp
-x.swap(y);
-```
 ### Class template `set` <a id="set">[[set]]</a>
 #### Class template `set` overview <a id="set.overview">[[set.overview]]</a>
@@ -664,13 +851,13 @@ keys themselves. The `set` class supports bidirectional iterators.
 A `set` satisfies all of the requirements of a container, of a
 reversible container ([[container.requirements]]), of an associative
 container ([[associative.reqmts]]), and of an allocator-aware container
 (Table  [[tab:containers.allocatoraware]]). A `set` also provides most
-operations described in ([[associative.reqmts]]) for unique keys. This
-means that a `set` supports the `a_uniq` operations in (
-[[associative.reqmts]]) but not the `a_eq` operations. For a `set<Key>`
 both the `key_type` and `value_type` are `Key`. Descriptions are
 provided here only for operations on `set` that are not described in one
 of these tables and for operations where there is additional semantic
 information.
@@ -679,49 +866,51 @@ namespace std {
   template <class Key, class Compare = less<Key>,
             class Allocator = allocator<Key>>
   class set {
   public:
     // types:
- typedef Key                                   key_type;
- typedef Key                                   value_type;
- typedef Compare                               key_compare;
- typedef Compare                               value_compare;
- typedef Allocator                             allocator_type;
- typedef value_type&                           reference;
- typedef const value_type&                     const_reference;
- typedef implementation-defined                iterator;       // See [container.requirements]
- typedef implementation-defined                const_iterator; // See [container.requirements]
- typedef implementation-defined                size_type; // See [container.requirements]
- typedef implementation-defined                difference_type;// See [container.requirements]
- typedef typename allocator_traits<Allocator>::pointer           pointer;
- 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;
@@ -753,16 +942,33 @@ namespace std {
     iterator insert(const_iterator position, value_type&& x);
     template <class InputIterator>
       void insert(InputIterator first, InputIterator last);
     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:
@@ -790,10 +996,29 @@ namespace std {
       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);
   template <class Key, class Compare, class Allocator>
     bool operator< (const set<Key, Compare, Allocator>& x,
@@ -809,25 +1034,25 @@ namespace std {
                     const set<Key, Compare, Allocator>& y);
   template <class Key, class Compare, class Allocator>
     bool operator<=(const set<Key, Compare, Allocator>& x,
                     const set<Key, Compare, Allocator>& y);
-  // specialized algorithms:
   template <class Key, class Compare, class Allocator>
     void swap(set<Key, Compare, Allocator>& x,
-              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.
 *Complexity:* Constant.
 ``` cpp
@@ -838,29 +1063,23 @@ 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 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>
 ``` cpp
 template <class Key, class Compare, class Allocator>
   void swap(set<Key, Compare, Allocator>& x,
-            set<Key,Compare,Allocator>& y);
 ```
-*Effects:*
-``` cpp
-x.swap(y);
-```
 ### Class template `multiset` <a id="multiset">[[multiset]]</a>
 #### Class template `multiset` overview <a id="multiset.overview">[[multiset.overview]]</a>
@@ -871,13 +1090,13 @@ bidirectional iterators.
 A `multiset` satisfies all of the requirements of a container, of a
 reversible container ([[container.requirements]]), of an associative
 container ([[associative.reqmts]]), and of an allocator-aware container
 (Table  [[tab:containers.allocatoraware]]). `multiset` also provides
-most operations described in ([[associative.reqmts]]) for duplicate
-keys. This means that a `multiset` supports the `a_eq` operations in (
-[[associative.reqmts]]) but not the `a_uniq` operations. For a
 `multiset<Key>` both the `key_type` and `value_type` are `Key`.
 Descriptions are provided here only for operations on `multiset` that
 are not described in one of these tables and for operations where there
 is additional semantic information.
@@ -886,50 +1105,50 @@ namespace std {
   template <class Key, class Compare = less<Key>,
             class Allocator = allocator<Key>>
   class multiset {
   public:
     // types:
- typedef Key                                                     key_type;
- typedef Key                                                     value_type;
- typedef Compare                                                 key_compare;
- typedef Compare                                                 value_compare;
- typedef Allocator                                               allocator_type;
- typedef value_type&                                             reference;
- typedef const value_type&                                       const_reference;
- typedef implementation-defined                iterator;       // see [container.requirements]
- typedef implementation-defined                const_iterator; // see [container.requirements]
- typedef implementation-defined                size_type; // see [container.requirements]
- typedef implementation-defined                difference_type;// see [container.requirements]
- typedef typename allocator_traits<Allocator>::pointer           pointer;
- 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;
@@ -961,16 +1180,33 @@ namespace std {
     iterator insert(const_iterator position, value_type&& x);
     template <class InputIterator>
       void insert(InputIterator first, InputIterator last);
     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:
@@ -998,10 +1234,29 @@ namespace std {
       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);
   template <class Key, class Compare, class Allocator>
     bool operator< (const multiset<Key, Compare, Allocator>& x,
@@ -1017,38 +1272,35 @@ namespace std {
                     const multiset<Key, Compare, Allocator>& y);
   template <class Key, class Compare, class Allocator>
     bool operator<=(const multiset<Key, Compare, Allocator>& x,
                     const multiset<Key, Compare, Allocator>& y);
-  // specialized algorithms:
   template <class Key, class Compare, class Allocator>
     void swap(multiset<Key, Compare, Allocator>& x,
-              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`).
 *Complexity:* Linear in N if the range \[`first`, `last`) is already
@@ -1057,14 +1309,11 @@ sorted using `comp` and otherwise N log N, where N is `last - first`.
 #### `multiset` specialized algorithms <a id="multiset.special">[[multiset.special]]</a>
 ``` cpp
 template <class Key, class Compare, class Allocator>
   void swap(multiset<Key, Compare, Allocator>& x,
-            multiset<Key,Compare,Allocator>& y);
 ```
-*Effects:*
-``` cpp
-x.swap(y);
-```

 ### In general <a id="associative.general">[[associative.general]]</a>
 The header `<map>` defines the class templates `map` and `multimap`; the
 header `<set>` defines the class templates `set` and `multiset`.
+The following exposition-only alias templates may appear in deduction
+guides for associative containers:
+``` cpp
+template<class InputIterator>
+  using iter_key_t = remove_const_t<
+    typename iterator_traits<InputIterator>::value_type::first_type>; // exposition only
+template<class InputIterator>
+  using iter_val_t
+    = typename iterator_traits<InputIterator>::value_type::second_type; // exposition only
+template<class InputIterator>
+  using iter_to_alloc_t
+    = pair<add_const_t<typename iterator_traits<InputIterator>::value_type::first_type>,
+           typename iterator_traits<InputIterator>::value_type::second_type>; // exposition only
+```
 ### Header `<map>` synopsis <a id="associative.map.syn">[[associative.map.syn]]</a>
 ``` cpp
 #include <initializer_list>
 namespace std {
+  // [map], class template map
   template <class Key, class T, class Compare = less<Key>,
             class Allocator = allocator<pair<const Key, T>>>
     class map;
   template <class Key, class T, class Compare, class Allocator>
     bool operator==(const map<Key, T, Compare, Allocator>& x,
   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);
   template <class Key, class T, class Compare, class Allocator>
     void swap(map<Key, T, Compare, Allocator>& x,
+              map<Key, T, Compare, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
+  // [multimap], class template multimap
   template <class Key, class T, class Compare = less<Key>,
             class Allocator = allocator<pair<const Key, T>>>
     class multimap;
   template <class Key, class T, class Compare, class Allocator>
     bool operator==(const multimap<Key, T, Compare, Allocator>& x,
   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);
   template <class Key, class T, class Compare, class Allocator>
     void swap(multimap<Key, T, Compare, Allocator>& x,
+              multimap<Key, T, Compare, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
+  namespace pmr {
+    template <class Key, class T, class Compare = less<Key>>
+      using map = std::map<Key, T, Compare,
+                           polymorphic_allocator<pair<const Key, T>>>;
+    template <class Key, class T, class Compare = less<Key>>
+      using multimap = std::multimap<Key, T, Compare,
+                                     polymorphic_allocator<pair<const Key, T>>>;
+  }
 }
 ```
 ### Header `<set>` synopsis <a id="associative.set.syn">[[associative.set.syn]]</a>
 ``` cpp
 #include <initializer_list>
 namespace std {
+  // [set], class template set
   template <class Key, class Compare = less<Key>,
             class Allocator = allocator<Key>>
     class set;
   template <class Key, class Compare, class Allocator>
     bool operator==(const set<Key, Compare, Allocator>& x,
   template <class Key, class Compare, class Allocator>
     bool operator<=(const set<Key, Compare, Allocator>& x,
                     const set<Key, Compare, Allocator>& y);
   template <class Key, class Compare, class Allocator>
     void swap(set<Key, Compare, Allocator>& x,
+              set<Key, Compare, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
+  // [multiset], class template multiset
   template <class Key, class Compare = less<Key>,
             class Allocator = allocator<Key>>
     class multiset;
   template <class Key, class Compare, class Allocator>
     bool operator==(const multiset<Key, Compare, Allocator>& x,
   template <class Key, class Compare, class Allocator>
     bool operator<=(const multiset<Key, Compare, Allocator>& x,
                     const multiset<Key, Compare, Allocator>& y);
   template <class Key, class Compare, class Allocator>
     void swap(multiset<Key, Compare, Allocator>& x,
+              multiset<Key, Compare, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
+  namespace pmr {
+    template <class Key, class Compare = less<Key>>
+      using set = std::set<Key, Compare,
+                           polymorphic_allocator<Key>>;
+    template <class Key, class Compare = less<Key>>
+      using multiset = std::multiset<Key, Compare,
+                                     polymorphic_allocator<Key>>;
+  }
 }
 ```
 ### Class template `map` <a id="map">[[map]]</a>
 A `map` satisfies all of the requirements of a container, of a
 reversible container ([[container.requirements]]), of an associative
 container ([[associative.reqmts]]), and of an allocator-aware container
 (Table  [[tab:containers.allocatoraware]]). A `map` also provides most
+operations described in  [[associative.reqmts]] for unique keys. This
+means that a `map` supports the `a_uniq` operations in
+[[associative.reqmts]] but not the `a_eq` operations. For a `map<Key,T>`
+the `key_type` is `Key` and the `value_type` is `pair<const Key,T>`.
+Descriptions are provided here only for operations on `map` that are not
+described in one of those tables or for operations where there is
+additional semantic information.
 ``` cpp
 namespace std {
   template <class Key, class T, class Compare = less<Key>,
             class Allocator = allocator<pair<const Key, T>>>
   class map {
   public:
     // types:
+ using key_type               = Key;
+ using mapped_type            = T;
+ using value_type             = pair<const Key, T>;
+ using key_compare            = Compare;
+ using allocator_type         = Allocator;
+ using pointer                = typename allocator_traits<Allocator>::pointer;
+ using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
+ using reference              = value_type&;
+ using const_reference        = const value_type&;
+ using size_type              = implementation-defined; // see [container.requirements]
+ using difference_type        = implementation-defined; // see [container.requirements]
+ using iterator               = implementation-defined  // type of map::iterator; // see [container.requirements]
+ using const_iterator         = implementation-defined  // type of map::const_iterator; // see [container.requirements]
+ using reverse_iterator       = std::reverse_iterator<iterator>;
+ using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+    using node_type              = unspecified;
+    using insert_return_type     = INSERT_RETURN_TYPE<iterator, node_type>;
     class value_compare {
       friend class map;
     protected:
       Compare comp;
       value_compare(Compare c) : comp(c) {}
     public:
       bool operator()(const value_type& x, const value_type& y) const {
         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);
         : 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)
+      noexcept(allocator_traits<Allocator>::is_always_equal::value &&
+               is_nothrow_move_assignable_v<Compare>);
     map& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
     // iterators:
     iterator               begin() noexcept;
     // capacity:
     bool      empty() const noexcept;
     size_type size() const noexcept;
     size_type max_size() const noexcept;
+    // [map.access], element access
     T& operator[](const key_type& x);
     T& operator[](key_type&& x);
     T&       at(const key_type& x);
     const T& at(const key_type& x) const;
+    // [map.modifiers], modifiers
     template <class... Args> pair<iterator, bool> emplace(Args&&... args);
     template <class... Args> iterator emplace_hint(const_iterator position, Args&&... args);
     pair<iterator, bool> insert(const value_type& x);
+    pair<iterator, bool> insert(value_type&& x);
     template <class P> pair<iterator, bool> insert(P&& x);
     iterator insert(const_iterator position, const value_type& x);
+    iterator insert(const_iterator position, value_type&& x);
     template <class P>
       iterator insert(const_iterator position, P&&);
     template <class InputIterator>
       void insert(InputIterator first, InputIterator last);
     void insert(initializer_list<value_type>);
+    node_type extract(const_iterator position);
+    node_type extract(const key_type& x);
+    insert_return_type insert(node_type&& nh);
+    iterator           insert(const_iterator hint, node_type&& nh);
+    template <class... Args>
+      pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
+    template <class... Args>
+      pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
+    template <class... Args>
+      iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
+    template <class... Args>
+      iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
+    template <class M>
+      pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
+    template <class M>
+      pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
+    template <class M>
+      iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
+    template <class M>
+      iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
+    iterator  erase(iterator position);
     iterator  erase(const_iterator position);
     size_type erase(const key_type& x);
     iterator  erase(const_iterator first, const_iterator last);
+    void swap(map&)
+      noexcept(allocator_traits<Allocator>::is_always_equal::value &&
+               is_nothrow_swappable_v<Compare>);
     void      clear() noexcept;
+    template<class C2>
+      void merge(map<Key, T, C2, Allocator>& source);
+    template<class C2>
+      void merge(map<Key, T, C2, Allocator>&& source);
+    template<class C2>
+      void merge(multimap<Key, T, C2, Allocator>& source);
+    template<class C2>
+      void merge(multimap<Key, T, C2, Allocator>&& source);
     // observers:
     key_compare key_comp() const;
     value_compare value_comp() const;
     // map operations:
     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 InputIterator, class Compare = less<iter_key_t<InputIterator>>,
+           class Allocator = allocator<iter_to_alloc_t<InputIterator>>>
+    map(InputIterator, InputIterator, Compare = Compare(), Allocator = Allocator())
+      -> map<iter_key_t<InputIterator>, iter_val_t<InputIterator>, Compare, Allocator>;
+  template<class Key, class T, class Compare = less<Key>,
+           class Allocator = allocator<pair<const Key, T>>>
+    map(initializer_list<pair<const Key, T>>, Compare = Compare(), Allocator = Allocator())
+      -> map<Key, T, Compare, Allocator>;
+  template <class InputIterator, class Allocator>
+    map(InputIterator, InputIterator, Allocator)
+      -> map<iter_key_t<InputIterator>, iter_val_t<InputIterator>,
+             less<iter_key_t<InputIterator>>, Allocator>;
+  template<class Key, class T, class Allocator>
+    map(initializer_list<pair<const Key, T>>, Allocator) -> map<Key, T, less<Key>, Allocator>;
   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);
   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);
   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.special], specialized algorithms
   template <class Key, class T, class Compare, class Allocator>
     void swap(map<Key, T, Compare, Allocator>& x,
+              map<Key, T, Compare, Allocator>& y)
+      noexcept(noexcept(x.swap(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());
 ```
 *Effects:* Constructs an empty `map` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
 `last`).
 *Complexity:* Linear in N if the range \[`first`, `last`) is already
+sorted using `comp` and otherwise N log N, where N is `last - first`.
 #### `map` element access <a id="map.access">[[map.access]]</a>
 ``` cpp
 T& operator[](const key_type& x);
 ```
+*Effects:* Equivalent to: `return try_emplace(x).first->second;`
 ``` cpp
 T& operator[](key_type&& x);
 ```
+*Effects:* Equivalent to: `return try_emplace(move(x)).first->second;`
 ``` cpp
 T&       at(const key_type& x);
 const T& at(const key_type& x) const;
 ```
 *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);
 ```
 *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 `is_constructible_v<value_type, P&&>` is `true`.
+``` cpp
+template <class... Args>
+  pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
+template <class... Args>
+  iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
+```
+*Requires:* `value_type` shall be `EmplaceConstructible` into `map` from
+`piecewise_construct`, `forward_as_tuple(k)`,
+`forward_as_tuple(std::forward<Args>(args)...)`.
+*Effects:* If the map already contains an element whose key is
+equivalent to `k`, there is no effect. Otherwise inserts an object of
+type `value_type` constructed with `piecewise_construct`,
+`forward_as_tuple(k)`, `forward_as_tuple(std::forward<Args>(args)...)`.
+*Returns:* In the first overload, the `bool` component of the returned
+pair is `true` if and only if the insertion took place. The returned
+iterator points to the map element whose key is equivalent to `k`.
+*Complexity:* The same as `emplace` and `emplace_hint`, respectively.
+``` cpp
+template <class... Args>
+  pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
+template <class... Args>
+  iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
+```
+*Requires:* `value_type` shall be `EmplaceConstructible` into `map` from
+`piecewise_construct`, `forward_as_tuple(std::move(k))`,
+`forward_as_tuple(std::forward<Args>(args)...)`.
+*Effects:* If the map already contains an element whose key is
+equivalent to `k`, there is no effect. Otherwise inserts an object of
+type `value_type` constructed with `piecewise_construct`,
+`forward_as_tuple(std::move(k))`,
+`forward_as_tuple(std::forward<Args>(args)...)`.
+*Returns:* In the first overload, the `bool` component of the returned
+pair is `true` if and only if the insertion took place. The returned
+iterator points to the map element whose key is equivalent to `k`.
+*Complexity:* The same as `emplace` and `emplace_hint`, respectively.
+``` cpp
+template <class M>
+  pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
+template <class M>
+  iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
+```
+*Requires:* `is_assignable_v<mapped_type&, M&&>` shall be `true`.
+`value_type` shall be `EmplaceConstructible` into `map` from `k`,
+`forward<M>(obj)`.
+*Effects:* If the map already contains an element `e` whose key is
+equivalent to `k`, assigns `std::forward<M>(obj)` to `e.second`.
+Otherwise inserts an object of type `value_type` constructed with `k`,
+`std::forward<M>(obj)`.
+*Returns:* In the first overload, the `bool` component of the returned
+pair is `true` if and only if the insertion took place. The returned
+iterator points to the map element whose key is equivalent to `k`.
+*Complexity:* The same as `emplace` and `emplace_hint`, respectively.
+``` cpp
+template <class M>
+  pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
+template <class M>
+  iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
+```
+*Requires:* `is_assignable_v<mapped_type&, M&&>` shall be `true`.
+`value_type` shall be `EmplaceConstructible` into `map` from `move(k)`,
+`forward<M>(obj)`.
+*Effects:* If the map already contains an element `e` whose key is
+equivalent to `k`, assigns `std::forward<M>(obj)` to `e.second`.
+Otherwise inserts an object of type `value_type` constructed with
+`std::move(k)`, `std::forward<M>(obj)`.
+*Returns:* In the first overload, the `bool` component of the returned
+pair is `true` if and only if the insertion took place. The returned
+iterator points to the map element whose key is equivalent to `k`.
+*Complexity:* The same as `emplace` and `emplace_hint`, respectively.
 #### `map` specialized algorithms <a id="map.special">[[map.special]]</a>
 ``` cpp
 template <class Key, class T, class Compare, class Allocator>
   void swap(map<Key, T, Compare, Allocator>& x,
+            map<Key, T, Compare, Allocator>& y)
+    noexcept(noexcept(x.swap(y)));
 ```
+*Effects:* As if by `x.swap(y)`.
 ### Class template `multimap` <a id="multimap">[[multimap]]</a>
 #### Class template `multimap` overview <a id="multimap.overview">[[multimap.overview]]</a>
 A `multimap` satisfies all of the requirements of a container and of a
 reversible container ([[container.requirements]]), of an associative
 container ([[associative.reqmts]]), and of an allocator-aware container
 (Table  [[tab:containers.allocatoraware]]). A `multimap` also provides
+most operations described in  [[associative.reqmts]] for equal keys.
+This means that a `multimap` supports the `a_eq` operations in
+[[associative.reqmts]] but not the `a_uniq` operations. For a
 `multimap<Key,T>` the `key_type` is `Key` and the `value_type` is
 `pair<const Key,T>`. Descriptions are provided here only for operations
 on `multimap` that are not described in one of those tables or for
 operations where there is additional semantic information.
   template <class Key, class T, class Compare = less<Key>,
             class Allocator = allocator<pair<const Key, T>>>
   class multimap {
   public:
     // types:
+ using key_type               = Key;
+ using mapped_type            = T;
+ using value_type             = pair<const Key, T>;
+ using key_compare            = Compare;
+ using allocator_type         = Allocator;
+ using pointer                = typename allocator_traits<Allocator>::pointer;
+ using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
+ using reference              = value_type&;
+ using const_reference        = const value_type&;
+ using size_type              = implementation-defined; // see [container.requirements]
+ using difference_type        = implementation-defined; // see [container.requirements]
+ using iterator               = implementation-defined  // type of multimap::iterator; // see [container.requirements]
+ using const_iterator         = implementation-defined  // type of multimap::const_iterator; // see [container.requirements]
+ using reverse_iterator       = std::reverse_iterator<iterator>;
+ using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+    using node_type              = unspecified;
     class value_compare {
       friend class multimap;
     protected:
       Compare comp;
       value_compare(Compare c) : comp(c) { }
     public:
       bool operator()(const value_type& x, const value_type& y) const {
         return comp(x.first, y.first);
       }
     };
+    // [multimap.cons], 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(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)
+      noexcept(allocator_traits<Allocator>::is_always_equal::value &&
+               is_nothrow_move_assignable_v<Compare>);
     multimap& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
     // iterators:
     iterator               begin() noexcept;
     // capacity:
     bool      empty() const noexcept;
     size_type size() const noexcept;
     size_type max_size() const noexcept;
+    // [multimap.modifiers], modifiers
     template <class... Args> iterator emplace(Args&&... args);
     template <class... Args> iterator emplace_hint(const_iterator position, Args&&... args);
     iterator insert(const value_type& x);
+    iterator insert(value_type&& x);
     template <class P> iterator insert(P&& x);
     iterator insert(const_iterator position, const value_type& x);
+    iterator insert(const_iterator position, value_type&& x);
     template <class P> iterator insert(const_iterator position, P&& x);
     template <class InputIterator>
       void insert(InputIterator first, InputIterator last);
     void insert(initializer_list<value_type>);
+    node_type extract(const_iterator position);
+    node_type extract(const key_type& x);
+    iterator insert(node_type&& nh);
+    iterator insert(const_iterator hint, node_type&& nh);
+    iterator  erase(iterator position);
     iterator  erase(const_iterator position);
     size_type erase(const key_type& x);
     iterator  erase(const_iterator first, const_iterator last);
+    void swap(multimap&)
+      noexcept(allocator_traits<Allocator>::is_always_equal::value &&
+               is_nothrow_swappable_v<Compare>);
     void      clear() noexcept;
+    template<class C2>
+      void merge(multimap<Key, T, C2, Allocator>& source);
+    template<class C2>
+      void merge(multimap<Key, T, C2, Allocator>&& source);
+    template<class C2>
+      void merge(map<Key, T, C2, Allocator>& source);
+    template<class C2>
+      void merge(map<Key, T, C2, Allocator>&& source);
     // observers:
     key_compare key_comp() const;
     value_compare value_comp() const;
     // map operations:
     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 InputIterator, class Compare = less<iter_key_t<InputIterator>>,
+           class Allocator = allocator<iter_to_alloc_t<InputIterator>>>
+    multimap(InputIterator, InputIterator, Compare = Compare(), Allocator = Allocator())
+      -> multimap<iter_key_t<InputIterator>, iter_val_t<InputIterator>, Compare, Allocator>;
+  template<class Key, class T, class Compare = less<Key>,
+           class Allocator = allocator<pair<const Key, T>>>
+    multimap(initializer_list<pair<const Key, T>>, Compare = Compare(), Allocator = Allocator())
+      -> multimap<Key, T, Compare, Allocator>;
+  template<class InputIterator, class Allocator>
+    multimap(InputIterator, InputIterator, Allocator)
+      -> multimap<iter_key_t<InputIterator>, iter_val_t<InputIterator>,
+                  less<iter_key_t<InputIterator>>, Allocator>;
+  template<class Key, class T, class Allocator>
+    multimap(initializer_list<pair<const Key, T>>, Allocator)
+      -> multimap<Key, T, less<Key>, Allocator>;
   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);
   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);
   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.special], specialized algorithms
   template <class Key, class T, class Compare, class Allocator>
     void swap(multimap<Key, T, Compare, Allocator>& x,
+              multimap<Key, T, Compare, Allocator>& y)
+      noexcept(noexcept(x.swap(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());
 ```
 *Effects:* Constructs an empty `multimap` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
 `last`).
 *Complexity:* Linear in N if the range \[`first`, `last`) is already
 *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 `is_constructible_v<value_type, P&&>` is `true`.
 #### `multimap` specialized algorithms <a id="multimap.special">[[multimap.special]]</a>
 ``` cpp
 template <class Key, class T, class Compare, class Allocator>
   void swap(multimap<Key, T, Compare, Allocator>& x,
+            multimap<Key, T, Compare, Allocator>& y)
+    noexcept(noexcept(x.swap(y)));
 ```
+*Effects:* As if by `x.swap(y)`.
 ### Class template `set` <a id="set">[[set]]</a>
 #### Class template `set` overview <a id="set.overview">[[set.overview]]</a>
 A `set` satisfies all of the requirements of a container, of a
 reversible container ([[container.requirements]]), of an associative
 container ([[associative.reqmts]]), and of an allocator-aware container
 (Table  [[tab:containers.allocatoraware]]). A `set` also provides most
+operations described in  [[associative.reqmts]] for unique keys. This
+means that a `set` supports the `a_uniq` operations in
+[[associative.reqmts]] but not the `a_eq` operations. For a `set<Key>`
 both the `key_type` and `value_type` are `Key`. Descriptions are
 provided here only for operations on `set` that are not described in one
 of these tables and for operations where there is additional semantic
 information.
   template <class Key, class Compare = less<Key>,
             class Allocator = allocator<Key>>
   class set {
   public:
     // types:
+ using key_type               = Key;
+ using key_compare            = Compare;
+ using value_type             = Key;
+ using value_compare          = Compare;
+ using allocator_type         = Allocator;
+ using pointer                = typename allocator_traits<Allocator>::pointer;
+ using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
+ using reference              = value_type&;
+ using const_reference        = const value_type&;
+ using size_type              = implementation-defined; // see [container.requirements]
+ using difference_type        = implementation-defined; // see [container.requirements]
+ using iterator               = implementation-defined  // type of set::iterator; // see [container.requirements]
+ using const_iterator         = implementation-defined  // type of set::const_iterator; // see [container.requirements]
+ using reverse_iterator       = std::reverse_iterator<iterator>;
+ using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+    using node_type              = unspecified;
+    using insert_return_type     = INSERT_RETURN_TYPE<iterator, node_type>;
+    // [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)
+      noexcept(allocator_traits<Allocator>::is_always_equal::value &&
+               is_nothrow_move_assignable_v<Compare>);
     set& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
     // iterators:
     iterator               begin() noexcept;
     iterator insert(const_iterator position, value_type&& x);
     template <class InputIterator>
       void insert(InputIterator first, InputIterator last);
     void insert(initializer_list<value_type>);
+    node_type extract(const_iterator position);
+    node_type extract(const key_type& x);
+    insert_return_type insert(node_type&& nh);
+    iterator           insert(const_iterator hint, node_type&& nh);
+    iterator  erase(iterator position);
     iterator  erase(const_iterator position);
     size_type erase(const key_type& x);
     iterator  erase(const_iterator first, const_iterator last);
+    void swap(set&)
+      noexcept(allocator_traits<Allocator>::is_always_equal::value &&
+               is_nothrow_swappable_v<Compare>);
     void      clear() noexcept;
+    template<class C2>
+      void merge(set<Key, C2, Allocator>& source);
+    template<class C2>
+      void merge(set<Key, C2, Allocator>&& source);
+    template<class C2>
+      void merge(multiset<Key, C2, Allocator>& source);
+    template<class C2>
+      void merge(multiset<Key, C2, Allocator>&& source);
     // observers:
     key_compare key_comp() const;
     value_compare value_comp() const;
     // set operations:
       pair<iterator, iterator>             equal_range(const K& x);
     template <class K>
       pair<const_iterator, const_iterator> equal_range(const K& x) const;
   };
+  template<class InputIterator,
+           class Compare = less<typename iterator_traits<InputIterator>::value_type>,
+           class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
+    set(InputIterator, InputIterator,
+        Compare = Compare(), Allocator = Allocator())
+      -> set<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+  template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
+    set(initializer_list<Key>, Compare = Compare(), Allocator = Allocator())
+      -> set<Key, Compare, Allocator>;
+  template<class InputIterator, class Allocator>
+    set(InputIterator, InputIterator, Allocator)
+      -> set<typename iterator_traits<InputIterator>::value_type,
+             less<typename iterator_traits<InputIterator>::value_type>, Allocator>;
+  template<class Key, class Allocator>
+    set(initializer_list<Key>, Allocator) -> set<Key, less<Key>, Allocator>;
   template <class Key, class Compare, class Allocator>
     bool operator==(const set<Key, Compare, Allocator>& x,
                     const set<Key, Compare, Allocator>& y);
   template <class Key, class Compare, class Allocator>
     bool operator< (const set<Key, Compare, Allocator>& x,
                     const set<Key, Compare, Allocator>& y);
   template <class Key, class Compare, class Allocator>
     bool operator<=(const set<Key, Compare, Allocator>& x,
                     const set<Key, Compare, Allocator>& y);
+  // [set.special], specialized algorithms
   template <class Key, class Compare, class Allocator>
     void swap(set<Key, Compare, Allocator>& x,
+              set<Key, Compare, Allocator>& y)
+      noexcept(noexcept(x.swap(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.
 *Complexity:* Constant.
 ``` cpp
 *Effects:* Constructs an empty `set` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
 `last`).
 *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>
 ``` cpp
 template <class Key, class Compare, class Allocator>
   void swap(set<Key, Compare, Allocator>& x,
+            set<Key, Compare, Allocator>& y)
+    noexcept(noexcept(x.swap(y)));
 ```
+*Effects:* As if by `x.swap(y)`.
 ### Class template `multiset` <a id="multiset">[[multiset]]</a>
 #### Class template `multiset` overview <a id="multiset.overview">[[multiset.overview]]</a>
 A `multiset` satisfies all of the requirements of a container, of a
 reversible container ([[container.requirements]]), of an associative
 container ([[associative.reqmts]]), and of an allocator-aware container
 (Table  [[tab:containers.allocatoraware]]). `multiset` also provides
+most operations described in  [[associative.reqmts]] for duplicate keys.
+This means that a `multiset` supports the `a_eq` operations in
+[[associative.reqmts]] but not the `a_uniq` operations. For a
 `multiset<Key>` both the `key_type` and `value_type` are `Key`.
 Descriptions are provided here only for operations on `multiset` that
 are not described in one of these tables and for operations where there
 is additional semantic information.
   template <class Key, class Compare = less<Key>,
             class Allocator = allocator<Key>>
   class multiset {
   public:
     // types:
+ using key_type               = Key;
+ using key_compare            = Compare;
+ using value_type             = Key;
+ using value_compare          = Compare;
+ using allocator_type         = Allocator;
+ using pointer                = typename allocator_traits<Allocator>::pointer;
+ using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
+ using reference              = value_type&;
+ using const_reference        = const value_type&;
+ using size_type              = implementation-defined; // see [container.requirements]
+ using difference_type        = implementation-defined; // see [container.requirements]
+ using iterator               = implementation-defined  // type of multiset::iterator; // see [container.requirements]
+ using const_iterator         = implementation-defined  // type of multiset::const_iterator; // see [container.requirements]
+ using reverse_iterator       = std::reverse_iterator<iterator>;
+ using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+    using node_type              = unspecified;
+    // [multiset.cons], 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)
+      noexcept(allocator_traits<Allocator>::is_always_equal::value &&
+               is_nothrow_move_assignable_v<Compare>);
     multiset& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
     // iterators:
     iterator               begin() noexcept;
     iterator insert(const_iterator position, value_type&& x);
     template <class InputIterator>
       void insert(InputIterator first, InputIterator last);
     void insert(initializer_list<value_type>);
+    node_type extract(const_iterator position);
+    node_type extract(const key_type& x);
+    iterator insert(node_type&& nh);
+    iterator insert(const_iterator hint, node_type&& nh);
+    iterator  erase(iterator position);
     iterator  erase(const_iterator position);
     size_type erase(const key_type& x);
     iterator  erase(const_iterator first, const_iterator last);
+    void swap(multiset&)
+      noexcept(allocator_traits<Allocator>::is_always_equal::value &&
+               is_nothrow_swappable_v<Compare>);
     void      clear() noexcept;
+    template<class C2>
+      void merge(multiset<Key, C2, Allocator>& source);
+    template<class C2>
+      void merge(multiset<Key, C2, Allocator>&& source);
+    template<class C2>
+      void merge(set<Key, C2, Allocator>& source);
+    template<class C2>
+      void merge(set<Key, C2, Allocator>&& source);
     // observers:
     key_compare key_comp() const;
     value_compare value_comp() const;
     // set operations:
       pair<iterator, iterator>             equal_range(const K& x);
     template <class K>
       pair<const_iterator, const_iterator> equal_range(const K& x) const;
   };
+  template<class InputIterator,
+           class Compare = less<typename iterator_traits<InputIterator>::value_type>,
+           class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
+    multiset(InputIterator, InputIterator,
+             Compare = Compare(), Allocator = Allocator())
+      -> multiset<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+  template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
+    multiset(initializer_list<Key>, Compare = Compare(), Allocator = Allocator())
+      -> multiset<Key, Compare, Allocator>;
+  template<class InputIterator, class Allocator>
+    multiset(InputIterator, InputIterator, Allocator)
+      -> multiset<typename iterator_traits<InputIterator>::value_type,
+                  less<typename iterator_traits<InputIterator>::value_type>, Allocator>;
+  template<class Key, class Allocator>
+    multiset(initializer_list<Key>, Allocator) -> multiset<Key, less<Key>, Allocator>;
   template <class Key, class Compare, class Allocator>
     bool operator==(const multiset<Key, Compare, Allocator>& x,
                     const multiset<Key, Compare, Allocator>& y);
   template <class Key, class Compare, class Allocator>
     bool operator< (const multiset<Key, Compare, Allocator>& x,
                     const multiset<Key, Compare, Allocator>& y);
   template <class Key, class Compare, class Allocator>
     bool operator<=(const multiset<Key, Compare, Allocator>& x,
                     const multiset<Key, Compare, Allocator>& y);
+  // [multiset.special], specialized algorithms
   template <class Key, class Compare, class Allocator>
     void swap(multiset<Key, Compare, Allocator>& x,
+              multiset<Key, Compare, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
 }
 ```
 #### `multiset` constructors <a id="multiset.cons">[[multiset.cons]]</a>
 ``` cpp
+explicit multiset(const Compare& comp, const Allocator& = Allocator());
 ```
+*Effects:* Constructs an empty `multiset` 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());
 ```
 *Effects:* Constructs an empty `multiset` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
 `last`).
 *Complexity:* Linear in N if the range \[`first`, `last`) is already
 #### `multiset` specialized algorithms <a id="multiset.special">[[multiset.special]]</a>
 ``` cpp
 template <class Key, class Compare, class Allocator>
   void swap(multiset<Key, Compare, Allocator>& x,
+            multiset<Key, Compare, Allocator>& y)
+    noexcept(noexcept(x.swap(y)));
 ```
+*Effects:* As if by `x.swap(y)`.

Diff to HTML by rtfpessoa