diff --git a/AK/Atomic.h b/AK/Atomic.h
index a41a9a8414..b165435928 100644
--- a/AK/Atomic.h
+++ b/AK/Atomic.h
@@ -53,13 +53,13 @@ static inline T atomic_exchange(volatile T* var, T desired, MemoryOrder order =
     return __atomic_exchange_n(var, desired, order);
 }
 
-template<typename T, typename V = typename RemoveVolatile<T>::Type>
+template<typename T, typename V = RemoveVolatile<T>>
 static inline V* atomic_exchange(volatile T** var, V* desired, MemoryOrder order = memory_order_seq_cst) noexcept
 {
     return __atomic_exchange_n(var, desired, order);
 }
 
-template<typename T, typename V = typename RemoveVolatile<T>::Type>
+template<typename T, typename V = RemoveVolatile<T>>
 static inline V* atomic_exchange(volatile T** var, std::nullptr_t, MemoryOrder order = memory_order_seq_cst) noexcept
 {
     return __atomic_exchange_n(const_cast<V**>(var), nullptr, order);
@@ -74,7 +74,7 @@ template<typename T>
         return __atomic_compare_exchange_n(var, &expected, desired, false, order, order);
 }
 
-template<typename T, typename V = typename RemoveVolatile<T>::Type>
+template<typename T, typename V = RemoveVolatile<T>>
 [[nodiscard]] static inline bool atomic_compare_exchange_strong(volatile T** var, V*& expected, V* desired, MemoryOrder order = memory_order_seq_cst) noexcept
 {
     if (order == memory_order_acq_rel || order == memory_order_release)
@@ -83,7 +83,7 @@ template<typename T, typename V = typename RemoveVolatile<T>::Type>
         return __atomic_compare_exchange_n(var, &expected, desired, false, order, order);
 }
 
