[unord.map] - C++14 → C++17

Files changed (1) hide show

tmp/tmpawsqkqau/{from.md → to.md} +253 -69

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

@@ -12,46 +12,47 @@ an unordered associative container, and of an allocator-aware container
 (Table  [[tab:containers.allocatoraware]]). It provides the operations
 described in the preceding requirements table for unique keys; that is,
 an `unordered_map` supports the `a_uniq` operations in that table, not
 the `a_eq` operations. For an `unordered_map<Key, T>` the `key type` is
 `Key`, the mapped type is `T`, and the value type is
-`std::pair<const Key, T>`.
 This section only describes operations on `unordered_map` that are not
 described in one of the requirement tables, or for which there is
 additional semantic information.
 ``` cpp
 namespace std {
   template <class Key,
             class T,
             class Hash = hash<Key>,
-            class Pred = std::equal_to<Key>,
-            class Allocator = std::allocator<std::pair<const Key, T> > >
-  class unordered_map
-  {
   public:
-    // types
- typedef Key                                                 key_type;
- 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());
@@ -64,12 +65,12 @@ namespace std {
     unordered_map(const unordered_map&);
     unordered_map(unordered_map&&);
     explicit unordered_map(const Allocator&);
     unordered_map(const unordered_map&, const Allocator&);
     unordered_map(unordered_map&&, const Allocator&);
-    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) { }
@@ -87,61 +88,101 @@ namespace std {
     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;
-    // size and capacity
-    bool empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
-    // iterators
     iterator       begin() noexcept;
     const_iterator begin() const noexcept;
     iterator       end() noexcept;
     const_iterator end() const noexcept;
     const_iterator cbegin() const noexcept;
     const_iterator cend() const noexcept;
-    // 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& obj);
     template <class P> pair<iterator, bool> insert(P&& obj);
     iterator       insert(const_iterator hint, const value_type& obj);
     template <class P> iterator insert(const_iterator hint, P&& obj);
     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& k);
     iterator  erase(const_iterator first, const_iterator last);
     void      clear() noexcept;
- void swap(unordered_map&);
-    // observers
     hasher hash_function() const;
     key_equal key_eq() const;
-    // lookup
     iterator       find(const key_type& k);
     const_iterator find(const key_type& k) const;
     size_type      count(const key_type& k) const;
- std::pair<iterator, iterator>             equal_range(const key_type& k);
- std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
     mapped_type& operator[](const key_type& k);
     mapped_type& operator[](key_type&& k);
     mapped_type& at(const key_type& k);
     const mapped_type& at(const key_type& k) const;
-    // bucket interface
     size_type bucket_count() const noexcept;
     size_type max_bucket_count() const noexcept;
     size_type bucket_size(size_type n) const;
     size_type bucket(const key_type& k) const;
     local_iterator begin(size_type n);
@@ -149,31 +190,84 @@ namespace std {
     local_iterator end(size_type n);
     const_local_iterator end(size_type n) const;
     const_local_iterator cbegin(size_type n) const;
     const_local_iterator cend(size_type n) const;
-    // hash policy
     float load_factor() const noexcept;
     float max_load_factor() const noexcept;
     void max_load_factor(float z);
     void rehash(size_type n);
     void reserve(size_type n);
   };
-  template <class Key, class T, class Hash, class Pred, class Alloc>
-    void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
-              unordered_map<Key, T, Hash, Pred, Alloc>& y);
   template <class Key, class T, class Hash, class Pred, class Alloc>
     bool operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& a,
                     const unordered_map<Key, T, Hash, Pred, Alloc>& b);
   template <class Key, class T, class Hash, class Pred, class Alloc>
     bool operator!=(const unordered_map<Key, T, Hash, Pred, Alloc>& a,
                     const unordered_map<Key, T, Hash, Pred, Alloc>& b);
 }
 ```
 #### `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,
