Index: uspace/lib/cpp/include/impl/algorithm.hpp
===================================================================
--- uspace/lib/cpp/include/impl/algorithm.hpp	(revision 604038c9bd39b90aa63d03466a90bc792d43e345)
+++ uspace/lib/cpp/include/impl/algorithm.hpp	(revision f041811a48cd504e9b94b83be3db2419a075fe93)
@@ -30,4 +30,5 @@
 #define LIBCPP_ALGORITHM
 
+#include <iterator>
 #include <utility>
 
Index: uspace/lib/cpp/include/impl/iterator.hpp
===================================================================
--- uspace/lib/cpp/include/impl/iterator.hpp	(revision 604038c9bd39b90aa63d03466a90bc792d43e345)
+++ uspace/lib/cpp/include/impl/iterator.hpp	(revision f041811a48cd504e9b94b83be3db2419a075fe93)
@@ -30,4 +30,6 @@
 #define LIBCPP_ITERATOR
 
+#include <cstdlib>
+
 namespace std
 {
@@ -118,7 +120,7 @@
         public:
             using iterator_type   = Iterator;
-            using difference_type = typename Iterator::difference_type;
-            using reference       = typename Iterator::reference;
-            using pointer         = typename Iterator::pointer;
+            using difference_type = typename iterator_traits<Iterator>::difference_type;
+            using reference       = typename iterator_traits<Iterator>::reference;
+            using pointer         = typename iterator_traits<Iterator>::pointer;
 
             reverse_iterator()
@@ -229,13 +231,13 @@
                     const reverse_iterator<Iterator2>& rhs)
     {
-        return lhs.current_ == rhs.current_;
+        return lhs.base() == rhs.base();
     }
 
     template<class Iterator1, class Iterator2>
     bool operator<(const reverse_iterator<Iterator1>& lhs,
-                    const reverse_iterator<Iterator2>& rhs)
+                   const reverse_iterator<Iterator2>& rhs)
     {
         // Remember: they are reversed!
-        return lhs.current_ > rhs.current_;
+        return lhs.base() > rhs.base();
     }
 
@@ -244,5 +246,5 @@
                     const reverse_iterator<Iterator2>& rhs)
     {
-        return lhs.current_ != rhs.current_;
+        return lhs.base() != rhs.base();
     }
 
@@ -251,5 +253,5 @@
                     const reverse_iterator<Iterator2>& rhs)
     {
-        return lhs.current_ < rhs.current_;
+        return lhs.base() < rhs.base();
     }
 
@@ -258,5 +260,5 @@
                     const reverse_iterator<Iterator2>& rhs)
     {
-        return lhs.current_ <= rhs.current_;
+        return lhs.base() <= rhs.base();
     }
 
@@ -265,5 +267,5 @@
                     const reverse_iterator<Iterator2>& rhs)
     {
-        return lhs.current_ >= rhs.current_;
+        return lhs.base() >= rhs.base();
     }
 
@@ -273,5 +275,5 @@
         -> decltype(rhs.base() - lhs.base())
     {
-        return rhs.current_ - lhs.current_;
+        return rhs.base() - lhs.base();
     }
 
@@ -282,5 +284,5 @@
     )
     {
-        return reverse_iterator<Iterator>{it.current_ - n};
+        return reverse_iterator<Iterator>{it.base() - n};
     }
 
Index: uspace/lib/cpp/include/impl/utility.hpp
===================================================================
--- uspace/lib/cpp/include/impl/utility.hpp	(revision 604038c9bd39b90aa63d03466a90bc792d43e345)
+++ uspace/lib/cpp/include/impl/utility.hpp	(revision f041811a48cd504e9b94b83be3db2419a075fe93)
@@ -38,26 +38,29 @@
      */
 
-    template<typename T>
-    bool operator!=(const T& lhs, const T& rhs)
-    {
-        return !(lhs == rhs);
-    }
-
-    template<typename T>
-    bool operator>(const T& lhs, const T& rhs)
-    {
-        return (rhs < lhs);
-    }
-
-    template<typename T>
-    bool operator<=(const T& lhs, const T& rhs)
-    {
-        return !(rhs < lhs);
-    }
-
-    template<typename T>
-    bool operator>=(const T& lhs, const T& rhs)
-    {
-        return !(lhs < rhs);
+    namespace rel_ops
+    {
+        template<typename T>
+        bool operator!=(const T& lhs, const T& rhs)
+        {
+            return !(lhs == rhs);
+        }
+
+        template<typename T>
+        bool operator>(const T& lhs, const T& rhs)
+        {
+            return (rhs < lhs);
+        }
+
+        template<typename T>
+        bool operator<=(const T& lhs, const T& rhs)
+        {
+            return !(rhs < lhs);
+        }
+
+        template<typename T>
+        bool operator>=(const T& lhs, const T& rhs)
+        {
+            return !(lhs < rhs);
+        }
     }