-template<typename T, typename V = typename RemoveVolatile<T>::Type>
+template<typename T, typename V = RemoveVolatile<T>>
 [[nodiscard]] static inline bool atomic_compare_exchange_strong(volatile T** var, V*& expected, std::nullptr_t, MemoryOrder order = memory_order_seq_cst) noexcept
 {
     if (order == memory_order_acq_rel || order == memory_order_release)
@@ -128,7 +128,7 @@ static inline T atomic_load(volatile T* var, MemoryOrder order = memory_order_se
     return __atomic_load_n(var, order);
 }
 
-template<typename T, typename V = typename RemoveVolatile<T>::Type>
+template<typename T, typename V = RemoveVolatile<T>>
 static inline V* atomic_load(volatile T** var, MemoryOrder order = memory_order_seq_cst) noexcept
 {
     return __atomic_load_n(const_cast<V**>(var), order);
@@ -140,13 +140,13 @@ static inline void atomic_store(volatile T* var, T desired, MemoryOrder order =
     __atomic_store_n(var, desired, order);
 }
 
-template<typename T, typename V = typename RemoveVolatile<T>::Type>
+template<typename T, typename V = RemoveVolatile<T>>
 static inline void atomic_store(volatile T** var, V* desired, MemoryOrder order = memory_order_seq_cst) noexcept
 {
     __atomic_store_n(var, desired, order);
 }
 
-template<typename T, typename V = typename RemoveVolatile<T>::Type>
+template<typename T, typename V = RemoveVolatile<T>>
 static inline void atomic_store(volatile T** var, std::nullptr_t, MemoryOrder order = memory_order_seq_cst) noexcept
 {
     __atomic_store_n(const_cast<V**>(var), nullptr, order);
diff --git a/AK/Buffered.h b/AK/Buffered.h
index f671bd20fa..f3629cb7ff 100644
--- a/AK/Buffered.h
+++ b/AK/Buffered.h
@@ -41,7 +41,7 @@ template<typename StreamType, size_t Size = 4096, typename = void>
 class Buffered;
 
 template<typename StreamType, size_t Size>
-class Buffered<StreamType, Size, typename EnableIf<IsBaseOf<InputStream, StreamType>::value>::Type> final : public InputStream {
+class Buffered<StreamType, Size, typename EnableIf<IsBaseOf<InputStream, StreamType>>::Type> final : public InputStream {
     AK_MAKE_NONCOPYABLE(Buffered);
 
 public:
@@ -137,7 +137,7 @@ private:
 };
 
 template<typename StreamType, size_t Size>
-class Buffered<StreamType, Size, typename EnableIf<IsBaseOf<OutputStream, StreamType>::value>::Type> final : public OutputStream {
+class Buffered<StreamType, Size, typename EnableIf<IsBaseOf<OutputStream, StreamType>>::Type> final : public OutputStream {
     AK_MAKE_NONCOPYABLE(Buffered);
 
 public:
diff --git a/AK/CheckedFormatString.h b/AK/CheckedFormatString.h
index b4573289e7..c2fd09910e 100644
--- a/AK/CheckedFormatString.h
+++ b/AK/CheckedFormatString.h
@@ -237,6 +237,6 @@ private:
 namespace AK {
 
 template<typename... Args>
-using CheckedFormatString = Format::Detail::CheckedFormatString<typename IdentityType<Args>::Type...>;
+using CheckedFormatString = Format::Detail::CheckedFormatString<IdentityType<Args>...>;
 
 }
diff --git a/AK/Concepts.h b/AK/Concepts.h
index 1df01425d6..95c1d8a045 100644
--- a/AK/Concepts.h
+++ b/AK/Concepts.h
@@ -33,19 +33,19 @@ namespace AK::Concepts {
 #if defined(__cpp_concepts) && !defined(__COVERITY__)
 
 template<typename T>
-concept Integral = IsIntegral<T>::value;
+concept Integral = IsIntegral<T>;
 
 template<typename T>
-concept FloatingPoint = IsFloatingPoint<T>::value;
+concept FloatingPoint = IsFloatingPoint<T>;
 
 template<typename T>
-concept Arithmetic = IsArithmetic<T>::value;
+concept Arithmetic = IsArithmetic<T>;
 
 template<typename T>
-concept Signed = IsSigned<T>::value;
+concept Signed = IsSigned<T>;
 
 template<typename T>
-concept Unsigned = IsUnsigned<T>::value;
+concept Unsigned = IsUnsigned<T>;
 
 #endif
 
diff --git a/AK/DoublyLinkedList.h b/AK/DoublyLinkedList.h
index 0450c38faa..2d2ad3266a 100644
--- a/AK/DoublyLinkedList.h
+++ b/AK/DoublyLinkedList.h
@@ -132,7 +132,7 @@ public:
     template<typename U>
     void prepend(U&& value)
     {
-        static_assert(IsSame<T, U>::value);
+        static_assert(IsSame<T, U>);
         auto* node = new Node(forward<U>(value));
         if (!m_head) {
             VERIFY(!m_tail);
diff --git a/AK/EnumBits.h b/AK/EnumBits.h
index 57dea9b6b5..2be7226993 100644
--- a/AK/EnumBits.h
+++ b/AK/EnumBits.h
@@ -44,35 +44,35 @@
                                                                              \
     [[nodiscard]] Prefix constexpr inline Enum operator|(Enum lhs, Enum rhs) \
     {                                                                        \
-        using Type = UnderlyingType<Enum>::Type;                             \
+        using Type = UnderlyingType<Enum>;                                   \
         return static_cast<Enum>(                                            \
             static_cast<Type>(lhs) | static_cast<Type>(rhs));                \
     }                                                                        \
                                                                              \
     [[nodiscard]] Prefix constexpr inline Enum operator&(Enum lhs, Enum rhs) \
     {                                                                        \
-        using Type = UnderlyingType<Enum>::Type;                             \
+        using Type = UnderlyingType<Enum>;                                   \
         return static_cast<Enum>(                                            \
             static_cast<Type>(lhs) & static_cast<Type>(rhs));                \
     }                                                                        \
                                                                              \
     [[nodiscard]] Prefix constexpr inline Enum operator^(Enum lhs, Enum rhs) \
     {                                                                        \
-        using Type = UnderlyingType<Enum>::Type;                             \
+        using Type = UnderlyingType<Enum>;                                   \
         return static_cast<Enum>(                                            \
             static_cast<Type>(lhs) ^ static_cast<Type>(rhs));                \
     }                                                                        \
                                                                              \
     [[nodiscard]] Prefix constexpr inline Enum operator~(Enum rhs)           \
     {                                                                        \
-        using Type = UnderlyingType<Enum>::Type;                             \
+        using Type = UnderlyingType<Enum>;                                   \
         return static_cast<Enum>(                                            \
             ~static_cast<Type>(rhs));                                        \
     }                                                                        \
                                                                              \
     Prefix constexpr inline Enum& operator|=(Enum& lhs, Enum rhs)            \
     {                                                                        \
-        using Type = UnderlyingType<Enum>::Type;                             \
+        using Type = UnderlyingType<Enum>;                                   \
         lhs = static_cast<Enum>(                                             \
             static_cast<Type>(lhs) | static_cast<Type>(rhs));                \
         return lhs;                                                          \
@@ -80,7 +80,7 @@
                                                                              \
     Prefix constexpr inline Enum& operator&=(Enum& lhs, Enum rhs)            \
     {                                                                        \
-        using Type = UnderlyingType<Enum>::Type;                             \
+        using Type = UnderlyingType<Enum>;                                   \
         lhs = static_cast<Enum>(                                             \
             static_cast<Type>(lhs) & static_cast<Type>(rhs));                \
         return lhs;                                                          \
@@ -88,7 +88,7 @@
                                                                              \
     Prefix constexpr inline Enum& operator^=(Enum& lhs, Enum rhs)            \
     {                                                                        \
-        using Type = UnderlyingType<Enum>::Type;                             \
+        using Type = UnderlyingType<Enum>;                                   \
         lhs = static_cast<Enum>(                                             \
             static_cast<Type>(lhs) ^ static_cast<Type>(rhs));                \
         return lhs;                                                          \
@@ -96,6 +96,6 @@
                                                                              \
     Prefix constexpr inline bool has_flag(Enum value, Enum mask)             \
     {                                                                        \
-        using Type = UnderlyingType<Enum>::Type;                             \
+        using Type = UnderlyingType<Enum>;                                   \
         return static_cast<Type>(value & mask) != 0;                         \
     }
diff --git a/AK/Format.cpp b/AK/Format.cpp
index 1c33e962f5..0fe6f06a2b 100644
--- a/AK/Format.cpp
+++ b/AK/Format.cpp
@@ -534,7 +534,7 @@ void Formatter<FormatString>::vformat(FormatBuilder& builder, StringView fmtstr,
 }
 
 template<typename T>
-void Formatter<T, typename EnableIf<IsIntegral<T>::value>::Type>::format(FormatBuilder& builder, T value)
+void Formatter<T, typename EnableIf<IsIntegral<T>>::Type>::format(FormatBuilder& builder, T value)
 {
     if (m_mode == Mode::Character) {
         // FIXME: We just support ASCII for now, in the future maybe unicode?
@@ -587,7 +587,7 @@ void Formatter<T, typename EnableIf<IsIntegral<T>::value>::Type>::format(FormatB
 
     m_width = m_width.value_or(0);
 
-    if (IsSame<typename MakeUnsigned<T>::Type, T>::value)
+    if constexpr (IsSame<MakeUnsigned<T>, T>)
         builder.put_u64(value, base, m_alternative_form, upper_case, m_zero_pad, m_align, m_width.value(), m_fill, m_sign_mode);
     else
         builder.put_i64(value, base, m_alternative_form, upper_case, m_zero_pad, m_align, m_width.value(), m_fill, m_sign_mode);
diff --git a/AK/Format.h b/AK/Format.h
index 8da01d3b26..a46b06c4b5 100644
--- a/AK/Format.h
+++ b/AK/Format.h
@@ -93,10 +93,10 @@ struct TypeErasedParameter {
     template<typename T>
     static Type get_type()
     {
-        if (IsIntegral<T>::value)
-            return get_type_from_size(sizeof(T), IsUnsigned<T>::value);
-
-        return Type::Custom;
+        if constexpr (IsIntegral<T>)
+            return get_type_from_size(sizeof(T), IsUnsigned<T>);
+        else
+            return Type::Custom;
     }
 
     size_t to_size() const;
@@ -269,7 +269,7 @@ struct StandardFormatter {
 };
 
 template<typename T>
-struct Formatter<T, typename EnableIf<IsIntegral<T>::value>::Type> : StandardFormatter {
+struct Formatter<T, typename EnableIf<IsIntegral<T>>::Type> : StandardFormatter {
     Formatter() = default;
     explicit Formatter(StandardFormatter formatter)
         : StandardFormatter(formatter)
@@ -416,11 +416,10 @@ void dmesgln(CheckedFormatString<Parameters...>&& fmt, const Parameters&... para
 #endif
 
 template<typename T, typename = void>
-struct HasFormatter : TrueType {
-};
+inline constexpr bool HasFormatter = true;
+
 template<typename T>
-struct HasFormatter<T, typename Formatter<T>::__no_formatter_defined> : FalseType {
-};
+inline constexpr bool HasFormatter<T, typename Formatter<T>::__no_formatter_defined> = false;
 
 template<typename T>
 class FormatIfSupported {
@@ -450,7 +449,7 @@ struct __FormatIfSupported<T, true> : Formatter<T> {
     }
 };
 template<typename T>
-struct Formatter<FormatIfSupported<T>> : __FormatIfSupported<T, HasFormatter<T>::value> {
+struct Formatter<FormatIfSupported<T>> : __FormatIfSupported<T, HasFormatter<T>> {
 };
 
 // This is a helper class, the idea is that if you want to implement a formatter you can inherit
diff --git a/AK/Function.h b/AK/Function.h
index d5bef1cb28..ca1ac2e1c8 100644
--- a/AK/Function.h
+++ b/AK/Function.h
@@ -39,13 +39,13 @@ class Function<Out(In...)> {
 public:
     Function() = default;
 
-    template<typename CallableType, class = typename EnableIf<!(IsPointer<CallableType>::value && IsFunction<typename RemovePointer<CallableType>::Type>::value) && IsRvalueReference<CallableType&&>::value>::Type>
+    template<typename CallableType, class = typename EnableIf<!(IsPointer<CallableType> && IsFunction<RemovePointer<CallableType>>)&&IsRvalueReference<CallableType&&>>::Type>
     Function(CallableType&& callable)
         : m_callable_wrapper(make<CallableWrapper<CallableType>>(move(callable)))
     {
     }
 
-    template<typename FunctionType, class = typename EnableIf<IsPointer<FunctionType>::value && IsFunction<typename RemovePointer<FunctionType>::Type>::value>::Type>
+    template<typename FunctionType, class = typename EnableIf<IsPointer<FunctionType> && IsFunction<RemovePointer<FunctionType>>>::Type>
     Function(FunctionType f)
         : m_callable_wrapper(make<CallableWrapper<FunctionType>>(move(f)))
     {
@@ -59,14 +59,14 @@ public:
 
     explicit operator bool() const { return !!m_callable_wrapper; }
 
-    template<typename CallableType, class = typename EnableIf<!(IsPointer<CallableType>::value && IsFunction<typename RemovePointer<CallableType>::Type>::value) && IsRvalueReference<CallableType&&>::value>::Type>
+    template<typename CallableType, class = typename EnableIf<!(IsPointer<CallableType> && IsFunction<RemovePointer<CallableType>>)&&IsRvalueReference<CallableType&&>>::Type>
     Function& operator=(CallableType&& callable)
     {
         m_callable_wrapper = make<CallableWrapper<CallableType>>(move(callable));
         return *this;
     }
 
-    template<typename FunctionType, class = typename EnableIf<IsPointer<FunctionType>::value && IsFunction<typename RemovePointer<FunctionType>::Type>::value>::Type>
+    template<typename FunctionType, class = typename EnableIf<IsPointer<FunctionType> && IsFunction<RemovePointer<FunctionType>>>::Type>
     Function& operator=(FunctionType f)
     {
         m_callable_wrapper = make<CallableWrapper<FunctionType>>(move(f));
@@ -103,7 +103,7 @@ private:
                 return m_callable(forward<In>(in)...);
             } else if constexpr (requires { m_callable(); }) {
                 return m_callable();
-            } else if constexpr (IsSame<void, Out>::value) {
+            } else if constexpr (IsVoid<Out>) {
                 return;
             } else {
                 return {};
diff --git a/AK/Iterator.h b/AK/Iterator.h
index 0ee6d1c198..6ef2d58093 100644
--- a/AK/Iterator.h
+++ b/AK/Iterator.h
@@ -89,9 +89,9 @@ private:
     static constexpr SimpleIterator begin(Container& container) { return { container, 0 }; }
     static constexpr SimpleIterator end(Container& container)
     {
-        using RawContainerType = typename RemoveCV<Container>::Type;
+        using RawContainerType = RemoveCV<Container>;
 
-        if constexpr (IsSame<StringView, RawContainerType>::value || IsSame<String, RawContainerType>::value)
+        if constexpr (IsSame<StringView, RawContainerType> || IsSame<String, RawContainerType>)
             return { container, container.length() };
         else
             return { container, container.size() };
diff --git a/AK/RefPtr.h b/AK/RefPtr.h
index 2a1720f9ac..a73b81dd50 100644
--- a/AK/RefPtr.h
+++ b/AK/RefPtr.h
@@ -379,7 +379,7 @@ public:
 
     ALWAYS_INLINE bool is_null() const { return PtrTraits::is_null(m_bits.load(AK::MemoryOrder::memory_order_relaxed)); }
 
-    template<typename U = T, typename EnableIf<IsSame<U, T>::value && !IsNullPointer<typename PtrTraits::NullType>::value>::Type* = nullptr>
+    template<typename U = T, typename EnableIf<IsSame<U, T> && !IsNullPointer<typename PtrTraits::NullType>>::Type* = nullptr>
     typename PtrTraits::NullType null_value() const
     {
         // make sure we are holding a null value
@@ -387,7 +387,7 @@ public:
         VERIFY(PtrTraits::is_null(bits));
         return PtrTraits::to_null_value(bits);
     }
-    template<typename U = T, typename EnableIf<IsSame<U, T>::value && !IsNullPointer<typename PtrTraits::NullType>::value>::Type* = nullptr>
+    template<typename U = T, typename EnableIf<IsSame<U, T> && !IsNullPointer<typename PtrTraits::NullType>>::Type* = nullptr>
     void set_null_value(typename PtrTraits::NullType value)
     {
         // make sure that new null value would be interpreted as a null value
diff --git a/AK/Span.h b/AK/Span.h
index 42393f315a..dd719136bb 100644
--- a/AK/Span.h
+++ b/AK/Span.h
@@ -167,16 +167,16 @@ public:
         __builtin_memcpy(this->data() + offset, data, data_size);
     }
 
-    ALWAYS_INLINE constexpr size_t copy_to(Span<typename RemoveConst<T>::Type> other) const
+    ALWAYS_INLINE constexpr size_t copy_to(Span<RemoveConst<T>> other) const
     {
         VERIFY(other.size() >= size());
-        return TypedTransfer<typename RemoveConst<T>::Type>::copy(other.data(), data(), size());
+        return TypedTransfer<RemoveConst<T>>::copy(other.data(), data(), size());
     }
 
-    ALWAYS_INLINE constexpr size_t copy_trimmed_to(Span<typename RemoveConst<T>::Type> other) const
+    ALWAYS_INLINE constexpr size_t copy_trimmed_to(Span<RemoveConst<T>> other) const
     {
         const auto count = min(size(), other.size());
-        return TypedTransfer<typename RemoveConst<T>::Type>::copy(other.data(), data(), count);
+        return TypedTransfer<RemoveConst<T>>::copy(other.data(), data(), count);
     }
 
     ALWAYS_INLINE constexpr size_t fill(const T& value)
diff --git a/AK/StdLibExtraDetails.h b/AK/StdLibExtraDetails.h
new file mode 100644
index 0000000000..121c3120ae
--- /dev/null
+++ b/AK/StdLibExtraDetails.h
@@ -0,0 +1,498 @@
+/*
+ * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
+ * Copyright (c) 2021, Ali Mohammad Pur <ali.mpfard@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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.
+ */
+
+#pragma once
+
+namespace AK::Detail {
+
+template<bool B, class T = void>
+struct EnableIf {
+};
+
+template<class T>
+struct EnableIf<true, T> {
+    using Type = T;
+};
+
+template<class T, T v>
+struct IntegralConstant {
+    static constexpr T value = v;
+    using ValueType = T;
+    using Type = IntegralConstant;
+    constexpr operator ValueType() const { return value; }
+    constexpr ValueType operator()() const { return value; }
+};
+
+using FalseType = IntegralConstant<bool, false>;
+using TrueType = IntegralConstant<bool, true>;
+
+template<class T>
+using AddConst = const T;
+
+template<class T>
+struct __RemoveConst {
+    using Type = T;
+};
+template<class T>
+struct __RemoveConst<const T> {
+    using Type = T;
+};
+template<class T>
+using RemoveConst = typename __RemoveConst<T>::Type;
+
+template<class T>
+struct __RemoveVolatile {
+    using Type = T;
+};
+
+template<class T>
+struct __RemoveVolatile<volatile T> {
+    using Type = T;
+};
+
+template<typename T>
+using RemoveVolatile = typename __RemoveVolatile<T>::Type;
+
+template<class T>
+using RemoveCV = RemoveVolatile<RemoveConst<T>>;
+
+template<typename...>
+using VoidType = void;
+
+template<class T>
+inline constexpr bool IsLvalueReference = false;
+
+template<class T>
+inline constexpr bool IsLvalueReference<T&> = true;
+
+template<class T>
+inline constexpr bool __IsPointerHelper = false;
+
+template<class T>
+inline constexpr bool __IsPointerHelper<T*> = true;
+
+template<class T>
+inline constexpr bool IsPointer = __IsPointerHelper<RemoveCV<T>>;
+
+template<class>
+inline constexpr bool IsFunction = false;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args...)> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args..., ...)> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args...) const> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args..., ...) const> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args...) volatile> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args..., ...) volatile> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args...) const volatile> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args..., ...) const volatile> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args...)&> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args..., ...)&> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args...) const&> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args..., ...) const&> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args...) volatile&> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args..., ...) volatile&> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args...) const volatile&> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args..., ...) const volatile&> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args...) &&> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args..., ...) &&> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args...) const&&> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args..., ...) const&&> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args...) volatile&&> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args..., ...) volatile&&> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args...) const volatile&&> = true;
+template<class Ret, class... Args>
+inline constexpr bool IsFunction<Ret(Args..., ...) const volatile&&> = true;
+
+template<class T>
+inline constexpr bool IsRvalueReference = false;
+template<class T>
+inline constexpr bool IsRvalueReference<T&&> = true;
+
+template<class T>
+struct __RemovePointer {
+    using Type = T;
+};
+template<class T>
+struct __RemovePointer<T*> {
+    using Type = T;
+};
+template<class T>
+struct __RemovePointer<T* const> {
+    using Type = T;
+};
+template<class T>
+struct __RemovePointer<T* volatile> {
+    using Type = T;
+};
+template<class T>
+struct __RemovePointer<T* const volatile> {
+    using Type = T;
+};
+template<typename T>
+using RemovePointer = typename __RemovePointer<T>::Type;
+
+template<typename T, typename U>
+inline constexpr bool IsSame = false;
+
+template<typename T>
+inline constexpr bool IsSame<T, T> = true;
+
+template<bool condition, class TrueType, class FalseType>
+struct __Conditional {
+    using Type = TrueType;
+};
+
+template<class TrueType, class FalseType>
+struct __Conditional<false, TrueType, FalseType> {
+    using Type = FalseType;
+};
+
+template<bool condition, class TrueType, class FalseType>
+using Conditional = typename __Conditional<condition, TrueType, FalseType>::Type;
+
+template<typename T>
+inline constexpr bool IsNullPointer = IsSame<decltype(nullptr), RemoveCV<T>>;
+
+template<typename T>
+struct __RemoveReference {
+    using Type = T;
+};
+template<class T>
+struct __RemoveReference<T&> {
+    using Type = T;
+};
+template<class T>
+struct __RemoveReference<T&&> {
+    using Type = T;
+};
+
+template<typename T>
+using RemoveReference = typename __RemoveReference<T>::Type;
+
+template<typename T>
+struct __MakeUnsigned {
+    using Type = void;
+};
+template<>
+struct __MakeUnsigned<signed char> {
+    using Type = unsigned char;
+};
+template<>
+struct __MakeUnsigned<short> {
+    using Type = unsigned short;
+};
+template<>
+struct __MakeUnsigned<int> {
+    using Type = unsigned int;
+};
+template<>
+struct __MakeUnsigned<long> {
+    using Type = unsigned long;
+};
+template<>
+struct __MakeUnsigned<long long> {
+    using Type = unsigned long long;
+};
+template<>
+struct __MakeUnsigned<unsigned char> {
+    using Type = unsigned char;
+};
+template<>
+struct __MakeUnsigned<unsigned short> {
+    using Type = unsigned short;
+};
+template<>
+struct __MakeUnsigned<unsigned int> {
+    using Type = unsigned int;
+};
+template<>
+struct __MakeUnsigned<unsigned long> {
+    using Type = unsigned long;
+};
+template<>
+struct __MakeUnsigned<unsigned long long> {
+    using Type = unsigned long long;
+};
+template<>
+struct __MakeUnsigned<char> {
+    using Type = unsigned char;
+};
+template<>
+struct __MakeUnsigned<char8_t> {
+    using Type = char8_t;
+};
+template<>
+struct __MakeUnsigned<char16_t> {
+    using Type = char16_t;
+};
+template<>
+struct __MakeUnsigned<char32_t> {
+    using Type = char32_t;
+};
+template<>
+struct __MakeUnsigned<bool> {
+    using Type = bool;
+};
+
+template<typename T>
+using MakeUnsigned = typename __MakeUnsigned<T>::Type;
+
+template<typename T>
+struct __MakeSigned {
+};
+template<>
+struct __MakeSigned<signed char> {
+    using Type = signed char;
+};
+template<>
+struct __MakeSigned<short> {
+    using Type = short;
+};
+template<>
+struct __MakeSigned<int> {
+    using Type = int;
+};
+template<>
+struct __MakeSigned<long> {
+    using Type = long;
+};
+template<>
+struct __MakeSigned<long long> {
+    using Type = long long;
+};
+template<>
+struct __MakeSigned<unsigned char> {
+    using Type = char;
+};
+template<>
+struct __MakeSigned<unsigned short> {
+    using Type = short;
+};
+template<>
+struct __MakeSigned<unsigned int> {
+    using Type = int;
+};
+template<>
+struct __MakeSigned<unsigned long> {
+    using Type = long;
+};
+template<>
+struct __MakeSigned<unsigned long long> {
+    using Type = long long;
+};
+template<>
+struct __MakeSigned<char> {
+    using Type = char;
+};
+
+template<typename T>
+using MakeSigned = typename __MakeSigned<T>::Type;
+
+template<class T>
+inline constexpr bool IsVoid = IsSame<void, RemoveCV<T>>;
+
+template<class T>
+inline constexpr bool IsConst = false;
+
+template<class T>
+inline constexpr bool IsConst<const T> = true;
+
+template<typename T>
+inline constexpr bool IsEnum = __is_enum(T);
+
+template<typename T>
+inline constexpr bool IsUnion = __is_union(T);
+
+template<typename T>
+inline constexpr bool IsClass = __is_class(T);
+
+template<typename Base, typename Derived>
+inline constexpr bool IsBaseOf = __is_base_of(Base, Derived);
+
+template<typename T>
+inline constexpr bool __IsIntegral = false;
+
+template<>
+inline constexpr bool __IsIntegral<bool> = true;
+template<>
+inline constexpr bool __IsIntegral<unsigned char> = true;
+template<>
+inline constexpr bool __IsIntegral<char8_t> = true;
+template<>
+inline constexpr bool __IsIntegral<char16_t> = true;
+template<>
+inline constexpr bool __IsIntegral<char32_t> = true;
+template<>
+inline constexpr bool __IsIntegral<unsigned short> = true;
+template<>
+inline constexpr bool __IsIntegral<unsigned int> = true;
+template<>
+inline constexpr bool __IsIntegral<unsigned long> = true;
+template<>
+inline constexpr bool __IsIntegral<unsigned long long> = true;
+
+template<typename T>
+inline constexpr bool IsIntegral = __IsIntegral<MakeUnsigned<RemoveCV<T>>>;
+
+template<typename T>
+inline constexpr bool __IsFloatingPoint = false;
+template<>
+inline constexpr bool __IsFloatingPoint<float> = true;
+template<>
+inline constexpr bool __IsFloatingPoint<double> = true;
+template<>
+inline constexpr bool __IsFloatingPoint<long double> = true;
+
+template<typename T>
+inline constexpr bool IsFloatingPoint = __IsFloatingPoint<RemoveCV<T>>;
+
+template<typename ReferenceType, typename T>
+using CopyConst = Conditional<IsConst<ReferenceType>, AddConst<T>, RemoveConst<T>>;
+
+template<typename... Ts>
+using Void = void;
+
+template<typename... _Ignored>
+constexpr auto DependentFalse = false;
+
+template<typename T>
+inline constexpr bool IsSigned = IsSame<T, MakeSigned<T>>;
+
+template<typename T>
+inline constexpr bool IsUnsigned = IsSame<T, MakeUnsigned<T>>;
+
+template<typename T>
+inline constexpr bool IsArithmetic = IsIntegral<T> || IsFloatingPoint<T>;
+
+template<typename T>
+inline constexpr bool IsFundamental = IsArithmetic<T> || IsVoid<T> || IsNullPointer<T>;
+
+template<typename T, T... Ts>
+struct IntegerSequence {
+    using Type = T;
+    static constexpr unsigned size() noexcept { return sizeof...(Ts); };
+};
+
+template<unsigned... Indices>
+using IndexSequence = IntegerSequence<unsigned, Indices...>;
+
+template<typename T, T N, T... Ts>
+auto make_integer_sequence_impl()
+{
+    if constexpr (N == 0)
+        return IntegerSequence<T, Ts...> {};
+    else
+        return make_integer_sequence_impl<T, N - 1, N - 1, Ts...>();
+}
+
+template<typename T, T N>
+using MakeIntegerSequence = decltype(make_integer_sequence_impl<T, N>());
+
+template<unsigned N>
+using MakeIndexSequence = MakeIntegerSequence<unsigned, N>;
+
+template<typename T>
+struct __IdentityType {
+    using Type = T;
+};
+
+template<typename T>
+using IdentityType = typename __IdentityType<T>::Type;
+
+template<class T>
+requires(IsEnum<T>) using UnderlyingType = __underlying_type(T);
+
+template<typename T>
+inline constexpr bool IsTrivial = __is_trivial(T);
+
+template<typename T>
+inline constexpr bool IsTriviallyCopyable = __is_trivially_copyable(T);
+
+}
+using AK::Detail::AddConst;
+using AK::Detail::Conditional;
+using AK::Detail::CopyConst;
+using AK::Detail::DependentFalse;
+using AK::Detail::EnableIf;
+using AK::Detail::FalseType;
+using AK::Detail::IdentityType;
+using AK::Detail::IndexSequence;
+using AK::Detail::IntegerSequence;
+using AK::Detail::IsArithmetic;
+using AK::Detail::IsBaseOf;
+using AK::Detail::IsClass;
+using AK::Detail::IsConst;
+using AK::Detail::IsEnum;
+using AK::Detail::IsFloatingPoint;
+using AK::Detail::IsFunction;
+using AK::Detail::IsFundamental;
+using AK::Detail::IsIntegral;
+using AK::Detail::IsLvalueReference;
+using AK::Detail::IsNullPointer;
+using AK::Detail::IsPointer;
+using AK::Detail::IsRvalueReference;
+using AK::Detail::IsSame;
+using AK::Detail::IsSigned;
+using AK::Detail::IsTrivial;
+using AK::Detail::IsTriviallyCopyable;
+using AK::Detail::IsUnion;
+using AK::Detail::IsUnsigned;
+using AK::Detail::IsVoid;
+using AK::Detail::MakeIndexSequence;
+using AK::Detail::MakeIntegerSequence;
+using AK::Detail::MakeSigned;
+using AK::Detail::MakeUnsigned;
+using AK::Detail::RemoveConst;
+using AK::Detail::RemoveCV;
+using AK::Detail::RemovePointer;
+using AK::Detail::RemoveReference;
+using AK::Detail::RemoveVolatile;
+using AK::Detail::TrueType;
+using AK::Detail::UnderlyingType;
+using AK::Detail::Void;
diff --git a/AK/StdLibExtras.h b/AK/StdLibExtras.h
index c46ad6e86d..8f1845b6d3 100644
--- a/AK/StdLibExtras.h
+++ b/AK/StdLibExtras.h
@@ -26,6 +26,8 @@
 
 #pragma once
 
+#include <AK/StdLibExtraDetails.h>
+
 #include <AK/Assertions.h>
 
 constexpr unsigned round_up_to_power_of_two(unsigned value, unsigned power_of_two)
@@ -52,6 +54,19 @@ namespace AK {
 template<typename T>
 auto declval() -> T;
 
+template<class T>
+constexpr T&& forward(RemoveReference<T>& param)
+{
+    return static_cast<T&&>(param);
+}
+
+template<class T>
+constexpr T&& forward(RemoveReference<T>&& param) noexcept
+{
+    static_assert(!IsLvalueReference<T>, "Can't forward an rvalue as an lvalue.");
+    return static_cast<T&&>(param);
+}
+
 template<typename T, typename SizeType = decltype(sizeof(T)), SizeType N>
 constexpr SizeType array_size(T (&)[N])
 {
@@ -99,359 +114,6 @@ inline void swap(T& a, U& b)
     b = move(tmp);
 }
 
-template<bool B, class T = void>
-struct EnableIf {
-};
-
-template<class T>
-struct EnableIf<true, T> {
-    using Type = T;
-};
-
-template<class T>
-struct AddConst {
-    using Type = const T;
-};
-
-template<class T>
-struct RemoveConst {
-    using Type = T;
-};
-
-template<class T>
-struct RemoveConst<const T> {
-    using Type = T;
-};
-
-template<class T>
-struct RemoveVolatile {
-    using Type = T;
-};
-template<class T>
-struct RemoveVolatile<volatile T> {
-    using Type = T;
-};
-template<class T>
-struct RemoveCV {
-    using Type = typename RemoveVolatile<typename RemoveConst<T>::Type>::Type;
-};
-
-template<class T, T v>
-struct IntegralConstant {
-    static constexpr T value = v;
-    using ValueType = T;
-    using Type = IntegralConstant;
-    constexpr operator ValueType() const { return value; }
-    constexpr ValueType operator()() const { return value; }
-};
-
-using FalseType = IntegralConstant<bool, false>;
-using TrueType = IntegralConstant<bool, true>;
-template<typename...>
-using VoidType = void;
-
-template<class T>
-struct IsLvalueReference : FalseType {
-};
-
-template<class T>
-struct IsLvalueReference<T&> : TrueType {
-};
-
-template<class T>
-struct __IsPointerHelper : FalseType {
-};
-
-template<class T>
-struct __IsPointerHelper<T*> : TrueType {
-};
-
-template<class T>
-struct IsPointer : __IsPointerHelper<typename RemoveCV<T>::Type> {
-};
-
-template<class>
-struct IsFunction : FalseType {
-};
-
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args...)> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args..., ...)> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args...) const> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args..., ...) const> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args...) volatile> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args..., ...) volatile> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args...) const volatile> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args..., ...) const volatile> : TrueType {
-};
-
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args...)&> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args..., ...)&> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args...) const&> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args..., ...) const&> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args...) volatile&> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args..., ...) volatile&> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args...) const volatile&> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args..., ...) const volatile&> : TrueType {
-};
-
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args...) &&> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args..., ...) &&> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args...) const&&> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args..., ...) const&&> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args...) volatile&&> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args..., ...) volatile&&> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args...) const volatile&&> : TrueType {
-};
-template<class Ret, class... Args>
-struct IsFunction<Ret(Args..., ...) const volatile&&> : TrueType {
-};
-
-template<class T>
-struct IsRvalueReference : FalseType {
-};
-template<class T>
-struct IsRvalueReference<T&&> : TrueType {
-};
-
-template<class T>
-struct RemovePointer {
-    using Type = T;
-};
-template<class T>
-struct RemovePointer<T*> {
-    using Type = T;
-};
-template<class T>
-struct RemovePointer<T* const> {
-    using Type = T;
-};
-template<class T>
-struct RemovePointer<T* volatile> {
-    using Type = T;
-};
-template<class T>
-struct RemovePointer<T* const volatile> {
-    using Type = T;
-};
-
-template<typename T, typename U>
-struct IsSame {
-    static constexpr bool value = false;
-};
-
-template<typename T>
-struct IsSame<T, T> {
-    static constexpr bool value = true;
-};
-
-template<bool condition, class TrueType, class FalseType>
-struct Conditional {
-    using Type = TrueType;
-};
-
-template<class TrueType, class FalseType>
-struct Conditional<false, TrueType, FalseType> {
-    using Type = FalseType;
-};
-
-template<typename T>
-struct IsNullPointer : IsSame<decltype(nullptr), typename RemoveCV<T>::Type> {
-};
-
-template<typename T>
-struct RemoveReference {
-    using Type = T;
-};
-template<class T>
-struct RemoveReference<T&> {
-    using Type = T;
-};
-template<class T>
-struct RemoveReference<T&&> {
-    using Type = T;
-};
-
-template<class T>
-constexpr T&& forward(typename RemoveReference<T>::Type& param)
-{
-    return static_cast<T&&>(param);
-}
-
-template<class T>
-constexpr T&& forward(typename RemoveReference<T>::Type&& param) noexcept
-{
-    static_assert(!IsLvalueReference<T>::value, "Can't forward an rvalue as an lvalue.");
-    return static_cast<T&&>(param);
-}
-
-template<typename T>
-struct MakeUnsigned {
-    using Type = void;
-};
-template<>
-struct MakeUnsigned<signed char> {
-    using Type = unsigned char;
-};
-template<>
-struct MakeUnsigned<short> {
-    using Type = unsigned short;
-};
-template<>
-struct MakeUnsigned<int> {
-    using Type = unsigned int;
-};
-template<>
-struct MakeUnsigned<long> {
-    using Type = unsigned long;
-};
-template<>
-struct MakeUnsigned<long long> {
-    using Type = unsigned long long;
-};
-template<>
-struct MakeUnsigned<unsigned char> {
-    using Type = unsigned char;
-};
-template<>
-struct MakeUnsigned<unsigned short> {
-    using Type = unsigned short;
-};
-template<>
-struct MakeUnsigned<unsigned int> {
-    using Type = unsigned int;
-};
-template<>
-struct MakeUnsigned<unsigned long> {
-    using Type = unsigned long;
-};
-template<>
-struct MakeUnsigned<unsigned long long> {
-    using Type = unsigned long long;
-};
-template<>
-struct MakeUnsigned<char> {
-    using Type = unsigned char;
-};
-template<>
-struct MakeUnsigned<char8_t> {
-    using Type = char8_t;
-};
-template<>
-struct MakeUnsigned<char16_t> {
-    using Type = char16_t;
-};
-template<>
-struct MakeUnsigned<char32_t> {
-    using Type = char32_t;
-};
-template<>
-struct MakeUnsigned<bool> {
-    using Type = bool;
-};
-
-template<typename T>
-struct MakeSigned {
-};
-template<>
-struct MakeSigned<signed char> {
-    using Type = signed char;
-};
-template<>
-struct MakeSigned<short> {
-    using Type = short;
-};
-template<>
-struct MakeSigned<int> {
-    using Type = int;
-};
-template<>
-struct MakeSigned<long> {
-    using Type = long;
-};
-template<>
-struct MakeSigned<long long> {
-    using Type = long long;
-};
-template<>
-struct MakeSigned<unsigned char> {
-    using Type = char;
-};
-template<>
-struct MakeSigned<unsigned short> {
-    using Type = short;
-};
-template<>
-struct MakeSigned<unsigned int> {
-    using Type = int;
-};
-template<>
-struct MakeSigned<unsigned long> {
-    using Type = long;
-};
-template<>
-struct MakeSigned<unsigned long long> {
-    using Type = long long;
-};
-template<>
-struct MakeSigned<char> {
-    using Type = signed char;
-};
-
-template<class T>
-struct IsVoid : IsSame<void, typename RemoveCV<T>::Type> {
-};
-
-template<class T>
-struct IsConst : FalseType {
-};
-
-template<class T>
-struct IsConst<const T> : TrueType {
-};
-
 template<typename T, typename U = T>
 constexpr T exchange(T& slot, U&& value)
 {
@@ -460,183 +122,14 @@ constexpr T exchange(T& slot, U&& value)
     return old_value;
 }
 
