```c++ unordered_flat_set(unordered_flat_set&& other); ```

```c++ unordered_flat_set(unordered_flat_set&& other, Allocator const& a); ```

```c++ unordered_flat_set(concurrent_flat_set<Key, Hash, Pred, Allocator>&& other); ```

```c++ unordered_flat_set& operator=(unordered_flat_set&& other) noexcept((boost::allocator_traits<Allocator>::is_always_equal::value || boost::allocator_traits<Allocator>::propagate_on_container_move_assignment::value) && std::is_same<pointer, value_type*>::value); ``` The move assignment operator. Destroys previously existing elements, swaps the hash function and predicate from `other`, and move-assigns the allocator from `other` if `Alloc::propagate_on_container_move_assignment` exists and `Alloc::propagate_on_container_move_assignment::value` is `true`. If at this point the allocator is equal to `other.get_allocator()`, the internal bucket array of `other` is transferred directly to the new container; otherwise, inserts move-constructed copies of the elements of `other`. If statistics are xref:unordered_flat_set_boost_unordered_enable_stats[enabled], transfers the internal statistical information from `other` iff the final allocator is equal to `other.get_allocator()`, and always calls `other.reset_stats()`.

```c++ std::pair<iterator, bool> insert(value_type&& obj); ```

```c++ template<class K> std::pair<iterator, bool> insert(K&& k); ```

```c++ iterator insert(const_iterator hint, value_type&& obj); ```

```c++ template<class K> std::pair<iterator, bool> insert(const_iterator hint, K&& k); ```

```c++ size_type erase(const key_type& k); template<class K> size_type erase(K&& k); ```

```c++ template<class H2, class P2> void merge(unordered_flat_set<Key, T, H2, P2, Allocator>& source); template<class H2, class P2> void merge(unordered_flat_set<Key, T, H2, P2, Allocator>&& source); ```

```c++ template<class Key, class T, class Hash, class Pred, class Alloc> bool operator==(const unordered_flat_set<Key, T, Hash, Pred, Alloc>& x, const unordered_flat_set<Key, T, Hash, Pred, Alloc>& y); ```

```c++ template<class Key, class T, class Hash, class Pred, class Alloc> bool operator!=(const unordered_flat_set<Key, T, Hash, Pred, Alloc>& x, const unordered_flat_set<Key, T, Hash, Pred, Alloc>& y); ```

```c++ template<class Key, class T, class Hash, class Pred, class Alloc> void swap(unordered_flat_set<Key, T, Hash, Pred, Alloc>& x, unordered_flat_set<Key, T, Hash, Pred, Alloc>& y) noexcept(noexcept(x.swap(y))); ```

```c++ template<class K, class T, class H, class P, class A, class Predicate> typename unordered_flat_set<K, T, H, P, A>::size_type erase_if(unordered_flat_set<K, T, H, P, A>& c, Predicate pred); ```