diff --git a/include/util/packed_vector.hpp b/include/util/packed_vector.hpp
index 4dd202e104..338962587b 100644
--- a/include/util/packed_vector.hpp
+++ b/include/util/packed_vector.hpp
@@ -11,6 +11,7 @@
 #include <array>
 #include <atomic>
 #include <cmath>
+#include <concepts>
 #include <iterator>
 #include <limits>
 #include <tuple>
@@ -39,67 +40,53 @@ namespace detail
 {
 
 template <typename WordT, typename T>
-inline T get_lower_half_value(WordT word,
-                              WordT mask,
-                              std::uint8_t offset,
-                              typename std::enable_if_t<std::is_integral<T>::value> * = nullptr)
+inline T get_lower_half_value(WordT word, WordT mask, std::uint8_t offset)
+    requires std::integral<T>
 {
     return static_cast<T>((word & mask) >> offset);
 }
 
 template <typename WordT, typename T>
-inline T get_lower_half_value(WordT word,
-                              WordT mask,
-                              std::uint8_t offset,
-                              typename T::value_type * = nullptr)
+inline T get_lower_half_value(WordT word, WordT mask, std::uint8_t offset)
+    requires(!std::integral<T>)
 {
     return T{static_cast<T::value_type>((word & mask) >> offset)};
 }
 
 template <typename WordT, typename T>
-inline T get_upper_half_value(WordT word,
-                              WordT mask,
-                              std::uint8_t offset,
-                              typename std::enable_if_t<std::is_integral<T>::value> * = nullptr)
+inline T get_upper_half_value(WordT word, WordT mask, std::uint8_t offset)
+    requires std::integral<T>
 {
     return static_cast<T>((word & mask) << offset);
 }
 
 template <typename WordT, typename T>
-inline T get_upper_half_value(WordT word,
-                              WordT mask,
-                              std::uint8_t offset,
-                              typename T::value_type * = nullptr)
+inline T get_upper_half_value(WordT word, WordT mask, std::uint8_t offset)
+    requires(!std::integral<T>)
 {
     static_assert(std::is_unsigned<WordT>::value, "Only unsigned word types supported for now.");
     return T{static_cast<T::value_type>((word & mask) << offset)};
 }
 
 template <typename WordT, typename T>
-inline WordT set_lower_value(WordT word,
-                             WordT mask,
-                             std::uint8_t offset,
-                             T value,
-                             typename std::enable_if_t<std::is_integral<T>::value> * = nullptr)
+inline WordT set_lower_value(WordT word, WordT mask, std::uint8_t offset, T value)
+    requires std::integral<T>
 {
     static_assert(std::is_unsigned<WordT>::value, "Only unsigned word types supported for now.");
     return (word & ~mask) | ((static_cast<WordT>(value) << offset) & mask);
 }
 
 template <typename WordT, typename T>
-inline WordT set_upper_value(WordT word,
-                             WordT mask,
-                             std::uint8_t offset,
-                             T value,
-                             typename std::enable_if_t<std::is_integral<T>::value> * = nullptr)
+inline WordT set_upper_value(WordT word, WordT mask, std::uint8_t offset, T value)
+    requires std::integral<T>
 {
     static_assert(std::is_unsigned<WordT>::value, "Only unsigned word types supported for now.");
     return (word & ~mask) | ((static_cast<WordT>(value) >> offset) & mask);
 }
 
 template <typename WordT, typename T>
-inline WordT set_lower_value(
-    WordT word, WordT mask, std::uint8_t offset, T value, typename T::value_type * = nullptr)
+inline WordT set_lower_value(WordT word, WordT mask, std::uint8_t offset, T value)
+    requires(!std::integral<T>)
 {
     static_assert(std::is_unsigned<WordT>::value, "Only unsigned word types supported for now.");
     return (word & ~mask) |
@@ -107,8 +94,8 @@ inline WordT set_lower_value(
 }
 
 template <typename WordT, typename T>
-inline WordT set_upper_value(
-    WordT word, WordT mask, std::uint8_t offset, T value, typename T::value_type * = nullptr)
+inline WordT set_upper_value(WordT word, WordT mask, std::uint8_t offset, T value)
+    requires(!std::integral<T>)
 {
     static_assert(std::is_unsigned<WordT>::value, "Only unsigned word types supported for now.");
     return (word & ~mask) |
@@ -512,8 +499,8 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
 
     std::size_t capacity() const { return (vec.capacity() / BLOCK_WORDS) * BLOCK_ELEMENTS; }
 
-    template <bool enabled = (Ownership == storage::Ownership::View)>
-    void reserve(std::enable_if<!enabled, std::size_t>::type capacity)
+    void reserve(std::size_t capacity)
+        requires(Ownership != storage::Ownership::View)
     {
         auto num_blocks = (capacity + BLOCK_ELEMENTS - 1) / BLOCK_ELEMENTS;
         vec.reserve(num_blocks * BLOCK_WORDS + 1);