-template<typename T>
-struct IsEnum : public IntegralConstant<bool, __is_enum(T)> {
-};
-
-template<typename T>
-struct IsUnion : public IntegralConstant<bool, __is_union(T)> {
-};
-
-template<typename T>
-struct IsClass : public IntegralConstant<bool, __is_class(T)> {
-};
-
-template<typename Base, typename Derived>
-struct IsBaseOf : public IntegralConstant<bool, __is_base_of(Base, Derived)> {
-};
-
-template<typename T>
-constexpr bool is_trivial()
-{
-    return __is_trivial(T);
 }
 
-template<typename T>
-constexpr bool is_trivially_copyable()
-{
-    return __is_trivially_copyable(T);
-}
-
-template<typename T>
-struct __IsIntegral : FalseType {
-};
-template<>
-struct __IsIntegral<bool> : TrueType {
-};
-template<>
-struct __IsIntegral<unsigned char> : TrueType {
-};
-template<>
-struct __IsIntegral<char8_t> : TrueType {
-};
-template<>
-struct __IsIntegral<char16_t> : TrueType {
-};
-template<>
-struct __IsIntegral<char32_t> : TrueType {
-};
-template<>
-struct __IsIntegral<unsigned short> : TrueType {
-};
-template<>
-struct __IsIntegral<unsigned int> : TrueType {
-};
-template<>
-struct __IsIntegral<unsigned long> : TrueType {
-};
-template<>
-struct __IsIntegral<unsigned long long> : TrueType {
-};
-template<typename T>
-using IsIntegral = __IsIntegral<typename MakeUnsigned<typename RemoveCV<T>::Type>::Type>;
-
-template<typename T>
-struct __IsFloatingPoint : FalseType {
-};
-template<>
-struct __IsFloatingPoint<float> : TrueType {
-};
-template<>
-struct __IsFloatingPoint<double> : TrueType {
-};
-template<>
-struct __IsFloatingPoint<long double> : TrueType {
-};
-template<typename T>
-using IsFloatingPoint = __IsFloatingPoint<typename RemoveCV<T>::Type>;
-
-template<typename ReferenceType, typename T>
-using CopyConst =
-    typename Conditional<IsConst<ReferenceType>::value, typename AddConst<T>::Type, typename RemoveConst<T>::Type>::Type;
-
-template<typename... Ts>
-using Void = void;
-
-template<typename... _Ignored>
-constexpr auto DependentFalse = false;
-
-template<typename T>
-using IsSigned = IsSame<T, typename MakeSigned<T>::Type>;
-
-template<typename T>
-using IsUnsigned = IsSame<T, typename MakeUnsigned<T>::Type>;
-
-template<typename T>
-using IsArithmetic = IntegralConstant<bool, IsIntegral<T>::value || IsFloatingPoint<T>::value>;
-
-template<typename T>
-using IsFundamental = IntegralConstant<bool, IsArithmetic<T>::value || IsVoid<T>::value || IsNullPointer<T>::value>;
-
-template<typename T, T... Ts>
-struct IntegerSequence {
-    using Type = T;
-    static constexpr unsigned size() noexcept { return sizeof...(Ts); };
-};
-
-template<unsigned... Indices>
-using IndexSequence = IntegerSequence<unsigned, Indices...>;
-
-template<typename T, T N, T... Ts>
-auto make_integer_sequence_impl()
-{
-    if constexpr (N == 0)
-        return IntegerSequence<T, Ts...> {};
-    else
-        return make_integer_sequence_impl<T, N - 1, N - 1, Ts...>();
-}
-
-template<typename T, T N>
-using MakeIntegerSequence = decltype(make_integer_sequence_impl<T, N>());
-
-template<unsigned N>
-using MakeIndexSequence = MakeIntegerSequence<unsigned, N>;
-
-template<typename T>
-struct IdentityType {
-    using Type = T;
-};
-
-template<class T, bool = IsEnum<T>::value>
-struct __UnderlyingType {
-    using Type = __underlying_type(T);
-};
-
-template<class T>
-struct __UnderlyingType<T, false> {
-};
-
-template<class T>
-struct UnderlyingType : __UnderlyingType<T> {
-};
-
-}
-
-using AK::AddConst;
 using AK::array_size;
 using AK::ceil_div;
 using AK::clamp;
