Index: uspace/lib/cpp/include/impl/type_traits.hpp
===================================================================
--- uspace/lib/cpp/include/impl/type_traits.hpp	(revision 22ba3003ec18c194abc8c550273c644732411b20)
+++ uspace/lib/cpp/include/impl/type_traits.hpp	(revision ee51635f8ffd6ed2cf506722aa499a7760c269b5)
@@ -103,6 +103,12 @@
 
     template<class T>
+    inline constexpr bool is_void_v = is_void<T>::value;
+
+    template<class T>
     struct is_null_pointer: aux::is_same<remove_cv_t<T>, nullptr_t>
     { /* DUMMY BODY */ };
+
+    template<class T>
+    inline constexpr bool is_null_pointer_v = is_null_pointer<T>::value;
 
     template<class T>
@@ -110,5 +116,6 @@
             bool, char, unsigned char, signed char,
             long, unsigned long, int, unsigned int, short,
-            unsigned short, long long, unsigned long long>
+            unsigned short, long long, unsigned long long,
+            char16_t, char32_t, wchar_t>
     { /* DUMMY BODY */ };
 
@@ -118,4 +125,7 @@
     { /* DUMMY BODY */ };
 
+    template<class T>
+    inline constexpr bool is_floating_point_v = is_floating_point<T>::value;
+
     template<class>
     struct is_array: false_type
@@ -125,4 +135,7 @@
     struct is_array<T[]>: true_type
     { /* DUMMY BODY */ };
+
+    template<class T>
+    inline constexpr bool is_array_v = is_array<T>::value;
 
     namespace aux
@@ -142,4 +155,7 @@
 
     template<class T>
+    inline constexpr bool is_pointer_v = is_pointer<T>::value;
+
+    template<class T>
     struct is_lvalue_reference: false_type
     { /* DUMMY BODY */ };
@@ -148,4 +164,7 @@
     struct is_lvalue_reference<T&>: true_type
     { /* DUMMY BODY */ };
+
+    template<class T>
+    inline constexpr bool is_lvalue_reference_v = is_lvalue_reference<T>::value;
 
     template<class T>
@@ -156,4 +175,7 @@
     struct is_rvalue_reference<T&&>: true_type
     { /* DUMMY BODY*/ };
+
+    template<class T>
+    inline constexpr bool is_rvalue_reference_v = is_rvalue_reference<T>::value;
 
     template<class>
@@ -168,4 +190,7 @@
                             !is_member_function_pointer<T>::value>
     { /* DUMMY BODY */ };
+
+    template<class T>
+    inline constexpr bool is_member_object_pointer_v = is_member_object_pointer<T>::value;
 
     template<class>
@@ -188,14 +213,26 @@
 
     template<class T>
+    inline constexpr bool is_member_function_pointer_v = is_member_function_pointer<T>::value;
+
+    template<class T>
     struct is_enum: aux::value_is<bool, __is_enum(T)>
     { /* DUMMY BODY */ };
 
     template<class T>
+    inline constexpr bool is_enum_v = is_enum<T>::value;
+
+    template<class T>
     struct is_union: aux::value_is<bool, __is_union(T)>
     { /* DUMMY BODY */ };
 
     template<class T>
+    inline constexpr bool is_union_v = is_union<T>::value;
+
+    template<class T>
     struct is_class: aux::value_is<bool, __is_class(T)>
     { /* DUMMY BODY */ };
+
+    template<class T>
+    inline constexpr bool is_class_v = is_class<T>::value;
 
     /**
@@ -399,4 +436,7 @@
     { /* DUMMY BODY */ };
 
+    template<class T>
+    inline constexpr bool is_function_v = is_function<T>::value;
+
     /**
      * 20.10.4.2, composite type categories:
@@ -414,4 +454,7 @@
     struct is_reference<T&&>: true_type
     { /* DUMMY BODY */ };
+
+    template<class T>
+    inline constexpr bool is_reference_v = is_reference<T>::value;
 
     template<class T>
@@ -420,4 +463,7 @@
         is_integral<T>::value || is_floating_point<T>::value>
     { /* DUMMY BODY */ };
+
+    template<class T>
+    inline constexpr bool is_arithmetic_v = is_arithmetic<T>::value;
 
     template<class T>
@@ -448,4 +494,7 @@
     { /* DUMMY BODY */ };
 
+    template<class T>
+    inline constexpr bool is_member_pointer_v = is_member_pointer<T>::value;
+
     /**
      * 20.10.4.3, type properties:
@@ -461,4 +510,7 @@
 
     template<class T>
+    inline constexpr bool is_const_v = is_const<T>::value;
+
+    template<class T>
     struct is_volatile: false_type
     { /* DUMMY BODY */};
@@ -467,4 +519,7 @@
     struct is_volatile<T volatile>: true_type
     { /* DUMMY BODY */ };
