Index: uspace/lib/cpp/include/impl/unordered_map.hpp
===================================================================
--- uspace/lib/cpp/include/impl/unordered_map.hpp	(revision 86b3ae983d35b9ff2aba04174835e12eefe2a13c)
+++ uspace/lib/cpp/include/impl/unordered_map.hpp	(revision 86d193944078ba8b964bd441ce40f4ab101f3e55)
@@ -31,5 +31,5 @@
 
 #include <initializer_list>
-#include <internal/hash_map.hpp>
+#include <internal/hash_table.hpp>
 #include <functional>
 #include <memory>
@@ -43,5 +43,5 @@
 
     template<
-        class Key, class Value
+        class Key, class Value,
         class Hash = hash<Key>,
         class Pred = equal_to<Key>,
@@ -81,5 +81,5 @@
             { /* DUMMY BODY */ }
 
-            explicit unordered_map(size_type bucket_count = default_bucket_count_,
+            explicit unordered_map(size_type bucket_count,
                                    const hasher& hf = hasher{},
                                    const key_equal& eql = key_equal{},
@@ -96,5 +96,5 @@
                 : unordered_map{bucket_count, hf, eql, alloc}
             {
-                // TODO: insert the range
+                insert(first, last);
             }
 
@@ -126,5 +126,5 @@
                 : unordered_map{bucket_count, hf, eql, alloc}
             {
-                // TODO: insert the range
+                insert(init.begin(), init.end());
             }
 
@@ -179,5 +179,9 @@
             unordered_map& operator=(initializer_list<value_type>& init)
             {
-                // TODO: implement
+                table_.clear();
+                table_.reserve(init.size());
+
+                insert(init.begin(), init.end());
+
                 return *this;
             }
@@ -338,15 +342,21 @@
             iterator erase(const_iterator position)
             {
-                // TODO: implement
+                return table_.erase(position);
             }
 
             size_type erase(const key_type& key)
             {
-                // TODO: implement
+                return table_.erase(key);
             }
 
             iterator erase(const_iterator first, const_iterator last)
             {
-                // TODO: implement
+                while (first != last)
+                    first = erase(first);
+
+                return iterator{
+                    table_.table(), first.idx(),
+                    table_.size(), table_.head(first.idx())
+                };
             }
 
@@ -377,35 +387,75 @@
             iterator find(const key_type& key)
             {
-                // TODO: implement
+                return table_.find(key);
             }
 
             const_iterator find(const key_type& key) const
             {
-                // TODO: implement
+                return table_.find(key);
             }
 
             size_type count(const key_type& key) const
             {
-                // TODO: implement
+                return table_.count(key);
             }
 
             pair<iterator, iterator> equal_range(const key_type& key)
             {
-                // TODO: implement
+                return table_.equal_range(key);
             }
 
             pair<const_iterator, const_iterator> equal_range(const key_type& key) const
             {
-                // TODO: implement
+                return table_.equal_range(key);
             }
 
             mapped_type& operator[](const key_type& key)
             {
-                // TODO: implement
+                auto spot = table_.find_insertion_spot(key);
+                auto bucket = get<0>(spot);
+
+                if (bucket->head)
+                {
+                    auto head = bucket->head;
+                    auto current = bucket->head;
+
+                    do
+                    {
+                        if (table_.keys_equal(key, current->value))
+                            return current->value.second;
+                        else
+                            current = current->next;
+                    }
+                    while (current != head);
+                }
+
+                bucket->append(new node_type{key, mapped_type{}});
+
+                return bucket->head->value.second;
             }
 
             mapped_type& operator[](key_type&& key)
             {
-                // TODO: implement
+                auto spot = table_.find_insertion_spot(key);
+                auto bucket = get<0>(spot);
+
+                if (bucket->head)
+                {
+                    auto head = bucket->head;
+                    auto current = bucket->head;
+
+                    do
+                    {
+                        if (table_.keys_equal(key, current->value))
+                            return current->value.second;
+                        else
+                            current = current->next;
+                    }
+                    while (current != head);
+                }
+
+                bucket->append(new node_type{move(key), mapped_type{}});
+
+                return bucket->head->value.second;
             }
 
@@ -496,11 +546,13 @@
 
         private:
-            aux::hash_map<
+            using table_type = aux::hash_table<
                 value_type, key_type, aux::key_value_key_extractor<key_type, mapped_type>,
                 hasher, key_equal, allocator_type, size_type,
                 iterator, const_iterator, local_iterator, const_local_iterator,
                 aux::hash_single_policy
-            > table_;
-
+            >;
+            using node_type = typename table_type::node_type;
+
+            table_type table_;
             allocator_type allocator_;
 
@@ -513,5 +565,5 @@
 
     template<
-        class Key, class Value
+        class Key, class Value,
         class Hash = hash<Key>,
         class Pred = equal_to<Key>,