-using AK::Conditional;
 using AK::declval;
-using AK::DependentFalse;
 using AK::exchange;
 using AK::forward;
-using AK::IdentityType;
-using AK::IndexSequence;
-using AK::IntegerSequence;
-using AK::is_trivial;
-using AK::is_trivially_copyable;
-using AK::IsArithmetic;
-using AK::IsBaseOf;
-using AK::IsClass;
-using AK::IsConst;
-using AK::IsEnum;
-using AK::IsFloatingPoint;
-using AK::IsFundamental;
-using AK::IsIntegral;
-using AK::IsNullPointer;
-using AK::IsSame;
-using AK::IsSigned;
-using AK::IsUnion;
-using AK::IsUnsigned;
-using AK::IsVoid;
-using AK::MakeIndexSequence;
-using AK::MakeIntegerSequence;
-using AK::MakeSigned;
-using AK::MakeUnsigned;
 using AK::max;
 using AK::min;
-using AK::RemoveConst;
 using AK::swap;
-using AK::UnderlyingType;
-using AK::Void;
diff --git a/AK/Stream.h b/AK/Stream.h
index a1226c44fa..5e6ac3f6ee 100644
--- a/AK/Stream.h
+++ b/AK/Stream.h
@@ -148,13 +148,13 @@ InputStream& operator>>(InputStream& stream, Optional<T>& value)
 }
 
 template<typename Integral>