+
+    template<class T>
+    inline constexpr bool is_volatile_v = is_volatile<T>::value;
 
     /**
@@ -486,8 +541,14 @@
 
     template<class T>
+    inline constexpr bool is_trivial_v = is_trivial<T>::value;
+
+    template<class T>
     struct is_trivially_copyable: aux::value_is<bool, __has_trivial_copy(T)>
     { /* DUMMY BODY */ };
 
     template<class T>
+    inline constexpr bool is_trivially_copyable_v = is_trivially_copyable<T>::value;
+
+    template<class T>
     struct is_standard_layout;
 
@@ -497,22 +558,40 @@
 
     template<class T>
+    inline constexpr bool is_pod_v = is_pod<T>::value;
+
+    template<class T>
     struct is_literal_type: aux::value_is<bool, __is_literal_type(T)>
     { /* DUMMY BODY */ };
 
     template<class T>
+    inline constexpr bool is_literal_type_v = is_literal_type<T>::value;
+
+    template<class T>
     struct is_empty: aux::value_is<bool, __is_empty(T)>
     { /* DUMMY BODY */ };
 
     template<class T>
+    inline constexpr bool is_empty_v = is_empty<T>::value;
+
+    template<class T>
     struct is_polymorphic: aux::value_is<bool, __is_polymorphic(T)>
     { /* DUMMY BODY */ };
 
     template<class T>
+    inline constexpr bool is_polymorphic_v = is_polymorphic<T>::value;
+
+    template<class T>
     struct is_abstract: aux::value_is<bool, __is_abstract(T)>
     { /* DUMMY BODY */ };
 
     template<class T>
+    inline constexpr bool is_abstract_v = is_abstract<T>::value;
+
+    template<class T>
     struct is_final: aux::value_is<bool, __is_final(T)>
     { /* DUMMY BODY */ };
+
+    template<class T>
+    inline constexpr bool is_final_v = is_final<T>::value;
 
     namespace aux
@@ -545,6 +624,12 @@
 
     template<class T>
+    inline constexpr bool is_signed_v = is_signed<T>::value;
+
+    template<class T>
     struct is_unsigned: aux::is_unsigned<T>
     { /* DUMMY BODY */ };
+
+    template<class T>
+    inline constexpr bool is_unsigned_v = is_unsigned<T>::value;
 
     template<class T, class... Args>
@@ -577,4 +662,7 @@
 
     template<class T>
+    inline constexpr bool is_trivially_constructible_v = is_trivially_constructible<T>::value;
+
+    template<class T>
     struct is_trivially_default_constructible;
 
@@ -582,4 +670,7 @@
     struct is_trivially_copy_constructible: aux::value_is<bool, __has_trivial_copy(T)>
     { /* DUMMY BODY */ };
+
+    template<class T>
+    inline constexpr bool is_trivially_copy_constructible_v = is_trivially_copy_constructible<T>::value;
 
     template<class T>
@@ -590,4 +681,7 @@
     { /* DUMMY BODY */ };
 
+    template<class T, class U>
+    inline constexpr bool is_trivially_assignable_v = is_trivially_assignable<T, U>::value;
+
     template<class T>
     struct is_trivially_copy_assignable;
@@ -599,4 +693,7 @@
     struct is_trivially_destructible: aux::value_is<bool, __has_trivial_destructor(T)>
     { /* DUMMY BODY */ };
+
+    template<class T>
+    inline constexpr bool is_trivially_destructible_v = is_trivially_destructible<T>::value;
 
     template<class T, class... Args>
@@ -605,4 +702,7 @@
 
     template<class T>
+    inline constexpr bool is_nothrow_constructible_v = is_nothrow_constructible<T>::value;
+
+    template<class T>
     struct is_nothrow_default_constructible;
 
@@ -610,4 +710,7 @@
     struct is_nothrow_copy_constructible: aux::value_is<bool, __has_nothrow_copy(T)>
     { /* DUMMY BODY */ };
+
+    template<class T>
+    inline constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<T>::value;
 
     template<class T>
@@ -618,4 +721,7 @@
     { /* DUMMY BODY */ };
 
+    template<class T, class U>
+    inline constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<T, U>::value;
+
     template<class T>
     struct is_nothrow_copy_assignable;
@@ -630,4 +736,7 @@
     struct has_virtual_destructor: aux::value_is<bool, __has_virtual_destructor(T)>
     { /* DUMMY BODY */ };
+
+    template<class T>
+    inline constexpr bool has_virtual_destructor_v = has_virtual_destructor<T>::value;
 
     /**
@@ -650,4 +759,7 @@
     { /* DUMMY BODY */ };
 
+    template<class T>
+    inline constexpr size_t rank_v = rank<T>::value;
+
     template<class T, unsigned I = 0>
     struct extent;
@@ -661,6 +773,12 @@
     { /* DUMMY BODY */ };
 
+    template<class T, class U>
+    inline constexpr bool is_same_v = is_same<T, U>::value;
+
     template<class Base, class Derived>
     struct is_base_of;
+
+    template<class Base, class Derived>
+    inline constexpr bool is_base_of_v = is_base_of<Base, Derived>::value;
 
     template<class From, class To>