Index: uspace/lib/cpp/include/impl/unordered_map.hpp
===================================================================
--- uspace/lib/cpp/include/impl/unordered_map.hpp	(revision 49343fe1aa5aa5bc541b46f5f476961d249ba819)
+++ uspace/lib/cpp/include/impl/unordered_map.hpp	(revision 544eae539ba0165a78b78826ac13d4eba0191eaa)
@@ -422,5 +422,44 @@
             pair<iterator, bool> try_emplace(const key_type& key, Args&&... args)
             {
-                // TODO: implement
+                /**
+                 * Note: If anyone (like me) wonders what is the difference between
+                 *       emplace and try_emplace, the former always constructs the value
+                 *       (in order to get the key) and the latter does it only if
+                 *       an insertion takes place.
+                 */
+
+                table_.increment_size();
+
+                auto spot = table_.find_insertion_spot(key);
+                auto bucket = get<0>(spot);
+                auto idx = get<2>(spot);
+
+                if (!bucket)
+                    return make_pair(end(), false);
+
+                auto target = table_.find_node_or_return_head(key, *bucket);
+                if (target && table_.keys_equal(key, target->value))
+                {
+                    table_.decrement_size();
+
+                    return make_pair(
+                        iterator{
+                            table_.table(), idx, table_.bucket_count(),
+                            target
+                        },
+                        false
+                    );
+                }
+                else
+                {
+                    auto node = new node_type{key, forward<Args>(args)...};
+                    bucket->append(node);
+
+                    return make_pair(iterator{
+                        table_.table(), idx,
+                        table_.bucket_count(),
+                        node
+                    }, true);
+                }
             }
 
@@ -428,17 +467,49 @@
             pair<iterator, bool> try_emplace(key_type&& key, Args&&... args)
             {
-                // TODO: implement
+                table_.increment_size();
+
+                auto spot = table_.find_insertion_spot(key);
+                auto bucket = get<0>(spot);
+                auto idx = get<2>(spot);
+
+                if (!bucket)
+                    return make_pair(end(), false);
+
+                auto target = table_.find_node_or_return_head(key, *bucket);
+                if (target && table_.keys_equal(key, target->value))
+                {
+                    table_.decrement_size();
+
+                    return make_pair(
+                        iterator{
+                            table_.table(), idx, table_.bucket_count(),
+                            target
+                        },
+                        false
+                    );
+                }
+                else
+                {
+                    auto node = new node_type{move(key), forward<Args>(args)...};
+                    bucket->append(node);
+
+                    return make_pair(iterator{
+                        table_.table(), idx,
+                        table_.bucket_count(),
+                        node
+                    }, true);
+                }
             }
 
             template<class... Args>
-            iterator try_emplace(const_iterator hint, const key_type& key, Args&&... args)
-            {
-                // TODO: implement
+            iterator try_emplace(const_iterator, const key_type& key, Args&&... args)
+            {
+                return try_emplace(key, forward<Args>(args)...).first;
             }
 
             template<class... Args>
-            iterator try_emplace(const_iterator hint, key_type&& key, Args&&... args)
-            {
-                // TODO: implement
+            iterator try_emplace(const_iterator, key_type&& key, Args&&... args)
+            {
+                return try_emplace(move(key), forward<Args>(args)...).first;
             }
 
@@ -446,5 +517,38 @@
             pair<iterator, bool> insert_or_assign(const key_type& key, T&& val)
             {
-                // TODO: implement
+                table_.increment_size();
+
+                auto spot = table_.find_insertion_spot(key);
+                auto bucket = get<0>(spot);
+                auto idx = get<2>(spot);
+
+                if (!bucket)
+                    return make_pair(end(), false);
+
+                auto target = table_.find_node_or_return_head(key, *bucket);
+                if (target && table_.keys_equal(key, target->value))
+                {
+                    table_.decrement_size();
+                    target->value.second = forward<T>(val);
+
+                    return make_pair(
+                        iterator{
+                            table_.table(), idx, table_.bucket_count(),
+                            target
+                        },
+                        false
+                    );
+                }
+                else
+                {
+                    auto node = new node_type{key, forward<T>(val)};
+                    bucket->append(node);
+
+                    return make_pair(iterator{
+                        table_.table(), idx,
+                        table_.bucket_count(),
+                        node
+                    }, true);
+                }
             }
 
@@ -452,17 +556,50 @@
             pair<iterator, bool> insert_or_assign(key_type&& key, T&& val)
             {
-                // TODO: implement
+                table_.increment_size();
+
+                auto spot = table_.find_insertion_spot(key);
+                auto bucket = get<0>(spot);
+                auto idx = get<2>(spot);
+
+                if (!bucket)
+                    return make_pair(end(), false);
+
+                auto target = table_.find_node_or_return_head(key, *bucket);
+                if (target && table_.keys_equal(key, target->value))
+                {
+                    table_.decrement_size();
+                    target->value.second = forward<T>(val);
+
+                    return make_pair(
+                        iterator{
+                            table_.table(), idx, table_.bucket_count(),
+                            target
+                        },
+                        false
+                    );
+                }
+                else
+                {
+                    auto node = new node_type{move(key), forward<T>(val)};
+                    bucket->append(node);
+
+                    return make_pair(iterator{
+                        table_.table(), idx,
+                        table_.bucket_count(),
+                        node
+                    }, true);
+                }
             }
 
             template<class T>
-            iterator insert_or_assign(const_iterator hint, const key_type& key, T&& val)
-            {
-                // TODO: implement
+            iterator insert_or_assign(const_iterator, const key_type& key, T&& val)
+            {
+                return insert_or_assign(key, forward<T>(val)).first;
             }
 
             template<class T>
-            iterator insert_or_assign(const_iterator hint, key_type&& key, T&& val)
-            {
-                // TODO: implement
+            iterator insert_or_assign(const_iterator, key_type&& key, T&& val)
+            {
+                return insert_or_assign(move(key), forward<T>(val)).first;
             }