-InputStream& operator>>(InputStream& stream, Integral& value) requires IsIntegral<Integral>::value
+InputStream& operator>>(InputStream& stream, Integral& value) requires IsIntegral<Integral>
 {
     stream.read_or_error({ &value, sizeof(value) });
     return stream;
 }
 template<typename Integral>
-OutputStream& operator<<(OutputStream& stream, Integral value) requires IsIntegral<Integral>::value
+OutputStream& operator<<(OutputStream& stream, Integral value) requires IsIntegral<Integral>
 {
     stream.write_or_error({ &value, sizeof(value) });
     return stream;
@@ -163,13 +163,13 @@ OutputStream& operator<<(OutputStream& stream, Integral value) requires IsIntegr
 #ifndef KERNEL
 
 template<typename FloatingPoint>
-InputStream& operator>>(InputStream& stream, FloatingPoint& value) requires IsFloatingPoint<FloatingPoint>::value
+InputStream& operator>>(InputStream& stream, FloatingPoint& value) requires IsFloatingPoint<FloatingPoint>
 {
     stream.read_or_error({ &value, sizeof(value) });
     return stream;
 }
 template<typename FloatingPoint>
-OutputStream& operator<<(OutputStream& stream, FloatingPoint value) requires IsFloatingPoint<FloatingPoint>::value
+OutputStream& operator<<(OutputStream& stream, FloatingPoint value) requires IsFloatingPoint<FloatingPoint>
 {
     stream.write_or_error({ &value, sizeof(value) });
     return stream;
diff --git a/AK/String.h b/AK/String.h
index 6d7e8f31da..d8f5110d99 100644
--- a/AK/String.h
+++ b/AK/String.h
@@ -276,7 +276,7 @@ public:
     }
 
     template<typename T>
-    static String number(T value) requires IsArithmetic<T>::value
+    static String number(T value) requires IsArithmetic<T>
     {
         return formatted("{}", value);
     }
diff --git a/AK/Tests/TestBadge.cpp b/AK/Tests/TestBadge.cpp
index dea46a91b8..fb5d9d86d8 100644
--- a/AK/Tests/TestBadge.cpp
+++ b/AK/Tests/TestBadge.cpp
@@ -30,7 +30,7 @@
 
 TEST_CASE(should_provide_underlying_type)
 {
-    static_assert(IsSame<int, Badge<int>::Type>::value);
+    static_assert(IsSame<int, Badge<int>::Type>);
 }
 
 TEST_MAIN(Badge)
diff --git a/AK/Tests/TestFormat.cpp b/AK/Tests/TestFormat.cpp
index 22a754b424..6ee5b8ed55 100644
--- a/AK/Tests/TestFormat.cpp
+++ b/AK/Tests/TestFormat.cpp
@@ -31,8 +31,8 @@
 
 TEST_CASE(is_integral_works_properly)
 {
-    EXPECT(!IsIntegral<const char*>::value);
-    EXPECT(IsIntegral<unsigned long>::value);
+    EXPECT(!IsIntegral<const char*>);
+    EXPECT(IsIntegral<unsigned long>);
 }
 
 TEST_CASE(format_string_literals)
diff --git a/AK/Tests/TestIndexSequence.cpp b/AK/Tests/TestIndexSequence.cpp
index 8ae15cfea5..296e802674 100644
--- a/AK/Tests/TestIndexSequence.cpp
+++ b/AK/Tests/TestIndexSequence.cpp
@@ -46,14 +46,14 @@ TEST_CASE(TestIndexSequence)
 {
     constexpr auto integer_seq1 = IntegerSequence<int, 0, 1, 2, 3, 4> {};
     constexpr auto integer_seq2 = MakeIntegerSequence<int, 5> {};
-    static_assert(IsSame<decltype(integer_seq1), decltype(integer_seq2)>::value, "");
+    static_assert(IsSame<decltype(integer_seq1), decltype(integer_seq2)>, "");
 
     static_assert(integer_seq1.size() == 5, "");
     static_assert(integer_seq2.size() == 5, "");
 
     constexpr auto index_seq1 = IndexSequence<0, 1, 2> {};
     constexpr auto index_seq2 = MakeIndexSequence<3> {};
-    static_assert(IsSame<decltype(index_seq1), decltype(index_seq2)>::value, "");
+    static_assert(IsSame<decltype(index_seq1), decltype(index_seq2)>, "");
 
     verify_sequence(MakeIndexSequence<10> {}, std::initializer_list<unsigned> { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U });
     verify_sequence(MakeIntegerSequence<long, 16> {}, std::initializer_list<long> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 });
@@ -62,9 +62,9 @@ TEST_CASE(TestIndexSequence)
 TEST_CASE(TypeList)
 {
     using MyTypes = TypeList<int, bool, char>;
-    static_assert(IsSame<MyTypes::Type<0>, int>::value, "");
-    static_assert(IsSame<MyTypes::Type<1>, bool>::value, "");
-    static_assert(IsSame<MyTypes::Type<2>, char>::value, "");
+    static_assert(IsSame<MyTypes::Type<0>, int>, "");
+    static_assert(IsSame<MyTypes::Type<1>, bool>, "");
+    static_assert(IsSame<MyTypes::Type<2>, char>, "");
 }
 
 TEST_MAIN(IndexSequence);
diff --git a/AK/Tests/TestSpan.cpp b/AK/Tests/TestSpan.cpp
index 9a4a6d76b1..1b8c3cb14b 100644
--- a/AK/Tests/TestSpan.cpp
+++ b/AK/Tests/TestSpan.cpp
@@ -49,7 +49,7 @@ TEST_CASE(span_works_with_constant_types)
     static constexpr u8 buffer[4] { 1, 2, 3, 4 };
     constexpr ReadonlyBytes bytes { buffer, 4 };
 
-    static_assert(IsConst<AK::RemoveReference<decltype(bytes[1])>::Type>::value);
+    static_assert(IsConst<RemoveReference<decltype(bytes[1])>>);
     static_assert(bytes[2] == 3);
 }
 
diff --git a/AK/Tests/TestTypeTraits.cpp b/AK/Tests/TestTypeTraits.cpp
index 1b13d71903..d77c995417 100644
--- a/AK/Tests/TestTypeTraits.cpp
+++ b/AK/Tests/TestTypeTraits.cpp
@@ -29,13 +29,13 @@
 #include <AK/TypeList.h>
 
 #define STATIC_EXPECT_EQ(lhs, rhs) \
-    static_assert(IsSame<lhs, rhs>::value, "");
+    static_assert(IsSame<lhs, rhs>, "");
 
 #define STATIC_EXPECT_FALSE(Expression) \
-    static_assert(!Expression::value, "");
+    static_assert(!Expression, "");
 
 #define STATIC_EXPECT_TRUE(Expression) \