@@ -181,53 +275,52 @@ explicit unordered_map(size_type n,
                        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
 template <class InputIterator>
   unordered_map(InputIterator f, InputIterator l,
                 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*. Then inserts elements from the range
-`[`*`f`*`, `*`l`*`)`. `max_load_factor()` returns 1.0.
 *Complexity:* Average case linear, worst case quadratic.
 #### `unordered_map` element access <a id="unord.map.elem">[[unord.map.elem]]</a>
 ``` 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())`.
-*Returns:* A reference to `x.second`, where `x` is the (unique) element
-whose key is equivalent to *`k`*.
-*Complexity:* Average case 𝑂(1), worst case 𝑂(`size()`).
 ``` cpp
 mapped_type& at(const key_type& k);
 const mapped_type& at(const key_type& k) const;
 ```
@@ -243,31 +336,122 @@ is present.
 ``` 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>
   void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
-            unordered_map<Key, T, Hash, Pred, Alloc>& y);
 ```
-*Effects:* `x.swap(y)`.

 (Table  [[tab:containers.allocatoraware]]). It provides the operations
 described in the preceding requirements table for unique keys; that is,
 an `unordered_map` supports the `a_uniq` operations in that table, not
 the `a_eq` operations. For an `unordered_map<Key, T>` the `key type` is
 `Key`, the mapped type is `T`, and the value type is
+`pair<const Key, T>`.
 This section only describes operations on `unordered_map` that are not
 described in one of the requirement tables, or for which there is
 additional semantic information.
 ``` cpp
 namespace std {
   template <class Key,
             class T,
             class Hash = hash<Key>,
+            class Pred = equal_to<Key>,
+            class Allocator = allocator<pair<const Key, T>>>
+  class unordered_map {
   public:
+    // types:
+ using key_type             = Key;
+ using mapped_type          = T;
+ using value_type           = pair<const Key, T>;
+ using hasher               = Hash;
+ using key_equal            = Pred;
+ 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 unordered_map::iterator; // see [container.requirements]
+ using const_iterator       = implementation-defined  // type of unordered_map::const_iterator; // see [container.requirements]
+ using local_iterator       = implementation-defined  // type of unordered_map::local_iterator; // see [container.requirements]
+ using const_local_iterator = implementation-defined  // type of unordered_map::const_local_iterator; // see [container.requirements]
+    using node_type            = unspecified;
+    using insert_return_type   = INSERT_RETURN_TYPE<iterator, node_type>;
+    // [unord.map.cnstr], construct/copy/destroy
     unordered_map();
     explicit unordered_map(size_type n,
                            const hasher& hf = hasher(),
                            const key_equal& eql = key_equal(),
                            const allocator_type& a = allocator_type());
     unordered_map(const unordered_map&);
     unordered_map(unordered_map&&);
     explicit unordered_map(const Allocator&);
     unordered_map(const unordered_map&, const Allocator&);
     unordered_map(unordered_map&&, const Allocator&);
+    unordered_map(initializer_list<value_type> il,
+ size_type n = 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(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&&)
+      noexcept(allocator_traits<Allocator>::is_always_equal::value &&
+               is_nothrow_move_assignable_v<Hash> &&
+               is_nothrow_move_assignable_v<Pred>);
     unordered_map& operator=(initializer_list<value_type>);
     allocator_type get_allocator() const noexcept;
+    // iterators:
     iterator       begin() noexcept;
     const_iterator begin() const noexcept;
     iterator       end() noexcept;
     const_iterator end() const noexcept;
     const_iterator cbegin() const noexcept;
     const_iterator cend() const noexcept;
+    // capacity:
+    bool      empty() const noexcept;
+    size_type size() const noexcept;
+    size_type max_size() const noexcept;
+    // [unord.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& obj);
+    pair<iterator, bool> insert(value_type&& obj);
     template <class P> pair<iterator, bool> insert(P&& obj);
     iterator       insert(const_iterator hint, const value_type& obj);
+    iterator       insert(const_iterator hint, value_type&& obj);
     template <class P> iterator insert(const_iterator hint, P&& obj);
     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& k);
     iterator  erase(const_iterator first, const_iterator last);
+    void      swap(unordered_map&)
+      noexcept(allocator_traits<Allocator>::is_always_equal::value &&
+               is_nothrow_swappable_v<Hash> &&
+               is_nothrow_swappable_v<Pred>);
     void      clear() noexcept;
+ template<class H2, class P2>
+      void merge(unordered_map<Key, T, H2, P2, Allocator>& source);
+    template<class H2, class P2>
+      void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);
+    template<class H2, class P2>
+      void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source);
+    template<class H2, class P2>
+      void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source);
+    // observers:
     hasher hash_function() const;
     key_equal key_eq() const;
+    // map operations:
     iterator       find(const key_type& k);
     const_iterator find(const key_type& k) const;
     size_type      count(const key_type& k) const;
+    pair<iterator, iterator>             equal_range(const key_type& k);
+    pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
+    // [unord.map.elem], element access
     mapped_type& operator[](const key_type& k);
     mapped_type& operator[](key_type&& k);
     mapped_type& at(const key_type& k);
     const mapped_type& at(const key_type& k) const;
+    // bucket interface:
     size_type bucket_count() const noexcept;
     size_type max_bucket_count() const noexcept;
     size_type bucket_size(size_type n) const;
     size_type bucket(const key_type& k) const;
     local_iterator begin(size_type n);
     local_iterator end(size_type n);
     const_local_iterator end(size_type n) const;
     const_local_iterator cbegin(size_type n) const;
     const_local_iterator cend(size_type n) const;
+    // hash policy:
     float load_factor() const noexcept;
     float max_load_factor() const noexcept;
     void max_load_factor(float z);
     void rehash(size_type n);
     void reserve(size_type n);
   };
+  template<class InputIterator,
+           class Hash = hash<iter_key_t<InputIterator>>,
+           class Pred = equal_to<iter_key_t<InputIterator>>,
+           class Allocator = allocator<iter_to_alloc_t<InputIterator>>>
+    unordered_map(InputIterator, InputIterator, typename see below::size_type = see below,
+                  Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+      -> unordered_map<iter_key_t<InputIterator>, iter_value_t<InputIterator>, Hash, Pred,
+                       Allocator>;
+  template<class Key, class T, class Hash = hash<Key>,
+           class Pred = equal_to<Key>, class Allocator = allocator<pair<const Key, T>>>
+    unordered_map(initializer_list<pair<const Key, T>>,
+                  typename see below::size_type = see below, Hash = Hash(),
+                  Pred = Pred(), Allocator = Allocator())
+      -> unordered_map<Key, T, Hash, Pred, Allocator>;
+  template<class InputIterator, class Allocator>
+    unordered_map(InputIterator, InputIterator, typename see below::size_type, Allocator)
+      -> unordered_map<iter_key_t<InputIterator>, iter_val_t<InputIterator>,
+                       hash<iter_key_t<InputIterator>>, equal_to<iter_key_t<InputIterator>>,
+                       Allocator>;
+  template<class InputIterator, class Allocator>
+    unordered_map(InputIterator, InputIterator, Allocator)
+      -> unordered_map<iter_key_t<InputIterator>, iter_val_t<InputIterator>,
+                       hash<iter_key_t<InputIterator>>, equal_to<iter_key_t<InputIterator>>,
+                       Allocator>;
+  template<class InputIterator, class Hash, class Allocator>
+    unordered_map(InputIterator, InputIterator, typename see below::size_type, Hash, Allocator)
+      -> unordered_map<iter_key_t<InputIterator>, iter_val_t<InputIterator>, Hash,
+                       equal_to<iter_key_t<InputIterator>>, Allocator>;
+  template<class Key, class T, typename Allocator>
+    unordered_map(initializer_list<pair<const Key, T>>, typename see below::size_type,
+                  Allocator)
+      -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;
+  template<class Key, class T, typename Allocator>
+    unordered_map(initializer_list<pair<const Key, T>>, Allocator)
+      -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;
+  template<class Key, class T, class Hash, class Allocator>
+    unordered_map(initializer_list<pair<const Key, T>>, typename see below::size_type, Hash,
+                  Allocator)
+      -> unordered_map<Key, T, Hash, equal_to<Key>, Allocator>;
   template <class Key, class T, class Hash, class Pred, class Alloc>
     bool operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& a,
                     const unordered_map<Key, T, Hash, Pred, Alloc>& b);
   template <class Key, class T, class Hash, class Pred, class Alloc>
     bool operator!=(const unordered_map<Key, T, Hash, Pred, Alloc>& a,
                     const unordered_map<Key, T, Hash, Pred, Alloc>& b);
+  // [unord.map.swap], swap
+  template <class Key, class T, class Hash, class Pred, class Alloc>
+    void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
+              unordered_map<Key, T, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
 }
 ```
+A `size_type` parameter type in an `unordered_map` deduction guide
+refers to the `size_type` member type of the type deduced by the
+deduction guide.
 #### `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 key_equal& eql = key_equal(),
                        const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_map` using the specified hash
+function, key equality predicate, 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
 template <class InputIterator>
   unordered_map(InputIterator f, InputIterator l,
                 size_type n = see below,
                 const hasher& hf = hasher(),
                 const key_equal& eql = key_equal(),
                 const allocator_type& a = allocator_type());
+unordered_map(initializer_list<value_type> il,
+              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 predicate, and allocator, and using at least `n`
+buckets. If `n` is not provided, the number of buckets is
+*implementation-defined*. Then inserts elements from the range \[`f`,
+`l`) for the first form, or from the range \[`il.begin()`, `il.end()`)
+for the second form. `max_load_factor()` returns `1.0`.
 *Complexity:* Average case linear, worst case quadratic.
 #### `unordered_map` element access <a id="unord.map.elem">[[unord.map.elem]]</a>
 ``` cpp
 mapped_type& operator[](const key_type& k);
+```
+*Effects:* Equivalent to: `return try_emplace(k).first->second;`
+``` cpp
 mapped_type& operator[](key_type&& k);
 ```
+*Effects:* Equivalent to: `return try_emplace(move(k)).first->second;`
 ``` cpp
 mapped_type& at(const key_type& k);
 const mapped_type& at(const key_type& k) const;
 ```
 ``` 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 `is_constructible_v<value_type, P&&>` 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 `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
+`unordered_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
+`unordered_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 `unordered_map` from
+`k`, `std::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 `unordered_map` from
+`std::move(k)`, `std::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.
 #### `unordered_map` swap <a id="unord.map.swap">[[unord.map.swap]]</a>
 ``` cpp
 template <class Key, class T, class Hash, class Pred, class Alloc>
   void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
+            unordered_map<Key, T, Hash, Pred, Alloc>& y)
+    noexcept(noexcept(x.swap(y)));
 ```
+*Effects:* As if by `x.swap(y)`.

Diff to HTML by rtfpessoa