diff --git a/include/tsl/robin_hash.h b/include/tsl/robin_hash.h
index 163e0e2..c40e9df 100644
--- a/include/tsl/robin_hash.h
+++ b/include/tsl/robin_hash.h
@@ -75,8 +75,8 @@ static T numeric_cast(U value,
   }
 
   const bool is_same_signedness =
-      (std::is_unsigned<T>::value && std::is_unsigned<U>::value) ||
-      (std::is_signed<T>::value && std::is_signed<U>::value);
+      (std::is_unsigned_v<T> && std::is_unsigned_v<U>) ||
+      (std::is_signed_v<T> && std::is_signed_v<U>);
   if (!is_same_signedness && (ret < T{}) != (value < U{})) {
     TSL_RH_THROW_OR_TERMINATE(std::runtime_error, error_message);
   }
@@ -183,7 +183,7 @@ class bucket_entry : public bucket_entry_hash<StoreHash> {
   }
 
   bucket_entry(const bucket_entry& other) noexcept(
-      std::is_nothrow_copy_constructible<value_type>::value)
+      std::is_nothrow_copy_constructible_v<value_type>)
       : bucket_hash(other),
         m_dist_from_ideal_bucket(EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET),
         m_last_bucket(other.m_last_bucket) {
@@ -201,7 +201,7 @@ class bucket_entry : public bucket_entry_hash<StoreHash> {
    * robin_hash constructor for details.
    */
   bucket_entry(bucket_entry&& other) noexcept(
-      std::is_nothrow_move_constructible<value_type>::value)
+      std::is_nothrow_move_constructible_v<value_type>)
       : bucket_hash(std::move(other)),
         m_dist_from_ideal_bucket(EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET),
         m_last_bucket(other.m_last_bucket) {
@@ -214,7 +214,7 @@ class bucket_entry : public bucket_entry_hash<StoreHash> {
   }
 
   bucket_entry& operator=(const bucket_entry& other) noexcept(
-      std::is_nothrow_copy_constructible<value_type>::value) {
+      std::is_nothrow_copy_constructible_v<value_type>) {
     if (this != &other) {
       clear();
 
@@ -349,7 +349,7 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
  private:
   template <typename U>
   using has_mapped_type =
-      typename std::integral_constant<bool, !std::is_same<U, void>::value>;
+      typename std::integral_constant<bool, !std::is_same_v<U, void>>;
 
   static_assert(
       noexcept(std::declval<GrowthPolicy>().bucket_for_hash(std::size_t(0))),
@@ -388,8 +388,8 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
        (sizeof(std::size_t) == sizeof(truncated_hash_type) ||
         is_power_of_two_policy<GrowthPolicy>::value) &&
        // Don't store the hash for primitive types with default hash.
-       (!std::is_arithmetic<key_type>::value ||
-        !std::is_same<Hash, std::hash<key_type>>::value));
+       (!std::is_arithmetic_v<key_type> ||
+        !std::is_same_v<Hash, std::hash<key_type>>));
 
   /**
    * Only use the stored hash on lookup if we are explicitly asked. We are not
@@ -444,8 +444,7 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
 
    private:
     using bucket_entry_ptr =
-        typename std::conditional<IsConst, const bucket_entry*,
-                                  bucket_entry*>::type;
+        std::conditional_t<IsConst, const bucket_entry*, bucket_entry*>;
 
     robin_iterator(bucket_entry_ptr bucket) noexcept : m_bucket(bucket) {}
 
@@ -459,8 +458,7 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
     robin_iterator() noexcept {}
 
     // Copy constructor from iterator to const_iterator.
-    template <bool TIsConst = IsConst,
-              typename std::enable_if<TIsConst>::type* = nullptr>
+    template <bool TIsConst = IsConst, std::enable_if_t<TIsConst>* = nullptr>
     robin_iterator(const robin_iterator<!TIsConst>& other) noexcept
         : m_bucket(other.m_bucket) {}
 
@@ -474,15 +472,14 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
     }
 
     template <class U = ValueSelect,
-              typename std::enable_if<has_mapped_type<U>::value &&
-                                      IsConst>::type* = nullptr>
+              std::enable_if_t<has_mapped_type<U>::value && IsConst>* = nullptr>
     const typename U::value_type& value() const {
       return U()(m_bucket->value());
     }
 
-    template <class U = ValueSelect,
-              typename std::enable_if<has_mapped_type<U>::value &&
-                                      !IsConst>::type* = nullptr>
+    template <
+        class U = ValueSelect,
+        std::enable_if_t<has_mapped_type<U>::value && !IsConst>* = nullptr>
     typename U::value_type& value() const {
       return U()(m_bucket->value());
     }
@@ -571,10 +568,10 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
         m_try_shrink_on_next_insert(other.m_try_shrink_on_next_insert) {}
 
   robin_hash(robin_hash&& other) noexcept(
-      std::is_nothrow_move_constructible<
-          Hash>::value&& std::is_nothrow_move_constructible<KeyEqual>::value&&
-          std::is_nothrow_move_constructible<GrowthPolicy>::value&&
-              std::is_nothrow_move_constructible<buckets_container_type>::value)
+      std::is_nothrow_move_constructible_v<Hash> &&
+      std::is_nothrow_move_constructible_v<KeyEqual> &&
+      std::is_nothrow_move_constructible_v<GrowthPolicy> &&
+      std::is_nothrow_move_constructible_v<buckets_container_type>)
       : Hash(std::move(static_cast<Hash&>(other))),
         KeyEqual(std::move(static_cast<KeyEqual&>(other))),
         GrowthPolicy(std::move(static_cast<GrowthPolicy&>(other))),
@@ -698,9 +695,9 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
 
   template <class InputIt>
   void insert(InputIt first, InputIt last) {
-    if (std::is_base_of<
+    if (std::is_base_of_v<
             std::forward_iterator_tag,
-            typename std::iterator_traits<InputIt>::iterator_category>::value) {
+            typename std::iterator_traits<InputIt>::iterator_category>) {
       const auto nb_elements_insert = std::distance(first, last);
       const size_type nb_free_buckets = m_load_threshold - size();
       tsl_rh_assert(m_load_threshold >= size());
@@ -764,9 +761,7 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
     return try_emplace(std::forward<K>(key), std::forward<Args>(args)...).first;
   }
 
-  void erase_fast(iterator pos) {
-    erase_from_bucket(pos);
-  }
+  void erase_fast(iterator pos) { erase_from_bucket(pos); }
 
   /**
    * Here to avoid `template<class K> size_type erase(const K& key)` being used
@@ -889,26 +884,26 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
    * Lookup
    */
   template <class K, class U = ValueSelect,
-            typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+            std::enable_if_t<has_mapped_type<U>::value>* = nullptr>
   typename U::value_type& at(const K& key) {
     return at(key, hash_key(key));
   }
 
   template <class K, class U = ValueSelect,
-            typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+            std::enable_if_t<has_mapped_type<U>::value>* = nullptr>
   typename U::value_type& at(const K& key, std::size_t hash) {
     return const_cast<typename U::value_type&>(
         static_cast<const robin_hash*>(this)->at(key, hash));
   }
 
   template <class K, class U = ValueSelect,
-            typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+            std::enable_if_t<has_mapped_type<U>::value>* = nullptr>
   const typename U::value_type& at(const K& key) const {
     return at(key, hash_key(key));
   }
 
   template <class K, class U = ValueSelect,
-            typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+            std::enable_if_t<has_mapped_type<U>::value>* = nullptr>
   const typename U::value_type& at(const K& key, std::size_t hash) const {
     auto it = find(key, hash);
     if (it != cend()) {
@@ -919,7 +914,7 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
   }
 
   template <class K, class U = ValueSelect,
-            typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+            std::enable_if_t<has_mapped_type<U>::value>* = nullptr>
   typename U::value_type& operator[](K&& key) {
     return try_emplace(std::forward<K>(key)).first.value();
   }
@@ -1082,8 +1077,7 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
   }
 
   template <class U = GrowthPolicy,
-            typename std::enable_if<is_power_of_two_policy<U>::value>::type* =
-                nullptr>
+            std::enable_if_t<is_power_of_two_policy<U>::value>* = nullptr>
   std::size_t next_bucket(std::size_t index) const noexcept {
     tsl_rh_assert(index < bucket_count());
 
@@ -1091,8 +1085,7 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
   }
 
   template <class U = GrowthPolicy,
-            typename std::enable_if<!is_power_of_two_policy<U>::value>::type* =
-                nullptr>
+            std::enable_if_t<!is_power_of_two_policy<U>::value>* = nullptr>
   std::size_t next_bucket(std::size_t index) const noexcept {
     tsl_rh_assert(index < bucket_count());
 
diff --git a/include/tsl/robin_map.h b/include/tsl/robin_map.h
index b594810..298ee3d 100644
--- a/include/tsl/robin_map.h
+++ b/include/tsl/robin_map.h
@@ -234,8 +234,8 @@ class robin_map {
     return m_ht.insert(value);
   }
 
-  template <class P, typename std::enable_if<std::is_constructible<
-                         value_type, P&&>::value>::type* = nullptr>
+  template <class P, std::enable_if_t<
+                         std::is_constructible_v<value_type, P&&>>* = nullptr>
   std::pair<iterator, bool> insert(P&& value) {
     return m_ht.emplace(std::forward<P>(value));
   }
@@ -248,8 +248,8 @@ class robin_map {
     return m_ht.insert_hint(hint, value);
   }
 
-  template <class P, typename std::enable_if<std::is_constructible<
-                         value_type, P&&>::value>::type* = nullptr>
+  template <class P, std::enable_if_t<
+                         std::is_constructible_v<value_type, P&&>>* = nullptr>
   iterator insert(const_iterator hint, P&& value) {
     return m_ht.emplace_hint(hint, std::forward<P>(value));
   }
@@ -361,9 +361,8 @@ class robin_map {
    * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
    * to Key.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   size_type erase(const K& key) {
     return m_ht.erase(key);
   }
@@ -375,9 +374,8 @@ class robin_map {
    * hash value should be the same as hash_function()(key). Useful to speed-up
    * the lookup to the value if you already have the hash.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   size_type erase(const K& key, std::size_t precalculated_hash) {
     return m_ht.erase(key, precalculated_hash);
   }
@@ -412,9 +410,8 @@ class robin_map {
    * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
    * to Key.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   T& at(const K& key) {
     return m_ht.at(key);
   }
@@ -426,9 +423,8 @@ class robin_map {
    * hash value should be the same as hash_function()(key). Useful to speed-up
    * the lookup if you already have the hash.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   T& at(const K& key, std::size_t precalculated_hash) {
     return m_ht.at(key, precalculated_hash);
   }
@@ -436,9 +432,8 @@ class robin_map {
   /**
    * @copydoc at(const K& key)
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   const T& at(const K& key) const {
     return m_ht.at(key);
   }
@@ -446,9 +441,8 @@ class robin_map {
   /**
    * @copydoc at(const K& key, std::size_t precalculated_hash)
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   const T& at(const K& key, std::size_t precalculated_hash) const {
     return m_ht.at(key, precalculated_hash);
   }
@@ -472,9 +466,8 @@ class robin_map {
    * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
    * to Key.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   size_type count(const K& key) const {
     return m_ht.count(key);
   }
@@ -486,9 +479,8 @@ class robin_map {
    * hash value should be the same as hash_function()(key). Useful to speed-up
    * the lookup if you already have the hash.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   size_type count(const K& key, std::size_t precalculated_hash) const {
     return m_ht.count(key, precalculated_hash);
   }
@@ -518,9 +510,8 @@ class robin_map {
    * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
    * to Key.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   iterator find(const K& key) {
     return m_ht.find(key);
   }
@@ -532,9 +523,8 @@ class robin_map {
    * hash value should be the same as hash_function()(key). Useful to speed-up
    * the lookup if you already have the hash.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   iterator find(const K& key, std::size_t precalculated_hash) {
     return m_ht.find(key, precalculated_hash);
   }
@@ -542,9 +532,8 @@ class robin_map {
   /**
    * @copydoc find(const K& key)
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   const_iterator find(const K& key) const {
     return m_ht.find(key);
   }
@@ -556,9 +545,8 @@ class robin_map {
    * hash value should be the same as hash_function()(key). Useful to speed-up
    * the lookup if you already have the hash.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   const_iterator find(const K& key, std::size_t precalculated_hash) const {
     return m_ht.find(key, precalculated_hash);
   }
@@ -579,9 +567,8 @@ class robin_map {
    * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
    * to Key.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   bool contains(const K& key) const {
     return m_ht.contains(key);
   }
@@ -593,9 +580,8 @@ class robin_map {
    * hash value should be the same as hash_function()(key). Useful to speed-up
    * the lookup if you already have the hash.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   bool contains(const K& key, std::size_t precalculated_hash) const {
     return m_ht.contains(key, precalculated_hash);
   }
@@ -631,9 +617,8 @@ class robin_map {
    * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
    * to Key.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   std::pair<iterator, iterator> equal_range(const K& key) {
     return m_ht.equal_range(key);
   }
@@ -645,9 +630,8 @@ class robin_map {
    * hash value should be the same as hash_function()(key). Useful to speed-up
    * the lookup if you already have the hash.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   std::pair<iterator, iterator> equal_range(const K& key,
                                             std::size_t precalculated_hash) {
     return m_ht.equal_range(key, precalculated_hash);
@@ -656,9 +640,8 @@ class robin_map {
   /**
    * @copydoc equal_range(const K& key)
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   std::pair<const_iterator, const_iterator> equal_range(const K& key) const {
     return m_ht.equal_range(key);
   }
@@ -666,9 +649,8 @@ class robin_map {
   /**
    * @copydoc equal_range(const K& key, std::size_t precalculated_hash)
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   std::pair<const_iterator, const_iterator> equal_range(
       const K& key, std::size_t precalculated_hash) const {
     return m_ht.equal_range(key, precalculated_hash);
diff --git a/include/tsl/robin_set.h b/include/tsl/robin_set.h
index e115007..310894e 100644
--- a/include/tsl/robin_set.h
+++ b/include/tsl/robin_set.h
@@ -285,9 +285,8 @@ class robin_set {
    * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
    * to Key.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   size_type erase(const K& key) {
     return m_ht.erase(key);
   }
@@ -299,9 +298,8 @@ class robin_set {
    * hash value should be the same as hash_function()(key). Useful to speed-up
    * the lookup to the value if you already have the hash.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   size_type erase(const K& key, std::size_t precalculated_hash) {
     return m_ht.erase(key, precalculated_hash);
   }
@@ -327,9 +325,8 @@ class robin_set {
    * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
    * to Key.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   size_type count(const K& key) const {
     return m_ht.count(key);
   }
@@ -341,9 +338,8 @@ class robin_set {
    * hash value should be the same as hash_function()(key). Useful to speed-up
    * the lookup if you already have the hash.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   size_type count(const K& key, std::size_t precalculated_hash) const {
     return m_ht.count(key, precalculated_hash);
   }
@@ -373,9 +369,8 @@ class robin_set {
    * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
    * to Key.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   iterator find(const K& key) {
     return m_ht.find(key);
   }
@@ -387,9 +382,8 @@ class robin_set {
    * hash value should be the same as hash_function()(key). Useful to speed-up
    * the lookup if you already have the hash.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   iterator find(const K& key, std::size_t precalculated_hash) {
     return m_ht.find(key, precalculated_hash);
   }
@@ -397,9 +391,8 @@ class robin_set {
   /**
    * @copydoc find(const K& key)
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   const_iterator find(const K& key) const {
     return m_ht.find(key);
   }
@@ -411,9 +404,8 @@ class robin_set {
    * hash value should be the same as hash_function()(key). Useful to speed-up
    * the lookup if you already have the hash.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   const_iterator find(const K& key, std::size_t precalculated_hash) const {
     return m_ht.find(key, precalculated_hash);
   }
@@ -434,9 +426,8 @@ class robin_set {
    * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
    * to Key.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   bool contains(const K& key) const {
     return m_ht.contains(key);
   }
@@ -448,9 +439,8 @@ class robin_set {
    * hash value should be the same as hash_function()(key). Useful to speed-up
    * the lookup if you already have the hash.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   bool contains(const K& key, std::size_t precalculated_hash) const {
     return m_ht.contains(key, precalculated_hash);
   }
@@ -486,9 +476,8 @@ class robin_set {
    * KeyEqual::is_transparent exists. If so, K must be hashable and comparable
    * to Key.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   std::pair<iterator, iterator> equal_range(const K& key) {
     return m_ht.equal_range(key);
   }
@@ -500,9 +489,8 @@ class robin_set {
    * hash value should be the same as hash_function()(key). Useful to speed-up
    * the lookup if you already have the hash.
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   std::pair<iterator, iterator> equal_range(const K& key,
                                             std::size_t precalculated_hash) {
     return m_ht.equal_range(key, precalculated_hash);
@@ -511,9 +499,8 @@ class robin_set {
   /**
    * @copydoc equal_range(const K& key)
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   std::pair<const_iterator, const_iterator> equal_range(const K& key) const {
     return m_ht.equal_range(key);
   }
@@ -521,9 +508,8 @@ class robin_set {
   /**
    * @copydoc equal_range(const K& key, std::size_t precalculated_hash)
    */
-  template <
-      class K, class KE = KeyEqual,
-      typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
+  template <class K, class KE = KeyEqual,
+            std::enable_if_t<has_is_transparent<KE>::value>* = nullptr>
   std::pair<const_iterator, const_iterator> equal_range(
       const K& key, std::size_t precalculated_hash) const {
     return m_ht.equal_range(key, precalculated_hash);
diff --git a/tests/utils.h b/tests/utils.h
index 74433a3..556161d 100644
--- a/tests/utils.h
+++ b/tests/utils.h
@@ -374,8 +374,7 @@ class serializer {
     serialize_impl(val.value());
   }
 
-  template <class T, typename std::enable_if<
-                         std::is_arithmetic<T>::value>::type* = nullptr>
+  template <class T, std::enable_if_t<std::is_arithmetic_v<T>>* = nullptr>
   void serialize_impl(const T& val) {
     m_ostream.write(reinterpret_cast<const char*>(&val), sizeof(val));
   }
@@ -398,16 +397,15 @@ class deserializer {
   }
 
  private:
-  template <class T,
-            typename std::enable_if<is_pair<T>::value>::type* = nullptr>
+  template <class T, std::enable_if_t<is_pair<T>::value>* = nullptr>
   T deserialize_impl() {
     auto first = deserialize_impl<typename T::first_type>();
     return std::make_pair(std::move(first),
                           deserialize_impl<typename T::second_type>());
   }
 
-  template <class T, typename std::enable_if<
-                         std::is_same<std::string, T>::value>::type* = nullptr>
+  template <class T,
+            std::enable_if_t<std::is_same_v<std::string, T>>* = nullptr>
   T deserialize_impl() {
     const std::size_t str_size =
         tsl::detail_robin_hash::numeric_cast<std::size_t>(
@@ -421,14 +419,13 @@ class deserializer {
     return std::string(chars.data(), chars.size());
   }
 
-  template <class T, typename std::enable_if<std::is_same<
-                         move_only_test, T>::value>::type* = nullptr>
+  template <class T,
+            std::enable_if_t<std::is_same_v<move_only_test, T>>* = nullptr>
   move_only_test deserialize_impl() {
     return move_only_test(deserialize_impl<std::string>());
   }
 
-  template <class T, typename std::enable_if<
-                         std::is_arithmetic<T>::value>::type* = nullptr>
+  template <class T, std::enable_if_t<std::is_arithmetic_v<T>>* = nullptr>
   T deserialize_impl() {
     T val;
     m_istream.read(reinterpret_cast<char*>(&val), sizeof(val));