-    static_assert(Expression::value, "");
+    static_assert(Expression, "");
 
 #define EXPECT_TRAIT_TRUE(trait, ...)                                     \
     for_each_type<TypeList<__VA_ARGS__>>([]<typename T>(TypeWrapper<T>) { \
@@ -49,7 +49,7 @@
 
 #define EXPECT_EQ_WITH_TRAIT(trait, ListA, ListB)                                                   \
     for_each_type_zipped<ListA, ListB>([]<typename A, typename B>(TypeWrapper<A>, TypeWrapper<B>) { \
-        STATIC_EXPECT_EQ(typename trait<A>::Type, B);                                               \
+        STATIC_EXPECT_EQ(trait<A>, B);                                                              \
     })
 
 struct Empty {
@@ -120,7 +120,7 @@ TEST_CASE(AddConst)
 
 TEST_CASE(UnderlyingType)
 {
-    using Type = UnderlyingType<Enummer>::Type;
+    using Type = UnderlyingType<Enummer>;
 
     STATIC_EXPECT_EQ(Type, u8);
 }
diff --git a/AK/Trie.h b/AK/Trie.h
index 190344670e..3ed6d77cbf 100644
--- a/AK/Trie.h
+++ b/AK/Trie.h
@@ -140,9 +140,9 @@ public:
         return const_cast<Trie*>(this)->traverse_until_last_accessible_node(it, end);
     }
 
-    Optional<MetadataType> metadata() const requires(!IsNullPointer<MetadataType>::value) { return m_metadata; }
-    void set_metadata(MetadataType metadata) requires(!IsNullPointer<MetadataType>::value) { m_metadata = move(metadata); }
-    const MetadataType& metadata_value() const requires(!IsNullPointer<MetadataType>::value) { return m_metadata.value(); }
+    Optional<MetadataType> metadata() const requires(!IsNullPointer<MetadataType>) { return m_metadata; }
+    void set_metadata(MetadataType metadata) requires(!IsNullPointer<MetadataType>) { m_metadata = move(metadata); }
+    const MetadataType& metadata_value() const requires(!IsNullPointer<MetadataType>) { return m_metadata.value(); }
 
     const ValueType& value() const { return m_value; }
     ValueType& value() { return m_value; }
@@ -165,7 +165,7 @@ public:
 
     template<typename It, typename ProvideMetadataFunction>
     BaseType& insert(
-        It& it, const It& end, MetadataType metadata, ProvideMetadataFunction provide_missing_metadata) requires(!IsNullPointer<MetadataType>::value)
+        It& it, const It& end, MetadataType metadata, ProvideMetadataFunction provide_missing_metadata) requires(!IsNullPointer<MetadataType>)
     {
         Trie* last_root_node = &traverse_until_last_accessible_node(it, end);
         for (; it != end; ++it)
@@ -175,7 +175,7 @@ public:
     }
 
     template<typename It>
-    BaseType& insert(It& it, const It& end) requires(IsNullPointer<MetadataType>::value)
+    BaseType& insert(It& it, const It& end) requires(IsNullPointer<MetadataType>)
     {
         Trie* last_root_node = &traverse_until_last_accessible_node(it, end);
         for (; it != end; ++it)
@@ -185,14 +185,14 @@ public:
 
     template<typename It, typename ProvideMetadataFunction>
     BaseType& insert(
-        const It& begin, const It& end, MetadataType metadata, ProvideMetadataFunction provide_missing_metadata) requires(!IsNullPointer<MetadataType>::value)
+        const It& begin, const It& end, MetadataType metadata, ProvideMetadataFunction provide_missing_metadata) requires(!IsNullPointer<MetadataType>)
     {
         auto it = begin;
         return insert(it, end, move(metadata), move(provide_missing_metadata));
     }
 
     template<typename It>
-    BaseType& insert(const It& begin, const It& end) requires(IsNullPointer<MetadataType>::value)
+    BaseType& insert(const It& begin, const It& end) requires(IsNullPointer<MetadataType>)
     {
         auto it = begin;
         return insert(it, end);
@@ -231,7 +231,7 @@ public:
     using DetailTrie = Detail::Trie<BaseT, Trie<ValueType, MetadataT, ValueTraits>, ValueType, MetadataT, ValueTraits>;
     using MetadataType = typename DetailTrie::MetadataType;
 
-    Trie(ValueType value, MetadataType metadata) requires(!IsVoid<MetadataType>::value && !IsNullPointer<MetadataType>::value)
+    Trie(ValueType value, MetadataType metadata) requires(!IsVoid<MetadataType> && !IsNullPointer<MetadataType>)
         : DetailTrie(move(value), move(metadata))
     {
     }
diff --git a/AK/TypeCasts.h b/AK/TypeCasts.h
index 0e8f4e50ae..f70631a6d0 100644
--- a/AK/TypeCasts.h
+++ b/AK/TypeCasts.h
@@ -50,7 +50,7 @@ ALWAYS_INLINE bool is(InputType* input)
 template<typename OutputType, typename InputType>
 ALWAYS_INLINE CopyConst<InputType, OutputType>* downcast(InputType* input)
 {
-    static_assert(IsBaseOf<InputType, OutputType>::value);
+    static_assert(IsBaseOf<InputType, OutputType>);
     VERIFY(!input || is<OutputType>(*input));
     return static_cast<CopyConst<InputType, OutputType>*>(input);
 }
@@ -58,7 +58,7 @@ ALWAYS_INLINE CopyConst<InputType, OutputType>* downcast(InputType* input)
 template<typename OutputType, typename InputType>
 ALWAYS_INLINE CopyConst<InputType, OutputType>& downcast(InputType& input)
 {
-    static_assert(IsBaseOf<InputType, OutputType>::value);
+    static_assert(IsBaseOf<InputType, OutputType>);
     VERIFY(is<OutputType>(input));
     return static_cast<CopyConst<InputType, OutputType>&>(input);
 }
diff --git a/AK/Types.h b/AK/Types.h
index c4b09c9f75..a80154cdef 100644
--- a/AK/Types.h
+++ b/AK/Types.h
@@ -42,7 +42,7 @@ using i8 = __INT8_TYPE__;
 #ifdef __serenity__
 
 using size_t = __SIZE_TYPE__;
-using ssize_t = MakeSigned<size_t>::Type;
+using ssize_t = MakeSigned<size_t>;
 
 using ptrdiff_t = __PTRDIFF_TYPE__;
 
@@ -72,7 +72,7 @@ using __ptrdiff_t = __PTRDIFF_TYPE__;
 
 #endif
 
-using FlatPtr = Conditional<sizeof(void*) == 8, u64, u32>::Type;
+using FlatPtr = Conditional<sizeof(void*) == 8, u64, u32>;
 
 constexpr u64 KiB = 1024;
 constexpr u64 MiB = KiB * KiB;
diff --git a/AK/Userspace.h b/AK/Userspace.h
index c769468ec4..49e9aa7410 100644
--- a/AK/Userspace.h
+++ b/AK/Userspace.h
@@ -36,10 +36,10 @@ namespace AK {
 //       Once it supports C++20 concepts, we can remove this.
 #if defined(__cpp_concepts) && !defined(__COVERITY__)
 template<typename T>
-concept PointerTypeName = IsPointer<T>::value;
+concept PointerTypeName = IsPointer<T>;
 template<PointerTypeName T>
 #else
-template<typename T, typename EnableIf<IsPointer<T>::value, int>::Type = 0>
+template<typename T, typename EnableIf<IsPointer<T>, int>::Type = 0>
 #endif
 
 class Userspace {
diff --git a/AK/WeakPtr.h b/AK/WeakPtr.h
index 59bffa273a..f4e41281db 100644
--- a/AK/WeakPtr.h
+++ b/AK/WeakPtr.h
@@ -38,26 +38,26 @@ class WeakPtr {
 public:
     WeakPtr() = default;
 
-    template<typename U, typename EnableIf<IsBaseOf<T, U>::value>::Type* = nullptr>
+    template<typename U, typename EnableIf<IsBaseOf<T, U>>::Type* = nullptr>
     WeakPtr(const WeakPtr<U>& other)
         : m_link(other.m_link)
     {
     }
 
-    template<typename U, typename EnableIf<IsBaseOf<T, U>::value>::Type* = nullptr>
+    template<typename U, typename EnableIf<IsBaseOf<T, U>>::Type* = nullptr>
     WeakPtr(WeakPtr<U>&& other)
         : m_link(other.take_link())
     {
     }
 
-    template<typename U, typename EnableIf<IsBaseOf<T, U>::value>::Type* = nullptr>
+    template<typename U, typename EnableIf<IsBaseOf<T, U>>::Type* = nullptr>
     WeakPtr& operator=(WeakPtr<U>&& other)
     {
         m_link = other.take_link();
         return *this;
     }
 
-    template<typename U, typename EnableIf<IsBaseOf<T, U>::value>::Type* = nullptr>
+    template<typename U, typename EnableIf<IsBaseOf<T, U>>::Type* = nullptr>
     WeakPtr& operator=(const WeakPtr<U>& other)
     {
         if ((const void*)this != (const void*)&other)
@@ -71,20 +71,20 @@ public:
         return *this;
     }
 
-    template<typename U, typename EnableIf<IsBaseOf<T, U>::value>::Type* = nullptr>
+    template<typename U, typename EnableIf<IsBaseOf<T, U>>::Type* = nullptr>
     WeakPtr(const U& object)
         : m_link(object.template make_weak_ptr<U>().take_link())
     {
     }
 
-    template<typename U, typename EnableIf<IsBaseOf<T, U>::value>::Type* = nullptr>
+    template<typename U, typename EnableIf<IsBaseOf<T, U>>::Type* = nullptr>
     WeakPtr(const U* object)
     {
         if (object)
             m_link = object->template make_weak_ptr<U>().take_link();
     }
 
-    template<typename U, typename EnableIf<IsBaseOf<T, U>::value>::Type* = nullptr>
+    template<typename U, typename EnableIf<IsBaseOf<T, U>>::Type* = nullptr>
     WeakPtr(const RefPtr<U>& object)
     {
         object.do_while_locked([&](U* obj) {
@@ -93,7 +93,7 @@ public:
         });
     }
 
-    template<typename U, typename EnableIf<IsBaseOf<T, U>::value>::Type* = nullptr>
+    template<typename U, typename EnableIf<IsBaseOf<T, U>>::Type* = nullptr>
     WeakPtr(const NonnullRefPtr<U>& object)
     {
         object.do_while_locked([&](U* obj) {
@@ -102,14 +102,14 @@ public:
         });
     }
 
-    template<typename U, typename EnableIf<IsBaseOf<T, U>::value>::Type* = nullptr>
+    template<typename U, typename EnableIf<IsBaseOf<T, U>>::Type* = nullptr>
     WeakPtr& operator=(const U& object)
     {
         m_link = object.template make_weak_ptr<U>().take_link();
         return *this;
     }
 
-    template<typename U, typename EnableIf<IsBaseOf<T, U>::value>::Type* = nullptr>
+    template<typename U, typename EnableIf<IsBaseOf<T, U>>::Type* = nullptr>
     WeakPtr& operator=(const U* object)
     {
         if (object)
@@ -119,7 +119,7 @@ public:
         return *this;
     }
 
-    template<typename U, typename EnableIf<IsBaseOf<T, U>::value>::Type* = nullptr>
+    template<typename U, typename EnableIf<IsBaseOf<T, U>>::Type* = nullptr>
     WeakPtr& operator=(const RefPtr<U>& object)
     {
         object.do_while_locked([&](U* obj) {
@@ -131,7 +131,7 @@ public:
         return *this;
     }
 
-    template<typename U, typename EnableIf<IsBaseOf<T, U>::value>::Type* = nullptr>
+    template<typename U, typename EnableIf<IsBaseOf<T, U>>::Type* = nullptr>
     WeakPtr& operator=(const NonnullRefPtr<U>& object)
     {
         object.do_while_locked([&](U* obj) {
@@ -199,7 +199,7 @@ template<typename T>
 template<typename U>
 inline WeakPtr<U> Weakable<T>::make_weak_ptr() const
 {
-    if constexpr (IsBaseOf<RefCountedBase, T>::value) {
+    if constexpr (IsBaseOf<RefCountedBase, T>) {
         // Checking m_being_destroyed isn't sufficient when dealing with
         // a RefCounted type.The reference count will drop to 0 before the
         // destructor is invoked and revoke_weak_ptrs is called. So, try
@@ -223,7 +223,7 @@ inline WeakPtr<U> Weakable<T>::make_weak_ptr() const
 
     WeakPtr<U> weak_ptr(m_link);
 
-    if constexpr (IsBaseOf<RefCountedBase, T>::value) {
+    if constexpr (IsBaseOf<RefCountedBase, T>) {
         // Now drop the reference we temporarily added
         if (static_cast<const T*>(this)->unref()) {
             // We just dropped the last reference, which should have called
diff --git a/AK/Weakable.h b/AK/Weakable.h
index 605acfb2ee..2781fdd028 100644
--- a/AK/Weakable.h
+++ b/AK/Weakable.h
@@ -49,7 +49,7 @@ class WeakLink : public RefCounted<WeakLink> {
     friend class WeakPtr;
 
 public:
-    template<typename T, typename PtrTraits = RefPtrTraits<T>, typename EnableIf<IsBaseOf<RefCountedBase, T>::value>::Type* = nullptr>
+    template<typename T, typename PtrTraits = RefPtrTraits<T>, typename EnableIf<IsBaseOf<RefCountedBase, T>>::Type* = nullptr>
     RefPtr<T, PtrTraits> strong_ref() const
     {
         RefPtr<T, PtrTraits> ref;
diff --git a/Kernel/StdLib.h b/Kernel/StdLib.h
index c00447b8b1..d11ab36ea4 100644
--- a/Kernel/StdLib.h
+++ b/Kernel/StdLib.h
@@ -77,28 +77,28 @@ const void* memmem(const void* haystack, size_t, const void* needle, size_t);
 template<typename T>
 [[nodiscard]] inline bool copy_from_user(T* dest, const T* src)
 {
-    static_assert(is_trivially_copyable<T>());
+    static_assert(IsTriviallyCopyable<T>);
     return copy_from_user(dest, src, sizeof(T));
 }
 
 template<typename T>
 [[nodiscard]] inline bool copy_to_user(T* dest, const T* src)
 {
-    static_assert(is_trivially_copyable<T>());
+    static_assert(IsTriviallyCopyable<T>);
     return copy_to_user(dest, src, sizeof(T));
 }
 
 template<typename T>
 [[nodiscard]] inline bool copy_from_user(T* dest, Userspace<const T*> src)
 {
-    static_assert(is_trivially_copyable<T>());
+    static_assert(IsTriviallyCopyable<T>);
     return copy_from_user(dest, src.unsafe_userspace_ptr(), sizeof(T));
 }
 
 template<typename T>
 [[nodiscard]] inline bool copy_from_user(T* dest, Userspace<T*> src)
 {
-    static_assert(is_trivially_copyable<T>());
+    static_assert(IsTriviallyCopyable<T>);
     return copy_from_user(dest, src.unsafe_userspace_ptr(), sizeof(T));
 }
 
@@ -125,28 +125,28 @@ DEPRECATE_COPY_FROM_USER_TYPE(timeval, copy_time_from_user)
 template<typename T>
 [[nodiscard]] inline bool copy_to_user(Userspace<T*> dest, const T* src)
 {
-    static_assert(is_trivially_copyable<T>());
+    static_assert(IsTriviallyCopyable<T>);
     return copy_to_user(dest.unsafe_userspace_ptr(), src, sizeof(T));
 }
 
 template<typename T>
 [[nodiscard]] inline bool copy_to_user(Userspace<T*> dest, const void* src, size_t size)
 {
-    static_assert(is_trivially_copyable<T>());
+    static_assert(IsTriviallyCopyable<T>);
     return copy_to_user(dest.unsafe_userspace_ptr(), src, size);
 }
 
 template<typename T>
 [[nodiscard]] inline bool copy_from_user(void* dest, Userspace<const T*> src, size_t size)
 {
-    static_assert(is_trivially_copyable<T>());
+    static_assert(IsTriviallyCopyable<T>);
     return copy_from_user(dest, src.unsafe_userspace_ptr(), size);
 }
 
 template<typename T>
 [[nodiscard]] inline bool copy_n_from_user(T* dest, const T* src, size_t count)
 {
-    static_assert(is_trivially_copyable<T>());
+    static_assert(IsTriviallyCopyable<T>);
     Checked size = sizeof(T);
     size *= count;
     if (size.has_overflow())
@@ -157,7 +157,7 @@ template<typename T>
 template<typename T>
 [[nodiscard]] inline bool copy_n_to_user(T* dest, const T* src, size_t count)
 {
-    static_assert(is_trivially_copyable<T>());
+    static_assert(IsTriviallyCopyable<T>);
     Checked size = sizeof(T);
     size *= count;
     if (size.has_overflow())
@@ -168,7 +168,7 @@ template<typename T>
 template<typename T>
 [[nodiscard]] inline bool copy_n_from_user(T* dest, Userspace<const T*> src, size_t count)
 {
-    static_assert(is_trivially_copyable<T>());
+    static_assert(IsTriviallyCopyable<T>);
     Checked size = sizeof(T);
     size *= count;
     if (size.has_overflow())
@@ -179,7 +179,7 @@ template<typename T>
 template<typename T>
 [[nodiscard]] inline bool copy_n_to_user(Userspace<T*> dest, const T* src, size_t count)
 {
-    static_assert(is_trivially_copyable<T>());
+    static_assert(IsTriviallyCopyable<T>);
     Checked size = sizeof(T);
     size *= count;
     if (size.has_overflow())
diff --git a/Userland/Libraries/LibC/scanf.cpp b/Userland/Libraries/LibC/scanf.cpp
index 9676388e43..f7d676ad9b 100644
--- a/Userland/Libraries/LibC/scanf.cpp
+++ b/Userland/Libraries/LibC/scanf.cpp
@@ -277,19 +277,19 @@ struct ReadElement {
         case Short:
             return ReadElementConcrete<T, short, kind> {}(input_lexer, ap);
         case Long:
-            if constexpr (IsSame<T, int>::value)
+            if constexpr (IsSame<T, int>)
                 return ReadElementConcrete<T, long, kind> {}(input_lexer, ap);
-            if constexpr (IsSame<T, unsigned>::value)
+            if constexpr (IsSame<T, unsigned>)
                 return ReadElementConcrete<T, unsigned, kind> {}(input_lexer, ap);
-            if constexpr (IsSame<T, float>::value)
+            if constexpr (IsSame<T, float>)
                 return ReadElementConcrete<int, double, kind> {}(input_lexer, ap);
             return false;
         case LongLong:
-            if constexpr (IsSame<T, int>::value)
+            if constexpr (IsSame<T, int>)
                 return ReadElementConcrete<long long, long long, kind> {}(input_lexer, ap);
-            if constexpr (IsSame<T, unsigned>::value)
+            if constexpr (IsSame<T, unsigned>)
                 return ReadElementConcrete<unsigned long long, unsigned long long, kind> {}(input_lexer, ap);
-            if constexpr (IsSame<T, float>::value)
+            if constexpr (IsSame<T, float>)
                 return ReadElementConcrete<long long, double, kind> {}(input_lexer, ap);
             return false;
         case IntMax:
diff --git a/Userland/Libraries/LibCore/AnonymousBuffer.h b/Userland/Libraries/LibCore/AnonymousBuffer.h
index d65f892175..fe5a91a0f9 100644
--- a/Userland/Libraries/LibCore/AnonymousBuffer.h
+++ b/Userland/Libraries/LibCore/AnonymousBuffer.h
@@ -68,7 +68,7 @@ public:
     template<typename T>
     T* data()
     {
-        static_assert(IsVoid<T>::value || is_trivial<T>());
+        static_assert(IsVoid<T> || IsTrivial<T>);
         if (!m_impl)
             return nullptr;
         return (T*)m_impl->data();
@@ -77,7 +77,7 @@ public:
     template<typename T>
     const T* data() const
     {
-        static_assert(IsVoid<T>::value || is_trivial<T>());
+        static_assert(IsVoid<T> || IsTrivial<T>);
         if (!m_impl)
             return nullptr;
         return (const T*)m_impl->data();
diff --git a/Userland/Libraries/LibCore/Object.h b/Userland/Libraries/LibCore/Object.h
index 105ca91260..4b0ced96be 100644
--- a/Userland/Libraries/LibCore/Object.h
+++ b/Userland/Libraries/LibCore/Object.h
@@ -90,13 +90,13 @@ public:
     }
 
     template<typename T, typename Callback>
-    void for_each_child_of_type(Callback callback) requires IsBaseOf<Object, T>::value;
+    void for_each_child_of_type(Callback callback) requires IsBaseOf<Object, T>;
 
     template<typename T>
-    T* find_child_of_type_named(const String&) requires IsBaseOf<Object, T>::value;
+    T* find_child_of_type_named(const String&) requires IsBaseOf<Object, T>;
 
     template<typename T>
-    T* find_descendant_of_type_named(const String&) requires IsBaseOf<Object, T>::value;
+    T* find_descendant_of_type_named(const String&) requires IsBaseOf<Object, T>;
 
     bool is_ancestor_of(const Object&) const;
 
@@ -187,7 +187,7 @@ struct AK::Formatter<Core::Object> : AK::Formatter<FormatString> {
 
 namespace Core {
 template<typename T, typename Callback>
-inline void Object::for_each_child_of_type(Callback callback) requires IsBaseOf<Object, T>::value
+inline void Object::for_each_child_of_type(Callback callback) requires IsBaseOf<Object, T>
 {
     for_each_child([&](auto& child) {
         if (auto* child_as_t = dynamic_cast<T*>(&child); child_as_t)
@@ -197,7 +197,7 @@ inline void Object::for_each_child_of_type(Callback callback) requires IsBaseOf<
 }
 
 template<typename T>
-T* Object::find_child_of_type_named(const String& name) requires IsBaseOf<Object, T>::value
+T* Object::find_child_of_type_named(const String& name) requires IsBaseOf<Object, T>
 {
     T* found_child = nullptr;
     for_each_child_of_type<T>([&](auto& child) {
@@ -212,7 +212,7 @@ T* Object::find_child_of_type_named(const String& name) requires IsBaseOf<Object
 }
 
 template<typename T>
-T* Object::find_descendant_of_type_named(const String& name) requires IsBaseOf<Object, T>::value
+T* Object::find_descendant_of_type_named(const String& name) requires IsBaseOf<Object, T>
 {
     auto* this_as_t = dynamic_cast<T*>(this);
     if (this_as_t && this->name() == name)
diff --git a/Userland/Libraries/LibGUI/ItemListModel.h b/Userland/Libraries/LibGUI/ItemListModel.h
index 8226a51342..30947404d3 100644
--- a/Userland/Libraries/LibGUI/ItemListModel.h
+++ b/Userland/Libraries/LibGUI/ItemListModel.h
@@ -37,13 +37,13 @@ class ItemListModel : public Model {
 public:
     static constexpr auto IsTwoDimensional = requires(Container data)
     {
-        requires !IsVoid<ColumnNameListType>::value;
+        requires !IsVoid<ColumnNameListType>;
         data.at(0).at(0);
         data.at(0).size();
     };
 
     // Substitute 'void' for a dummy u8.
-    using ColumnNamesT = typename Conditional<IsVoid<ColumnNameListType>::value, u8, ColumnNameListType>::Type;
+    using ColumnNamesT = Conditional<IsVoid<ColumnNameListType>, u8, ColumnNameListType>;
 
     static NonnullRefPtr<ItemListModel> create(const Container& data, const ColumnNamesT& column_names, const Optional<size_t>& row_count = {}) requires(IsTwoDimensional)
     {
diff --git a/Userland/Libraries/LibGfx/Filters/SpatialGaussianBlurFilter.h b/Userland/Libraries/LibGfx/Filters/SpatialGaussianBlurFilter.h
index 8bf8d414ca..54ad5744c4 100644
--- a/Userland/Libraries/LibGfx/Filters/SpatialGaussianBlurFilter.h
+++ b/Userland/Libraries/LibGfx/Filters/SpatialGaussianBlurFilter.h
@@ -31,7 +31,7 @@
 
 namespace Gfx {
 
-template<size_t N, typename = typename AK::EnableIf<N % 2 == 1>::Type>
+template<size_t N, typename = typename EnableIf<N % 2 == 1>::Type>
 class SpatialGaussianBlurFilter : public GenericConvolutionFilter<N> {
 public:
     SpatialGaussianBlurFilter() { }
diff --git a/Userland/Libraries/LibJS/Heap/Heap.h b/Userland/Libraries/LibJS/Heap/Heap.h
index c36bc34539..fefa4aa5c3 100644
--- a/Userland/Libraries/LibJS/Heap/Heap.h
+++ b/Userland/Libraries/LibJS/Heap/Heap.h
@@ -62,7 +62,7 @@ public:
         auto* memory = allocate_cell(sizeof(T));
         new (memory) T(forward<Args>(args)...);
         auto* cell = static_cast<T*>(memory);
-        constexpr bool is_object = IsBaseOf<Object, T>::value;
+        constexpr bool is_object = IsBaseOf<Object, T>;
         if constexpr (is_object)
             static_cast<Object*>(cell)->disable_transitions();
         cell->initialize(global_object);
diff --git a/Userland/Libraries/LibJS/Runtime/TypedArray.h b/Userland/Libraries/LibJS/Runtime/TypedArray.h
index 0b580be39d..2110dd30b2 100644
--- a/Userland/Libraries/LibJS/Runtime/TypedArray.h
+++ b/Userland/Libraries/LibJS/Runtime/TypedArray.h
@@ -101,7 +101,7 @@ public:
             return Value((i32)data()[property_index]);
         } else if constexpr (sizeof(T) == 4 || sizeof(T) == 8) {
             auto value = data()[property_index];
-            if constexpr (IsFloatingPoint<T>::value) {
+            if constexpr (IsFloatingPoint<T>) {
                 return Value((double)value);
             } else if constexpr (NumericLimits<T>::is_signed()) {
                 if (value > NumericLimits<i32>::max() || value < NumericLimits<i32>::min())
diff --git a/Userland/Libraries/LibThread/Thread.h b/Userland/Libraries/LibThread/Thread.h
index 7fff078827..ea19753082 100644
--- a/Userland/Libraries/LibThread/Thread.h
+++ b/Userland/Libraries/LibThread/Thread.h
@@ -68,7 +68,7 @@ Result<T, ThreadError> Thread::join()
     }
 
     m_tid = 0;
-    if constexpr (IsVoid<T>::value)
+    if constexpr (IsVoid<T>)
         return {};
     else
         return { static_cast<T>(thread_return) };
diff --git a/Userland/Libraries/LibWeb/Bindings/ExceptionOrUtils.h b/Userland/Libraries/LibWeb/Bindings/ExceptionOrUtils.h
index dc75dd123c..463e3bc495 100644
--- a/Userland/Libraries/LibWeb/Bindings/ExceptionOrUtils.h
+++ b/Userland/Libraries/LibWeb/Bindings/ExceptionOrUtils.h
@@ -34,12 +34,10 @@
 namespace Web::Bindings {
 
 template<typename>
-struct IsExceptionOr : AK::FalseType {
-};
+constexpr bool IsExceptionOr = false;
 
 template<typename T>
-struct IsExceptionOr<DOM::ExceptionOr<T>> : AK::TrueType {
-};
+constexpr bool IsExceptionOr<DOM::ExceptionOr<T>> = true;
 
 template<typename T>
 ALWAYS_INLINE bool throw_dom_exception(JS::VM& vm, JS::GlobalObject& global_object, DOM::ExceptionOr<T>& result)
@@ -51,17 +49,17 @@ ALWAYS_INLINE bool throw_dom_exception(JS::VM& vm, JS::GlobalObject& global_obje
     return false;
 }
 
-template<typename F, typename T = decltype(declval<F>()()), typename Ret = typename Conditional<!IsExceptionOr<T>::value && !IsVoid<T>::value, T, JS::Value>::Type>
+template<typename F, typename T = decltype(declval<F>()()), typename Ret = Conditional<!IsExceptionOr<T> && !IsVoid<T>, T, JS::Value>>
 Ret throw_dom_exception_if_needed(auto&& vm, auto&& global_object, F&& fn)
 {
-    if constexpr (IsExceptionOr<T>::value) {
+    if constexpr (IsExceptionOr<T>) {
         auto&& result = fn();
         if (throw_dom_exception(vm, global_object, result))
             return JS::Value();
         if constexpr (requires(T v) { v.value(); })
             return result.value();
         return JS::Value();
-    } else if constexpr (IsVoid<T>::value) {
+    } else if constexpr (IsVoid<T>) {
         fn();
         return JS::js_undefined();
     } else {
@@ -72,7 +70,7 @@ Ret throw_dom_exception_if_needed(auto&& vm, auto&& global_object, F&& fn)
 template<typename T>
 bool should_return_empty(T&& value)
 {
-    if constexpr (IsSame<JS::Value, T>::value)
+    if constexpr (IsSame<JS::Value, T>)
         return value.is_empty();
     return false;
 }
diff --git a/Userland/Libraries/LibWeb/HighResolutionTime/Performance.h b/Userland/Libraries/LibWeb/HighResolutionTime/Performance.h
index c51d4ad080..8d62ff7c0f 100644
--- a/Userland/Libraries/LibWeb/HighResolutionTime/Performance.h
+++ b/Userland/Libraries/LibWeb/HighResolutionTime/Performance.h
@@ -39,7 +39,7 @@ class Performance final
     , public Bindings::Wrappable {
 public:
     using WrapperType = Bindings::PerformanceWrapper;
-    using AllowOwnPtr = AK::TrueType;
+    using AllowOwnPtr = TrueType;
 
     explicit Performance(DOM::Window&);
     ~Performance();
diff --git a/Userland/Libraries/LibWeb/NavigationTiming/PerformanceTiming.h b/Userland/Libraries/LibWeb/NavigationTiming/PerformanceTiming.h
index 1460ccee50..776e40e98e 100644
--- a/Userland/Libraries/LibWeb/NavigationTiming/PerformanceTiming.h
+++ b/Userland/Libraries/LibWeb/NavigationTiming/PerformanceTiming.h
@@ -34,7 +34,7 @@ namespace Web::NavigationTiming {
 class PerformanceTiming final : public Bindings::Wrappable {
 public:
     using WrapperType = Bindings::PerformanceTimingWrapper;
-    using AllowOwnPtr = AK::TrueType;
+    using AllowOwnPtr = TrueType;
 
     explicit PerformanceTiming(DOM::Window&);
     ~PerformanceTiming();
diff --git a/Userland/Libraries/LibWeb/TreeNode.h b/Userland/Libraries/LibWeb/TreeNode.h
index fa4853486b..77b4139db4 100644
--- a/Userland/Libraries/LibWeb/TreeNode.h
+++ b/Userland/Libraries/LibWeb/TreeNode.h
@@ -49,7 +49,7 @@ public:
         VERIFY(!m_in_removed_last_ref);
         VERIFY(m_ref_count);
         if (!--m_ref_count) {
-            if constexpr (IsBaseOf<DOM::Node, T>::value) {
+            if constexpr (IsBaseOf<DOM::Node, T>) {
                 m_in_removed_last_ref = true;
                 static_cast<T*>(this)->removed_last_ref();
             } else {
diff --git a/Userland/Libraries/LibX86/Instruction.h b/Userland/Libraries/LibX86/Instruction.h
index 0473841724..1c29ce65dd 100644
--- a/Userland/Libraries/LibX86/Instruction.h
+++ b/Userland/Libraries/LibX86/Instruction.h
@@ -47,7 +47,7 @@ template<typename T>
 struct TypeTrivia {
     static const size_t bits = sizeof(T) * 8;
     static const T sign_bit = 1 << (bits - 1);
-    static const T mask = typename MakeUnsigned<T>::Type(-1);
+    static const T mask = MakeUnsigned<T>(-1);
 };
 
 template<typename T, typename U>