Index: uspace/lib/cpp/include/functional
===================================================================
--- uspace/lib/cpp/include/functional	(revision 6a3a64f9ca5ecfac019f3def74bb32509be36d1b)
+++ uspace/lib/cpp/include/functional	(revision a1448e4c66f0e657e59b3caa9aef7cfc0b547edc)
@@ -32,3 +32,4 @@
 #include <internal/functional/function.hpp>
 #include <internal/functional/invoke.hpp>
+#include <internal/functional/hash.hpp>
 #include <internal/functional/reference_wrapper.hpp>
Index: uspace/lib/cpp/include/impl/functional.hpp
===================================================================
--- uspace/lib/cpp/include/impl/functional.hpp	(revision 6a3a64f9ca5ecfac019f3def74bb32509be36d1b)
+++ uspace/lib/cpp/include/impl/functional.hpp	(revision a1448e4c66f0e657e59b3caa9aef7cfc0b547edc)
@@ -80,278 +80,4 @@
         return aux::mem_fn_t<R T::*>{f};
     }
-
-    /**
-     * 20.9.13, hash function primary template:
-     */
-
-    namespace aux
-    {
-        template<class T>
-        union converter
-        {
-            T value;
-            uint64_t converted;
-        };
-
-        template<class T>
-        T hash_(uint64_t x) noexcept
-        {
-            /**
-             * Note: std::hash is used for indexing in
-             *       unordered containers, not for cryptography.
-             *       Because of this, we decided to simply convert
-             *       the value to uin64_t, which will help us
-             *       with testing (since in order to create
-             *       a collision in a multiset or multimap
-             *       we simply need 2 values that congruent
-             *       by the size of the table.
-             */
-            return static_cast<T>(x);
-        }
-
-        template<class T>
-        size_t hash(T x) noexcept
-        {
-            static_assert(is_arithmetic_v<T> || is_pointer_v<T>,
-                          "invalid type passed to aux::hash");
-
-            converter<T> conv;
-            conv.value = x;
-
-            return hash_<size_t>(conv.converted);
-        }
-    }
-
-    template<class T>
-    struct hash
-    { /* DUMMY BODY */ };
-
-    template<>
-    struct hash<bool>
-    {
-        size_t operator()(bool x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = bool;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<char>
-    {
-        size_t operator()(char x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = char;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<signed char>
-    {
-        size_t operator()(signed char x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = signed char;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<unsigned char>
-    {
-        size_t operator()(unsigned char x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = unsigned char;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<char16_t>
-    {
-        size_t operator()(char16_t x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = char16_t;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<char32_t>
-    {
-        size_t operator()(char32_t x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = char32_t;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<wchar_t>
-    {
-        size_t operator()(wchar_t x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = wchar_t;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<short>
-    {
-        size_t operator()(short x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = short;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<unsigned short>
-    {
-        size_t operator()(unsigned short x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = unsigned short;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<int>
-    {
-        size_t operator()(int x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = int;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<unsigned int>
-    {
-        size_t operator()(unsigned int x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = unsigned int;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<long>
-    {
-        size_t operator()(long x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = long;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<long long>
-    {
-        size_t operator()(long long x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = long long;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<unsigned long>
-    {
-        size_t operator()(unsigned long x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = unsigned long;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<unsigned long long>
-    {
-        size_t operator()(unsigned long long x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = unsigned long long;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<float>
-    {
-        size_t operator()(float x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = float;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<double>
-    {
-        size_t operator()(double x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = double;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<long double>
-    {
-        size_t operator()(long double x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = long double;
-        using result_type   = size_t;
-    };
-
-    template<class T>
-    struct hash<T*>
-    {
-        size_t operator()(T* x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = T*;
-        using result_type   = size_t;
-    };
 }
 
Index: uspace/lib/cpp/include/internal/functional/hash.hpp
===================================================================
--- uspace/lib/cpp/include/internal/functional/hash.hpp	(revision a1448e4c66f0e657e59b3caa9aef7cfc0b547edc)
+++ uspace/lib/cpp/include/internal/functional/hash.hpp	(revision a1448e4c66f0e657e59b3caa9aef7cfc0b547edc)
@@ -0,0 +1,309 @@
+/*
+ * Copyright (c) 2018 Jaroslav Jindrak
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef LIBCPP_INTERNAL_FUNCTIONAL_HASH
+#define LIBCPP_INTERNAL_FUNCTIONAL_HASH
+
+namespace std
+{
+    /**
+     * 20.9.13, hash function primary template:
+     */
+
+    namespace aux
+    {
+        template<class T>
+        union converter
+        {
+            T value;
+            uint64_t converted;
+        };
+
+        template<class T>
+        T hash_(uint64_t x) noexcept
+        {
+            /**
+             * Note: std::hash is used for indexing in
+             *       unordered containers, not for cryptography.
+             *       Because of this, we decided to simply convert
+             *       the value to uin64_t, which will help us
+             *       with testing (since in order to create
+             *       a collision in a multiset or multimap
+             *       we simply need 2 values that congruent
+             *       by the size of the table.
+             */
+            return static_cast<T>(x);
+        }
+
+        template<class T>
+        size_t hash(T x) noexcept
+        {
+            static_assert(is_arithmetic_v<T> || is_pointer_v<T>,
+                          "invalid type passed to aux::hash");
+
+            converter<T> conv;
+            conv.value = x;
+
+            return hash_<size_t>(conv.converted);
+        }
+    }
+
+    template<class T>
+    struct hash
+    { /* DUMMY BODY */ };
+
+    template<>
+    struct hash<bool>
+    {
+        size_t operator()(bool x) const noexcept
+        {
+            return aux::hash(x);
+        }
+
+        using argument_type = bool;
+        using result_type   = size_t;
+    };
+
+    template<>
+    struct hash<char>
+    {
+        size_t operator()(char x) const noexcept
+        {
+            return aux::hash(x);
+        }
+
+        using argument_type = char;
+        using result_type   = size_t;
+    };
+
+    template<>
+    struct hash<signed char>
+    {
+        size_t operator()(signed char x) const noexcept
+        {
+            return aux::hash(x);
+        }
+
+        using argument_type = signed char;
+        using result_type   = size_t;
+    };
+
+    template<>
+    struct hash<unsigned char>
+    {
+        size_t operator()(unsigned char x) const noexcept
+        {
+            return aux::hash(x);
+        }
+
+        using argument_type = unsigned char;
+        using result_type   = size_t;
+    };
+
+    template<>
+    struct hash<char16_t>
+    {
+        size_t operator()(char16_t x) const noexcept
+        {
+            return aux::hash(x);
+        }
+
+        using argument_type = char16_t;
+        using result_type   = size_t;
+    };
+
+    template<>
+    struct hash<char32_t>
+    {
+        size_t operator()(char32_t x) const noexcept
+        {
+            return aux::hash(x);
+        }
+
+        using argument_type = char32_t;
+        using result_type   = size_t;
+    };
+
+    template<>
+    struct hash<wchar_t>
+    {
+        size_t operator()(wchar_t x) const noexcept
+        {
+            return aux::hash(x);
+        }
+
+        using argument_type = wchar_t;
+        using result_type   = size_t;
+    };
+
+    template<>
+    struct hash<short>
+    {
+        size_t operator()(short x) const noexcept
+        {
+            return aux::hash(x);
+        }
+
+        using argument_type = short;
+        using result_type   = size_t;
+    };
+
+    template<>
+    struct hash<unsigned short>
+    {
+        size_t operator()(unsigned short x) const noexcept
+        {
+            return aux::hash(x);
+        }
+
+        using argument_type = unsigned short;
+        using result_type   = size_t;
+    };
+
+    template<>
+    struct hash<int>
+    {
+        size_t operator()(int x) const noexcept
+        {
+            return aux::hash(x);
+        }
+
+        using argument_type = int;
+        using result_type   = size_t;
+    };
+
+    template<>
+    struct hash<unsigned int>
+    {
+        size_t operator()(unsigned int x) const noexcept
+        {
+            return aux::hash(x);
+        }
+
+        using argument_type = unsigned int;
+        using result_type   = size_t;
+    };
+
+    template<>
+    struct hash<long>
+    {
+        size_t operator()(long x) const noexcept
+        {
+            return aux::hash(x);
+        }
+
+        using argument_type = long;
+        using result_type   = size_t;
+    };
+
+    template<>
+    struct hash<long long>
+    {
+        size_t operator()(long long x) const noexcept
+        {
+            return aux::hash(x);
+        }
+
+        using argument_type = long long;
+        using result_type   = size_t;
+    };
+
+    template<>
+    struct hash<unsigned long>
+    {
+        size_t operator()(unsigned long x) const noexcept
+        {
+            return aux::hash(x);
+        }
+
+        using argument_type = unsigned long;
+        using result_type   = size_t;
+    };
+
+    template<>
+    struct hash<unsigned long long>
+    {
+        size_t operator()(unsigned long long x) const noexcept
+        {
+            return aux::hash(x);
+        }
+
+        using argument_type = unsigned long long;
+        using result_type   = size_t;
+    };
+
+    template<>
+    struct hash<float>
+    {
+        size_t operator()(float x) const noexcept
+        {
+            return aux::hash(x);
+        }
+
+        using argument_type = float;
+        using result_type   = size_t;
+    };
+
+    template<>
+    struct hash<double>
+    {
+        size_t operator()(double x) const noexcept
+        {
+            return aux::hash(x);
+        }
+
+        using argument_type = double;
+        using result_type   = size_t;
+    };
+
+    template<>
+    struct hash<long double>
+    {
+        size_t operator()(long double x) const noexcept
+        {
+            return aux::hash(x);
+        }
+
+        using argument_type = long double;
+        using result_type   = size_t;
+    };
+
+    template<class T>
+    struct hash<T*>
+    {
+        size_t operator()(T* x) const noexcept
+        {
+            return aux::hash(x);
+        }
+
+        using argument_type = T*;
+        using result_type   = size_t;
+    };
+}
+
+#endif