diff --git a/.github/workflows/cxx-versions.yml b/.github/workflows/cxx-versions.yml
index e6b8a2f01..5ec2f0768 100644
--- a/.github/workflows/cxx-versions.yml
+++ b/.github/workflows/cxx-versions.yml
@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        cxx-version: [11, 14, 17, 20]
+        cxx-version: [14, 17, 20]
     steps:
     - uses: actions/checkout@v3
     - name: Install dependencies
diff --git a/README.md b/README.md
index 0ff4ad6e6..9b7861210 100644
--- a/README.md
+++ b/README.md
@@ -37,7 +37,7 @@ The mathematical functions are a lightweight implementation of the algorithms or
 
 ## Requirements
 
-`xsimd` requires a C++11 compliant compiler. The following C++ compilers are supported:
+`xsimd` requires a C++14 compliant compiler. The following C++ compilers are supported:
 
 Compiler                | Version
 ------------------------|-------------------------------
diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
index 8cfad36c0..732d8d7b7 100644
--- a/benchmark/CMakeLists.txt
+++ b/benchmark/CMakeLists.txt
@@ -35,19 +35,18 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "GNU"
     endif()
 
     if(NOT MSVC)
-        CHECK_CXX_COMPILER_FLAG("-std=c++11" HAS_CPP11_FLAG)
         if (ENABLE_XTL_COMPLEX)
-            CHECK_CXX_COMPILER_FLAG("-std=c++14" HAS_CPP14_FLAG)
-            if (NOT HAS_CPP14_FLAG)
-                message(FATAL_ERROR "Unsupported compiler -- xsimd requires C++14 support when xtl complex support is enabled")
+            CHECK_CXX_COMPILER_FLAG("-std=c++17" HAS_CPP17_FLAG)
+            if (NOT HAS_CPP17_FLAG)
+                message(FATAL_ERROR "Unsupported compiler -- xsimd requires C++17 support when xtl complex support is enabled")
             endif()
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
+            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
         else()
-            CHECK_CXX_COMPILER_FLAG("-std=c++11" HAS_CPP11_FLAG)
-            if (NOT HAS_CPP11_FLAG)
-                message(FATAL_ERROR "Unsupported compiler -- xsimd requires C++11 support!")
+            CHECK_CXX_COMPILER_FLAG("-std=c++14" HAS_CPP14_FLAG)
+            if (NOT HAS_CPP14_FLAG)
+                message(FATAL_ERROR "Unsupported compiler -- xsimd requires C++14 support!")
             else()
-                set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+                set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
             endif()
         endif()
     endif()
diff --git a/docs/source/index.rst b/docs/source/index.rst
index e6f0fcf40..ac24da463 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -69,7 +69,7 @@ The following SIMD instruction set extensions are supported:
 +--------------+---------------------------------------------------------+
 
 
-`xsimd` requires a C++11 compliant compiler. The following C++ compilers are supported:
+`xsimd` requires a C++14 compliant compiler. The following C++ compilers are supported:
 
 +-------------------------+-------------------------------+
 | Compiler                | Version                       |
diff --git a/examples/pico_bench.hpp b/examples/pico_bench.hpp
index b948cfbf5..727f5e35e 100644
--- a/examples/pico_bench.hpp
+++ b/examples/pico_bench.hpp
@@ -202,16 +202,14 @@ namespace pico_bench
         }
 
         template <typename Fn>
-        typename std::enable_if<std::is_void<decltype(std::declval<Fn>()())>::value,
-                                stats_type>::type
+        std::enable_if_t<std::is_void<decltype(std::declval<Fn>()())>::value, stats_type>
         operator()(Fn fn) const
         {
             return (*this)(BenchWrapper<Fn> { fn });
         }
 
         template <typename Fn>
-        typename std::enable_if<std::is_same<decltype(std::declval<Fn>()()), T>::value,
-                                stats_type>::type
+        std::enable_if_t<std::is_same<decltype(std::declval<Fn>()()), T>::value, stats_type>
         operator()(Fn fn) const
         {
             // Do a single un-timed warm up run
diff --git a/include/xsimd/arch/common/xsimd_common_arithmetic.hpp b/include/xsimd/arch/common/xsimd_common_arithmetic.hpp
index f7c3ad524..ff2fb4118 100644
--- a/include/xsimd/arch/common/xsimd_common_arithmetic.hpp
+++ b/include/xsimd/arch/common/xsimd_common_arithmetic.hpp
@@ -28,14 +28,14 @@ namespace xsimd
         using namespace types;
 
         // bitwise_lshift
-        template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value>::type*/>
+        template <class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return detail::apply([](T x, T y) noexcept
                                  { return x << y; },
                                  self, other);
         }
-        template <size_t shift, class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value>::type*/>
+        template <size_t shift, class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
@@ -44,14 +44,14 @@ namespace xsimd
         }
 
         // bitwise_rshift
-        template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value>::type*/>
+        template <class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return detail::apply([](T x, T y) noexcept
                                  { return x >> y; },
                                  self, other);
         }
-        template <size_t shift, class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value>::type*/>
+        template <size_t shift, class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
@@ -74,7 +74,7 @@ namespace xsimd
         }
 
         // div
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> div(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return detail::apply([](T x, T y) noexcept -> T
@@ -169,7 +169,7 @@ namespace xsimd
         }
 
         // mul
-        template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value>::type*/>
+        template <class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
         XSIMD_INLINE batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return detail::apply([](T x, T y) noexcept -> T
@@ -213,7 +213,7 @@ namespace xsimd
         {
             return add(self, other); // no saturated arithmetic on floating point numbers
         }
-        template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value>::type*/>
+        template <class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
         XSIMD_INLINE batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -241,7 +241,7 @@ namespace xsimd
         {
             return sub(self, other); // no saturated arithmetic on floating point numbers
         }
-        template <class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value>::type*/>
+        template <class A, class T, class /*=std::enable_if_t<std::is_integral<T>::value>*/>
         XSIMD_INLINE batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             if (std::is_signed<T>::value)
diff --git a/include/xsimd/arch/common/xsimd_common_details.hpp b/include/xsimd/arch/common/xsimd_common_details.hpp
index 2c8adc97d..efe01806b 100644
--- a/include/xsimd/arch/common/xsimd_common_details.hpp
+++ b/include/xsimd/arch/common/xsimd_common_details.hpp
@@ -95,7 +95,7 @@ namespace xsimd
     template <class T, class A>
     XSIMD_INLINE batch<T, A> sqrt(batch<T, A> const& self) noexcept;
     template <class T, class A, class Vt, Vt... Values>
-    XSIMD_INLINE typename std::enable_if<std::is_arithmetic<T>::value, batch<T, A>>::type
+    XSIMD_INLINE std::enable_if_t<std::is_arithmetic<T>::value, batch<T, A>>
     swizzle(batch<T, A> const& x, batch_constant<Vt, A, Values...> mask) noexcept;
     template <class T, class A>
     XSIMD_INLINE batch<T, A> tan(batch<T, A> const& self) noexcept;
diff --git a/include/xsimd/arch/common/xsimd_common_logical.hpp b/include/xsimd/arch/common/xsimd_common_logical.hpp
index 69ab75305..83e9a9f11 100644
--- a/include/xsimd/arch/common/xsimd_common_logical.hpp
+++ b/include/xsimd/arch/common/xsimd_common_logical.hpp
@@ -116,7 +116,7 @@ namespace xsimd
         }
 
         // isinf
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> isinf(batch<T, A> const&, requires_arch<common>) noexcept
         {
             return batch_bool<T, A>(false);
@@ -143,7 +143,7 @@ namespace xsimd
         }
 
         // isfinite
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> isfinite(batch<T, A> const&, requires_arch<common>) noexcept
         {
             return batch_bool<T, A>(true);
@@ -160,14 +160,14 @@ namespace xsimd
         }
 
         // isnan
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> isnan(batch<T, A> const&, requires_arch<common>) noexcept
         {
             return batch_bool<T, A>(false);
         }
 
         // le
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> le(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return (self < other) || (self == other);
@@ -220,7 +220,7 @@ namespace xsimd
             using is_batch_bool_register_same = std::is_same<typename batch_bool<T, A>::register_type, typename batch<T, A>::register_type>;
         }
 
-        template <class A, class T, typename std::enable_if<detail::is_batch_bool_register_same<T, A>::value, int>::type = 3>
+        template <class A, class T, std::enable_if_t<detail::is_batch_bool_register_same<T, A>::value, int> = 3>
         XSIMD_INLINE batch_bool<T, A> select(batch_bool<T, A> const& cond, batch_bool<T, A> const& true_br, batch_bool<T, A> const& false_br, requires_arch<common>)
         {
             using register_type = typename batch_bool<T, A>::register_type;
@@ -230,7 +230,7 @@ namespace xsimd
             return batch_bool<T, A> { select(cond, true_v, false_v) };
         }
 
-        template <class A, class T, typename std::enable_if<!detail::is_batch_bool_register_same<T, A>::value, int>::type = 3>
+        template <class A, class T, std::enable_if_t<!detail::is_batch_bool_register_same<T, A>::value, int> = 3>
         XSIMD_INLINE batch_bool<T, A> select(batch_bool<T, A> const& cond, batch_bool<T, A> const& true_br, batch_bool<T, A> const& false_br, requires_arch<common>)
         {
             return (true_br & cond) | (bitwise_andnot(false_br, cond));
diff --git a/include/xsimd/arch/common/xsimd_common_math.hpp b/include/xsimd/arch/common/xsimd_common_math.hpp
index 75d4f1096..f84883405 100644
--- a/include/xsimd/arch/common/xsimd_common_math.hpp
+++ b/include/xsimd/arch/common/xsimd_common_math.hpp
@@ -60,7 +60,7 @@ namespace xsimd
                 // Inspired by
                 // https://stackoverflow.com/questions/5697500/take-the-average-of-two-signed-numbers-in-c
                 auto t = (x & y) + ((x ^ y) >> 1);
-                auto t_u = bitwise_cast<typename std::make_unsigned<T>::type>(t);
+                auto t_u = bitwise_cast<std::make_unsigned_t<T>>(t);
                 auto avg = t + (bitwise_cast<T>(t_u >> (8 * sizeof(T) - 1)) & (x ^ y));
                 return avg;
             }
@@ -286,7 +286,7 @@ namespace xsimd
         }
 
         // copysign
-        template <class A, class T, class = typename std::enable_if<std::is_floating_point<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_floating_point<T>::value>>
         XSIMD_INLINE batch<T, A> copysign(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return abs(self) | bitofsign(other);
@@ -613,7 +613,7 @@ namespace xsimd
                 }
 
                 template <size_t... Is, class Tuple>
-                XSIMD_INLINE B eval(::xsimd::detail::index_sequence<Is...>, const Tuple& tuple)
+                XSIMD_INLINE B eval(std::index_sequence<Is...>, const Tuple& tuple)
                 {
                     return estrin { x * x }(std::get<Is>(tuple)...);
                 }
@@ -621,7 +621,7 @@ namespace xsimd
                 template <class... Args>
                 XSIMD_INLINE B eval(const std::tuple<Args...>& tuple) noexcept
                 {
-                    return eval(::xsimd::detail::make_index_sequence<sizeof...(Args)>(), tuple);
+                    return eval(std::make_index_sequence<sizeof...(Args)>(), tuple);
                 }
 
                 template <class... Args>
@@ -1877,7 +1877,7 @@ namespace xsimd
         }
 
         // mod
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> mod(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             return detail::apply([](T x, T y) noexcept -> T
@@ -1886,7 +1886,7 @@ namespace xsimd
         }
 
         // nearbyint
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> nearbyint(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return self;
@@ -1926,7 +1926,7 @@ namespace xsimd
         }
 
         // nearbyint_as_int
-        template <class T, class A, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class T, class A, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> nearbyint_as_int(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return self;
@@ -2088,7 +2088,7 @@ namespace xsimd
         }
 
         // reciprocal
-        template <class T, class A, class = typename std::enable_if<std::is_floating_point<T>::value>::type>
+        template <class T, class A, class = std::enable_if_t<std::is_floating_point<T>::value>>
         XSIMD_INLINE batch<T, A> reciprocal(batch<T, A> const& self,
                                             requires_arch<common>) noexcept
         {
@@ -2103,7 +2103,7 @@ namespace xsimd
             return { reduce_add(self.real()), reduce_add(self.imag()) };
         }
 
-        template <class A, class T, class /*=typename std::enable_if<std::is_scalar<T>::value>::type*/>
+        template <class A, class T, class /*=std::enable_if_t<std::is_scalar<T>::value>*/>
         XSIMD_INLINE T reduce_add(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             alignas(A::alignment()) T buffer[batch<T, A>::size];
@@ -2175,7 +2175,7 @@ namespace xsimd
             return res;
         }
 
-        template <class A, class T, class /*=typename std::enable_if<std::is_scalar<T>::value>::type*/>
+        template <class A, class T, class /*=std::enable_if_t<std::is_scalar<T>::value>*/>
         XSIMD_INLINE T reduce_mul(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             alignas(A::alignment()) T buffer[batch<T, A>::size];
@@ -2199,7 +2199,7 @@ namespace xsimd
         {
             return fnma(nearbyint(self / other), other, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> remainder(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept
         {
             auto mod = self % other;
@@ -2214,7 +2214,7 @@ namespace xsimd
         }
 
         // sign
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> sign(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
@@ -2260,7 +2260,7 @@ namespace xsimd
         }
 
         // signnz
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> signnz(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             using batch_type = batch<T, A>;
diff --git a/include/xsimd/arch/common/xsimd_common_memory.hpp b/include/xsimd/arch/common/xsimd_common_memory.hpp
index 2d4f1515f..6a301dd44 100644
--- a/include/xsimd/arch/common/xsimd_common_memory.hpp
+++ b/include/xsimd/arch/common/xsimd_common_memory.hpp
@@ -63,7 +63,7 @@ namespace xsimd
         namespace detail
         {
             template <class IT, class A, class I, size_t... Is>
-            XSIMD_INLINE batch<IT, A> create_compress_swizzle_mask(I bitmask, ::xsimd::detail::index_sequence<Is...>)
+            XSIMD_INLINE batch<IT, A> create_compress_swizzle_mask(I bitmask, std::index_sequence<Is...>)
             {
                 batch<IT, A> swizzle_mask(IT(0));
                 alignas(A::alignment()) IT mask_buffer[batch<IT, A>::size] = { Is... };
@@ -84,7 +84,7 @@ namespace xsimd
             constexpr std::size_t size = batch_bool<T, A>::size;
             auto bitmask = mask.mask();
             auto z = select(mask, x, batch<T, A>((T)0));
-            auto compress_mask = detail::create_compress_swizzle_mask<IT, A>(bitmask, ::xsimd::detail::make_index_sequence<size>());
+            auto compress_mask = detail::create_compress_swizzle_mask<IT, A>(bitmask, std::make_index_sequence<size>());
             return swizzle(z, compress_mask);
         }
 
@@ -136,14 +136,14 @@ namespace xsimd
         namespace detail
         {
             // Not using XSIMD_INLINE here as it makes msvc hand got ever on avx512
-            template <size_t N, typename T, typename A, typename U, typename V, typename std::enable_if<N == 0, int>::type = 0>
+            template <size_t N, typename T, typename A, typename U, typename V, std::enable_if_t<N == 0, int> = 0>
             inline batch<T, A> gather(U const* src, batch<V, A> const& index,
                                       ::xsimd::index<N> I) noexcept
             {
                 return insert(batch<T, A> {}, static_cast<T>(src[index.get(I)]), I);
             }
 
-            template <size_t N, typename T, typename A, typename U, typename V, typename std::enable_if<N != 0, int>::type = 0>
+            template <size_t N, typename T, typename A, typename U, typename V, std::enable_if_t<N != 0, int> = 0>
             inline batch<T, A>
             gather(U const* src, batch<V, A> const& index, ::xsimd::index<N> I) noexcept
             {
@@ -222,7 +222,7 @@ namespace xsimd
         }
 
         template <class A, size_t I, class T>
-        XSIMD_INLINE auto get(batch<std::complex<T>, A> const& self, ::xsimd::index<I>, requires_arch<common>) noexcept -> typename batch<std::complex<T>, A>::value_type
+        XSIMD_INLINE typename batch<std::complex<T>, A>::value_type get(batch<std::complex<T>, A> const& self, ::xsimd::index<I>, requires_arch<common>) noexcept
         {
             alignas(A::alignment()) T buffer[batch<std::complex<T>, A>::size];
             self.store_aligned(&buffer[0]);
@@ -246,7 +246,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE auto get(batch<std::complex<T>, A> const& self, std::size_t i, requires_arch<common>) noexcept -> typename batch<std::complex<T>, A>::value_type
+        XSIMD_INLINE typename batch<std::complex<T>, A>::value_type get(batch<std::complex<T>, A> const& self, std::size_t i, requires_arch<common>) noexcept
         {
             using T2 = typename batch<std::complex<T>, A>::value_type;
             alignas(A::alignment()) T2 buffer[batch<std::complex<T>, A>::size];
@@ -268,7 +268,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE auto first(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept -> typename batch<std::complex<T>, A>::value_type
+        XSIMD_INLINE typename batch<std::complex<T>, A>::value_type first(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept
         {
             return { first(self.real(), A {}), first(self.imag(), A {}) };
         }
@@ -397,7 +397,7 @@ namespace xsimd
         }
 
         template <class A, bool... Values, class Mode>
-        XSIMD_INLINE typename std::enable_if<types::has_simd_register<double, A>::value, batch<int64_t, A>>::type
+        XSIMD_INLINE std::enable_if_t<types::has_simd_register<double, A>::value, batch<int64_t, A>>
         load_masked(int64_t const* mem, batch_bool_constant<int64_t, A, Values...>, convert<int64_t>, Mode, requires_arch<A>) noexcept
         {
             const auto d = load_masked<A>(reinterpret_cast<const double*>(mem), batch_bool_constant<double, A, Values...> {}, convert<double> {}, Mode {}, A {});
@@ -405,7 +405,7 @@ namespace xsimd
         }
 
         template <class A, bool... Values, class Mode>
-        XSIMD_INLINE typename std::enable_if<types::has_simd_register<double, A>::value, batch<uint64_t, A>>::type
+        XSIMD_INLINE std::enable_if_t<types::has_simd_register<double, A>::value, batch<uint64_t, A>>
         load_masked(uint64_t const* mem, batch_bool_constant<uint64_t, A, Values...>, convert<uint64_t>, Mode, requires_arch<A>) noexcept
         {
             const auto d = load_masked<A>(reinterpret_cast<const double*>(mem), batch_bool_constant<double, A, Values...> {}, convert<double> {}, Mode {}, A {});
@@ -425,14 +425,14 @@ namespace xsimd
         }
 
         template <class A, bool... Values, class Mode>
-        XSIMD_INLINE typename std::enable_if<types::has_simd_register<double, A>::value, void>::type
+        XSIMD_INLINE std::enable_if_t<types::has_simd_register<double, A>::value>
         store_masked(int64_t* mem, batch<int64_t, A> const& src, batch_bool_constant<int64_t, A, Values...>, Mode, requires_arch<A>) noexcept
         {
             store_masked<A>(reinterpret_cast<double*>(mem), bitwise_cast<double>(src), batch_bool_constant<double, A, Values...> {}, Mode {}, A {});
         }
 
         template <class A, bool... Values, class Mode>
-        XSIMD_INLINE typename std::enable_if<types::has_simd_register<double, A>::value, void>::type
+        XSIMD_INLINE std::enable_if_t<types::has_simd_register<double, A>::value>
         store_masked(uint64_t* mem, batch<uint64_t, A> const& src, batch_bool_constant<uint64_t, A, Values...>, Mode, requires_arch<A>) noexcept
         {
             store_masked<A>(reinterpret_cast<double*>(mem), bitwise_cast<double>(src), batch_bool_constant<double, A, Values...> {}, Mode {}, A {});
@@ -483,7 +483,7 @@ namespace xsimd
         // Scatter with runtime indexes.
         namespace detail
         {
-            template <size_t N, typename T, typename A, typename U, typename V, typename std::enable_if<N == 0, int>::type = 0>
+            template <size_t N, typename T, typename A, typename U, typename V, std::enable_if_t<N == 0, int> = 0>
             XSIMD_INLINE void scatter(batch<T, A> const& src, U* dst,
                                       batch<V, A> const& index,
                                       ::xsimd::index<N> I) noexcept
@@ -491,7 +491,7 @@ namespace xsimd
                 dst[index.get(I)] = static_cast<U>(src.get(I));
             }
 
-            template <size_t N, typename T, typename A, typename U, typename V, typename std::enable_if<N != 0, int>::type = 0>
+            template <size_t N, typename T, typename A, typename U, typename V, std::enable_if_t<N != 0, int> = 0>
             XSIMD_INLINE void
             scatter(batch<T, A> const& src, U* dst, batch<V, A> const& index,
                     ::xsimd::index<N> I) noexcept
@@ -829,7 +829,7 @@ namespace xsimd
         }
 
         // transpose
-        template <class A, class = typename std::enable_if<batch<int16_t, A>::size == 8>::type>
+        template <class A, class = std::enable_if_t<batch<int16_t, A>::size == 8>>
         XSIMD_INLINE void transpose(batch<int16_t, A>* matrix_begin, batch<int16_t, A>* matrix_end, requires_arch<common>) noexcept
         {
             assert((matrix_end - matrix_begin == batch<int16_t, A>::size) && "correctly sized matrix");
@@ -873,7 +873,7 @@ namespace xsimd
             transpose(reinterpret_cast<batch<int16_t, A>*>(matrix_begin), reinterpret_cast<batch<int16_t, A>*>(matrix_end), A {});
         }
 
-        template <class A, class = typename std::enable_if<batch<int8_t, A>::size == 16>::type>
+        template <class A, class = std::enable_if_t<batch<int8_t, A>::size == 16>>
         XSIMD_INLINE void transpose(batch<int8_t, A>* matrix_begin, batch<int8_t, A>* matrix_end, requires_arch<common>) noexcept
         {
             assert((matrix_end - matrix_begin == batch<int8_t, A>::size) && "correctly sized matrix");
diff --git a/include/xsimd/arch/common/xsimd_common_rounding.hpp b/include/xsimd/arch/common/xsimd_common_rounding.hpp
index 251a9f819..af2a5c2a7 100644
--- a/include/xsimd/arch/common/xsimd_common_rounding.hpp
+++ b/include/xsimd/arch/common/xsimd_common_rounding.hpp
@@ -49,7 +49,7 @@ namespace xsimd
         }
 
         // trunc
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> trunc(batch<T, A> const& self, requires_arch<common>) noexcept
         {
             return self;
diff --git a/include/xsimd/arch/common/xsimd_common_swizzle.hpp b/include/xsimd/arch/common/xsimd_common_swizzle.hpp
index 535f1bf74..5f51aaf9b 100644
--- a/include/xsimd/arch/common/xsimd_common_swizzle.hpp
+++ b/include/xsimd/arch/common/xsimd_common_swizzle.hpp
@@ -54,11 +54,11 @@ namespace xsimd
             // ────────────────────────────────────────────────────────────────────────
             // dup_lo_impl
             template <std::size_t I, std::size_t N, typename T,
-                      T... Vs, typename std::enable_if<I == N / 2, int>::type = 0>
+                      T... Vs, std::enable_if_t<I == N / 2, int> = 0>
             XSIMD_INLINE constexpr bool dup_lo_impl() noexcept { return true; }
 
             template <std::size_t I, std::size_t N, typename T,
-                      T... Vs, typename std::enable_if<(I < N / 2), int>::type = 0>
+                      T... Vs, std::enable_if_t<(I < N / 2), int> = 0>
             XSIMD_INLINE constexpr bool dup_lo_impl() noexcept
             {
                 return get_at<T, I, Vs...>::value < static_cast<T>(N / 2)
@@ -69,11 +69,11 @@ namespace xsimd
             // ────────────────────────────────────────────────────────────────────────
             // dup_hi_impl
             template <std::size_t I, std::size_t N, typename T,
-                      T... Vs, typename std::enable_if<I == N / 2, int>::type = 0>
+                      T... Vs, std::enable_if_t<I == N / 2, int> = 0>
             XSIMD_INLINE constexpr bool dup_hi_impl() noexcept { return true; }
 
             template <std::size_t I, std::size_t N, typename T,
-                      T... Vs, typename std::enable_if<(I < N / 2), int>::type = 0>
+                      T... Vs, std::enable_if_t<(I < N / 2), int> = 0>
             XSIMD_INLINE constexpr bool dup_hi_impl() noexcept
             {
                 return get_at<T, I, Vs...>::value >= static_cast<T>(N / 2)
diff --git a/include/xsimd/arch/common/xsimd_common_trigo.hpp b/include/xsimd/arch/common/xsimd_common_trigo.hpp
index dedfd3982..7f90cc559 100644
--- a/include/xsimd/arch/common/xsimd_common_trigo.hpp
+++ b/include/xsimd/arch/common/xsimd_common_trigo.hpp
@@ -158,7 +158,7 @@ namespace xsimd
          */
         namespace detail
         {
-            template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+            template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
             XSIMD_INLINE batch<T, A>
             average(const batch<T, A>& x1, const batch<T, A>& x2) noexcept
             {
diff --git a/include/xsimd/arch/xsimd_avx.hpp b/include/xsimd/arch/xsimd_avx.hpp
index 66ef31bf4..27f14b505 100644
--- a/include/xsimd/arch/xsimd_avx.hpp
+++ b/include/xsimd/arch/xsimd_avx.hpp
@@ -115,7 +115,7 @@ namespace xsimd
         }
 
         // add
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> add(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
         {
             return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
@@ -144,7 +144,7 @@ namespace xsimd
         {
             return _mm256_testc_pd(self, batch_bool<double, A>(true)) != 0;
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE bool all(batch_bool<T, A> const& self, requires_arch<avx>) noexcept
         {
             return _mm256_testc_si256(self, batch_bool<T, A>(true)) != 0;
@@ -161,7 +161,7 @@ namespace xsimd
         {
             return !_mm256_testz_pd(self, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE bool any(batch_bool<T, A> const& self, requires_arch<avx>) noexcept
         {
             return !_mm256_testz_si256(self, self);
@@ -197,14 +197,14 @@ namespace xsimd
             return _mm256_and_pd(self, other);
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_and(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
         {
             return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
                                       { return bitwise_and(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); },
                                       self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> bitwise_and(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx>) noexcept
         {
             return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
@@ -235,14 +235,14 @@ namespace xsimd
             return _mm256_andnot_pd(other, self);
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_andnot(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
         {
             return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
                                       { return bitwise_andnot(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); },
                                       self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx>) noexcept
         {
             return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
@@ -251,7 +251,7 @@ namespace xsimd
         }
 
         // bitwise_lshift
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, int32_t other, requires_arch<avx>) noexcept
         {
             return detail::fwd_to_sse([](__m128i s, int32_t o) noexcept
@@ -260,14 +260,14 @@ namespace xsimd
         }
 
         // bitwise_not
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_not(batch<T, A> const& self, requires_arch<avx>) noexcept
         {
             return detail::fwd_to_sse([](__m128i s) noexcept
                                       { return bitwise_not(batch<T, sse4_2>(s), sse4_2 {}); },
                                       self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> bitwise_not(batch_bool<T, A> const& self, requires_arch<avx>) noexcept
         {
             return detail::fwd_to_sse([](__m128i s) noexcept
@@ -296,14 +296,14 @@ namespace xsimd
         {
             return _mm256_or_pd(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_or(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
         {
             return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
                                       { return bitwise_or(batch<T, sse4_2>(s), batch<T, sse4_2>(o)); },
                                       self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> bitwise_or(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx>) noexcept
         {
             return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
@@ -312,7 +312,7 @@ namespace xsimd
         }
 
         // bitwise_rshift
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, int32_t other, requires_arch<avx>) noexcept
         {
             return detail::fwd_to_sse([](__m128i s, int32_t o) noexcept
@@ -341,14 +341,14 @@ namespace xsimd
         {
             return _mm256_xor_pd(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_xor(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
         {
             return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
                                       { return bitwise_xor(batch<T, sse4_2>(s), batch<T, sse4_2>(o), sse4_2 {}); },
                                       self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_xor(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx>) noexcept
         {
             return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
@@ -357,17 +357,17 @@ namespace xsimd
         }
 
         // bitwise_cast
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<float, A> bitwise_cast(batch<T, A> const& self, batch<float, A> const&, requires_arch<avx>) noexcept
         {
             return _mm256_castsi256_ps(self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<double, A> bitwise_cast(batch<T, A> const& self, batch<double, A> const&, requires_arch<avx>) noexcept
         {
             return _mm256_castsi256_pd(self);
         }
-        template <class A, class T, class Tp, class = typename std::enable_if<std::is_integral<typename std::common_type<T, Tp>::type>::value>::type>
+        template <class A, class T, class Tp, class = std::enable_if_t<std::is_integral<std::common_type_t<T, Tp>>::value>>
         XSIMD_INLINE batch<Tp, A> bitwise_cast(batch<T, A> const& self, batch<Tp, A> const&, requires_arch<avx>) noexcept
         {
             return batch<Tp, A>(self.data);
@@ -377,7 +377,7 @@ namespace xsimd
         {
             return _mm256_castps_pd(self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_cast(batch<float, A> const& self, batch<T, A> const&, requires_arch<avx>) noexcept
         {
             return _mm256_castps_si256(self);
@@ -387,7 +387,7 @@ namespace xsimd
         {
             return _mm256_castpd_ps(self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_cast(batch<double, A> const& self, batch<T, A> const&, requires_arch<avx>) noexcept
         {
             return _mm256_castpd_si256(self);
@@ -416,7 +416,7 @@ namespace xsimd
         }
 
         // broadcast
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> broadcast(T val, requires_arch<avx>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -535,7 +535,7 @@ namespace xsimd
         }
 
         // decr_if
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> decr_if(batch<T, A> const& self, batch_bool<T, A> const& mask, requires_arch<avx>) noexcept
         {
             return self + batch<T, A>(mask.data);
@@ -574,7 +574,7 @@ namespace xsimd
         {
             return ~(self != other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
         {
             return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
@@ -582,7 +582,7 @@ namespace xsimd
                                       self, other);
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> eq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx>) noexcept
         {
             return ~(self != other);
@@ -637,7 +637,7 @@ namespace xsimd
             assert(!(mask & ~0xFul) && "inbound mask");
             return _mm256_castsi256_pd(_mm256_load_si256((const __m256i*)lut64[mask]));
         }
-        template <class T, class A, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class T, class A, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> from_mask(batch_bool<T, A> const&, uint64_t mask, requires_arch<avx>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -742,14 +742,14 @@ namespace xsimd
         }
 
         // incr_if
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> incr_if(batch<T, A> const& self, batch_bool<T, A> const& mask, requires_arch<avx>) noexcept
         {
             return self - batch<T, A>(mask.data);
         }
 
         // insert
-        template <class A, class T, size_t I, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, size_t I, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> insert(batch<T, A> const& self, T val, index<I> pos, requires_arch<avx>) noexcept
         {
 #if !defined(_MSC_VER) || _MSC_VER > 1900
@@ -798,7 +798,7 @@ namespace xsimd
         }
 
         // load_aligned
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> load_aligned(T const* mem, convert<T>, requires_arch<avx>) noexcept
         {
             return _mm256_load_si256((__m256i const*)mem);
@@ -856,7 +856,7 @@ namespace xsimd
         }
 
         // load_unaligned
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> load_unaligned(T const* mem, convert<T>, requires_arch<avx>) noexcept
         {
             return _mm256_loadu_si256((__m256i const*)mem);
@@ -914,7 +914,7 @@ namespace xsimd
         }
 
         // load_masked (single overload for float/double)
-        template <class A, class T, bool... Values, class Mode, class = typename std::enable_if<std::is_floating_point<T>::value>::type>
+        template <class A, class T, bool... Values, class Mode, class = std::enable_if_t<std::is_floating_point<T>::value>>
         XSIMD_INLINE batch<T, A> load_masked(T const* mem, batch_bool_constant<T, A, Values...> mask, convert<T>, Mode, requires_arch<avx>) noexcept
         {
             using int_t = as_integer_t<T>;
@@ -994,7 +994,7 @@ namespace xsimd
             return _mm256_cmp_pd(self, other, _CMP_LT_OQ);
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> lt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
         {
             return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
@@ -1003,7 +1003,7 @@ namespace xsimd
         }
 
         // mask
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE uint64_t mask(batch_bool<T, A> const& self, requires_arch<avx>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1 || sizeof(T) == 2)
@@ -1048,7 +1048,7 @@ namespace xsimd
         {
             return _mm256_max_pd(other, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
         {
             return select(self > other, self, other);
@@ -1065,7 +1065,7 @@ namespace xsimd
         {
             return _mm256_min_pd(other, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
         {
             return select(self <= other, self, other);
@@ -1104,7 +1104,7 @@ namespace xsimd
         }
 
         // neg
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> neg(batch<T, A> const& self, requires_arch<avx>) noexcept
         {
             return 0 - self;
@@ -1131,7 +1131,7 @@ namespace xsimd
         {
             return _mm256_cmp_pd(self, other, _CMP_NEQ_UQ);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> neq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
         {
             return ~(self == other);
@@ -1147,7 +1147,7 @@ namespace xsimd
         {
             return _mm256_xor_pd(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> neq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx>) noexcept
         {
             return _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(self.data), _mm256_castsi256_ps(other.data)));
@@ -1162,7 +1162,7 @@ namespace xsimd
         }
 
         // reduce_add
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE T reduce_add(batch<T, A> const& self, requires_arch<avx>) noexcept
         {
             typename batch<T, sse4_2>::register_type low = detail::lower_half(self), high = detail::upper_half(self);
@@ -1171,7 +1171,7 @@ namespace xsimd
         }
 
         // reduce_max
-        template <class A, class T, class = typename std::enable_if<(sizeof(T) <= 2)>::type>
+        template <class A, class T, class = std::enable_if_t<(sizeof(T) <= 2)>>
         XSIMD_INLINE T reduce_max(batch<T, A> const& self, requires_arch<avx>) noexcept
         {
             constexpr auto mask = detail::shuffle(1, 0);
@@ -1182,7 +1182,7 @@ namespace xsimd
         }
 
         // reduce_min
-        template <class A, class T, class = typename std::enable_if<(sizeof(T) <= 2)>::type>
+        template <class A, class T, class = std::enable_if_t<(sizeof(T) <= 2)>>
         XSIMD_INLINE T reduce_min(batch<T, A> const& self, requires_arch<avx>) noexcept
         {
             constexpr auto mask = detail::shuffle(1, 0);
@@ -1193,7 +1193,7 @@ namespace xsimd
         }
 
         // reduce_mul
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE T reduce_mul(batch<T, A> const& self, requires_arch<avx>) noexcept
         {
             typename batch<T, sse4_2>::register_type low = detail::lower_half(self), high = detail::upper_half(self);
@@ -1214,7 +1214,7 @@ namespace xsimd
         }
 
         // sadd
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -1243,7 +1243,7 @@ namespace xsimd
         {
             return _mm256_blendv_pd(false_br, true_br, cond);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx>) noexcept
         {
             __m128i cond_low = detail::lower_half(cond), cond_hi = detail::upper_half(cond);
@@ -1256,7 +1256,7 @@ namespace xsimd
             __m128i res_hi = select(batch_bool<T, sse4_2>(cond_hi), batch<T, sse4_2>(true_hi), batch<T, sse4_2>(false_hi), sse4_2 {});
             return detail::merge_sse(res_low, res_hi);
         }
-        template <class A, class T, bool... Values, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, bool... Values, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> select(batch_bool_constant<T, A, Values...> const&, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx>) noexcept
         {
             return select(batch_bool<T, A> { Values... }, true_br, false_br, avx2 {});
@@ -1290,29 +1290,29 @@ namespace xsimd
             static_assert(sizeof...(Values) == batch<double, A>::size, "consistent init");
             return _mm256_setr_pd(values...);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> set(batch<T, A> const&, requires_arch<avx>, T v0, T v1, T v2, T v3) noexcept
         {
             return _mm256_set_epi64x(v3, v2, v1, v0);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> set(batch<T, A> const&, requires_arch<avx>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7) noexcept
         {
             return _mm256_setr_epi32(v0, v1, v2, v3, v4, v5, v6, v7);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> set(batch<T, A> const&, requires_arch<avx>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15) noexcept
         {
             return _mm256_setr_epi16(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> set(batch<T, A> const&, requires_arch<avx>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15,
                                      T v16, T v17, T v18, T v19, T v20, T v21, T v22, T v23, T v24, T v25, T v26, T v27, T v28, T v29, T v30, T v31) noexcept
         {
             return _mm256_setr_epi8(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31);
         }
 
-        template <class A, class T, class... Values, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class... Values, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> set(batch_bool<T, A> const&, requires_arch<avx>, Values... values) noexcept
         {
             return set(batch<T, A>(), A {}, static_cast<T>(values ? -1LL : 0LL)...).data;
@@ -1457,7 +1457,7 @@ namespace xsimd
         }
 
         // ssub
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -1472,12 +1472,12 @@ namespace xsimd
         }
 
         // store_aligned
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE void store_aligned(T* mem, batch<T, A> const& self, requires_arch<avx>) noexcept
         {
             return _mm256_store_si256((__m256i*)mem, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE void store_aligned(T* mem, batch_bool<T, A> const& self, requires_arch<avx>) noexcept
         {
             return _mm256_store_si256((__m256i*)mem, self);
@@ -1494,12 +1494,12 @@ namespace xsimd
         }
 
         // store_unaligned
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE void store_unaligned(T* mem, batch<T, A> const& self, requires_arch<avx>) noexcept
         {
             return _mm256_storeu_si256((__m256i*)mem, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE void store_unaligned(T* mem, batch_bool<T, A> const& self, requires_arch<avx>) noexcept
         {
             return _mm256_storeu_si256((__m256i*)mem, self);
@@ -1516,7 +1516,7 @@ namespace xsimd
         }
 
         // sub
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> sub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
         {
             return detail::fwd_to_sse([](__m128i s, __m128i o) noexcept
@@ -1872,7 +1872,7 @@ namespace xsimd
         }
 
         // zip_hi
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> zip_hi(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1 || sizeof(T) == 2)
@@ -1935,7 +1935,7 @@ namespace xsimd
         }
 
         // zip_lo
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> zip_lo(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1 || sizeof(T) == 2)
@@ -2011,7 +2011,7 @@ namespace xsimd
             return _mm256_cvtsd_f64(self);
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE T first(batch<T, A> const& self, requires_arch<avx>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
diff --git a/include/xsimd/arch/xsimd_avx2.hpp b/include/xsimd/arch/xsimd_avx2.hpp
index f9628f450..699f40ec3 100644
--- a/include/xsimd/arch/xsimd_avx2.hpp
+++ b/include/xsimd/arch/xsimd_avx2.hpp
@@ -28,7 +28,7 @@ namespace xsimd
         using namespace types;
 
         // abs
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> abs(batch<T, A> const& self, requires_arch<avx2>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -54,7 +54,7 @@ namespace xsimd
         }
 
         // add
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> add(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -80,7 +80,7 @@ namespace xsimd
         }
 
         // avgr
-        template <class A, class T, class = typename std::enable_if<std::is_unsigned<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_unsigned<T>::value>>
         XSIMD_INLINE batch<T, A> avgr(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -98,7 +98,7 @@ namespace xsimd
         }
 
         // avg
-        template <class A, class T, class = typename std::enable_if<std::is_unsigned<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_unsigned<T>::value>>
         XSIMD_INLINE batch<T, A> avg(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -139,11 +139,11 @@ namespace xsimd
 
         // single templated implementation for integer masked loads (32/64-bit)
         template <class A, class T, bool... Values, class Mode>
-        XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value && (sizeof(T) >= 4), batch<T, A>>::type
+        XSIMD_INLINE std::enable_if_t<std::is_integral<T>::value && (sizeof(T) >= 4), batch<T, A>>
         load_masked(T const* mem, batch_bool_constant<T, A, Values...> mask, convert<T>, Mode, requires_arch<avx2>) noexcept
         {
             static_assert(sizeof(T) == 4 || sizeof(T) == 8, "load_masked supports only 32/64-bit integers on AVX2");
-            using int_t = typename std::conditional<sizeof(T) == 4, int32_t, long long>::type;
+            using int_t = std::conditional_t<sizeof(T) == 4, int32_t, long long>;
             // Use the raw register-level maskload helpers for the remaining cases.
             return detail::maskload(reinterpret_cast<const int_t*>(mem), mask.as_batch());
         }
@@ -230,43 +230,43 @@ namespace xsimd
         }
 
         // bitwise_and
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_and(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
         {
             return _mm256_and_si256(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> bitwise_and(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx2>) noexcept
         {
             return _mm256_and_si256(self, other);
         }
 
         // bitwise_andnot
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_andnot(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
         {
             return _mm256_andnot_si256(other, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx2>) noexcept
         {
             return _mm256_andnot_si256(other, self);
         }
 
         // bitwise_not
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_not(batch<T, A> const& self, requires_arch<avx2>) noexcept
         {
             return _mm256_xor_si256(self, _mm256_set1_epi32(-1));
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> bitwise_not(batch_bool<T, A> const& self, requires_arch<avx2>) noexcept
         {
             return _mm256_xor_si256(self, _mm256_set1_epi32(-1));
         }
 
         // bitwise_lshift
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, int32_t other, requires_arch<avx2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 2)
@@ -287,7 +287,7 @@ namespace xsimd
             }
         }
 
-        template <size_t shift, class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <size_t shift, class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, requires_arch<avx2>) noexcept
         {
             constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
@@ -315,7 +315,7 @@ namespace xsimd
             }
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 4)
@@ -333,19 +333,19 @@ namespace xsimd
         }
 
         // bitwise_or
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_or(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
         {
             return _mm256_or_si256(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> bitwise_or(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx2>) noexcept
         {
             return _mm256_or_si256(self, other);
         }
 
         // bitwise_rshift
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, int32_t other, requires_arch<avx2>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -395,7 +395,7 @@ namespace xsimd
             }
         }
 
-        template <size_t shift, class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <size_t shift, class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, requires_arch<avx2>) noexcept
         {
             constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
@@ -452,7 +452,7 @@ namespace xsimd
             }
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -484,12 +484,12 @@ namespace xsimd
         }
 
         // bitwise_xor
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_xor(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
         {
             return _mm256_xor_si256(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_xor(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<avx2>) noexcept
         {
             return _mm256_xor_si256(self, other);
@@ -548,7 +548,7 @@ namespace xsimd
         }
 
         // eq
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -631,7 +631,7 @@ namespace xsimd
         }
 
         // lt
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> lt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -689,7 +689,7 @@ namespace xsimd
 
         // load_unaligned<batch_bool>
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> load_unaligned(bool const* mem, batch_bool<T, A>, requires_arch<avx2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -741,7 +741,7 @@ namespace xsimd
         }
 
         // mask
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE uint64_t mask(batch_bool<T, A> const& self, requires_arch<avx2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -760,7 +760,7 @@ namespace xsimd
         }
 
         // max
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -804,7 +804,7 @@ namespace xsimd
         }
 
         // min
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -848,7 +848,7 @@ namespace xsimd
         }
 
         // mul
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -876,7 +876,7 @@ namespace xsimd
         }
 
         // reduce_add
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE T reduce_add(batch<T, A> const& self, requires_arch<avx2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 4)
@@ -948,7 +948,7 @@ namespace xsimd
         }
 
         // sadd
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -984,7 +984,7 @@ namespace xsimd
         }
 
         // select
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -1008,7 +1008,7 @@ namespace xsimd
                 return select(cond, true_br, false_br, avx {});
             }
         }
-        template <class A, class T, bool... Values, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, bool... Values, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> select(batch_bool_constant<T, A, Values...> const&, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx2>) noexcept
         {
             // FIXME: for some reason mask here is not considered as an immediate,
@@ -1150,7 +1150,7 @@ namespace xsimd
         }
 
         // ssub
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -1186,7 +1186,7 @@ namespace xsimd
         }
 
         // sub
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> sub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -1287,17 +1287,16 @@ namespace xsimd
             }
 
             template <typename T, typename A, T... Vals, std::size_t... Ids>
-            constexpr auto swizzle_make_self_batch_impl(::xsimd::detail::index_sequence<Ids...>)
-                -> batch_constant<T, A, swizzle_self_val(Vals, T(Ids), static_cast<T>(sizeof...(Vals)))...>
+            constexpr batch_constant<T, A, swizzle_self_val(Vals, T(Ids), static_cast<T>(sizeof...(Vals)))...>
+            swizzle_make_self_batch_impl(std::index_sequence<Ids...>)
             {
                 return {};
             }
 
             template <typename T, typename A, T... Vals>
             constexpr auto swizzle_make_self_batch()
-                -> decltype(swizzle_make_self_batch_impl<T, A, Vals...>(::xsimd::detail::make_index_sequence<sizeof...(Vals)>()))
             {
-                return {};
+                return swizzle_make_self_batch_impl<T, A, Vals...>(std::make_index_sequence<sizeof...(Vals)>());
             }
 
             template <typename T>
@@ -1309,17 +1308,16 @@ namespace xsimd
             }
 
             template <typename T, typename A, T... Vals, std::size_t... Ids>
-            constexpr auto swizzle_make_cross_batch_impl(::xsimd::detail::index_sequence<Ids...>)
-                -> batch_constant<T, A, swizzle_cross_val(Vals, T(Ids), static_cast<T>(sizeof...(Vals)))...>
+            constexpr batch_constant<T, A, swizzle_cross_val(Vals, T(Ids), static_cast<T>(sizeof...(Vals)))...>
+            swizzle_make_cross_batch_impl(std::index_sequence<Ids...>)
             {
                 return {};
             }
 
             template <typename T, typename A, T... Vals>
             constexpr auto swizzle_make_cross_batch()
-                -> decltype(swizzle_make_cross_batch_impl<T, A, Vals...>(::xsimd::detail::make_index_sequence<sizeof...(Vals)>()))
             {
-                return {};
+                return swizzle_make_cross_batch_impl<T, A, Vals...>(std::make_index_sequence<sizeof...(Vals)>());
             }
         }
 
@@ -1452,7 +1450,7 @@ namespace xsimd
         }
 
         // zip_hi
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> zip_hi(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -1487,7 +1485,7 @@ namespace xsimd
         }
 
         // zip_lo
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> zip_lo(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -1522,7 +1520,7 @@ namespace xsimd
         }
 
         // widen
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE std::array<batch<widen_t<T>, A>, 2> widen(batch<T, A> const& x, requires_arch<avx2>) noexcept
         {
             __m128i x_lo = detail::lower_half(x);
diff --git a/include/xsimd/arch/xsimd_avx512bw.hpp b/include/xsimd/arch/xsimd_avx512bw.hpp
index 767c5960b..28e2e98d6 100644
--- a/include/xsimd/arch/xsimd_avx512bw.hpp
+++ b/include/xsimd/arch/xsimd_avx512bw.hpp
@@ -72,7 +72,7 @@ namespace xsimd
         }
 
         // abs
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> abs(batch<T, A> const& self, requires_arch<avx512bw>) noexcept
         {
             if (std::is_unsigned<T>::value)
@@ -95,7 +95,7 @@ namespace xsimd
         }
 
         // add
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> add(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -113,7 +113,7 @@ namespace xsimd
         }
 
         // avgr
-        template <class A, class T, class = typename std::enable_if<std::is_unsigned<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_unsigned<T>::value>>
         XSIMD_INLINE batch<T, A> avgr(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -131,7 +131,7 @@ namespace xsimd
         }
 
         // avg
-        template <class A, class T, class = typename std::enable_if<std::is_unsigned<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_unsigned<T>::value>>
         XSIMD_INLINE batch<T, A> avg(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -151,7 +151,7 @@ namespace xsimd
         }
 
         // bitwise_lshift
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, int32_t other, requires_arch<avx512bw>) noexcept
         {
 #if defined(XSIMD_AVX512_SHIFT_INTRINSICS_IMM_ONLY)
@@ -171,7 +171,7 @@ namespace xsimd
         }
 
         // bitwise_rshift
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, int32_t other, requires_arch<avx512bw>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -225,7 +225,7 @@ namespace xsimd
         }
 
         // decr_if
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> decr_if(batch<T, A> const& self, batch_bool<T, A> const& mask, requires_arch<avx512bw>) noexcept
         {
 
@@ -244,28 +244,28 @@ namespace xsimd
         }
 
         // eq
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
         {
             return detail::compare_int_avx512bw<A, T, _MM_CMPINT_EQ>(self, other);
         }
 
         // ge
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> ge(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
         {
             return detail::compare_int_avx512bw<A, T, _MM_CMPINT_GE>(self, other);
         }
 
         // gt
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
         {
             return detail::compare_int_avx512bw<A, T, _MM_CMPINT_GT>(self, other);
         }
 
         // incr_if
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> incr_if(batch<T, A> const& self, batch_bool<T, A> const& mask, requires_arch<avx512bw>) noexcept
         {
 
@@ -284,7 +284,7 @@ namespace xsimd
         }
 
         // insert
-        template <class A, class T, size_t I, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, size_t I, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> insert(batch<T, A> const& self, T val, index<I> pos, requires_arch<avx512bw>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -302,21 +302,21 @@ namespace xsimd
         }
 
         // le
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> le(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
         {
             return detail::compare_int_avx512bw<A, T, _MM_CMPINT_LE>(self, other);
         }
 
         // lt
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> lt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
         {
             return detail::compare_int_avx512bw<A, T, _MM_CMPINT_LT>(self, other);
         }
 
         // load
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> load_unaligned(bool const* mem, batch_bool<T, A>, requires_arch<avx512bw>) noexcept
         {
             using mask_type = typename batch_bool<T, A>::register_type;
@@ -347,7 +347,7 @@ namespace xsimd
             }
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> load_aligned(bool const* mem, batch_bool<T, A>, requires_arch<avx512bw>) noexcept
         {
             using mask_type = typename batch_bool<T, A>::register_type;
@@ -379,7 +379,7 @@ namespace xsimd
         }
 
         // max
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -415,7 +415,7 @@ namespace xsimd
         }
 
         // min
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -451,7 +451,7 @@ namespace xsimd
         }
 
         // mul
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -471,14 +471,14 @@ namespace xsimd
         }
 
         // neq
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> neq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
         {
             return detail::compare_int_avx512bw<A, T, _MM_CMPINT_NE>(self, other);
         }
 
         // sadd
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -514,7 +514,7 @@ namespace xsimd
         }
 
         // select
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx512bw>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -532,7 +532,7 @@ namespace xsimd
         }
 
         // slide_left
-        template <size_t N, class A, class T, class = typename std::enable_if<(N & 3) == 2 && (N < 64)>::type>
+        template <size_t N, class A, class T, class = std::enable_if_t<(N & 3) == 2 && (N < 64)>>
         XSIMD_INLINE batch<T, A> slide_left(batch<T, A> const& x, requires_arch<avx512bw>) noexcept
         {
             static_assert((N & 3) == 2 && N < 64, "The AVX512F implementation may have a lower latency.");
@@ -543,7 +543,7 @@ namespace xsimd
         }
 
         // slide_right
-        template <size_t N, class A, class T, class = typename std::enable_if<(N & 3) == 2 && (N < 64)>::type>
+        template <size_t N, class A, class T, class = std::enable_if_t<(N & 3) == 2 && (N < 64)>>
         XSIMD_INLINE batch<T, A> slide_right(batch<T, A> const& x, requires_arch<avx512bw>) noexcept
         {
             static_assert((N & 3) == 2 && N < 64, "The AVX512F implementation may have a lower latency.");
@@ -554,7 +554,7 @@ namespace xsimd
         }
 
         // ssub
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -600,7 +600,7 @@ namespace xsimd
         }
 
         // sub
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> sub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -664,7 +664,7 @@ namespace xsimd
         }
 
         // zip_hi
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> zip_hi(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
         {
             __m512i lo, hi;
@@ -692,7 +692,7 @@ namespace xsimd
         }
 
         // zip_lo
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> zip_lo(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512bw>) noexcept
         {
             __m512i lo, hi;
diff --git a/include/xsimd/arch/xsimd_avx512dq.hpp b/include/xsimd/arch/xsimd_avx512dq.hpp
index 480511ddb..0bedb9b41 100644
--- a/include/xsimd/arch/xsimd_avx512dq.hpp
+++ b/include/xsimd/arch/xsimd_avx512dq.hpp
@@ -236,8 +236,9 @@ namespace xsimd
             XSIMD_IF_CONSTEXPR(dup_lo || dup_hi)
             {
                 const batch<float, avx2> half = _mm512_extractf32x8_ps(self, dup_lo ? 0 : 1);
-                constexpr typename std::conditional<dup_lo, batch_constant<uint32_t, avx2, V0 % 8, V1 % 8, V2 % 8, V3 % 8, V4 % 8, V5 % 8, V6 % 8, V7 % 8>,
-                                                    batch_constant<uint32_t, avx2, V8 % 8, V9 % 8, V10 % 8, V11 % 8, V12 % 8, V13 % 8, V14 % 8, V15 % 8>>::type half_mask {};
+                constexpr std::conditional_t<dup_lo, batch_constant<uint32_t, avx2, V0 % 8, V1 % 8, V2 % 8, V3 % 8, V4 % 8, V5 % 8, V6 % 8, V7 % 8>,
+                                             batch_constant<uint32_t, avx2, V8 % 8, V9 % 8, V10 % 8, V11 % 8, V12 % 8, V13 % 8, V14 % 8, V15 % 8>>
+                    half_mask {};
                 auto permuted = swizzle(half, half_mask, avx2 {});
                 // merge the two slices into an AVX512F register:
                 return _mm512_broadcast_f32x8(permuted); // duplicates the 256-bit perm into both halves
diff --git a/include/xsimd/arch/xsimd_avx512f.hpp b/include/xsimd/arch/xsimd_avx512f.hpp
index 5b8599a8d..b9ec7916b 100644
--- a/include/xsimd/arch/xsimd_avx512f.hpp
+++ b/include/xsimd/arch/xsimd_avx512f.hpp
@@ -299,7 +299,7 @@ namespace xsimd
         } // namespace detail
 
         template <class A, class T, bool... Values, class Mode,
-                  typename = typename std::enable_if<(sizeof(T) >= 4), void>::type>
+                  typename = std::enable_if_t<(sizeof(T) >= 4)>>
         XSIMD_INLINE batch<T, A> load_masked(T const* mem,
                                              batch_bool_constant<T, A, Values...> mask,
                                              convert<T>, Mode, requires_arch<avx512f>) noexcept
@@ -325,7 +325,7 @@ namespace xsimd
         }
 
         template <class A, class T, bool... Values, class Mode,
-                  typename = typename std::enable_if<(sizeof(T) >= 4), void>::type>
+                  typename = std::enable_if_t<(sizeof(T) >= 4)>>
         XSIMD_INLINE void store_masked(T* mem,
                                        batch<T, A> const& src,
                                        batch_bool_constant<T, A, Values...> mask,
@@ -369,7 +369,7 @@ namespace xsimd
                                                self_asi);
             return *reinterpret_cast<__m512d*>(&res_asi);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> abs(batch<T, A> const& self, requires_arch<avx512f>) noexcept
         {
             if (std::is_unsigned<T>::value)
@@ -405,7 +405,7 @@ namespace xsimd
         }
 
         // add
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> add(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -484,7 +484,7 @@ namespace xsimd
             return _mm512_castsi512_pd(_mm512_and_si512(_mm512_castpd_si512(self), _mm512_castpd_si512(other)));
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_and(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
             return _mm512_and_si512(self, other);
@@ -509,7 +509,7 @@ namespace xsimd
             return _mm512_castsi512_pd(_mm512_andnot_si512(_mm512_castpd_si512(other), _mm512_castpd_si512(self)));
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_andnot(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
             return _mm512_andnot_si512(other, self);
@@ -523,7 +523,7 @@ namespace xsimd
         }
 
         // bitwise_lshift
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, int32_t other, requires_arch<avx512f>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -568,7 +568,7 @@ namespace xsimd
         }
 
         // bitwise_not
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_not(batch<T, A> const& self, requires_arch<avx512f>) noexcept
         {
             return _mm512_xor_si512(self, _mm512_set1_epi32(-1));
@@ -610,14 +610,14 @@ namespace xsimd
             return register_type(self.data | other.data);
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_or(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
             return _mm512_or_si512(self, other);
         }
 
         // bitwise_rshift
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, int32_t other, requires_arch<avx512f>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -687,7 +687,7 @@ namespace xsimd
         }
 
         // rotl
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 4)
@@ -702,12 +702,12 @@ namespace xsimd
                                       { return rotl(batch<T, avx2>(s), batch<T, avx2>(o), avx2 {}); },
                                       self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& self, int32_t other, requires_arch<avx512f>) noexcept
         {
             return rotl(self, batch<T, A>(other), A {});
         }
-        template <size_t count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <size_t count, class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& self, requires_arch<avx512f>) noexcept
         {
             constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
@@ -727,7 +727,7 @@ namespace xsimd
         }
 
         // rotr
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> rotr(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) < 4)
@@ -749,13 +749,13 @@ namespace xsimd
             }
             return rotr(self, other, common {});
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> rotr(batch<T, A> const& self, int32_t other, requires_arch<avx512f>) noexcept
         {
             return rotr(self, batch<T, A>(other), A {});
         }
 
-        template <size_t count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <size_t count, class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> rotr(batch<T, A> const& self, requires_arch<avx512f>) noexcept
         {
             constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
@@ -799,24 +799,24 @@ namespace xsimd
             return register_type(self.data ^ other.data);
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_xor(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
             return _mm512_xor_si512(self, other);
         }
 
         // bitwise_cast
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<float, A> bitwise_cast(batch<T, A> const& self, batch<float, A> const&, requires_arch<avx512f>) noexcept
         {
             return _mm512_castsi512_ps(self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<double, A> bitwise_cast(batch<T, A> const& self, batch<double, A> const&, requires_arch<avx512f>) noexcept
         {
             return _mm512_castsi512_pd(self);
         }
-        template <class A, class T, class Tp, class = typename std::enable_if<std::is_integral<typename std::common_type<T, Tp>::type>::value>::type>
+        template <class A, class T, class Tp, class = std::enable_if_t<std::is_integral<std::common_type_t<T, Tp>>::value>>
         XSIMD_INLINE batch<Tp, A> bitwise_cast(batch<T, A> const& self, batch<Tp, A> const&, requires_arch<avx512f>) noexcept
         {
             return batch<Tp, A>(self.data);
@@ -826,7 +826,7 @@ namespace xsimd
         {
             return _mm512_castps_pd(self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_cast(batch<float, A> const& self, batch<T, A> const&, requires_arch<avx512f>) noexcept
         {
             return _mm512_castps_si512(self);
@@ -836,14 +836,14 @@ namespace xsimd
         {
             return _mm512_castpd_ps(self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_cast(batch<double, A> const& self, batch<T, A> const&, requires_arch<avx512f>) noexcept
         {
             return _mm512_castpd_si512(self);
         }
 
         // broadcast
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> broadcast(T val, requires_arch<avx512f>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -982,7 +982,7 @@ namespace xsimd
             }
         }
         // incr_if
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> decr_if(batch<T, A> const& self, batch_bool<T, A> const& mask, requires_arch<avx512f>) noexcept
         {
 
@@ -1024,7 +1024,7 @@ namespace xsimd
             return _mm512_cmp_pd_mask(self, other, _CMP_EQ_OQ);
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
             return detail::compare_int_avx512f<A, T, _MM_CMPINT_EQ>(self, other);
@@ -1208,7 +1208,7 @@ namespace xsimd
         {
             return _mm512_cmp_pd_mask(self, other, _CMP_GE_OQ);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> ge(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
             return detail::compare_int_avx512f<A, T, _MM_CMPINT_GE>(self, other);
@@ -1225,7 +1225,7 @@ namespace xsimd
         {
             return _mm512_cmp_pd_mask(self, other, _CMP_GT_OQ);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
             return detail::compare_int_avx512f<A, T, _MM_CMPINT_GT>(self, other);
@@ -1328,7 +1328,7 @@ namespace xsimd
         }
 
         // incr_if
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> incr_if(batch<T, A> const& self, batch_bool<T, A> const& mask, requires_arch<avx512f>) noexcept
         {
 
@@ -1361,7 +1361,7 @@ namespace xsimd
             int64_t tmp = bit_cast<int64_t>(val);
             return _mm512_castsi512_pd(_mm512_mask_set1_epi64(_mm512_castpd_si512(self), __mmask8(1 << (I & 7)), tmp));
         }
-        template <class A, class T, size_t I, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, size_t I, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> insert(batch<T, A> const& self, T val, index<I> pos, requires_arch<avx512f>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 4)
@@ -1417,7 +1417,7 @@ namespace xsimd
         {
             return _mm512_cmp_pd_mask(self, other, _CMP_LE_OQ);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> le(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
             return detail::compare_int_avx512f<A, T, _MM_CMPINT_LE>(self, other);
@@ -1457,7 +1457,7 @@ namespace xsimd
         }
 
         // load_aligned
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> load_aligned(T const* mem, convert<T>, requires_arch<avx512f>) noexcept
         {
             return _mm512_load_si512((__m512i const*)mem);
@@ -1497,7 +1497,7 @@ namespace xsimd
         }
 
         // load_unaligned
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> load_unaligned(T const* mem, convert<T>, requires_arch<avx512f>) noexcept
         {
             return _mm512_loadu_si512((__m512i const*)mem);
@@ -1525,7 +1525,7 @@ namespace xsimd
             return _mm512_cmp_pd_mask(self, other, _CMP_LT_OQ);
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> lt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
             return detail::compare_int_avx512f<A, T, _MM_CMPINT_LT>(self, other);
@@ -1549,7 +1549,7 @@ namespace xsimd
         {
             return _mm512_max_pd(other, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -1599,7 +1599,7 @@ namespace xsimd
         {
             return _mm512_min_pd(other, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -1649,7 +1649,7 @@ namespace xsimd
         {
             return _mm512_mul_pd(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 4)
@@ -1702,7 +1702,7 @@ namespace xsimd
         {
             return _mm512_cmp_pd_mask(self, other, _CMP_NEQ_UQ);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> neq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
             return ~(self == other);
@@ -1743,7 +1743,7 @@ namespace xsimd
         {
             return _mm512_reduce_add_pd(rhs);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE T reduce_add(batch<T, A> const& self, requires_arch<avx512f>) noexcept
         {
             __m256i low = detail::lower_half(self), high = detail::upper_half(self);
@@ -1752,7 +1752,7 @@ namespace xsimd
         }
 
         // reduce_max
-        template <class A, class T, class = typename std::enable_if<(sizeof(T) == 1)>::type>
+        template <class A, class T, class = std::enable_if_t<(sizeof(T) == 1)>>
         XSIMD_INLINE T reduce_max(batch<T, A> const& self, requires_arch<avx512f>) noexcept
         {
             constexpr batch_constant<uint64_t, A, 5, 6, 7, 8, 0, 0, 0, 0> mask;
@@ -1763,7 +1763,7 @@ namespace xsimd
         }
 
         // reduce_min
-        template <class A, class T, class = typename std::enable_if<(sizeof(T) == 1)>::type>
+        template <class A, class T, class = std::enable_if_t<(sizeof(T) == 1)>>
         XSIMD_INLINE T reduce_min(batch<T, A> const& self, requires_arch<avx512f>) noexcept
         {
             constexpr batch_constant<uint64_t, A, 5, 6, 7, 8, 0, 0, 0, 0> mask;
@@ -1784,7 +1784,7 @@ namespace xsimd
         {
             return _mm512_reduce_mul_pd(rhs);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE T reduce_mul(batch<T, A> const& self, requires_arch<avx512f>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 4)
@@ -1816,7 +1816,7 @@ namespace xsimd
         }
 
         // sadd
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -1836,7 +1836,7 @@ namespace xsimd
 
         // scatter
         template <class A, class T,
-                  class = typename std::enable_if<std::is_same<uint32_t, T>::value || std::is_same<int32_t, T>::value>::type>
+                  class = std::enable_if_t<std::is_same<uint32_t, T>::value || std::is_same<int32_t, T>::value>>
         XSIMD_INLINE void scatter(batch<T, A> const& src, T* dst,
                                   batch<int32_t, A> const& index,
                                   kernel::requires_arch<avx512f>) noexcept
@@ -1845,7 +1845,7 @@ namespace xsimd
         }
 
         template <class A, class T,
-                  class = typename std::enable_if<std::is_same<uint64_t, T>::value || std::is_same<int64_t, T>::value>::type>
+                  class = std::enable_if_t<std::is_same<uint64_t, T>::value || std::is_same<int64_t, T>::value>>
         XSIMD_INLINE void scatter(batch<T, A> const& src, T* dst,
                                   batch<int64_t, A> const& index,
                                   kernel::requires_arch<avx512f>) noexcept
@@ -1881,7 +1881,7 @@ namespace xsimd
             return _mm512_mask_blend_pd(cond, false_br, true_br);
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx512f>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -1927,7 +1927,7 @@ namespace xsimd
             }
         }
 
-        template <class A, class T, bool... Values, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, bool... Values, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> select(batch_bool_constant<T, A, Values...> const&, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<avx512f>) noexcept
         {
             return select(batch_bool<T, A> { Values... }, true_br, false_br, avx512f {});
@@ -1936,12 +1936,12 @@ namespace xsimd
         namespace detail
         {
             template <class T>
-            using enable_signed_integer_t = typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value,
-                                                                    int>::type;
+            using enable_signed_integer_t = std::enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value,
+                                                             int>;
 
             template <class T>
-            using enable_unsigned_integer_t = typename std::enable_if<std::is_integral<T>::value && std::is_unsigned<T>::value,
-                                                                      int>::type;
+            using enable_unsigned_integer_t = std::enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value,
+                                                               int>;
         }
 
         // set
@@ -1956,12 +1956,12 @@ namespace xsimd
         {
             return _mm512_setr_pd(v0, v1, v2, v3, v4, v5, v6, v7);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> set(batch<T, A> const&, requires_arch<avx512f>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7) noexcept
         {
             return _mm512_set_epi64(v7, v6, v5, v4, v3, v2, v1, v0);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> set(batch<T, A> const&, requires_arch<avx512f>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7,
                                      T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15) noexcept
         {
@@ -2217,7 +2217,7 @@ namespace xsimd
         }
 
         // ssub
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -2242,12 +2242,12 @@ namespace xsimd
         }
 
         // store_aligned
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE void store_aligned(T* mem, batch<T, A> const& self, requires_arch<avx512f>) noexcept
         {
             return _mm512_store_si512((__m512i*)mem, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE void store_aligned(T* mem, batch_bool<T, A> const& self, requires_arch<avx512f>) noexcept
         {
             return _mm512_store_si512((__m512i*)mem, self);
@@ -2264,12 +2264,12 @@ namespace xsimd
         }
 
         // store_unaligned
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE void store_unaligned(T* mem, batch<T, A> const& self, requires_arch<avx512f>) noexcept
         {
             return _mm512_storeu_si512((__m512i*)mem, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE void store_unaligned(T* mem, batch_bool<T, A> const& self, requires_arch<avx512f>) noexcept
         {
             return _mm512_storeu_si512((__m512i*)mem, self);
@@ -2286,7 +2286,7 @@ namespace xsimd
         }
 
         // sub
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> sub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -2405,8 +2405,9 @@ namespace xsimd
             XSIMD_IF_CONSTEXPR(dup_lo || dup_hi)
             {
                 const batch<double, avx2> half = _mm512_extractf64x4_pd(self, dup_lo ? 0 : 1);
-                constexpr typename std::conditional<dup_lo, batch_constant<uint64_t, avx2, V0 % 4, V1 % 4, V2 % 4, V3 % 4>,
-                                                    batch_constant<uint64_t, avx2, V4 % 4, V5 % 4, V6 % 4, V7 % 4>>::type half_mask {};
+                constexpr std::conditional_t<dup_lo, batch_constant<uint64_t, avx2, V0 % 4, V1 % 4, V2 % 4, V3 % 4>,
+                                             batch_constant<uint64_t, avx2, V4 % 4, V5 % 4, V6 % 4, V7 % 4>>
+                    half_mask {};
                 return _mm512_broadcast_f64x4(swizzle(half, half_mask, avx2 {}));
             }
             // General case
@@ -2464,7 +2465,7 @@ namespace xsimd
 
         }
 
-        template <class A, uint16_t... Idx, class = typename std::enable_if<detail::is_pair_of_contiguous_indices<uint16_t, A, Idx...>::value>::type>
+        template <class A, uint16_t... Idx, class = std::enable_if_t<detail::is_pair_of_contiguous_indices<uint16_t, A, Idx...>::value>>
         XSIMD_INLINE batch<uint16_t, A> swizzle(batch<uint16_t, A> const& self, batch_constant<uint16_t, A, Idx...>, requires_arch<avx512f>) noexcept
         {
             constexpr typename detail::fold_batch_constant<A, Idx...>::type mask32;
@@ -2583,7 +2584,7 @@ namespace xsimd
         }
 
         // zip_hi
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A>
         zip_hi(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
@@ -2651,7 +2652,7 @@ namespace xsimd
         }
 
         // zip_lo
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A>
         zip_lo(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
@@ -2731,7 +2732,7 @@ namespace xsimd
             return _mm512_cvtsd_f64(self);
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE T first(batch<T, A> const& self, requires_arch<avx512f>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
diff --git a/include/xsimd/arch/xsimd_avx512vbmi.hpp b/include/xsimd/arch/xsimd_avx512vbmi.hpp
index 7158ec839..7c00d94ea 100644
--- a/include/xsimd/arch/xsimd_avx512vbmi.hpp
+++ b/include/xsimd/arch/xsimd_avx512vbmi.hpp
@@ -25,7 +25,7 @@ namespace xsimd
         using namespace types;
 
         // slide_left
-        template <size_t N, class A, class T, class = typename std::enable_if<(N & 3) != 0 && (N < 64)>::type>
+        template <size_t N, class A, class T, class = std::enable_if_t<(N & 3) != 0 && (N < 64)>>
         XSIMD_INLINE batch<T, A> slide_left(batch<T, A> const& x, requires_arch<avx512vbmi>) noexcept
         {
             static_assert((N & 3) != 0 && N < 64, "The AVX512F implementation may have a lower latency.");
@@ -36,7 +36,7 @@ namespace xsimd
         }
 
         // slide_right
-        template <size_t N, class A, class T, class = typename std::enable_if<(N & 3) != 0 && (N < 64)>::type>
+        template <size_t N, class A, class T, class = std::enable_if_t<(N & 3) != 0 && (N < 64)>>
         XSIMD_INLINE batch<T, A> slide_right(batch<T, A> const& x, requires_arch<avx512vbmi>) noexcept
         {
             static_assert((N & 3) != 0 && N < 64, "The AVX512F implementation may have a lower latency.");
diff --git a/include/xsimd/arch/xsimd_avx512vbmi2.hpp b/include/xsimd/arch/xsimd_avx512vbmi2.hpp
index 229acb28e..8852b2a1e 100644
--- a/include/xsimd/arch/xsimd_avx512vbmi2.hpp
+++ b/include/xsimd/arch/xsimd_avx512vbmi2.hpp
@@ -69,7 +69,7 @@ namespace xsimd
         }
 
         // rotl
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& self, int32_t other, requires_arch<avx512vbmi2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 2)
@@ -82,7 +82,7 @@ namespace xsimd
             }
         }
 
-        template <size_t count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <size_t count, class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& self, requires_arch<avx512vbmi2>) noexcept
         {
             constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
@@ -98,7 +98,7 @@ namespace xsimd
         }
 
         // rotr
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> rotr(batch<T, A> const& self, int32_t other, requires_arch<avx512vbmi2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 2)
@@ -111,7 +111,7 @@ namespace xsimd
             }
         }
 
-        template <size_t count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <size_t count, class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> rotr(batch<T, A> const& self, requires_arch<avx512vbmi2>) noexcept
         {
             constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
diff --git a/include/xsimd/arch/xsimd_common_fwd.hpp b/include/xsimd/arch/xsimd_common_fwd.hpp
index 21f99b004..74bcd2351 100644
--- a/include/xsimd/arch/xsimd_common_fwd.hpp
+++ b/include/xsimd/arch/xsimd_common_fwd.hpp
@@ -43,27 +43,27 @@ namespace xsimd
     namespace kernel
     {
         // forward declaration
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> abs(batch<T, A> const& self, requires_arch<common>) noexcept;
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept;
-        template <size_t shift, class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <size_t shift, class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, requires_arch<common>) noexcept;
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept;
-        template <size_t shift, class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <size_t shift, class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, requires_arch<common>) noexcept;
         template <class A, class T>
         XSIMD_INLINE batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept;
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept;
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept;
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept;
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE T reduce_add(batch<T, A> const& self, requires_arch<common>) noexcept;
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE T reduce_mul(batch<T, A> const& self, requires_arch<common>) noexcept;
         template <class A, class T, class STy>
         XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& self, STy other, requires_arch<common>) noexcept;
@@ -86,17 +86,17 @@ namespace xsimd
         template <class A, bool... Values, class Mode>
         XSIMD_INLINE batch<uint32_t, A> load_masked(uint32_t const* mem, batch_bool_constant<uint32_t, A, Values...> mask, convert<uint32_t>, Mode, requires_arch<A>) noexcept;
         template <class A, bool... Values, class Mode>
-        XSIMD_INLINE typename std::enable_if<types::has_simd_register<double, A>::value, batch<int64_t, A>>::type load_masked(int64_t const*, batch_bool_constant<int64_t, A, Values...>, convert<int64_t>, Mode, requires_arch<A>) noexcept;
+        XSIMD_INLINE std::enable_if_t<types::has_simd_register<double, A>::value, batch<int64_t, A>> load_masked(int64_t const*, batch_bool_constant<int64_t, A, Values...>, convert<int64_t>, Mode, requires_arch<A>) noexcept;
         template <class A, bool... Values, class Mode>
-        XSIMD_INLINE typename std::enable_if<types::has_simd_register<double, A>::value, batch<uint64_t, A>>::type load_masked(uint64_t const*, batch_bool_constant<uint64_t, A, Values...>, convert<uint64_t>, Mode, requires_arch<A>) noexcept;
+        XSIMD_INLINE std::enable_if_t<types::has_simd_register<double, A>::value, batch<uint64_t, A>> load_masked(uint64_t const*, batch_bool_constant<uint64_t, A, Values...>, convert<uint64_t>, Mode, requires_arch<A>) noexcept;
         template <class A, bool... Values, class Mode>
         XSIMD_INLINE void store_masked(int32_t* mem, batch<int32_t, A> const& src, batch_bool_constant<int32_t, A, Values...> mask, Mode, requires_arch<A>) noexcept;
         template <class A, bool... Values, class Mode>
         XSIMD_INLINE void store_masked(uint32_t* mem, batch<uint32_t, A> const& src, batch_bool_constant<uint32_t, A, Values...> mask, Mode, requires_arch<A>) noexcept;
         template <class A, bool... Values, class Mode>
-        XSIMD_INLINE typename std::enable_if<types::has_simd_register<double, A>::value, void>::type store_masked(int64_t*, batch<int64_t, A> const&, batch_bool_constant<int64_t, A, Values...>, Mode, requires_arch<A>) noexcept;
+        XSIMD_INLINE std::enable_if_t<types::has_simd_register<double, A>::value> store_masked(int64_t*, batch<int64_t, A> const&, batch_bool_constant<int64_t, A, Values...>, Mode, requires_arch<A>) noexcept;
         template <class A, bool... Values, class Mode>
-        XSIMD_INLINE typename std::enable_if<types::has_simd_register<double, A>::value, void>::type store_masked(uint64_t*, batch<uint64_t, A> const&, batch_bool_constant<uint64_t, A, Values...>, Mode, requires_arch<A>) noexcept;
+        XSIMD_INLINE std::enable_if_t<types::has_simd_register<double, A>::value> store_masked(uint64_t*, batch<uint64_t, A> const&, batch_bool_constant<uint64_t, A, Values...>, Mode, requires_arch<A>) noexcept;
 
         // Forward declarations for pack-level helpers
         namespace detail
diff --git a/include/xsimd/arch/xsimd_emulated.hpp b/include/xsimd/arch/xsimd_emulated.hpp
index 639850335..4437174a9 100644
--- a/include/xsimd/arch/xsimd_emulated.hpp
+++ b/include/xsimd/arch/xsimd_emulated.hpp
@@ -46,21 +46,21 @@ namespace xsimd
         namespace detail
         {
             template <size_t I, class F, class... Bs>
-            auto emulated_apply(F func, Bs const&... bs) -> decltype(func(bs.data[I]...))
+            auto emulated_apply(F func, Bs const&... bs)
             {
                 return func(bs.data[I]...);
             }
 
             template <class F, class B, class... Bs, size_t... Is>
-            auto emulated_apply(F func, ::xsimd::detail::index_sequence<Is...>, B const& b, Bs const&... bs) -> std::array<decltype(func(b.data[0], bs.data[0]...)), B::size>
+            auto emulated_apply(F func, std::index_sequence<Is...>, B const& b, Bs const&... bs) -> std::array<decltype(func(b.data[0], bs.data[0]...)), B::size>
             {
                 return { emulated_apply<Is>(func, b, bs...)... };
             }
 
             template <class B, class F, class... Bs>
-            auto emulated_apply(F func, B const& b, Bs const&... bs) -> std::array<decltype(func(b.data[0], bs.data[0]...)), B::size>
+            auto emulated_apply(F func, B const& b, Bs const&... bs)
             {
-                return emulated_apply(func, ::xsimd::detail::make_index_sequence<B::size>(), b, bs...);
+                return emulated_apply(func, std::make_index_sequence<B::size>(), b, bs...);
             }
         }
 
@@ -433,7 +433,7 @@ namespace xsimd
         }
 
         // isnan
-        template <class A, typename T, size_t N = 8 * sizeof(T) * batch<T, A>::size, class = typename std::enable_if<std::is_floating_point<T>::value>::type>
+        template <class A, typename T, size_t N = 8 * sizeof(T) * batch<T, A>::size, class = std::enable_if_t<std::is_floating_point<T>::value>>
         XSIMD_INLINE batch_bool<T, A> isnan(batch<T, A> const& self, requires_arch<emulated<N>>) noexcept
         {
             return detail::emulated_apply([](T v)
diff --git a/include/xsimd/arch/xsimd_neon.hpp b/include/xsimd/arch/xsimd_neon.hpp
index d97be3cc2..6bf5b4dad 100644
--- a/include/xsimd/arch/xsimd_neon.hpp
+++ b/include/xsimd/arch/xsimd_neon.hpp
@@ -169,7 +169,7 @@ namespace xsimd
                     return_type<U> apply(U rhs) const noexcept
                     {
                         using func_type = return_type<U> (*)(U);
-                        auto func = xsimd::detail::get<func_type>(m_func);
+                        auto func = std::get<func_type>(m_func);
                         return func(rhs);
                     }
                 };
@@ -183,7 +183,7 @@ namespace xsimd
                     return_type<U> apply(U lhs, U rhs) const noexcept
                     {
                         using func_type = return_type<U> (*)(U, U);
-                        auto func = xsimd::detail::get<func_type>(m_func);
+                        auto func = std::get<func_type>(m_func);
                         return func(lhs, rhs);
                     }
                 };
@@ -295,12 +295,12 @@ namespace xsimd
              **************************************/
 
             template <class T>
-            using enable_neon_type_t = typename std::enable_if<std::is_integral<T>::value || std::is_same<T, float>::value,
-                                                               int>::type;
+            using enable_neon_type_t = std::enable_if_t<std::is_integral<T>::value || std::is_same<T, float>::value,
+                                                        int>;
 
             template <class T>
             using exclude_int64_neon_t
-                = typename std::enable_if<(std::is_integral<T>::value && sizeof(T) != 8) || std::is_same<T, float>::value, int>::type;
+                = std::enable_if_t<(std::is_integral<T>::value && sizeof(T) != 8) || std::is_same<T, float>::value, int>;
         }
 
         /*************
@@ -870,7 +870,7 @@ namespace xsimd
 
         WRAP_BINARY_UINT_EXCLUDING_64(vhaddq, detail::identity_return_type)
 
-        template <class A, class T, class = typename std::enable_if<(std::is_unsigned<T>::value && sizeof(T) != 8)>::type>
+        template <class A, class T, class = std::enable_if_t<(std::is_unsigned<T>::value && sizeof(T) != 8)>>
         XSIMD_INLINE batch<T, A> avg(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
@@ -886,7 +886,7 @@ namespace xsimd
 
         WRAP_BINARY_UINT_EXCLUDING_64(vrhaddq, detail::identity_return_type)
 
-        template <class A, class T, class = typename std::enable_if<(std::is_unsigned<T>::value && sizeof(T) != 8)>::type>
+        template <class A, class T, class = std::enable_if_t<(std::is_unsigned<T>::value && sizeof(T) != 8)>>
         XSIMD_INLINE batch<T, A> avgr(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<neon>) noexcept
         {
             using register_type = typename batch<T, A>::register_type;
@@ -1866,7 +1866,7 @@ namespace xsimd
                 U apply(comp_return_type<U> cond, U lhs, U rhs) const noexcept
                 {
                     using func_type = U (*)(comp_return_type<U>, U, U);
-                    auto func = xsimd::detail::get<func_type>(m_func);
+                    auto func = std::get<func_type>(m_func);
                     return func(cond, lhs, rhs);
                 }
             };
@@ -2097,14 +2097,14 @@ namespace xsimd
         namespace detail
         {
             template <class A, class T>
-            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const&, batch<T, A> const& /*rhs*/, std::size_t, ::xsimd::detail::index_sequence<>) noexcept
+            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const&, batch<T, A> const& /*rhs*/, std::size_t, std::index_sequence<>) noexcept
             {
                 assert(false && "extract_pair out of bounds");
                 return batch<T, A> {};
             }
 
             template <class A, class T, size_t I, size_t... Is, detail::enable_sized_unsigned_t<T, 1> = 0>
-            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
+            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -2112,12 +2112,12 @@ namespace xsimd
                 }
                 else
                 {
-                    return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
+                    return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
                 }
             }
 
             template <class A, class T, size_t I, size_t... Is, detail::enable_sized_signed_t<T, 1> = 0>
-            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
+            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -2125,12 +2125,12 @@ namespace xsimd
                 }
                 else
                 {
-                    return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
+                    return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
                 }
             }
 
             template <class A, class T, size_t I, size_t... Is, detail::enable_sized_unsigned_t<T, 2> = 0>
-            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
+            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -2138,12 +2138,12 @@ namespace xsimd
                 }
                 else
                 {
-                    return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
+                    return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
                 }
             }
 
             template <class A, class T, size_t I, size_t... Is, detail::enable_sized_signed_t<T, 2> = 0>
-            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
+            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -2151,12 +2151,12 @@ namespace xsimd
                 }
                 else
                 {
-                    return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
+                    return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
                 }
             }
 
             template <class A, class T, size_t I, size_t... Is, detail::enable_sized_unsigned_t<T, 4> = 0>
-            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
+            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -2164,12 +2164,12 @@ namespace xsimd
                 }
                 else
                 {
-                    return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
+                    return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
                 }
             }
 
             template <class A, class T, size_t I, size_t... Is, detail::enable_sized_signed_t<T, 4> = 0>
-            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
+            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -2177,12 +2177,12 @@ namespace xsimd
                 }
                 else
                 {
-                    return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
+                    return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
                 }
             }
 
             template <class A, class T, size_t I, size_t... Is, detail::enable_sized_unsigned_t<T, 8> = 0>
-            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
+            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -2190,12 +2190,12 @@ namespace xsimd
                 }
                 else
                 {
-                    return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
+                    return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
                 }
             }
 
             template <class A, class T, size_t I, size_t... Is, detail::enable_sized_signed_t<T, 8> = 0>
-            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
+            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -2203,12 +2203,12 @@ namespace xsimd
                 }
                 else
                 {
-                    return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
+                    return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
                 }
             }
 
             template <class A, size_t I, size_t... Is>
-            XSIMD_INLINE batch<float, A> extract_pair(batch<float, A> const& lhs, batch<float, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
+            XSIMD_INLINE batch<float, A> extract_pair(batch<float, A> const& lhs, batch<float, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -2216,12 +2216,12 @@ namespace xsimd
                 }
                 else
                 {
-                    return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
+                    return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
                 }
             }
 
             template <class A, class T, size_t... Is>
-            XSIMD_INLINE batch<T, A> extract_pair_impl(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<0, Is...>) noexcept
+            XSIMD_INLINE batch<T, A> extract_pair_impl(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<0, Is...>) noexcept
             {
                 if (n == 0)
                 {
@@ -2229,7 +2229,7 @@ namespace xsimd
                 }
                 else
                 {
-                    return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
+                    return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
                 }
             }
         }
@@ -2239,7 +2239,7 @@ namespace xsimd
         {
             constexpr std::size_t size = batch<T, A>::size;
             assert(n < size && "index in bounds");
-            return detail::extract_pair_impl(lhs, rhs, n, ::xsimd::detail::make_index_sequence<size>());
+            return detail::extract_pair_impl(lhs, rhs, n, std::make_index_sequence<size>());
         }
 
         /******************
@@ -2886,7 +2886,7 @@ namespace xsimd
                 R apply(U rhs) const noexcept
                 {
                     using func_type = R (*)(U);
-                    auto func = xsimd::detail::get<func_type>(m_func);
+                    auto func = std::get<func_type>(m_func);
                     return func(rhs);
                 }
             };
@@ -2915,7 +2915,7 @@ namespace xsimd
                 V apply(U rhs) const noexcept
                 {
                     using caster_type = bitwise_caster_impl<V, T...>;
-                    auto caster = xsimd::detail::get<caster_type>(m_caster);
+                    auto caster = std::get<caster_type>(m_caster);
                     return caster.apply(rhs);
                 }
             };
diff --git a/include/xsimd/arch/xsimd_neon64.hpp b/include/xsimd/arch/xsimd_neon64.hpp
index 565747446..c13ee1fa7 100644
--- a/include/xsimd/arch/xsimd_neon64.hpp
+++ b/include/xsimd/arch/xsimd_neon64.hpp
@@ -15,6 +15,7 @@
 #include <complex>
 #include <cstddef>
 #include <tuple>
+#include <utility>
 
 #include "../types/xsimd_neon64_register.hpp"
 #include "../types/xsimd_utils.hpp"
@@ -857,8 +858,8 @@ namespace xsimd
                                                                          uint64x2_t, int64x2_t,
                                                                          float32x4_t, float64x2_t>;
             template <class T>
-            using enable_neon64_type_t = typename std::enable_if<std::is_integral<T>::value || std::is_same<T, float>::value || std::is_same<T, double>::value,
-                                                                 int>::type;
+            using enable_neon64_type_t = std::enable_if_t<std::is_integral<T>::value || std::is_same<T, float>::value || std::is_same<T, double>::value,
+                                                          int>;
         }
 
         /**************
@@ -1132,7 +1133,7 @@ namespace xsimd
         {
             template <class A, size_t I, size_t... Is>
             XSIMD_INLINE batch<double, A> extract_pair(batch<double, A> const& lhs, batch<double, A> const& rhs, std::size_t n,
-                                                       ::xsimd::detail::index_sequence<I, Is...>) noexcept
+                                                       std::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -1140,7 +1141,7 @@ namespace xsimd
                 }
                 else
                 {
-                    return extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
+                    return extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
                 }
             }
         }
@@ -1150,7 +1151,7 @@ namespace xsimd
         {
             constexpr std::size_t size = batch<double, A>::size;
             assert(n < size && "index in bounds");
-            return detail::extract_pair(lhs, rhs, n, ::xsimd::detail::make_index_sequence<size>());
+            return detail::extract_pair(lhs, rhs, n, std::make_index_sequence<size>());
         }
 
         /******************
@@ -1240,7 +1241,7 @@ namespace xsimd
                 V apply(float64x2_t rhs) const
                 {
                     using func_type = V (*)(float64x2_t);
-                    auto func = xsimd::detail::get<func_type>(m_func);
+                    auto func = std::get<func_type>(m_func);
                     return func(rhs);
                 }
             };
@@ -1396,8 +1397,6 @@ namespace xsimd
         namespace detail
         {
             using ::xsimd::batch_constant;
-            using ::xsimd::detail::integer_sequence;
-            using ::xsimd::detail::make_integer_sequence;
 
             template <class CB1, class CB2, class IS>
             struct index_burst_impl;
@@ -1405,7 +1404,7 @@ namespace xsimd
             template <typename T1, class A, typename T2, T2... V,
                       T2... incr>
             struct index_burst_impl<batch_constant<T1, A>, batch_constant<T2, A, V...>,
-                                    integer_sequence<T2, incr...>>
+                                    std::integer_sequence<T2, incr...>>
             {
                 using type = batch_constant<T2, A, V...>;
             };
@@ -1413,11 +1412,11 @@ namespace xsimd
             template <typename T1, class A, T1 V0, T1... V1,
                       typename T2, T2... V2, T2... incr>
             struct index_burst_impl<batch_constant<T1, A, V0, V1...>, batch_constant<T2, A, V2...>,
-                                    integer_sequence<T2, incr...>>
+                                    std::integer_sequence<T2, incr...>>
             {
                 using next_input = batch_constant<T1, A, V1...>;
                 using next_output = batch_constant<T2, A, V2..., (V0 + incr)...>;
-                using type = typename index_burst_impl<next_input, next_output, integer_sequence<T2, incr...>>::type;
+                using type = typename index_burst_impl<next_input, next_output, std::integer_sequence<T2, incr...>>::type;
             };
 
             template <class B, class T>
@@ -1429,7 +1428,7 @@ namespace xsimd
                 static constexpr size_t mul = sizeof(Tp) / sizeof(T);
                 using input = batch_constant<Tp, A, (mul * V)...>;
                 using output = batch_constant<T, A>;
-                using type = typename index_burst_impl<input, output, make_integer_sequence<T, mul>>::type;
+                using type = typename index_burst_impl<input, output, std::make_integer_sequence<T, mul>>::type;
             };
 
             template <class B, typename T>
diff --git a/include/xsimd/arch/xsimd_rvv.hpp b/include/xsimd/arch/xsimd_rvv.hpp
index 610c0944f..c659c14e4 100644
--- a/include/xsimd/arch/xsimd_rvv.hpp
+++ b/include/xsimd/arch/xsimd_rvv.hpp
@@ -436,23 +436,23 @@ namespace xsimd
 
             // enable for signed integers
             template <class T>
-            using rvv_enable_signed_int_t = typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value, int>::type;
+            using rvv_enable_signed_int_t = std::enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value, int>;
 
             // enable for unsigned integers
             template <class T>
-            using rvv_enable_unsigned_int_t = typename std::enable_if<std::is_integral<T>::value && std::is_unsigned<T>::value, int>::type;
+            using rvv_enable_unsigned_int_t = std::enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value, int>;
 
             // enable for floating points
             template <class T>
-            using rvv_enable_floating_point_t = typename std::enable_if<std::is_floating_point<T>::value, int>::type;
+            using rvv_enable_floating_point_t = std::enable_if_t<std::is_floating_point<T>::value, int>;
 
             // enable for signed integers or floating points
             template <class T>
-            using rvv_enable_signed_int_or_floating_point_t = typename std::enable_if<std::is_signed<T>::value, int>::type;
+            using rvv_enable_signed_int_or_floating_point_t = std::enable_if_t<std::is_signed<T>::value, int>;
 
             // enable for all RVE supported types
             template <class T>
-            using rvv_enable_all_t = typename std::enable_if<std::is_arithmetic<T>::value, int>::type;
+            using rvv_enable_all_t = std::enable_if_t<std::is_arithmetic<T>::value, int>;
         } // namespace detail
 
         /********************
@@ -505,7 +505,7 @@ namespace xsimd
         // load_complex
         namespace detail
         {
-            template <class T, size_t W, typename std::enable_if<W >= types::detail::rvv_width_m1, int>::type = 0>
+            template <class T, size_t W, std::enable_if_t<W >= types::detail::rvv_width_m1, int> = 0>
             XSIMD_INLINE rvv_reg_t<T, W * 2> rvvabut(rvv_reg_t<T, W> const& lo, rvv_reg_t<T, W> const& hi) noexcept
             {
                 typename rvv_reg_t<T, W * 2>::register_type tmp;
@@ -513,7 +513,7 @@ namespace xsimd
                 return __riscv_vset(tmp, 1, hi);
             }
 
-            template <class T, size_t W, typename std::enable_if<W<types::detail::rvv_width_m1, int>::type = 0> XSIMD_INLINE rvv_reg_t<T, W * 2> rvvabut(rvv_reg_t<T, W> const& lo, rvv_reg_t<T, W> const& hi) noexcept
+            template <class T, size_t W, std::enable_if_t<W<types::detail::rvv_width_m1, int>::type = 0> D_INLINE rvv_reg_t<T, W * 2> rvvabut(rvv_reg_t<T, W> const& lo, rvv_reg_t<T, W> const& hi) noexcept
             {
                 return __riscv_vslideup(lo, hi, lo.vl, lo.vl * 2);
             }
@@ -521,24 +521,24 @@ namespace xsimd
             XSIMD_RVV_OVERLOAD(rvvget_lo_, (__riscv_vget_ XSIMD_RVV_TSM), _DROP_1ST_CUSTOM_ARGS_NOVL, vec(T, wide_vec), args..., 0)
             XSIMD_RVV_OVERLOAD(rvvget_hi_, (__riscv_vget_ XSIMD_RVV_TSM), _DROP_1ST_CUSTOM_ARGS_NOVL, vec(T, wide_vec), args..., 1)
 
-            template <class T, size_t W, typename std::enable_if<W >= types::detail::rvv_width_m1, int>::type = 0>
+            template <class T, size_t W, std::enable_if_t<W >= types::detail::rvv_width_m1, int> = 0>
             rvv_reg_t<T, W> rvvget_lo(rvv_reg_t<T, W * 2> const& vv) noexcept
             {
                 typename rvv_reg_t<T, W>::register_type tmp = rvvget_lo_(T {}, vv);
                 return tmp;
             }
-            template <class T, size_t W, typename std::enable_if<W >= types::detail::rvv_width_m1, int>::type = 0>
+            template <class T, size_t W, std::enable_if_t<W >= types::detail::rvv_width_m1, int> = 0>
             rvv_reg_t<T, W> rvvget_hi(rvv_reg_t<T, W * 2> const& vv) noexcept
             {
                 typename rvv_reg_t<T, W>::register_type tmp = rvvget_hi_(T {}, vv);
                 return tmp;
             }
-            template <class T, size_t W, typename std::enable_if<W<types::detail::rvv_width_m1, int>::type = 0> rvv_reg_t<T, W> rvvget_lo(rvv_reg_t<T, W * 2> const& vv) noexcept
+            template <class T, size_t W, std::enable_if_t<W<types::detail::rvv_width_m1, int> = 0> rvv_reg_t<T, W> rvvget_lo(rvv_reg_t<T, W * 2> const& vv) noexcept
             {
                 typename rvv_reg_t<T, W>::register_type tmp = vv;
                 return tmp;
             }
-            template <class T, size_t W, typename std::enable_if<W<types::detail::rvv_width_m1, int>::type = 0> rvv_reg_t<T, W> rvvget_hi(rvv_reg_t<T, W * 2> const& vv) noexcept
+            template <class T, size_t W, std::enable_if_t<W<types::detail::rvv_width_m1, int>::type = 0> reg_t<T, W> rvvget_hi(rvv_reg_t<T, W * 2> const& vv) noexcept
             {
                 return __riscv_vslidedown(vv, vv.vl / 2, vv.vl);
             }
@@ -579,7 +579,7 @@ namespace xsimd
         namespace detail
         {
             template <class T, class U>
-            using rvv_enable_sg_t = typename std::enable_if<(sizeof(T) == sizeof(U) && (sizeof(T) == 4 || sizeof(T) == 8)), int>::type;
+            using rvv_enable_sg_t = std::enable_if_t<(sizeof(T) == sizeof(U) && (sizeof(T) == 4 || sizeof(T) == 8)), int>;
             XSIMD_RVV_OVERLOAD(rvvloxei, (__riscv_vloxei XSIMD_RVV_S), , vec(T const*, uvec))
             XSIMD_RVV_OVERLOAD(rvvsoxei, (__riscv_vsoxei XSIMD_RVV_S), , void(T*, uvec, vec))
             XSIMD_RVV_OVERLOAD3(rvvmul_splat,
@@ -1289,9 +1289,9 @@ namespace xsimd
             XSIMD_RVV_OVERLOAD_INTS(rvvfcvt_f, (__riscv_vfcvt_f), , fvec(vec))
 
             template <class T, class U>
-            using rvv_enable_ftoi_t = typename std::enable_if<(sizeof(T) == sizeof(U) && std::is_floating_point<T>::value && !std::is_floating_point<U>::value), int>::type;
+            using rvv_enable_ftoi_t = std::enable_if_t<(sizeof(T) == sizeof(U) && std::is_floating_point<T>::value && !std::is_floating_point<U>::value), int>;
             template <class T, class U>
-            using rvv_enable_itof_t = typename std::enable_if<(sizeof(T) == sizeof(U) && !std::is_floating_point<T>::value && std::is_floating_point<U>::value), int>::type;
+            using rvv_enable_itof_t = std::enable_if_t<(sizeof(T) == sizeof(U) && !std::is_floating_point<T>::value && std::is_floating_point<U>::value), int>;
 
             template <class A, class T, class U, rvv_enable_ftoi_t<T, U> = 0>
             XSIMD_INLINE batch<U, A> fast_cast(batch<T, A> const& arg, batch<U, A> const&, requires_arch<rvv>) noexcept
diff --git a/include/xsimd/arch/xsimd_scalar.hpp b/include/xsimd/arch/xsimd_scalar.hpp
index f4ffb8c80..6d9f19b31 100644
--- a/include/xsimd/arch/xsimd_scalar.hpp
+++ b/include/xsimd/arch/xsimd_scalar.hpp
@@ -84,14 +84,14 @@ namespace xsimd
     using std::trunc;
 
     template <typename T>
-    XSIMD_INLINE constexpr typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value, T>::type
+    XSIMD_INLINE constexpr std::enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value, T>
     abs(T v) noexcept
     {
         return v < 0 ? -v : v;
     }
 
     template <typename T>
-    XSIMD_INLINE constexpr typename std::enable_if<std::is_integral<T>::value && std::is_unsigned<T>::value, T>::type
+    XSIMD_INLINE constexpr std::enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value, T>
     abs(T v) noexcept
     {
         return v;
@@ -105,42 +105,42 @@ namespace xsimd
 
     // Windows defines catch all templates
     template <class T>
-    XSIMD_INLINE typename std::enable_if<std::is_floating_point<T>::value, bool>::type
+    XSIMD_INLINE std::enable_if_t<std::is_floating_point<T>::value, bool>
     isfinite(T var) noexcept
     {
         return std::isfinite(var);
     }
 
     template <class T>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, bool>::type
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T>::value, bool>
     isfinite(T var) noexcept
     {
         return isfinite(double(var));
     }
 
     template <class T>
-    XSIMD_INLINE typename std::enable_if<std::is_floating_point<T>::value, bool>::type
+    XSIMD_INLINE std::enable_if_t<std::is_floating_point<T>::value, bool>
     isinf(T var) noexcept
     {
         return std::isinf(var);
     }
 
     template <class T>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, bool>::type
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T>::value, bool>
     isinf(T var) noexcept
     {
         return isinf(double(var));
     }
 
     template <class T>
-    XSIMD_INLINE typename std::enable_if<std::is_floating_point<T>::value, bool>::type
+    XSIMD_INLINE std::enable_if_t<std::is_floating_point<T>::value, bool>
     isnan(T var) noexcept
     {
         return std::isnan(var);
     }
 
     template <class T>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, bool>::type
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T>::value, bool>
     isnan(T var) noexcept
     {
         return isnan(double(var));
@@ -148,15 +148,15 @@ namespace xsimd
 #endif
 
     template <class T, class Tp>
-    XSIMD_INLINE typename std::common_type<T, Tp>::type add(T const& x, Tp const& y) noexcept
+    XSIMD_INLINE std::common_type_t<T, Tp> add(T const& x, Tp const& y) noexcept
     {
         return x + y;
     }
 
     template <class T, class Tp>
-    XSIMD_INLINE typename std::common_type<T, Tp>::type avg(T const& x, Tp const& y) noexcept
+    XSIMD_INLINE std::common_type_t<T, Tp> avg(T const& x, Tp const& y) noexcept
     {
-        using common_type = typename std::common_type<T, Tp>::type;
+        using common_type = std::common_type_t<T, Tp>;
         if (std::is_floating_point<common_type>::value)
             return (x + y) / 2;
         else if (std::is_unsigned<common_type>::value)
@@ -168,16 +168,16 @@ namespace xsimd
             // Inspired by
             // https://stackoverflow.com/questions/5697500/take-the-average-of-two-signed-numbers-in-c
             auto t = (x & y) + ((x ^ y) >> 1);
-            auto t_u = static_cast<typename std::make_unsigned<common_type>::type>(t);
+            auto t_u = static_cast<std::make_unsigned_t<common_type>>(t);
             auto avg = t + (static_cast<T>(t_u >> (8 * sizeof(T) - 1)) & (x ^ y));
             return avg;
         }
     }
 
     template <class T, class Tp>
-    XSIMD_INLINE typename std::common_type<T, Tp>::type avgr(T const& x, Tp const& y) noexcept
+    XSIMD_INLINE std::common_type_t<T, Tp> avgr(T const& x, Tp const& y) noexcept
     {
-        using common_type = typename std::common_type<T, Tp>::type;
+        using common_type = std::common_type_t<T, Tp>;
         if (std::is_floating_point<common_type>::value)
             return avg(x, y);
         else
@@ -214,7 +214,7 @@ namespace xsimd
     }
 
     template <class T>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, T>::type
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T>::value, T>
     bitwise_and(T x, T y) noexcept
     {
         return x & y;
@@ -252,14 +252,14 @@ namespace xsimd
     }
 
     template <class T0, class T1>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T0>::value && std::is_integral<T1>::value, T0>::type
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T0>::value && std::is_integral<T1>::value, T0>
     bitwise_lshift(T0 x, T1 shift) noexcept
     {
         return x << shift;
     }
 
     template <size_t shift, class T>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, T>::type
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T>::value, T>
     bitwise_lshift(T x) noexcept
     {
         constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
@@ -268,13 +268,13 @@ namespace xsimd
     }
 
     template <class T0, class T1>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T0>::value && std::is_integral<T1>::value, T0>::type
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T0>::value && std::is_integral<T1>::value, T0>
     bitwise_rshift(T0 x, T1 shift) noexcept
     {
         return x >> shift;
     }
     template <size_t shift, class T>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, T>::type
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T>::value, T>
     bitwise_rshift(T x) noexcept
     {
         constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
@@ -283,7 +283,7 @@ namespace xsimd
     }
 
     template <class T>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, T>::type
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T>::value, T>
     bitwise_not(T x) noexcept
     {
         return ~x;
@@ -315,13 +315,13 @@ namespace xsimd
     }
 
     template <class T>
-    XSIMD_INLINE typename std::enable_if<std::is_scalar<T>::value, T>::type bitwise_andnot(T x, T y) noexcept
+    XSIMD_INLINE std::enable_if_t<std::is_scalar<T>::value, T> bitwise_andnot(T x, T y) noexcept
     {
         return bitwise_and(x, bitwise_not(y));
     }
 
     template <class T>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, T>::type
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T>::value, T>
     bitwise_or(T x, T y) noexcept
     {
         return x | y;
@@ -350,7 +350,7 @@ namespace xsimd
     }
 
     template <class T>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, T>::type
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T>::value, T>
     bitwise_xor(T x, T y) noexcept
     {
         return x ^ y;
@@ -379,19 +379,19 @@ namespace xsimd
     }
 
     template <class T, class Tp>
-    XSIMD_INLINE typename std::common_type<T, Tp>::type div(T const& x, Tp const& y) noexcept
+    XSIMD_INLINE std::common_type_t<T, Tp> div(T const& x, Tp const& y) noexcept
     {
         return x / y;
     }
 
     template <class T, class Tp>
-    XSIMD_INLINE auto mod(T const& x, Tp const& y) noexcept -> decltype(x % y)
+    XSIMD_INLINE auto mod(T const& x, Tp const& y) noexcept
     {
         return x % y;
     }
 
     template <class T, class Tp>
-    XSIMD_INLINE typename std::common_type<T, Tp>::type mul(T const& x, Tp const& y) noexcept
+    XSIMD_INLINE std::common_type_t<T, Tp> mul(T const& x, Tp const& y) noexcept
     {
         return x * y;
     }
@@ -403,7 +403,7 @@ namespace xsimd
     }
 
     template <class T>
-    XSIMD_INLINE auto pos(T const& x) noexcept -> decltype(+x)
+    XSIMD_INLINE auto pos(T const& x) noexcept
     {
         return +x;
     }
@@ -419,14 +419,14 @@ namespace xsimd
     }
 
     template <class T0, class T1>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T0>::value && std::is_integral<T1>::value, T0>::type
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T0>::value && std::is_integral<T1>::value, T0>
     rotl(T0 x, T1 shift) noexcept
     {
         constexpr auto bits = std::numeric_limits<T0>::digits + std::numeric_limits<T0>::is_signed;
         return (x << shift) | (x >> (bits - shift));
     }
     template <size_t count, class T>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, T>::type
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T>::value, T>
     rotl(T x) noexcept
     {
         constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
@@ -435,14 +435,14 @@ namespace xsimd
     }
 
     template <class T0, class T1>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T0>::value && std::is_integral<T1>::value, T0>::type
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T0>::value && std::is_integral<T1>::value, T0>
     rotr(T0 x, T1 shift) noexcept
     {
         constexpr auto bits = std::numeric_limits<T0>::digits + std::numeric_limits<T0>::is_signed;
         return (x >> shift) | (x << (bits - shift));
     }
     template <size_t count, class T>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, T>::type
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T>::value, T>
     rotr(T x) noexcept
     {
         constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
@@ -491,14 +491,14 @@ namespace xsimd
     using xtl::tanh;
 #endif
 
-    template <typename T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+    template <typename T, class = std::enable_if_t<std::is_scalar<T>::value>>
     XSIMD_INLINE T clip(const T& val, const T& low, const T& hi) noexcept
     {
         assert(low <= hi && "ordered clipping bounds");
         return low > val ? low : (hi < val ? hi : val);
     }
 
-    template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+    template <class T, class = std::enable_if_t<std::is_scalar<T>::value>>
     XSIMD_INLINE bool is_flint(const T& x) noexcept
     {
 #ifdef __FAST_MATH__
@@ -508,13 +508,13 @@ namespace xsimd
 #endif
     }
 
-    template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+    template <class T, class = std::enable_if_t<std::is_scalar<T>::value>>
     XSIMD_INLINE bool is_even(const T& x) noexcept
     {
         return is_flint(x * T(0.5));
     }
 
-    template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+    template <class T, class = std::enable_if_t<std::is_scalar<T>::value>>
     XSIMD_INLINE bool is_odd(const T& x) noexcept
     {
         return is_even(x - 1.);
@@ -530,7 +530,7 @@ namespace xsimd
         return static_cast<int64_t>(std::nearbyint(var));
     }
 
-    template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+    template <class T, class = std::enable_if_t<std::is_scalar<T>::value>>
     XSIMD_INLINE bool eq(const T& x0, const T& x1) noexcept
     {
         return x0 == x1;
@@ -542,31 +542,31 @@ namespace xsimd
         return x0 == x1;
     }
 
-    template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+    template <class T, class = std::enable_if_t<std::is_scalar<T>::value>>
     XSIMD_INLINE bool ge(const T& x0, const T& x1) noexcept
     {
         return x0 >= x1;
     }
 
-    template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+    template <class T, class = std::enable_if_t<std::is_scalar<T>::value>>
     XSIMD_INLINE bool gt(const T& x0, const T& x1) noexcept
     {
         return x0 > x1;
     }
 
-    template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+    template <class T, class = std::enable_if_t<std::is_scalar<T>::value>>
     XSIMD_INLINE bool le(const T& x0, const T& x1) noexcept
     {
         return x0 <= x1;
     }
 
-    template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+    template <class T, class = std::enable_if_t<std::is_scalar<T>::value>>
     XSIMD_INLINE bool lt(const T& x0, const T& x1) noexcept
     {
         return x0 < x1;
     }
 
-    template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+    template <class T, class = std::enable_if_t<std::is_scalar<T>::value>>
     XSIMD_INLINE bool neq(const T& x0, const T& x1) noexcept
     {
         return x0 != x1;
@@ -606,7 +606,7 @@ namespace xsimd
         return __builtin_exp10(x);
     }
 #elif defined(_WIN32)
-    template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+    template <class T, class = std::enable_if_t<std::is_scalar<T>::value>>
     XSIMD_INLINE T exp10(const T& x) noexcept
     {
         // Very inefficient but other implementations give incorrect results
@@ -626,8 +626,8 @@ namespace xsimd
     }
 #endif
 
-    template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
-    XSIMD_INLINE auto rsqrt(const T& x) noexcept -> decltype(std::sqrt(x))
+    template <class T, class = std::enable_if_t<std::is_scalar<T>::value>>
+    XSIMD_INLINE auto rsqrt(const T& x) noexcept
     {
         using float_type = decltype(std::sqrt(x));
         return static_cast<float_type>(1) / std::sqrt(x);
@@ -684,7 +684,7 @@ namespace xsimd
         return log(val) / std::log(T(2));
     }
 
-    template <typename T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+    template <typename T, class = std::enable_if_t<std::is_scalar<T>::value>>
     XSIMD_INLINE T sadd(const T& lhs, const T& rhs) noexcept
     {
         if (std::numeric_limits<T>::is_signed)
@@ -715,7 +715,7 @@ namespace xsimd
         }
     }
 
-    template <typename T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+    template <typename T, class = std::enable_if_t<std::is_scalar<T>::value>>
     XSIMD_INLINE T ssub(const T& lhs, const T& rhs) noexcept
     {
         if (std::numeric_limits<T>::is_signed)
@@ -738,7 +738,7 @@ namespace xsimd
     namespace detail
     {
         template <class T0, class T1>
-        XSIMD_INLINE typename std::enable_if<std::is_integral<T1>::value, T0>::type
+        XSIMD_INLINE std::enable_if_t<std::is_integral<T1>::value, T0>
         ipow(const T0& x, const T1& n) noexcept
         {
             static_assert(std::is_integral<T1>::value, "second argument must be an integer");
@@ -764,43 +764,41 @@ namespace xsimd
     }
 
     template <class T0, class T1>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T1>::value, T0>::type
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T1>::value, T0>
     pow(const T0& x, const T1& n) noexcept
     {
         return detail::ipow(x, n);
     }
 
-    template <class T0, class T1>
+    template <class T0, class T1, class = std::enable_if_t<std::is_scalar<T0>::value && std::is_floating_point<T1>::value>>
     XSIMD_INLINE auto
     pow(const T0& t0, const T1& t1) noexcept
-        -> typename std::enable_if<std::is_scalar<T0>::value && std::is_floating_point<T1>::value, decltype(std::pow(t0, t1))>::type
     {
         return std::pow(t0, t1);
     }
 
     template <class T0, class T1>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T1>::value, std::complex<T0>>::type
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T1>::value, std::complex<T0>>
     pow(const std::complex<T0>& t0, const T1& t1) noexcept
     {
         return detail::ipow(t0, t1);
     }
 
     template <class T0, class T1>
-    XSIMD_INLINE typename std::enable_if<!std::is_integral<T1>::value, std::complex<T0>>::type
+    XSIMD_INLINE std::enable_if_t<!std::is_integral<T1>::value, std::complex<T0>>
     pow(const std::complex<T0>& t0, const T1& t1) noexcept
     {
         return std::pow(t0, t1);
     }
 
-    template <class T0, class T1>
+    template <class T0, class T1, class = std::enable_if_t<std::is_scalar<T0>::value>>
     XSIMD_INLINE auto
     pow(const T0& t0, const std::complex<T1>& t1) noexcept
-        -> typename std::enable_if<std::is_scalar<T0>::value, decltype(std::pow(t0, t1))>::type
     {
         return std::pow(t0, t1);
     }
 
-    template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+    template <class T, class = std::enable_if_t<std::is_scalar<T>::value>>
     XSIMD_INLINE T bitofsign(T const& x) noexcept
     {
         return T(x < T(0));
@@ -822,7 +820,7 @@ namespace xsimd
     }
 
     template <class T>
-    XSIMD_INLINE auto signbit(T const& v) noexcept -> decltype(bitofsign(v))
+    XSIMD_INLINE auto signbit(T const& v) noexcept
     {
         return bitofsign(v);
     }
@@ -832,7 +830,7 @@ namespace xsimd
         return v;
     }
 
-    template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+    template <class T, class = std::enable_if_t<std::is_scalar<T>::value>>
     XSIMD_INLINE T sign(const T& v) noexcept
     {
         return v < T(0) ? T(-1.) : v == T(0) ? T(0.)
@@ -875,14 +873,14 @@ namespace xsimd
         return 1;
     }
 
-    template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+    template <class T, class = std::enable_if_t<std::is_scalar<T>::value>>
     XSIMD_INLINE T signnz(const T& v) noexcept
     {
         return v < T(0) ? T(-1.) : T(1.);
     }
 
     template <class T, class Tp>
-    XSIMD_INLINE typename std::common_type<T, Tp>::type sub(T const& x, Tp const& y) noexcept
+    XSIMD_INLINE std::common_type_t<T, Tp> sub(T const& x, Tp const& y) noexcept
     {
         return x - y;
     }
@@ -915,52 +913,48 @@ namespace xsimd
     }
 #endif
 
-    template <class T0, class T1>
+    template <class T0, class T1, class = std::enable_if_t<std::is_scalar<T0>::value && std::is_scalar<T1>::value>>
     XSIMD_INLINE auto min(T0 const& self, T1 const& other) noexcept
-        -> typename std::enable_if<std::is_scalar<T0>::value && std::is_scalar<T1>::value,
-                                   typename std::decay<decltype(self > other ? other : self)>::type>::type
     {
         return self > other ? other : self;
     }
 
     // numpy defines minimum operator on complex using lexical comparison
     template <class T0, class T1>
-    XSIMD_INLINE std::complex<typename std::common_type<T0, T1>::type>
+    XSIMD_INLINE std::complex<std::common_type_t<T0, T1>>
     min(std::complex<T0> const& self, std::complex<T1> const& other) noexcept
     {
         return (self.real() < other.real()) ? (self) : (self.real() == other.real() ? (self.imag() < other.imag() ? self : other) : other);
     }
 
-    template <class T0, class T1>
+    template <class T0, class T1, class = std::enable_if_t<std::is_scalar<T0>::value && std::is_scalar<T1>::value>>
     XSIMD_INLINE auto max(T0 const& self, T1 const& other) noexcept
-        -> typename std::enable_if<std::is_scalar<T0>::value && std::is_scalar<T1>::value,
-                                   typename std::decay<decltype(self > other ? other : self)>::type>::type
     {
         return self < other ? other : self;
     }
 
     // numpy defines maximum operator on complex using lexical comparison
     template <class T0, class T1>
-    XSIMD_INLINE std::complex<typename std::common_type<T0, T1>::type>
+    XSIMD_INLINE std::complex<std::common_type_t<T0, T1>>
     max(std::complex<T0> const& self, std::complex<T1> const& other) noexcept
     {
         return (self.real() > other.real()) ? (self) : (self.real() == other.real() ? (self.imag() > other.imag() ? self : other) : other);
     }
 
     template <class T>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, T>::type fma(const T& a, const T& b, const T& c) noexcept
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T>::value, T> fma(const T& a, const T& b, const T& c) noexcept
     {
         return a * b + c;
     }
 
     template <class T>
-    XSIMD_INLINE typename std::enable_if<std::is_floating_point<T>::value, T>::type fma(const T& a, const T& b, const T& c) noexcept
+    XSIMD_INLINE std::enable_if_t<std::is_floating_point<T>::value, T> fma(const T& a, const T& b, const T& c) noexcept
     {
         return std::fma(a, b, c);
     }
 
     template <class T>
-    XSIMD_INLINE typename std::enable_if<std::is_scalar<T>::value, T>::type fms(const T& a, const T& b, const T& c) noexcept
+    XSIMD_INLINE std::enable_if_t<std::is_scalar<T>::value, T> fms(const T& a, const T& b, const T& c) noexcept
     {
         return a * b - c;
     }
@@ -1014,13 +1008,13 @@ namespace xsimd
 #endif
 
     template <class T>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, T>::type fnma(const T& a, const T& b, const T& c) noexcept
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T>::value, T> fnma(const T& a, const T& b, const T& c) noexcept
     {
         return -(a * b) + c;
     }
 
     template <class T>
-    XSIMD_INLINE typename std::enable_if<std::is_floating_point<T>::value, T>::type fnma(const T& a, const T& b, const T& c) noexcept
+    XSIMD_INLINE std::enable_if_t<std::is_floating_point<T>::value, T> fnma(const T& a, const T& b, const T& c) noexcept
     {
         return std::fma(-a, b, c);
     }
@@ -1050,13 +1044,13 @@ namespace xsimd
 #endif
 
     template <class T>
-    XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, T>::type fnms(const T& a, const T& b, const T& c) noexcept
+    XSIMD_INLINE std::enable_if_t<std::is_integral<T>::value, T> fnms(const T& a, const T& b, const T& c) noexcept
     {
         return -(a * b) - c;
     }
 
     template <class T>
-    XSIMD_INLINE typename std::enable_if<std::is_floating_point<T>::value, T>::type fnms(const T& a, const T& b, const T& c) noexcept
+    XSIMD_INLINE std::enable_if_t<std::is_floating_point<T>::value, T> fnms(const T& a, const T& b, const T& c) noexcept
     {
         return -std::fma(a, b, c);
     }
@@ -1107,21 +1101,21 @@ namespace xsimd
         struct common_sincosf
         {
             template <class T>
-            XSIMD_INLINE typename std::enable_if<XSIMD_HASSINCOS(sincosf, T)>::type
+            XSIMD_INLINE std::enable_if_t<XSIMD_HASSINCOS(sincosf, T)>
             operator()(float val, T& s, T& c)
             {
                 sincosf(val, &s, &c);
             }
 
             template <class T>
-            XSIMD_INLINE typename std::enable_if<!XSIMD_HASSINCOS(sincosf, T) && XSIMD_HASSINCOS(__sincosf, T)>::type
+            XSIMD_INLINE std::enable_if_t<!XSIMD_HASSINCOS(sincosf, T) && XSIMD_HASSINCOS(__sincosf, T)>
             operator()(float val, T& s, T& c)
             {
                 __sincosf(val, &s, &c);
             }
 
             template <class T>
-            XSIMD_INLINE typename std::enable_if<!XSIMD_HASSINCOS(sincosf, T) && !XSIMD_HASSINCOS(__sincosf, T)>::type
+            XSIMD_INLINE std::enable_if_t<!XSIMD_HASSINCOS(sincosf, T) && !XSIMD_HASSINCOS(__sincosf, T)>
             operator()(float val, T& s, T& c)
             {
                 s = std::sin(val);
@@ -1132,21 +1126,21 @@ namespace xsimd
         struct common_sincos
         {
             template <class T>
-            XSIMD_INLINE typename std::enable_if<XSIMD_HASSINCOS(sincos, T)>::type
+            XSIMD_INLINE std::enable_if_t<XSIMD_HASSINCOS(sincos, T)>
             operator()(double val, T& s, T& c)
             {
                 sincos(val, &s, &c);
             }
 
             template <class T>
-            XSIMD_INLINE typename std::enable_if<!XSIMD_HASSINCOS(sincos, T) && XSIMD_HASSINCOS(__sincos, T)>::type
+            XSIMD_INLINE std::enable_if_t<!XSIMD_HASSINCOS(sincos, T) && XSIMD_HASSINCOS(__sincos, T)>
             operator()(double val, T& s, T& c)
             {
                 __sincos(val, &s, &c);
             }
 
             template <class T>
-            XSIMD_INLINE typename std::enable_if<!XSIMD_HASSINCOS(sincos, T) && !XSIMD_HASSINCOS(__sincos, T)>::type
+            XSIMD_INLINE std::enable_if_t<!XSIMD_HASSINCOS(sincos, T) && !XSIMD_HASSINCOS(__sincos, T)>
             operator()(double val, T& s, T& c)
             {
                 s = std::sin(val);
@@ -1187,7 +1181,7 @@ namespace xsimd
     }
 #endif
 
-    template <class T, class = typename std::enable_if<std::is_floating_point<T>::value>::type>
+    template <class T, class = std::enable_if_t<std::is_floating_point<T>::value>>
     XSIMD_INLINE T frexp(T const& val, int& exp) noexcept
     {
         return std::frexp(val, &exp);
diff --git a/include/xsimd/arch/xsimd_sse2.hpp b/include/xsimd/arch/xsimd_sse2.hpp
index 009e39c23..7959c494f 100644
--- a/include/xsimd/arch/xsimd_sse2.hpp
+++ b/include/xsimd/arch/xsimd_sse2.hpp
@@ -81,7 +81,7 @@ namespace xsimd
         }
 
         // add
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> add(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -130,7 +130,7 @@ namespace xsimd
         {
             return _mm_movemask_pd(self) == 0x03;
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE bool all(batch_bool<T, A> const& self, requires_arch<sse2>) noexcept
         {
             return _mm_movemask_epi8(self) == 0xFFFF;
@@ -147,14 +147,14 @@ namespace xsimd
         {
             return _mm_movemask_pd(self) != 0;
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE bool any(batch_bool<T, A> const& self, requires_arch<sse2>) noexcept
         {
             return _mm_movemask_epi8(self) != 0;
         }
 
         // avgr
-        template <class A, class T, class = typename std::enable_if<std::is_unsigned<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_unsigned<T>::value>>
         XSIMD_INLINE batch<T, A> avgr(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -172,7 +172,7 @@ namespace xsimd
         }
 
         // avg
-        template <class A, class T, class = typename std::enable_if<std::is_unsigned<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_unsigned<T>::value>>
         XSIMD_INLINE batch<T, A> avg(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -209,12 +209,12 @@ namespace xsimd
         {
             return _mm_and_ps(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_and(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
         {
             return _mm_and_si128(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> bitwise_and(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<sse2>) noexcept
         {
             return _mm_and_si128(self, other);
@@ -244,12 +244,12 @@ namespace xsimd
         {
             return _mm_andnot_ps(other, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_andnot(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
         {
             return _mm_andnot_si128(other, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<sse2>) noexcept
         {
             return _mm_andnot_si128(other, self);
@@ -268,7 +268,7 @@ namespace xsimd
         }
 
         // bitwise_lshift
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, int32_t other, requires_arch<sse2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -293,7 +293,7 @@ namespace xsimd
                 return {};
             }
         }
-        template <size_t shift, class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <size_t shift, class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, requires_arch<sse2>) noexcept
         {
             constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
@@ -337,12 +337,12 @@ namespace xsimd
         {
             return _mm_xor_ps(self, _mm_castsi128_ps(_mm_set1_epi32(-1)));
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_not(batch<T, A> const& self, requires_arch<sse2>) noexcept
         {
             return _mm_xor_si128(self, _mm_set1_epi32(-1));
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> bitwise_not(batch_bool<T, A> const& self, requires_arch<sse2>) noexcept
         {
             return _mm_xor_si128(self, _mm_set1_epi32(-1));
@@ -369,12 +369,12 @@ namespace xsimd
         {
             return _mm_or_ps(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_or(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
         {
             return _mm_or_si128(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> bitwise_or(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<sse2>) noexcept
         {
             return _mm_or_si128(self, other);
@@ -393,7 +393,7 @@ namespace xsimd
         }
 
         // bitwise_rshift
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, int32_t other, requires_arch<sse2>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -453,7 +453,7 @@ namespace xsimd
                 }
             }
         }
-        template <size_t shift, class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <size_t shift, class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, requires_arch<sse2>) noexcept
         {
             constexpr auto bits = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
@@ -524,7 +524,7 @@ namespace xsimd
         {
             return _mm_xor_ps(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_xor(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
         {
             return _mm_xor_si128(self, other);
@@ -539,29 +539,29 @@ namespace xsimd
         {
             return _mm_xor_pd(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_xor(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<sse2>) noexcept
         {
             return _mm_xor_si128(self, other);
         }
 
         // bitwise_cast
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<float, A> bitwise_cast(batch<T, A> const& self, batch<float, A> const&, requires_arch<sse2>) noexcept
         {
             return _mm_castsi128_ps(self);
         }
-        template <class A, class T, class Tp, class = typename std::enable_if<std::is_integral<typename std::common_type<T, Tp>::type>::value>::type>
+        template <class A, class T, class Tp, class = std::enable_if_t<std::is_integral<std::common_type_t<T, Tp>>::value>>
         XSIMD_INLINE batch<Tp, A> bitwise_cast(batch<T, A> const& self, batch<Tp, A> const&, requires_arch<sse2>) noexcept
         {
             return batch<Tp, A>(self.data);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_cast(batch<float, A> const& self, batch<T, A> const&, requires_arch<sse2>) noexcept
         {
             return _mm_castps_si128(self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<double, A> bitwise_cast(batch<T, A> const& self, batch<double, A> const&, requires_arch<sse2>) noexcept
         {
             return _mm_castsi128_pd(self);
@@ -576,7 +576,7 @@ namespace xsimd
         {
             return _mm_castpd_ps(self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_cast(batch<double, A> const& self, batch<T, A> const&, requires_arch<sse2>) noexcept
         {
             return _mm_castpd_si128(self);
@@ -588,7 +588,7 @@ namespace xsimd
         {
             return _mm_set1_ps(val);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> broadcast(T val, requires_arch<sse2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -648,7 +648,7 @@ namespace xsimd
         }
 
         // decr_if
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> decr_if(batch<T, A> const& self, batch_bool<T, A> const& mask, requires_arch<sse2>) noexcept
         {
             return self + batch<T, A>(mask.data);
@@ -720,7 +720,7 @@ namespace xsimd
         {
             return _mm_castsi128_ps(_mm_cmpeq_epi32(_mm_castps_si128(self), _mm_castps_si128(other)));
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -749,7 +749,7 @@ namespace xsimd
                 return {};
             }
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> eq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<sse2>) noexcept
         {
             return ~(self != other);
@@ -778,7 +778,7 @@ namespace xsimd
             return _mm_cvtsd_f64(self);
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE T first(batch<T, A> const& self, requires_arch<sse2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -849,7 +849,7 @@ namespace xsimd
             assert(!(mask & ~0x3ul) && "inbound mask");
             return _mm_castsi128_pd(_mm_load_si128((const __m128i*)lut[mask]));
         }
-        template <class T, class A, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class T, class A, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> from_mask(batch_bool<T, A> const&, uint64_t mask, requires_arch<sse2>) noexcept
         {
             alignas(A::alignment()) static const uint64_t lut64[] = {
@@ -926,7 +926,7 @@ namespace xsimd
         {
             return _mm_cmpgt_ps(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -982,14 +982,14 @@ namespace xsimd
         }
 
         // incr_if
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> incr_if(batch<T, A> const& self, batch_bool<T, A> const& mask, requires_arch<sse2>) noexcept
         {
             return self - batch<T, A>(mask.data);
         }
 
         // insert
-        template <class A, class T, size_t I, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, size_t I, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> insert(batch<T, A> const& self, T val, index<I> pos, requires_arch<sse2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 2)
@@ -1020,7 +1020,7 @@ namespace xsimd
         {
             return _mm_load_ps(mem);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> load_aligned(T const* mem, convert<T>, requires_arch<sse2>) noexcept
         {
             return _mm_load_si128((__m128i const*)mem);
@@ -1037,7 +1037,7 @@ namespace xsimd
         {
             return _mm_loadu_ps(mem);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> load_unaligned(T const* mem, convert<T>, requires_arch<sse2>) noexcept
         {
             return _mm_loadu_si128((__m128i const*)mem);
@@ -1068,7 +1068,7 @@ namespace xsimd
         }
 
         // load_masked
-        template <class A, class T, bool... Values, class Mode, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, bool... Values, class Mode, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> load_masked(T const* mem, batch_bool_constant<T, A, Values...> mask, Mode, requires_arch<sse2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(mask.mask() == 0x1)
@@ -1209,7 +1209,7 @@ namespace xsimd
         {
             return _mm_cmplt_ps(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> lt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -1314,7 +1314,7 @@ namespace xsimd
         }
 
         // mask
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE uint64_t mask(batch_bool<T, A> const& self, requires_arch<sse2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -1358,7 +1358,7 @@ namespace xsimd
         {
             return _mm_max_ps(other, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
         {
             return select(self > other, self, other);
@@ -1375,7 +1375,7 @@ namespace xsimd
         {
             return _mm_min_ps(other, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
         {
             return select(self <= other, self, other);
@@ -1414,7 +1414,7 @@ namespace xsimd
         }
 
         // neg
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> neg(batch<T, A> const& self, requires_arch<sse2>) noexcept
         {
             return 0 - self;
@@ -1438,7 +1438,7 @@ namespace xsimd
         {
             return _mm_cmpneq_ps(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> neq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
         {
             return ~(self == other);
@@ -1448,7 +1448,7 @@ namespace xsimd
         {
             return _mm_xor_ps(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> neq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<sse2>) noexcept
         {
             return _mm_castps_si128(_mm_xor_ps(_mm_castsi128_ps(self.data), _mm_castsi128_ps(other.data)));
@@ -1482,7 +1482,7 @@ namespace xsimd
             return _mm_cvtss_f32(tmp1);
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE T reduce_add(batch<T, A> const& self, requires_arch<sse2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 4)
@@ -1520,7 +1520,7 @@ namespace xsimd
         }
 
         // reduce_max
-        template <class A, class T, class = typename std::enable_if<(sizeof(T) <= 2)>::type>
+        template <class A, class T, class = std::enable_if_t<(sizeof(T) <= 2)>>
         XSIMD_INLINE T reduce_max(batch<T, A> const& self, requires_arch<sse2>) noexcept
         {
             constexpr auto mask0 = detail::shuffle(2, 3, 0, 0);
@@ -1542,7 +1542,7 @@ namespace xsimd
         }
 
         // reduce_min
-        template <class A, class T, class = typename std::enable_if<(sizeof(T) <= 2)>::type>
+        template <class A, class T, class = std::enable_if_t<(sizeof(T) <= 2)>>
         XSIMD_INLINE T reduce_min(batch<T, A> const& self, requires_arch<sse2>) noexcept
         {
             constexpr auto mask0 = detail::shuffle(2, 3, 0, 0);
@@ -1578,7 +1578,7 @@ namespace xsimd
             return _mm_cvtsd_f64(_mm_mul_sd(self, _mm_unpackhi_pd(self, self)));
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE T reduce_mul(batch<T, A> const& self, requires_arch<sse2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 4)
@@ -1628,12 +1628,12 @@ namespace xsimd
             return _mm_or_ps(_mm_and_ps(cond, true_br), _mm_andnot_ps(cond, false_br));
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<sse2>) noexcept
         {
             return _mm_or_si128(_mm_and_si128(cond, true_br), _mm_andnot_si128(cond, false_br));
         }
-        template <class A, class T, bool... Values, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, bool... Values, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> select(batch_bool_constant<T, A, Values...> const&, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<sse2>) noexcept
         {
             return select(batch_bool<T, A> { Values... }, true_br, false_br, sse2 {});
@@ -1701,7 +1701,7 @@ namespace xsimd
 
         // sadd
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -1744,22 +1744,22 @@ namespace xsimd
             return _mm_setr_ps(values...);
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> set(batch<T, A> const&, requires_arch<sse2>, T v0, T v1) noexcept
         {
             return _mm_set_epi64x(v1, v0);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> set(batch<T, A> const&, requires_arch<sse2>, T v0, T v1, T v2, T v3) noexcept
         {
             return _mm_setr_epi32(v0, v1, v2, v3);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> set(batch<T, A> const&, requires_arch<sse2>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7) noexcept
         {
             return _mm_setr_epi16(v0, v1, v2, v3, v4, v5, v6, v7);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> set(batch<T, A> const&, requires_arch<sse2>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15) noexcept
         {
             return _mm_setr_epi8(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15);
@@ -1772,7 +1772,7 @@ namespace xsimd
             return _mm_setr_pd(values...);
         }
 
-        template <class A, class T, class... Values, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class... Values, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> set(batch_bool<T, A> const&, requires_arch<sse2>, Values... values) noexcept
         {
             return set(batch<T, A>(), A {}, static_cast<T>(values ? -1LL : 0LL)...).data;
@@ -1794,7 +1794,7 @@ namespace xsimd
 
         // ssub
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -1889,12 +1889,12 @@ namespace xsimd
         {
             return _mm_store_ps(mem, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE void store_aligned(T* mem, batch<T, A> const& self, requires_arch<sse2>) noexcept
         {
             return _mm_store_si128((__m128i*)mem, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE void store_aligned(T* mem, batch_bool<T, A> const& self, requires_arch<sse2>) noexcept
         {
             return _mm_store_si128((__m128i*)mem, self);
@@ -1911,12 +1911,12 @@ namespace xsimd
         {
             return _mm_storeu_ps(mem, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE void store_unaligned(T* mem, batch<T, A> const& self, requires_arch<sse2>) noexcept
         {
             return _mm_storeu_si128((__m128i*)mem, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE void store_unaligned(T* mem, batch_bool<T, A> const& self, requires_arch<sse2>) noexcept
         {
             return _mm_storeu_si128((__m128i*)mem, self);
@@ -1933,7 +1933,7 @@ namespace xsimd
         {
             return _mm_sub_ps(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> sub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -2136,7 +2136,7 @@ namespace xsimd
         {
             return _mm_unpackhi_ps(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> zip_hi(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -2173,7 +2173,7 @@ namespace xsimd
         {
             return _mm_unpacklo_ps(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> zip_lo(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse2>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
diff --git a/include/xsimd/arch/xsimd_sse3.hpp b/include/xsimd/arch/xsimd_sse3.hpp
index 3e7cf9619..3ece0ae3b 100644
--- a/include/xsimd/arch/xsimd_sse3.hpp
+++ b/include/xsimd/arch/xsimd_sse3.hpp
@@ -36,7 +36,7 @@ namespace xsimd
         }
 
         // load_unaligned
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> load_unaligned(T const* mem, convert<T>, requires_arch<sse3>) noexcept
         {
             return _mm_lddqu_si128((__m128i const*)mem);
diff --git a/include/xsimd/arch/xsimd_sse4_1.hpp b/include/xsimd/arch/xsimd_sse4_1.hpp
index 1a64fc878..030fb29db 100644
--- a/include/xsimd/arch/xsimd_sse4_1.hpp
+++ b/include/xsimd/arch/xsimd_sse4_1.hpp
@@ -24,7 +24,7 @@ namespace xsimd
     {
         using namespace types;
         // any
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE bool any(batch<T, A> const& self, requires_arch<sse4_1>) noexcept
         {
             return !_mm_testz_si128(self, self);
@@ -69,7 +69,7 @@ namespace xsimd
         }
 
         // eq
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse4_1>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 8)
@@ -95,7 +95,7 @@ namespace xsimd
         }
 
         // insert
-        template <class A, class T, size_t I, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, size_t I, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> insert(batch<T, A> const& self, T val, index<I> pos, requires_arch<sse4_1>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -125,7 +125,7 @@ namespace xsimd
 
         // load_unaligned<batch_bool>
 
-        template <class A, class T, class = typename std::enable_if<(std::is_integral<T>::value && sizeof(T) > 1)>::type>
+        template <class A, class T, class = std::enable_if_t<(std::is_integral<T>::value && sizeof(T) > 1)>>
         XSIMD_INLINE batch_bool<T, A> load_unaligned(bool const* mem, batch_bool<T, A>, requires_arch<sse4_1>) noexcept
         {
             // GCC <12 have missing or buggy unaligned load intrinsics; use memcpy to work around this.
@@ -174,7 +174,7 @@ namespace xsimd
         }
 
         // max
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse4_1>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -218,7 +218,7 @@ namespace xsimd
         }
 
         // min
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse4_1>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -262,7 +262,7 @@ namespace xsimd
         }
 
         // mul
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse4_1>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -318,7 +318,7 @@ namespace xsimd
             }
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<sse4_1>) noexcept
         {
             return _mm_blendv_epi8(false_br, true_br, cond);
@@ -334,7 +334,7 @@ namespace xsimd
             return _mm_blendv_pd(false_br, true_br, cond);
         }
 
-        template <class A, class T, bool... Values, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, bool... Values, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> select(batch_bool_constant<T, A, Values...> const&, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<sse4_1>) noexcept
         {
             constexpr int mask = batch_bool_constant<T, A, Values...>::mask();
diff --git a/include/xsimd/arch/xsimd_ssse3.hpp b/include/xsimd/arch/xsimd_ssse3.hpp
index b86f08a2c..85e03288d 100644
--- a/include/xsimd/arch/xsimd_ssse3.hpp
+++ b/include/xsimd/arch/xsimd_ssse3.hpp
@@ -26,7 +26,7 @@ namespace xsimd
         using namespace types;
 
         // abs
-        template <class A, class T, typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value>::type>
+        template <class A, class T, std::enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value>>
         XSIMD_INLINE batch<T, A> abs(batch<T, A> const& self, requires_arch<ssse3>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -57,33 +57,33 @@ namespace xsimd
         {
 
             template <class T, class A>
-            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const&, batch<T, A> const& other, std::size_t, ::xsimd::detail::index_sequence<>) noexcept
+            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const&, batch<T, A> const& other, std::size_t, std::index_sequence<>) noexcept
             {
                 return other;
             }
 
             template <class T, class A, std::size_t I, std::size_t... Is>
-            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& self, batch<T, A> const& other, std::size_t i, ::xsimd::detail::index_sequence<I, Is...>) noexcept
+            XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& self, batch<T, A> const& other, std::size_t i, std::index_sequence<I, Is...>) noexcept
             {
                 if (i == I)
                 {
                     return _mm_alignr_epi8(self, other, sizeof(T) * I);
                 }
                 else
-                    return extract_pair(self, other, i, ::xsimd::detail::index_sequence<Is...>());
+                    return extract_pair(self, other, i, std::index_sequence<Is...>());
             }
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& self, batch<T, A> const& other, std::size_t i, requires_arch<ssse3>) noexcept
         {
             constexpr std::size_t size = batch<T, A>::size;
             assert(i < size && "index in bounds");
-            return detail::extract_pair(self, other, i, ::xsimd::detail::make_index_sequence<size>());
+            return detail::extract_pair(self, other, i, std::make_index_sequence<size>());
         }
 
         // reduce_add
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE T reduce_add(batch<T, A> const& self, requires_arch<ssse3>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 2)
@@ -141,7 +141,7 @@ namespace xsimd
         }
 
         template <class A, class T, class IT>
-        XSIMD_INLINE typename std::enable_if<std::is_arithmetic<T>::value, batch<T, A>>::type
+        XSIMD_INLINE std::enable_if_t<std::is_arithmetic<T>::value, batch<T, A>>
         swizzle(batch<T, A> const& self, batch<IT, A> mask, requires_arch<ssse3>) noexcept
         {
             constexpr auto pikes = static_cast<as_unsigned_integer_t<T>>(0x0706050403020100ul);
diff --git a/include/xsimd/arch/xsimd_sve.hpp b/include/xsimd/arch/xsimd_sve.hpp
index 4d81311f0..4a45e09aa 100644
--- a/include/xsimd/arch/xsimd_sve.hpp
+++ b/include/xsimd/arch/xsimd_sve.hpp
@@ -61,23 +61,23 @@ namespace xsimd
 
             // enable for signed integers
             template <class T>
-            using sve_enable_signed_int_t = typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value, int>::type;
+            using sve_enable_signed_int_t = std::enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value, int>;
 
             // enable for unsigned integers
             template <class T>
-            using sve_enable_unsigned_int_t = typename std::enable_if<std::is_integral<T>::value && !std::is_signed<T>::value, int>::type;
+            using sve_enable_unsigned_int_t = std::enable_if_t<std::is_integral<T>::value && !std::is_signed<T>::value, int>;
 
             // enable for floating points
             template <class T>
-            using sve_enable_floating_point_t = typename std::enable_if<std::is_floating_point<T>::value, int>::type;
+            using sve_enable_floating_point_t = std::enable_if_t<std::is_floating_point<T>::value, int>;
 
             // enable for signed integers or floating points
             template <class T>
-            using sve_enable_signed_int_or_floating_point_t = typename std::enable_if<std::is_signed<T>::value, int>::type;
+            using sve_enable_signed_int_or_floating_point_t = std::enable_if_t<std::is_signed<T>::value, int>;
 
             // enable for all SVE supported types
             template <class T>
-            using sve_enable_all_t = typename std::enable_if<std::is_arithmetic<T>::value, int>::type;
+            using sve_enable_all_t = std::enable_if_t<std::is_arithmetic<T>::value, int>;
         } // namespace detail
 
         /*********
@@ -87,11 +87,11 @@ namespace xsimd
         namespace detail
         {
             // "char" is not allowed in SVE load/store operations
-            using sve_fix_char_t_impl = typename std::conditional<std::is_signed<char>::value, int8_t, uint8_t>::type;
+            using sve_fix_char_t_impl = std::conditional_t<std::is_signed<char>::value, int8_t, uint8_t>;
 
             template <class T>
-            using sve_fix_char_t = typename std::conditional<std::is_same<char, typename std::decay<T>::type>::value,
-                                                             sve_fix_char_t_impl, T>::type;
+            using sve_fix_char_t = std::conditional_t<std::is_same<char, std::decay_t<T>>::value,
+                                                      sve_fix_char_t_impl, T>;
         }
 
         template <class A, class T, detail::sve_enable_all_t<T> = 0>
@@ -150,7 +150,7 @@ namespace xsimd
         template <class A, class T, detail::sve_enable_floating_point_t<T> = 0>
         XSIMD_INLINE void store_complex_aligned(std::complex<T>* dst, batch<std::complex<T>, A> const& src, requires_arch<sve>) noexcept
         {
-            using v2type = typename std::conditional<(sizeof(T) == 4), svfloat32x2_t, svfloat64x2_t>::type;
+            using v2type = std::conditional_t<(sizeof(T) == 4), svfloat32x2_t, svfloat64x2_t>;
             v2type tmp {};
             tmp = svset2(tmp, 0, src.real());
             tmp = svset2(tmp, 1, src.imag());
@@ -171,7 +171,7 @@ namespace xsimd
         namespace detail
         {
             template <class T, class U>
-            using sve_enable_sg_t = typename std::enable_if<(sizeof(T) == sizeof(U) && (sizeof(T) == 4 || sizeof(T) == 8)), int>::type;
+            using sve_enable_sg_t = std::enable_if_t<(sizeof(T) == sizeof(U) && (sizeof(T) == 4 || sizeof(T) == 8)), int>;
         }
 
         // scatter
@@ -299,7 +299,7 @@ namespace xsimd
         }
 
         // div
-        template <class A, class T, typename std::enable_if<sizeof(T) >= 4, int>::type = 0>
+        template <class A, class T, std::enable_if_t<sizeof(T) >= 4, int> = 0>
         XSIMD_INLINE batch<T, A> div(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return svdiv_x(detail::sve_ptrue<T>(), lhs, rhs);
@@ -780,14 +780,14 @@ namespace xsimd
         namespace detail
         {
             template <class A, class T>
-            XSIMD_INLINE batch<T, A> sve_extract_pair(batch<T, A> const&, batch<T, A> const& /*rhs*/, std::size_t, ::xsimd::detail::index_sequence<>) noexcept
+            XSIMD_INLINE batch<T, A> sve_extract_pair(batch<T, A> const&, batch<T, A> const& /*rhs*/, std::size_t, std::index_sequence<>) noexcept
             {
                 assert(false && "extract_pair out of bounds");
                 return batch<T, A> {};
             }
 
             template <class A, class T, size_t I, size_t... Is>
-            XSIMD_INLINE batch<T, A> sve_extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<I, Is...>) noexcept
+            XSIMD_INLINE batch<T, A> sve_extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<I, Is...>) noexcept
             {
                 if (n == I)
                 {
@@ -795,12 +795,12 @@ namespace xsimd
                 }
                 else
                 {
-                    return sve_extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
+                    return sve_extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
                 }
             }
 
             template <class A, class T, size_t... Is>
-            XSIMD_INLINE batch<T, A> sve_extract_pair_impl(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, ::xsimd::detail::index_sequence<0, Is...>) noexcept
+            XSIMD_INLINE batch<T, A> sve_extract_pair_impl(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, std::index_sequence<0, Is...>) noexcept
             {
                 if (n == 0)
                 {
@@ -808,7 +808,7 @@ namespace xsimd
                 }
                 else
                 {
-                    return sve_extract_pair(lhs, rhs, n, ::xsimd::detail::index_sequence<Is...>());
+                    return sve_extract_pair(lhs, rhs, n, std::index_sequence<Is...>());
                 }
             }
         }
@@ -818,7 +818,7 @@ namespace xsimd
         {
             constexpr std::size_t size = batch<T, A>::size;
             assert(n < size && "index in bounds");
-            return detail::sve_extract_pair_impl(lhs, rhs, n, ::xsimd::detail::make_index_sequence<size>());
+            return detail::sve_extract_pair_impl(lhs, rhs, n, std::make_index_sequence<size>());
         }
 
         // select
diff --git a/include/xsimd/arch/xsimd_vsx.hpp b/include/xsimd/arch/xsimd_vsx.hpp
index 1ed91e0df..c07d3eab7 100644
--- a/include/xsimd/arch/xsimd_vsx.hpp
+++ b/include/xsimd/arch/xsimd_vsx.hpp
@@ -53,28 +53,28 @@ namespace xsimd
         }
 
         // add
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> add(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_add(self.data, other.data);
         }
 
         // all
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE bool all(batch_bool<T, A> const& self, requires_arch<vsx>) noexcept
         {
             return vec_all_ne(self.data, vec_xor(self.data, self.data));
         }
 
         // any
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE bool any(batch_bool<T, A> const& self, requires_arch<vsx>) noexcept
         {
             return vec_any_ne(self.data, vec_xor(self.data, self.data));
         }
 
         // avgr
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value && sizeof(T) < 8>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value && sizeof(T) < 8>>
         XSIMD_INLINE batch<T, A> avgr(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_avg(self.data, other.data);
@@ -91,7 +91,7 @@ namespace xsimd
         }
 
         // avg
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> avg(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) < 8)
@@ -124,31 +124,31 @@ namespace xsimd
         }
 
         // bitwise_and
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_and(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_and(self.data, other.data);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch_bool<T, A> bitwise_and(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_and(self.data, other.data);
         }
 
         // bitwise_andnot
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_andnot(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_and(self.data, vec_nor(other.data, other.data));
         }
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return self.data & ~other.data;
         }
 
         // bitwise_lshift
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, int32_t other, requires_arch<vsx>) noexcept
         {
             using shift_type = as_unsigned_integer_t<T>;
@@ -157,31 +157,31 @@ namespace xsimd
         }
 
         // bitwise_not
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_not(batch<T, A> const& self, requires_arch<vsx>) noexcept
         {
             return vec_nor(self.data, self.data);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch_bool<T, A> bitwise_not(batch_bool<T, A> const& self, requires_arch<vsx>) noexcept
         {
             return vec_nor(self.data, self.data);
         }
 
         // bitwise_or
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_or(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_or(self.data, other.data);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch_bool<T, A> bitwise_or(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_or(self.data, other.data);
         }
 
         // bitwise_rshift
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, int32_t other, requires_arch<vsx>) noexcept
         {
             using shift_type = as_unsigned_integer_t<T>;
@@ -197,12 +197,12 @@ namespace xsimd
         }
 
         // bitwise_xor
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_xor(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_xor(self.data, other.data);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch_bool<T, A> bitwise_xor(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_xor(self.data, other.data);
@@ -216,14 +216,14 @@ namespace xsimd
         }
 
         // broadcast
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> broadcast(T val, requires_arch<vsx>) noexcept
         {
             return vec_splats(val);
         }
 
         // ceil
-        template <class A, class T, class = typename std::enable_if<std::is_floating_point<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_floating_point<T>::value>>
         XSIMD_INLINE batch<T, A> ceil(batch<T, A> const& self, requires_arch<vsx>) noexcept
         {
             return vec_ceil(self.data);
@@ -257,7 +257,7 @@ namespace xsimd
         }
 
         // decr_if
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> decr_if(batch<T, A> const& self, batch_bool<T, A> const& mask, requires_arch<vsx>) noexcept
         {
             return self + batch<T, A>((typename batch<T, A>::register_type)mask.data);
@@ -329,13 +329,13 @@ namespace xsimd
         }
 
         // eq
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             auto res = vec_cmpeq(self.data, other.data);
             return *reinterpret_cast<typename batch_bool<T, A>::register_type*>(&res);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch_bool<T, A> eq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<vsx>) noexcept
         {
             auto res = vec_cmpeq(self.data, other.data);
@@ -343,28 +343,28 @@ namespace xsimd
         }
 
         // first
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE T first(batch<T, A> const& self, requires_arch<vsx>) noexcept
         {
             return vec_extract(self.data, 0);
         }
 
         // floor
-        template <class A, class T, class = typename std::enable_if<std::is_floating_point<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_floating_point<T>::value>>
         XSIMD_INLINE batch<T, A> floor(batch<T, A> const& self, requires_arch<vsx>) noexcept
         {
             return vec_floor(self.data);
         }
 
         // ge
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch_bool<T, A> ge(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_cmpge(self.data, other.data);
         }
 
         // gt
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_cmpgt(self.data, other.data);
@@ -397,14 +397,14 @@ namespace xsimd
         }
 
         // incr_if
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> incr_if(batch<T, A> const& self, batch_bool<T, A> const& mask, requires_arch<vsx>) noexcept
         {
             return self - batch<T, A>((typename batch<T, A>::register_type)mask.data);
         }
 
         // insert
-        template <class A, class T, size_t I, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, size_t I, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> insert(batch<T, A> const& self, T val, index<I>, requires_arch<vsx>) noexcept
         {
             return vec_insert(val, self.data, I);
@@ -423,14 +423,14 @@ namespace xsimd
         }
 
         // load_aligned
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> load_aligned(T const* mem, convert<T>, requires_arch<vsx>) noexcept
         {
             return vec_ld(0, reinterpret_cast<const typename batch<T, A>::register_type*>(mem));
         }
 
         // load_unaligned
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> load_unaligned(T const* mem, convert<T>, requires_arch<vsx>) noexcept
         {
             return vec_vsx_ld(0, (typename batch<T, A>::register_type const*)mem);
@@ -454,54 +454,54 @@ namespace xsimd
         }
 
         // le
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch_bool<T, A> le(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_cmple(self.data, other.data);
         }
 
         // lt
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch_bool<T, A> lt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_cmplt(self.data, other.data);
         }
 
         // max
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_max(self.data, other.data);
         }
 
         // min
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_min(self.data, other.data);
         }
 
         // mul
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> mul(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return self.data * other.data;
         }
 
         // neg
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> neg(batch<T, A> const& self, requires_arch<vsx>) noexcept
         {
             return -(self.data);
         }
 
         // neq
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch_bool<T, A> neq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return ~vec_cmpeq(self.data, other.data);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch_bool<T, A> neq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return ~vec_cmpeq(self.data, other.data);
@@ -557,7 +557,7 @@ namespace xsimd
             auto tmp1 = vec_add(self.data, tmp0); // v0 + v1, v1 + v0
             return vec_extract(tmp1, 0);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE T reduce_add(batch<T, A> const& self, requires_arch<vsx>) noexcept
         {
             return reduce_add(self, common {});
@@ -599,14 +599,14 @@ namespace xsimd
             auto tmp1 = vec_mul(self.data, tmp0); // v0 * v1, v1 * v0
             return vec_extract(tmp1, 0);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE T reduce_mul(batch<T, A> const& self, requires_arch<vsx>) noexcept
         {
             return reduce_mul(self, common {});
         }
 
         // round
-        template <class A, class T, class = typename std::enable_if<std::is_floating_point<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_floating_point<T>::value>>
         XSIMD_INLINE batch<T, A> round(batch<T, A> const& self, requires_arch<vsx>) noexcept
         {
             return vec_round(self.data);
@@ -625,12 +625,12 @@ namespace xsimd
         }
 
         // select
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<vsx>) noexcept
         {
             return vec_sel(false_br.data, true_br.data, cond.data);
         }
-        template <class A, class T, bool... Values, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, bool... Values, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> select(batch_bool_constant<T, A, Values...> const&, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<vsx>) noexcept
         {
             return select(batch_bool<T, A> { Values... }, true_br, false_br, vsx {});
@@ -716,7 +716,7 @@ namespace xsimd
         }
 
         // sadd
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value && sizeof(T) != 8>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value && sizeof(T) != 8>>
         XSIMD_INLINE batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_adds(self.data, other.data);
@@ -730,7 +730,7 @@ namespace xsimd
             return typename batch<T, A>::register_type { values... };
         }
 
-        template <class A, class T, class... Values, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class... Values, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch_bool<T, A> set(batch_bool<T, A> const&, requires_arch<vsx>, Values... values) noexcept
         {
             static_assert(sizeof...(Values) == batch_bool<T, A>::size, "consistent init");
@@ -739,28 +739,28 @@ namespace xsimd
 
         // ssub
 
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value && sizeof(T) == 1>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value && sizeof(T) == 1>>
         XSIMD_INLINE batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_subs(self.data, other.data);
         }
 
         // store_aligned
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE void store_aligned(T* mem, batch<T, A> const& self, requires_arch<vsx>) noexcept
         {
             return vec_st(self.data, 0, reinterpret_cast<typename batch<T, A>::register_type*>(mem));
         }
 
         // store_unaligned
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE void store_unaligned(T* mem, batch<T, A> const& self, requires_arch<vsx>) noexcept
         {
             return vec_vsx_st(self.data, 0, reinterpret_cast<typename batch<T, A>::register_type*>(mem));
         }
 
         // sub
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> sub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_sub(self.data, other.data);
@@ -868,7 +868,7 @@ namespace xsimd
         }
 
         // trunc
-        template <class A, class T, class = typename std::enable_if<std::is_floating_point<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_floating_point<T>::value>>
         XSIMD_INLINE batch<T, A> trunc(batch<T, A> const& self, requires_arch<vsx>) noexcept
         {
             return vec_trunc(self.data);
@@ -880,7 +880,7 @@ namespace xsimd
         {
             return { batch<double, A>(vec_doublel(x.data)), batch<double, A>(vec_doubleh(x.data)) };
         }
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE std::array<batch<widen_t<T>, A>, 2> widen(batch<T, A> const& x, requires_arch<vsx>) noexcept
         {
             auto even = vec_mule(x.data, vec_splats(T(1))); // x0, x2, x4, x6
@@ -889,14 +889,14 @@ namespace xsimd
         }
 
         // zip_hi
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> zip_hi(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_mergel(self.data, other.data);
         }
 
         // zip_lo
-        template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_scalar<T>::value>>
         XSIMD_INLINE batch<T, A> zip_lo(batch<T, A> const& self, batch<T, A> const& other, requires_arch<vsx>) noexcept
         {
             return vec_mergeh(self.data, other.data);
diff --git a/include/xsimd/arch/xsimd_wasm.hpp b/include/xsimd/arch/xsimd_wasm.hpp
index 1d415f448..9e437dfb1 100644
--- a/include/xsimd/arch/xsimd_wasm.hpp
+++ b/include/xsimd/arch/xsimd_wasm.hpp
@@ -44,7 +44,7 @@ namespace xsimd
         XSIMD_INLINE void transpose(batch<T, A>* matrix_begin, batch<T, A>* matrix_end, requires_arch<common>) noexcept;
 
         // abs
-        template <class A, class T, typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value>::type>
+        template <class A, class T, std::enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value>>
         XSIMD_INLINE batch<T, A> abs(batch<T, A> const& self, requires_arch<wasm>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -83,7 +83,7 @@ namespace xsimd
         }
 
         // add
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> add(batch<T, A> const& self, batch<T, A> const& other, requires_arch<wasm>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -122,7 +122,7 @@ namespace xsimd
         }
 
         // avgr
-        template <class A, class T, class = typename std::enable_if<std::is_unsigned<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_unsigned<T>::value>>
         XSIMD_INLINE batch<T, A> avgr(batch<T, A> const& self, batch<T, A> const& other, requires_arch<wasm>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -140,7 +140,7 @@ namespace xsimd
         }
 
         // avg
-        template <class A, class T, class = typename std::enable_if<std::is_unsigned<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_unsigned<T>::value>>
         XSIMD_INLINE batch<T, A> avg(batch<T, A> const& self, batch<T, A> const& other, requires_arch<wasm>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -170,7 +170,7 @@ namespace xsimd
         {
             return wasm_i64x2_bitmask(self) == 0x03;
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE bool all(batch_bool<T, A> const& self, requires_arch<wasm>) noexcept
         {
             return wasm_i8x16_bitmask(self) == 0xFFFF;
@@ -187,7 +187,7 @@ namespace xsimd
         {
             return wasm_i64x2_bitmask(self) != 0;
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE bool any(batch_bool<T, A> const& self, requires_arch<wasm>) noexcept
         {
             return wasm_i8x16_bitmask(self) != 0;
@@ -247,7 +247,7 @@ namespace xsimd
         }
 
         // bitwise_lshift
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, int32_t other, requires_arch<wasm>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -274,7 +274,7 @@ namespace xsimd
         }
 
         // bitwise_rshift
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, int32_t other, requires_arch<wasm>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -359,7 +359,7 @@ namespace xsimd
         {
             return wasm_f32x4_splat(val);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> broadcast(T val, requires_arch<wasm>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -425,7 +425,7 @@ namespace xsimd
         {
             return wasm_i32x4_eq(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<wasm>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -450,7 +450,7 @@ namespace xsimd
                 return {};
             }
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> eq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<wasm>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -538,7 +538,7 @@ namespace xsimd
         {
             return wasm_f32x4_extract_lane(self, 0);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE T first(batch<T, A> const& self, requires_arch<wasm>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -619,7 +619,7 @@ namespace xsimd
             assert(!(mask & ~0x3ul) && "inbound mask");
             return wasm_v128_load((const v128_t*)lut[mask]);
         }
-        template <class T, class A, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class T, class A, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> from_mask(batch_bool<T, A> const&, uint64_t mask, requires_arch<wasm>) noexcept
         {
             alignas(A::alignment()) static const uint64_t lut64[] = {
@@ -722,7 +722,7 @@ namespace xsimd
         {
             return wasm_f32x4_gt(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<wasm>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -803,7 +803,7 @@ namespace xsimd
         {
             return wasm_f32x4_replace_lane(self, pos, val);
         }
-        template <class A, class T, size_t I, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, size_t I, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> insert(batch<T, A> const& self, T val, index<I> pos, requires_arch<wasm>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -892,7 +892,7 @@ namespace xsimd
         {
             return wasm_v128_load(mem);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> load_aligned(T const* mem, convert<T>, requires_arch<wasm>) noexcept
         {
             return wasm_v128_load((v128_t const*)mem);
@@ -924,7 +924,7 @@ namespace xsimd
         {
             return wasm_v128_load(mem);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> load_unaligned(T const* mem, convert<T>, requires_arch<wasm>) noexcept
         {
             return wasm_v128_load((v128_t const*)mem);
@@ -941,7 +941,7 @@ namespace xsimd
         {
             return wasm_f32x4_lt(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> lt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<wasm>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -1009,7 +1009,7 @@ namespace xsimd
         }
 
         // mask
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE uint64_t mask(batch_bool<T, A> const& self, requires_arch<wasm>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -1052,7 +1052,7 @@ namespace xsimd
         {
             return wasm_f32x4_pmax(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> max(batch<T, A> const& self, batch<T, A> const& other, requires_arch<wasm>) noexcept
         {
             return select(self > other, self, other);
@@ -1069,7 +1069,7 @@ namespace xsimd
         {
             return wasm_f32x4_pmin(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> min(batch<T, A> const& self, batch<T, A> const& other, requires_arch<wasm>) noexcept
         {
             return select(self <= other, self, other);
@@ -1093,7 +1093,7 @@ namespace xsimd
         }
 
         // neg
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> neg(batch<T, A> const& self, requires_arch<wasm>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -1137,7 +1137,7 @@ namespace xsimd
         {
             return wasm_f32x4_ne(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> neq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<wasm>) noexcept
         {
             return ~(self == other);
@@ -1147,7 +1147,7 @@ namespace xsimd
         {
             return wasm_v128_xor(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> neq(batch_bool<T, A> const& self, batch_bool<T, A> const& other, requires_arch<wasm>) noexcept
         {
             return ~(self == other);
@@ -1188,7 +1188,7 @@ namespace xsimd
             v128_t tmp3 = wasm_i32x4_shuffle(tmp0, tmp2, 4, 1, 2, 3);
             return wasm_f32x4_extract_lane(tmp3, 0);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE T reduce_add(batch<T, A> const& self, requires_arch<wasm>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 4)
@@ -1229,7 +1229,7 @@ namespace xsimd
             v128_t tmp3 = wasm_i32x4_shuffle(tmp0, tmp2, 4, 1, 2, 3);
             return wasm_f32x4_extract_lane(tmp3, 0);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE T reduce_mul(batch<T, A> const& self, requires_arch<wasm>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 4)
@@ -1307,7 +1307,7 @@ namespace xsimd
         }
 
         // sadd
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<wasm>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -1349,12 +1349,12 @@ namespace xsimd
             return wasm_v128_or(wasm_v128_and(cond, true_br), wasm_v128_andnot(false_br, cond));
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<wasm>) noexcept
         {
             return wasm_v128_or(wasm_v128_and(cond, true_br), wasm_v128_andnot(false_br, cond));
         }
-        template <class A, class T, bool... Values, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, bool... Values, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> select(batch_bool_constant<T, A, Values...> const&, batch<T, A> const& true_br, batch<T, A> const& false_br, requires_arch<wasm>) noexcept
         {
             return select(batch_bool<T, A> { Values... }, true_br, false_br, wasm {});
@@ -1386,25 +1386,25 @@ namespace xsimd
             return wasm_f32x4_make(values...);
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> set(batch<T, A> const&, requires_arch<wasm>, T v0, T v1) noexcept
         {
             return wasm_i64x2_make(v0, v1);
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> set(batch<T, A> const&, requires_arch<wasm>, T v0, T v1, T v2, T v3) noexcept
         {
             return wasm_i32x4_make(v0, v1, v2, v3);
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> set(batch<T, A> const&, requires_arch<wasm>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7) noexcept
         {
             return wasm_i16x8_make(v0, v1, v2, v3, v4, v5, v6, v7);
         }
 
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> set(batch<T, A> const&, requires_arch<wasm>, T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15) noexcept
         {
             return wasm_i8x16_make(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15);
@@ -1417,7 +1417,7 @@ namespace xsimd
             return wasm_f64x2_make(values...);
         }
 
-        template <class A, class T, class... Values, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class... Values, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch_bool<T, A> set(batch_bool<T, A> const&, requires_arch<wasm>, Values... values) noexcept
         {
             return set(batch<T, A>(), A {}, static_cast<T>(values ? -1LL : 0LL)...).data;
@@ -1438,7 +1438,7 @@ namespace xsimd
         }
 
         // ssub
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<wasm>) noexcept
         {
             if (std::is_signed<T>::value)
@@ -1479,12 +1479,12 @@ namespace xsimd
         {
             return wasm_v128_store(mem, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE void store_aligned(T* mem, batch<T, A> const& self, requires_arch<wasm>) noexcept
         {
             return wasm_v128_store((v128_t*)mem, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE void store_aligned(T* mem, batch_bool<T, A> const& self, requires_arch<wasm>) noexcept
         {
             return wasm_v128_store((v128_t*)mem, self);
@@ -1528,12 +1528,12 @@ namespace xsimd
         {
             return wasm_v128_store(mem, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE void store_unaligned(T* mem, batch<T, A> const& self, requires_arch<wasm>) noexcept
         {
             return wasm_v128_store((v128_t*)mem, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE void store_unaligned(T* mem, batch_bool<T, A> const& self, requires_arch<wasm>) noexcept
         {
             return wasm_v128_store((v128_t*)mem, self);
@@ -1550,7 +1550,7 @@ namespace xsimd
         {
             return wasm_f32x4_sub(self, other);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> sub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<wasm>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -1746,7 +1746,7 @@ namespace xsimd
         {
             return wasm_i32x4_shuffle(self, other, 2, 6, 3, 7);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> zip_hi(batch<T, A> const& self, batch<T, A> const& other, requires_arch<wasm>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
@@ -1783,7 +1783,7 @@ namespace xsimd
         {
             return wasm_i32x4_shuffle(self, other, 0, 4, 1, 5);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value>>
         XSIMD_INLINE batch<T, A> zip_lo(batch<T, A> const& self, batch<T, A> const& other, requires_arch<wasm>) noexcept
         {
             XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
diff --git a/include/xsimd/config/xsimd_arch.hpp b/include/xsimd/config/xsimd_arch.hpp
index ddd78e13d..d69ff7560 100644
--- a/include/xsimd/config/xsimd_arch.hpp
+++ b/include/xsimd/config/xsimd_arch.hpp
@@ -133,8 +133,8 @@ namespace xsimd
         template <class L, class Arch, class... Archs>
         struct supported_helper<L, arch_list<Arch, Archs...>>
             : supported_helper<
-                  typename std::conditional<Arch::supported(),
-                                            typename L::template add<Arch>, L>::type,
+                  std::conditional_t<Arch::supported(),
+                                     typename L::template add<Arch>, L>,
                   arch_list<Archs...>>
         {
         };
@@ -198,14 +198,14 @@ namespace xsimd
             F functor;
 
             template <class Arch, class... Tys>
-            XSIMD_INLINE auto walk_archs(arch_list<Arch>, Tys&&... args) noexcept -> decltype(functor(Arch {}, std::forward<Tys>(args)...))
+            XSIMD_INLINE auto walk_archs(arch_list<Arch>, Tys&&... args) noexcept
             {
                 assert(Arch::available() && "At least one arch must be supported during dispatch");
                 return functor(Arch {}, std::forward<Tys>(args)...);
             }
 
             template <class Arch, class ArchNext, class... Archs, class... Tys>
-            XSIMD_INLINE auto walk_archs(arch_list<Arch, ArchNext, Archs...>, Tys&&... args) noexcept -> decltype(functor(Arch {}, std::forward<Tys>(args)...))
+            XSIMD_INLINE auto walk_archs(arch_list<Arch, ArchNext, Archs...>, Tys&&... args) noexcept
             {
                 if (availables_archs.has(Arch {}))
                     return functor(Arch {}, std::forward<Tys>(args)...);
@@ -221,7 +221,7 @@ namespace xsimd
             }
 
             template <class... Tys>
-            XSIMD_INLINE auto operator()(Tys&&... args) noexcept -> decltype(functor(default_arch {}, std::forward<Tys>(args)...))
+            XSIMD_INLINE auto operator()(Tys&&... args) noexcept
             {
                 return walk_archs(ArchList {}, std::forward<Tys>(args)...);
             }
diff --git a/include/xsimd/memory/xsimd_aligned_allocator.hpp b/include/xsimd/memory/xsimd_aligned_allocator.hpp
index 6d4431f13..f6f446ac6 100644
--- a/include/xsimd/memory/xsimd_aligned_allocator.hpp
+++ b/include/xsimd/memory/xsimd_aligned_allocator.hpp
@@ -341,9 +341,9 @@ namespace xsimd
     }
 
     template <class T, class A = default_arch>
-    using default_allocator = typename std::conditional<A::requires_alignment(),
-                                                        aligned_allocator<T, A::alignment()>,
-                                                        std::allocator<T>>::type;
+    using default_allocator = std::conditional_t<A::requires_alignment(),
+                                                 aligned_allocator<T, A::alignment()>,
+                                                 std::allocator<T>>;
 }
 
 #endif
diff --git a/include/xsimd/types/xsimd_api.hpp b/include/xsimd/types/xsimd_api.hpp
index 960350331..aa64df4da 100644
--- a/include/xsimd/types/xsimd_api.hpp
+++ b/include/xsimd/types/xsimd_api.hpp
@@ -83,7 +83,7 @@ namespace xsimd
      * @return the sum of \c x and \c y
      */
     template <class T, class A>
-    XSIMD_INLINE auto add(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x + y)
+    XSIMD_INLINE batch<T, A> add(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x + y;
@@ -287,7 +287,7 @@ namespace xsimd
      * @return the result of the bitwise and.
      */
     template <class T, class A>
-    XSIMD_INLINE auto bitwise_and(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x & y)
+    XSIMD_INLINE batch<T, A> bitwise_and(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x & y;
@@ -302,7 +302,7 @@ namespace xsimd
      * @return the result of the bitwise and.
      */
     template <class T, class A>
-    XSIMD_INLINE auto bitwise_and(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept -> decltype(x & y)
+    XSIMD_INLINE batch_bool<T, A> bitwise_and(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x & y;
@@ -417,7 +417,7 @@ namespace xsimd
      * @return the result of the bitwise or.
      */
     template <class T, class A>
-    XSIMD_INLINE auto bitwise_or(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x | y)
+    XSIMD_INLINE batch<T, A> bitwise_or(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x | y;
@@ -432,7 +432,7 @@ namespace xsimd
      * @return the result of the bitwise or.
      */
     template <class T, class A>
-    XSIMD_INLINE auto bitwise_or(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept -> decltype(x | y)
+    XSIMD_INLINE batch_bool<T, A> bitwise_or(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x | y;
@@ -474,7 +474,7 @@ namespace xsimd
      * @return the result of the bitwise xor.
      */
     template <class T, class A>
-    XSIMD_INLINE auto bitwise_xor(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x ^ y)
+    XSIMD_INLINE batch<T, A> bitwise_xor(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x ^ y;
@@ -489,7 +489,7 @@ namespace xsimd
      * @return the result of the bitwise xor.
      */
     template <class T, class A>
-    XSIMD_INLINE auto bitwise_xor(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept -> decltype(x ^ y)
+    XSIMD_INLINE batch_bool<T, A> bitwise_xor(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x ^ y;
@@ -524,9 +524,9 @@ namespace xsimd
     {
         detail::static_check_supported_config<From, A>();
         using batch_value_type = typename simd_return_type<From, To, A>::value_type;
-        using value_type = typename std::conditional<std::is_same<From, bool>::value,
-                                                     bool,
-                                                     batch_value_type>::type;
+        using value_type = std::conditional_t<std::is_same<From, bool>::value,
+                                              bool,
+                                              batch_value_type>;
         return simd_return_type<From, To, A>(value_type(v));
     }
 
@@ -699,7 +699,7 @@ namespace xsimd
      * @return the result of the division.
      */
     template <class T, class A>
-    XSIMD_INLINE auto div(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x / y)
+    XSIMD_INLINE batch<T, A> div(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x / y;
@@ -714,7 +714,7 @@ namespace xsimd
      * @return a boolean batch.
      */
     template <class T, class A>
-    XSIMD_INLINE auto eq(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x == y)
+    XSIMD_INLINE auto eq(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x == y;
@@ -729,7 +729,7 @@ namespace xsimd
      * @return a boolean batch.
      */
     template <class T, class A>
-    XSIMD_INLINE auto eq(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept -> decltype(x == y)
+    XSIMD_INLINE batch_bool<T, A> eq(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x == y;
@@ -1607,7 +1607,7 @@ namespace xsimd
      * @return the result of the modulo.
      */
     template <class T, class A>
-    XSIMD_INLINE auto mod(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x % y)
+    XSIMD_INLINE batch<T, A> mod(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x % y;
@@ -1623,7 +1623,7 @@ namespace xsimd
      * @return the result of the product.
      */
     template <class T, class A>
-    XSIMD_INLINE auto mul(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x * y)
+    XSIMD_INLINE batch<T, A> mul(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x * y;
@@ -1671,7 +1671,7 @@ namespace xsimd
      * @return a boolean batch.
      */
     template <class T, class A>
-    XSIMD_INLINE auto neq(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x != y)
+    XSIMD_INLINE auto neq(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x != y;
@@ -1686,7 +1686,7 @@ namespace xsimd
      * @return a boolean batch.
      */
     template <class T, class A>
-    XSIMD_INLINE auto neq(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept -> decltype(x != y)
+    XSIMD_INLINE batch_bool<T, A> neq(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x != y;
@@ -1822,7 +1822,7 @@ namespace xsimd
      * @param y batch of integral values.
      * @return \c x raised to the power \c y.
      */
-    template <class T, class ITy, class A, class = typename std::enable_if<std::is_integral<ITy>::value>::type>
+    template <class T, class ITy, class A, class = std::enable_if_t<std::is_integral<ITy>::value>>
     XSIMD_INLINE batch<T, A> pow(batch<T, A> const& x, ITy y) noexcept
     {
         detail::static_check_supported_config<T, A>();
@@ -1866,7 +1866,7 @@ namespace xsimd
      * @param x batch of floating point numbers.
      * @return the reciprocal.
      */
-    template <class T, class A, class = typename std::enable_if<std::is_floating_point<T>::value>::type>
+    template <class T, class A, class = std::enable_if_t<std::is_floating_point<T>::value>>
     XSIMD_INLINE batch<T, A> reciprocal(batch<T, A> const& x) noexcept
     {
         detail::static_check_supported_config<T, A>();
@@ -2239,7 +2239,7 @@ namespace xsimd
      * @return combined batch
      */
     template <class T, class A, class Vt, Vt... Values>
-    XSIMD_INLINE typename std::enable_if<std::is_arithmetic<T>::value, batch<T, A>>::type
+    XSIMD_INLINE std::enable_if_t<std::is_arithmetic<T>::value, batch<T, A>>
     shuffle(batch<T, A> const& x, batch<T, A> const& y, batch_constant<Vt, A, Values...> mask) noexcept
     {
         static_assert(sizeof(T) == sizeof(Vt), "consistent mask");
@@ -2572,7 +2572,7 @@ namespace xsimd
      * @return the difference between \c x and \c y
      */
     template <class T, class A>
-    XSIMD_INLINE auto sub(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x - y)
+    XSIMD_INLINE batch<T, A> sub(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x - y;
@@ -2588,7 +2588,7 @@ namespace xsimd
      * @return swizzled batch
      */
     template <class T, class A, class Vt, Vt... Values>
-    XSIMD_INLINE typename std::enable_if<std::is_arithmetic<T>::value, batch<T, A>>::type
+    XSIMD_INLINE std::enable_if_t<std::is_arithmetic<T>::value, batch<T, A>>
     swizzle(batch<T, A> const& x, batch_constant<Vt, A, Values...> mask) noexcept
     {
         static_assert(sizeof(T) == sizeof(Vt), "consistent mask");
@@ -2614,7 +2614,7 @@ namespace xsimd
      * @return swizzled batch
      */
     template <class T, class A, class Vt>
-    XSIMD_INLINE typename std::enable_if<std::is_arithmetic<T>::value, batch<T, A>>::type
+    XSIMD_INLINE std::enable_if_t<std::is_arithmetic<T>::value, batch<T, A>>
     swizzle(batch<T, A> const& x, batch<Vt, A> mask) noexcept
     {
         static_assert(sizeof(T) == sizeof(Vt), "consistent mask");
@@ -2776,7 +2776,7 @@ namespace xsimd
      * @param self batch_bool of \c T
      * @return \c self cast to a \c batch of \c T
      */
-    template <class T, class A, typename std::enable_if<std::is_integral<T>::value, int>::type = 3>
+    template <class T, class A, std::enable_if_t<std::is_integral<T>::value, int> = 3>
     XSIMD_INLINE batch<T, A> bitwise_cast(batch_bool<T, A> const& self) noexcept
     {
         T z(0);
@@ -2784,7 +2784,7 @@ namespace xsimd
         return select(self, batch<T, A>(T(~z)), batch<T, A>(z));
     }
 
-    template <class T, class A, typename std::enable_if<std::is_floating_point<T>::value, int>::type = 3>
+    template <class T, class A, std::enable_if_t<std::is_floating_point<T>::value, int> = 3>
     XSIMD_INLINE batch<T, A> bitwise_cast(batch_bool<T, A> const& self) noexcept
     {
         T z0(0), z1(0);
diff --git a/include/xsimd/types/xsimd_avx512f_register.hpp b/include/xsimd/types/xsimd_avx512f_register.hpp
index c7af6d9f7..279ae4caa 100644
--- a/include/xsimd/types/xsimd_avx512f_register.hpp
+++ b/include/xsimd/types/xsimd_avx512f_register.hpp
@@ -42,9 +42,9 @@ namespace xsimd
         template <class T>
         struct simd_avx512_bool_register
         {
-            using register_type = typename std::conditional<
-                (sizeof(T) < 4), std::conditional<(sizeof(T) == 1), __mmask64, __mmask32>,
-                std::conditional<(sizeof(T) == 4), __mmask16, __mmask8>>::type::type;
+            using register_type = std::conditional_t<
+                (sizeof(T) < 4), std::conditional_t<(sizeof(T) == 1), __mmask64, __mmask32>,
+                std::conditional_t<(sizeof(T) == 4), __mmask16, __mmask8>>;
             register_type data;
             simd_avx512_bool_register() = default;
             simd_avx512_bool_register(register_type r) { data = r; }
diff --git a/include/xsimd/types/xsimd_batch.hpp b/include/xsimd/types/xsimd_batch.hpp
index 7ee1572d6..5ff525a11 100644
--- a/include/xsimd/types/xsimd_batch.hpp
+++ b/include/xsimd/types/xsimd_batch.hpp
@@ -354,10 +354,10 @@ namespace xsimd
 
     private:
         template <class U, class... V, size_t I, size_t... Is>
-        static XSIMD_INLINE register_type make_register(detail::index_sequence<I, Is...>, U u, V... v) noexcept;
+        static XSIMD_INLINE register_type make_register(std::index_sequence<I, Is...>, U u, V... v) noexcept;
 
         template <class... V>
-        static XSIMD_INLINE register_type make_register(detail::index_sequence<>, V... v) noexcept;
+        static XSIMD_INLINE register_type make_register(std::index_sequence<>, V... v) noexcept;
     };
 
 #if __cplusplus < 201703L
@@ -1166,20 +1166,20 @@ namespace xsimd
 
     template <class T, class A>
     XSIMD_INLINE batch_bool<T, A>::batch_bool(bool val) noexcept
-        : base_type { make_register(detail::make_index_sequence<size - 1>(), val) }
+        : base_type { make_register(std::make_index_sequence<size - 1>(), val) }
     {
     }
 
     template <class T, class A>
     template <class U, class... V, size_t I, size_t... Is>
-    XSIMD_INLINE auto batch_bool<T, A>::make_register(detail::index_sequence<I, Is...>, U u, V... v) noexcept -> register_type
+    XSIMD_INLINE auto batch_bool<T, A>::make_register(std::index_sequence<I, Is...>, U u, V... v) noexcept -> register_type
     {
-        return make_register(detail::index_sequence<Is...>(), u, u, v...);
+        return make_register(std::index_sequence<Is...>(), u, u, v...);
     }
 
     template <class T, class A>
     template <class... V>
-    XSIMD_INLINE auto batch_bool<T, A>::make_register(detail::index_sequence<>, V... v) noexcept -> register_type
+    XSIMD_INLINE auto batch_bool<T, A>::make_register(std::index_sequence<>, V... v) noexcept -> register_type
     {
         return kernel::set<A>(batch_bool<T, A>(), A {}, v...).data;
     }
@@ -1576,10 +1576,10 @@ namespace xsimd
         template <typename T, std::size_t N, class Arch, class... Archs>
         struct sized_batch<T, N, xsimd::arch_list<Arch, Archs...>>
         {
-            using type = typename std::conditional<
+            using type = std::conditional_t<
                 batch_trait<T, Arch>::size == N,
                 typename batch_trait<T, Arch>::type,
-                typename sized_batch<T, N, xsimd::arch_list<Archs...>>::type>::type;
+                typename sized_batch<T, N, xsimd::arch_list<Archs...>>::type>;
         };
     }
 
diff --git a/include/xsimd/types/xsimd_batch_constant.hpp b/include/xsimd/types/xsimd_batch_constant.hpp
index dca229cf9..10fff0df0 100644
--- a/include/xsimd/types/xsimd_batch_constant.hpp
+++ b/include/xsimd/types/xsimd_batch_constant.hpp
@@ -13,6 +13,7 @@
 #define XSIMD_BATCH_CONSTANT_HPP
 
 #include <cstddef>
+#include <functional>
 #include <utility>
 
 #include "./xsimd_batch.hpp"
@@ -121,24 +122,22 @@ namespace xsimd
 
         template <class F, class SelfPack, class OtherPack, std::size_t... Indices>
         static constexpr batch_bool_constant<T, A, F()(std::tuple_element<Indices, SelfPack>::type::value, std::tuple_element<Indices, OtherPack>::type::value)...>
-        apply(detail::index_sequence<Indices...>)
+        apply(std::index_sequence<Indices...>)
         {
             return {};
         }
 
         template <class F, bool... OtherValues>
         static constexpr auto apply(batch_bool_constant<T, A, Values...>, batch_bool_constant<T, A, OtherValues...>)
-            -> decltype(apply<F, std::tuple<std::integral_constant<bool, Values>...>, std::tuple<std::integral_constant<bool, OtherValues>...>>(detail::make_index_sequence<sizeof...(Values)>()))
         {
             static_assert(sizeof...(Values) == sizeof...(OtherValues), "compatible constant batches");
-            return {};
+            return apply<F, std::tuple<std::integral_constant<bool, Values>...>, std::tuple<std::integral_constant<bool, OtherValues>...>>(std::make_index_sequence<sizeof...(Values)>());
         }
 
     public:
 #define MAKE_BINARY_OP(OP, NAME)                                                      \
     template <bool... OtherValues>                                                    \
     constexpr auto operator OP(batch_bool_constant<T, A, OtherValues...> other) const \
-        -> decltype(apply<NAME>(*this, other))                                        \
     {                                                                                 \
         return apply<NAME>(*this, other);                                             \
     }
@@ -212,11 +211,11 @@ namespace xsimd
     namespace detail
     {
         template <class A2, std::size_t BeginIdx, typename T, class A, bool... Values, std::size_t... Is>
-        XSIMD_INLINE constexpr auto splice_impl(index_sequence<Is...>) noexcept
-            -> batch_bool_constant<
-                T, A2,
-                std::tuple_element<BeginIdx + Is,
-                                   std::tuple<std::integral_constant<bool, Values>...>>::type::value...>
+        XSIMD_INLINE constexpr batch_bool_constant<
+            T, A2,
+            std::tuple_element<BeginIdx + Is,
+                               std::tuple<std::integral_constant<bool, Values>...>>::type::value...>
+        splice_impl(std::index_sequence<Is...>) noexcept
         {
             return {};
         }
@@ -225,32 +224,29 @@ namespace xsimd
                   typename T, class A, bool... Values,
                   std::size_t N = (End >= Begin ? (End - Begin) : 0)>
         XSIMD_INLINE constexpr auto splice(batch_bool_constant<T, A, Values...>) noexcept
-            -> decltype(splice_impl<A2, Begin, T, A, Values...>(make_index_sequence<N>()))
         {
             static_assert(Begin <= End, "splice: Begin must be <= End");
             static_assert(End <= sizeof...(Values), "splice: End must be <= size");
             static_assert(N == batch_bool<T, A2>::size, "splice: target arch size must match submask length");
-            return {};
+            return splice_impl<A2, Begin, T, A, Values...>(std::make_index_sequence<N>());
         }
 
         template <class A2, typename T, class A, bool... Values>
         XSIMD_INLINE constexpr auto lower_half(batch_bool_constant<T, A, Values...>) noexcept
-            -> decltype(splice_impl<A2, 0, T, A, Values...>(make_index_sequence<sizeof...(Values) / 2>()))
         {
             static_assert(sizeof...(Values) % 2 == 0, "lower_half requires even size");
             static_assert(batch_bool<T, A2>::size == sizeof...(Values) / 2,
                           "lower_half: target arch size must match submask length");
-            return {};
+            return splice_impl<A2, 0, T, A, Values...>(std::make_index_sequence<sizeof...(Values) / 2>());
         }
 
         template <class A2, typename T, class A, bool... Values>
         XSIMD_INLINE constexpr auto upper_half(batch_bool_constant<T, A, Values...>) noexcept
-            -> decltype(splice_impl<A2, sizeof...(Values) / 2, T, A, Values...>(make_index_sequence<sizeof...(Values) / 2>()))
         {
             static_assert(sizeof...(Values) % 2 == 0, "upper_half requires even size");
             static_assert(batch_bool<T, A2>::size == sizeof...(Values) / 2,
                           "upper_half: target arch size must match submask length");
-            return {};
+            return splice_impl<A2, sizeof...(Values) / 2, T, A, Values...>(std::make_index_sequence<sizeof...(Values) / 2>());
         }
     } // namespace detail
 
@@ -294,42 +290,12 @@ namespace xsimd
             return values[i];
         }
 
-        struct arithmetic_add
-        {
-            constexpr T operator()(T x, T y) const { return x + y; }
-        };
-        struct arithmetic_sub
-        {
-            constexpr T operator()(T x, T y) const { return x - y; }
-        };
-        struct arithmetic_mul
-        {
-            constexpr T operator()(T x, T y) const { return x * y; }
-        };
-        struct arithmetic_div
-        {
-            constexpr T operator()(T x, T y) const { return x / y; }
-        };
-        struct arithmetic_mod
-        {
-            constexpr T operator()(T x, T y) const { return x % y; }
-        };
-        struct binary_and
-        {
-            constexpr T operator()(T x, T y) const { return x & y; }
-        };
-        struct binary_or
-        {
-            constexpr T operator()(T x, T y) const { return x | y; }
-        };
-        struct binary_xor
-        {
-            constexpr T operator()(T x, T y) const { return x ^ y; }
-        };
+        template <typename = void>
         struct binary_rshift
         {
             constexpr T operator()(T x, T y) const { return x >> y; }
         };
+        template <typename = void>
         struct binary_lshift
         {
             constexpr T operator()(T x, T y) const { return x << y; }
@@ -337,95 +303,66 @@ namespace xsimd
 
         template <class F, class SelfPack, class OtherPack, std::size_t... Indices>
         static constexpr batch_constant<T, A, F()(std::tuple_element<Indices, SelfPack>::type::value, std::tuple_element<Indices, OtherPack>::type::value)...>
-        apply(detail::index_sequence<Indices...>)
+        apply(std::index_sequence<Indices...>)
         {
             return {};
         }
 
         template <class F, T... OtherValues>
         static constexpr auto apply(batch_constant<T, A, Values...>, batch_constant<T, A, OtherValues...>)
-            -> decltype(apply<F, std::tuple<std::integral_constant<T, Values>...>, std::tuple<std::integral_constant<T, OtherValues>...>>(detail::make_index_sequence<sizeof...(Values)>()))
         {
             static_assert(sizeof...(Values) == sizeof...(OtherValues), "compatible constant batches");
-            return {};
+            return apply<F, std::tuple<std::integral_constant<T, Values>...>, std::tuple<std::integral_constant<T, OtherValues>...>>(std::make_index_sequence<sizeof...(Values)>());
         }
 
     public:
 #define MAKE_BINARY_OP(OP, NAME)                                                 \
     template <T... OtherValues>                                                  \
     constexpr auto operator OP(batch_constant<T, A, OtherValues...> other) const \
-        -> decltype(apply<NAME>(*this, other))                                   \
     {                                                                            \
-        return apply<NAME>(*this, other);                                        \
+        return apply<NAME<void>>(*this, other);                                  \
     }
 
-        MAKE_BINARY_OP(+, arithmetic_add)
-        MAKE_BINARY_OP(-, arithmetic_sub)
-        MAKE_BINARY_OP(*, arithmetic_mul)
-        MAKE_BINARY_OP(/, arithmetic_div)
-        MAKE_BINARY_OP(%, arithmetic_mod)
-        MAKE_BINARY_OP(&, binary_and)
-        MAKE_BINARY_OP(|, binary_or)
-        MAKE_BINARY_OP(^, binary_xor)
+        MAKE_BINARY_OP(+, std::plus)
+        MAKE_BINARY_OP(-, std::minus)
+        MAKE_BINARY_OP(*, std::multiplies)
+        MAKE_BINARY_OP(/, std::divides)
+        MAKE_BINARY_OP(%, std::modulus)
+        MAKE_BINARY_OP(&, std::bit_and)
+        MAKE_BINARY_OP(|, std::bit_or)
+        MAKE_BINARY_OP(^, std::bit_xor)
         MAKE_BINARY_OP(<<, binary_lshift)
         MAKE_BINARY_OP(>>, binary_rshift)
 
 #undef MAKE_BINARY_OP
 
-        struct boolean_eq
-        {
-            constexpr bool operator()(T x, T y) const { return x == y; }
-        };
-        struct boolean_ne
-        {
-            constexpr bool operator()(T x, T y) const { return x != y; }
-        };
-        struct boolean_gt
-        {
-            constexpr bool operator()(T x, T y) const { return x > y; }
-        };
-        struct boolean_ge
-        {
-            constexpr bool operator()(T x, T y) const { return x >= y; }
-        };
-        struct boolean_lt
-        {
-            constexpr bool operator()(T x, T y) const { return x < y; }
-        };
-        struct boolean_le
-        {
-            constexpr bool operator()(T x, T y) const { return x <= y; }
-        };
-
         template <class F, class SelfPack, class OtherPack, std::size_t... Indices>
         static constexpr batch_bool_constant<T, A, F()(std::tuple_element<Indices, SelfPack>::type::value, std::tuple_element<Indices, OtherPack>::type::value)...>
-        apply_bool(detail::index_sequence<Indices...>)
+        apply_bool(std::index_sequence<Indices...>)
         {
             return {};
         }
 
         template <class F, T... OtherValues>
         static constexpr auto apply_bool(batch_constant<T, A, Values...>, batch_constant<T, A, OtherValues...>)
-            -> decltype(apply_bool<F, std::tuple<std::integral_constant<T, Values>...>, std::tuple<std::integral_constant<T, OtherValues>...>>(detail::make_index_sequence<sizeof...(Values)>()))
         {
             static_assert(sizeof...(Values) == sizeof...(OtherValues), "compatible constant batches");
-            return {};
+            return apply_bool<F, std::tuple<std::integral_constant<T, Values>...>, std::tuple<std::integral_constant<T, OtherValues>...>>(std::make_index_sequence<sizeof...(Values)>());
         }
 
 #define MAKE_BINARY_BOOL_OP(OP, NAME)                                            \
     template <T... OtherValues>                                                  \
     constexpr auto operator OP(batch_constant<T, A, OtherValues...> other) const \
-        -> decltype(apply_bool<NAME>(*this, other))                              \
     {                                                                            \
-        return {};                                                               \
+        return apply_bool<NAME<void>>(*this, other);                             \
     }
 
-        MAKE_BINARY_BOOL_OP(==, boolean_eq)
-        MAKE_BINARY_BOOL_OP(!=, boolean_ne)
-        MAKE_BINARY_BOOL_OP(<, boolean_lt)
-        MAKE_BINARY_BOOL_OP(<=, boolean_le)
-        MAKE_BINARY_BOOL_OP(>, boolean_gt)
-        MAKE_BINARY_BOOL_OP(>=, boolean_ge)
+        MAKE_BINARY_BOOL_OP(==, std::equal_to)
+        MAKE_BINARY_BOOL_OP(!=, std::not_equal_to)
+        MAKE_BINARY_BOOL_OP(<, std::less)
+        MAKE_BINARY_BOOL_OP(<=, std::less_equal)
+        MAKE_BINARY_BOOL_OP(>, std::greater)
+        MAKE_BINARY_BOOL_OP(>=, std::greater_equal)
 
 #undef MAKE_BINARY_BOOL_OP
 
@@ -449,28 +386,28 @@ namespace xsimd
     {
         template <typename T, class G, class A, std::size_t... Is>
         XSIMD_INLINE constexpr batch_constant<T, A, (T)G::get(Is, sizeof...(Is))...>
-        make_batch_constant(detail::index_sequence<Is...>) noexcept
+        make_batch_constant(std::index_sequence<Is...>) noexcept
         {
             return {};
         }
 
         template <typename T, T Val, class A, std::size_t... Is>
         XSIMD_INLINE constexpr batch_constant<T, A, (static_cast<T>(0 * Is) + Val)...>
-        make_batch_constant(detail::index_sequence<Is...>) noexcept
+        make_batch_constant(std::index_sequence<Is...>) noexcept
         {
             return {};
         }
 
         template <typename T, class G, class A, std::size_t... Is>
         XSIMD_INLINE constexpr batch_bool_constant<T, A, G::get(Is, sizeof...(Is))...>
-        make_batch_bool_constant(detail::index_sequence<Is...>) noexcept
+        make_batch_bool_constant(std::index_sequence<Is...>) noexcept
         {
             return {};
         }
 
         template <typename T, bool Val, class A, std::size_t... Is>
         XSIMD_INLINE constexpr batch_bool_constant<T, A, ((static_cast<bool>(Is) | true) & Val)...>
-        make_batch_bool_constant(detail::index_sequence<Is...>) noexcept
+        make_batch_bool_constant(std::index_sequence<Is...>) noexcept
         {
             return {};
         }
@@ -498,7 +435,7 @@ namespace xsimd
      * @endcode
      */
     template <typename T, class G, class A = default_arch>
-    XSIMD_INLINE constexpr decltype(detail::make_batch_constant<T, G, A>(detail::make_index_sequence<batch<T, A>::size>()))
+    XSIMD_INLINE constexpr decltype(detail::make_batch_constant<T, G, A>(std::make_index_sequence<batch<T, A>::size>()))
     make_batch_constant() noexcept
     {
         return {};
@@ -510,7 +447,7 @@ namespace xsimd
      * Similar to @c make_batch_constant for @c batch_bool_constant
      */
     template <typename T, class G, class A = default_arch>
-    XSIMD_INLINE constexpr decltype(detail::make_batch_bool_constant<T, G, A>(detail::make_index_sequence<batch<T, A>::size>()))
+    XSIMD_INLINE constexpr decltype(detail::make_batch_bool_constant<T, G, A>(std::make_index_sequence<batch<T, A>::size>()))
     make_batch_bool_constant() noexcept
     {
         return {};
@@ -526,7 +463,7 @@ namespace xsimd
      * @tparam A Architecture that will be used when converting to a regular batch.
      */
     template <typename T, T Val, class A = default_arch>
-    XSIMD_INLINE constexpr decltype(detail::make_batch_constant<T, Val, A>(detail::make_index_sequence<batch<T, A>::size>()))
+    XSIMD_INLINE constexpr decltype(detail::make_batch_constant<T, Val, A>(std::make_index_sequence<batch<T, A>::size>()))
     make_batch_constant() noexcept
     {
         return {};
@@ -538,7 +475,7 @@ namespace xsimd
      * Similar to @c make_batch_constant for @c batch_bool_constant
      */
     template <typename T, bool Val, class A = default_arch>
-    XSIMD_INLINE constexpr decltype(detail::make_batch_bool_constant<T, Val, A>(detail::make_index_sequence<batch<T, A>::size>()))
+    XSIMD_INLINE constexpr decltype(detail::make_batch_bool_constant<T, Val, A>(std::make_index_sequence<batch<T, A>::size>()))
     make_batch_bool_constant() noexcept
     {
         return {};
diff --git a/include/xsimd/types/xsimd_neon_register.hpp b/include/xsimd/types/xsimd_neon_register.hpp
index 4f40a4287..ef9973828 100644
--- a/include/xsimd/types/xsimd_neon_register.hpp
+++ b/include/xsimd/types/xsimd_neon_register.hpp
@@ -78,13 +78,13 @@ namespace xsimd
             using unsigned_neon_vector_type = typename neon_vector_type_impl<8 * sizeof(T)>::unsigned_type;
 
             template <class T>
-            using neon_vector_type = typename std::conditional<std::is_signed<T>::value,
-                                                               signed_neon_vector_type<T>,
-                                                               unsigned_neon_vector_type<T>>::type;
+            using neon_vector_type = std::conditional_t<std::is_signed<T>::value,
+                                                        signed_neon_vector_type<T>,
+                                                        unsigned_neon_vector_type<T>>;
 
-            using char_neon_vector_type = typename std::conditional<std::is_signed<char>::value,
-                                                                    signed_neon_vector_type<char>,
-                                                                    unsigned_neon_vector_type<char>>::type;
+            using char_neon_vector_type = std::conditional_t<std::is_signed<char>::value,
+                                                             signed_neon_vector_type<char>,
+                                                             unsigned_neon_vector_type<char>>;
         }
 
         XSIMD_DECLARE_SIMD_REGISTER(signed char, neon, detail::neon_vector_type<signed char>);
diff --git a/include/xsimd/types/xsimd_register.hpp b/include/xsimd/types/xsimd_register.hpp
index a838f8786..018418af6 100644
--- a/include/xsimd/types/xsimd_register.hpp
+++ b/include/xsimd/types/xsimd_register.hpp
@@ -83,7 +83,7 @@ namespace xsimd
     {
         template <class A>
         // makes requires_arch equal to A const&, using type_traits functions
-        using requires_arch = typename std::add_lvalue_reference<typename std::add_const<A>::type>::type;
+        using requires_arch = std::add_lvalue_reference_t<std::add_const_t<A>>;
         template <class T>
         struct convert
         {
diff --git a/include/xsimd/types/xsimd_rvv_register.hpp b/include/xsimd/types/xsimd_rvv_register.hpp
index 268e27e82..e56cb5261 100644
--- a/include/xsimd/types/xsimd_rvv_register.hpp
+++ b/include/xsimd/types/xsimd_rvv_register.hpp
@@ -298,11 +298,11 @@ namespace xsimd
             // It's difficult dealing with both char and whichever *int8_t type
             // is compatible with char, so just avoid it altogether.
             //
-            using rvv_char_t = typename std::conditional<std::is_signed<char>::value, int8_t, uint8_t>::type;
+            using rvv_char_t = std::conditional_t<std::is_signed<char>::value, int8_t, uint8_t>;
             template <class T>
-            using rvv_fix_char_t = typename std::conditional<
-                std::is_same<char, typename std::decay<T>::type>::value,
-                rvv_char_t, T>::type;
+            using rvv_fix_char_t = std::conditional_t<
+                std::is_same<char, std::decay_t<T>>::value,
+                rvv_char_t, T>;
 
             // An explicit constructor isn't really explicit enough to allow
             // implicit bit-casting operations between incompatible types, so
@@ -342,7 +342,7 @@ namespace xsimd
                 operator register_type() const noexcept { return value.get(); }
             };
             template <class T, size_t Width = XSIMD_RVV_BITS>
-            using rvv_reg_t = typename std::conditional<!std::is_void<T>::value, rvv_reg<rvv_fix_char_t<T>, Width>, void>::type;
+            using rvv_reg_t = std::conditional_t<!std::is_void<T>::value, rvv_reg<rvv_fix_char_t<T>, Width>, void>;
 
             // And some more of the same stuff for bool types, which have
             // similar problems and similar workarounds.
@@ -385,7 +385,7 @@ namespace xsimd
                     : value(__riscv_vreinterpret_u8m1(v))
                 {
                 }
-                template <class U, typename std::enable_if<sizeof(T) == sizeof(U), int>::type = 0>
+                template <class U, std::enable_if_t<sizeof(T) == sizeof(U), int> = 0>
                 rvv_bool(rvv_bool<U, Width> v)
                     : value(v.value)
                 {
@@ -402,8 +402,8 @@ namespace xsimd
             };
 
             template <class T, size_t Width = XSIMD_RVV_BITS>
-            using rvv_bool_t = typename std::enable_if < !std::is_void<T>::value,
-                  rvv_bool<rvv_fix_char_t<T>, Width<rvv_width_m1 ? rvv_width_m1 : Width>>::type;
+            using rvv_bool_t = std::enable_if_t < !std::is_void<T>::value,
+                  rvv_bool<rvv_fix_char_t<T>, Width<rvv_width_m1 ? rvv_width_m1 : Width>>;
 
             template <size_t S>
             struct rvv_vector_type_impl;
@@ -450,14 +450,14 @@ namespace xsimd
             using floating_point_rvv_vector_type = typename rvv_vector_type_impl<8 * sizeof(T)>::floating_point_type;
 
             template <class T>
-            using signed_int_or_floating_point_rvv_vector_type = typename std::conditional<std::is_floating_point<T>::value,
-                                                                                           floating_point_rvv_vector_type<T>,
-                                                                                           signed_int_rvv_vector_type<T>>::type;
+            using signed_int_or_floating_point_rvv_vector_type = std::conditional_t<std::is_floating_point<T>::value,
+                                                                                    floating_point_rvv_vector_type<T>,
+                                                                                    signed_int_rvv_vector_type<T>>;
 
             template <class T>
-            using rvv_vector_type = typename std::conditional<std::is_signed<T>::value,
-                                                              signed_int_or_floating_point_rvv_vector_type<T>,
-                                                              unsigned_int_rvv_vector_type<T>>::type;
+            using rvv_vector_type = std::conditional_t<std::is_signed<T>::value,
+                                                       signed_int_or_floating_point_rvv_vector_type<T>,
+                                                       unsigned_int_rvv_vector_type<T>>;
         } // namespace detail
 
         XSIMD_DECLARE_SIMD_REGISTER(bool, rvv, detail::rvv_vector_type<unsigned char>);
diff --git a/include/xsimd/types/xsimd_sve_register.hpp b/include/xsimd/types/xsimd_sve_register.hpp
index 9d33fc484..7ac748f8d 100644
--- a/include/xsimd/types/xsimd_sve_register.hpp
+++ b/include/xsimd/types/xsimd_sve_register.hpp
@@ -108,14 +108,14 @@ namespace xsimd
             using floating_point_sve_vector_type = typename sve_vector_type_impl<8 * sizeof(T)>::floating_point_type;
 
             template <class T>
-            using signed_int_or_floating_point_sve_vector_type = typename std::conditional<std::is_floating_point<T>::value,
-                                                                                           floating_point_sve_vector_type<T>,
-                                                                                           signed_int_sve_vector_type<T>>::type;
+            using signed_int_or_floating_point_sve_vector_type = std::conditional_t<std::is_floating_point<T>::value,
+                                                                                    floating_point_sve_vector_type<T>,
+                                                                                    signed_int_sve_vector_type<T>>;
 
             template <class T>
-            using sve_vector_type = typename std::conditional<std::is_signed<T>::value,
-                                                              signed_int_or_floating_point_sve_vector_type<T>,
-                                                              unsigned_int_sve_vector_type<T>>::type;
+            using sve_vector_type = std::conditional_t<std::is_signed<T>::value,
+                                                       signed_int_or_floating_point_sve_vector_type<T>,
+                                                       unsigned_int_sve_vector_type<T>>;
         } // namespace detail
 
         XSIMD_DECLARE_SIMD_REGISTER(signed char, sve, detail::sve_vector_type<signed char>);
diff --git a/include/xsimd/types/xsimd_traits.hpp b/include/xsimd/types/xsimd_traits.hpp
index f11fb39e1..ace06dcfc 100644
--- a/include/xsimd/types/xsimd_traits.hpp
+++ b/include/xsimd/types/xsimd_traits.hpp
@@ -402,7 +402,7 @@ namespace xsimd
         template <typename T>
         struct widen
         {
-            using type = typename std::make_signed<typename widen<typename std::make_unsigned<T>::type>::type>::type;
+            using type = std::make_signed_t<typename widen<std::make_unsigned_t<T>>::type>;
         };
 
         template <>
diff --git a/include/xsimd/types/xsimd_utils.hpp b/include/xsimd/types/xsimd_utils.hpp
index 0aec70c1d..aa6b90607 100644
--- a/include/xsimd/types/xsimd_utils.hpp
+++ b/include/xsimd/types/xsimd_utils.hpp
@@ -17,6 +17,7 @@
 #include <cstring>
 #include <tuple>
 #include <type_traits>
+#include <utility>
 
 #ifdef XSIMD_ENABLE_XTL_COMPLEX
 #include "xtl/xcomplex.hpp"
@@ -211,35 +212,35 @@ namespace xsimd
              **************************************/
 
             template <class T>
-            using enable_integral_t = typename std::enable_if<std::is_integral<T>::value, int>::type;
+            using enable_integral_t = std::enable_if_t<std::is_integral<T>::value, int>;
 
             template <class T, size_t S>
-            using enable_sized_signed_t = typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value && sizeof(T) == S, int>::type;
+            using enable_sized_signed_t = std::enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value && sizeof(T) == S, int>;
 
             template <class T, size_t S>
-            using enable_sized_unsigned_t = typename std::enable_if<std::is_integral<T>::value && !std::is_signed<T>::value && sizeof(T) == S, int>::type;
+            using enable_sized_unsigned_t = std::enable_if_t<std::is_integral<T>::value && !std::is_signed<T>::value && sizeof(T) == S, int>;
 
             template <class T, size_t S>
-            using enable_sized_integral_t = typename std::enable_if<std::is_integral<T>::value && sizeof(T) == S, int>::type;
+            using enable_sized_integral_t = std::enable_if_t<std::is_integral<T>::value && sizeof(T) == S, int>;
 
             template <class T, size_t S>
-            using enable_sized_t = typename std::enable_if<sizeof(T) == S, int>::type;
+            using enable_sized_t = std::enable_if_t<sizeof(T) == S, int>;
 
             template <class T, size_t S>
-            using enable_max_sized_integral_t = typename std::enable_if<std::is_integral<T>::value && sizeof(T) <= S, int>::type;
+            using enable_max_sized_integral_t = std::enable_if_t<std::is_integral<T>::value && sizeof(T) <= S, int>;
 
             /********************************
              * Matching & mismatching sizes *
              ********************************/
 
             template <class T, class U, class B = int>
-            using sizes_match_t = typename std::enable_if<sizeof(T) == sizeof(U), B>::type;
+            using sizes_match_t = std::enable_if_t<sizeof(T) == sizeof(U), B>;
 
             template <class T, class U, class B = int>
-            using sizes_mismatch_t = typename std::enable_if<sizeof(T) != sizeof(U), B>::type;
+            using sizes_mismatch_t = std::enable_if_t<sizeof(T) != sizeof(U), B>;
 
             template <class T, class U, class B = int>
-            using stride_match_t = typename std::enable_if<!std::is_same<T, U>::value && sizeof(T) == sizeof(U), B>::type;
+            using stride_match_t = std::enable_if_t<!std::is_same<T, U>::value && sizeof(T) == sizeof(U), B>;
         } // namespace detail
     } // namespace kernel
 
@@ -256,77 +257,18 @@ namespace xsimd
             using type = T;
         };
 
-#ifdef __cpp_lib_integer_sequence
-        using std::index_sequence;
-        using std::integer_sequence;
-        using std::make_index_sequence;
-        using std::make_integer_sequence;
-
-        using std::index_sequence_for;
-#else
-        template <typename T, T... Is>
-        struct integer_sequence
-        {
-            using value_type = T;
-            static constexpr std::size_t size() noexcept { return sizeof...(Is); }
-        };
-
-        template <typename Lhs, typename Rhs>
-        struct make_integer_sequence_concat;
-
-        template <typename T, T... Lhs, T... Rhs>
-        struct make_integer_sequence_concat<integer_sequence<T, Lhs...>,
-                                            integer_sequence<T, Rhs...>>
-            : identity<integer_sequence<T, Lhs..., (sizeof...(Lhs) + Rhs)...>>
-        {
-        };
-
-        template <typename T>
-        struct make_integer_sequence_impl;
-
-        template <typename T>
-        struct make_integer_sequence_impl<std::integral_constant<T, (T)0>> : identity<integer_sequence<T>>
-        {
-        };
-
-        template <typename T>
-        struct make_integer_sequence_impl<std::integral_constant<T, (T)1>> : identity<integer_sequence<T, 0>>
-        {
-        };
-
-        template <typename T, T N>
-        struct make_integer_sequence_impl<std::integral_constant<T, N>>
-            : make_integer_sequence_concat<typename make_integer_sequence_impl<std::integral_constant<T, N / 2>>::type,
-                                           typename make_integer_sequence_impl<std::integral_constant<T, N - (N / 2)>>::type>
-        {
-        };
-
-        template <typename T, T N>
-        using make_integer_sequence = typename make_integer_sequence_impl<std::integral_constant<T, N>>::type;
-
-        template <std::size_t... Is>
-        using index_sequence = integer_sequence<std::size_t, Is...>;
-
-        template <std::size_t N>
-        using make_index_sequence = make_integer_sequence<std::size_t, N>;
-
-        template <typename... Ts>
-        using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
-
-#endif
-
         template <int... Is>
-        using int_sequence = integer_sequence<int, Is...>;
+        using int_sequence = std::integer_sequence<int, Is...>;
 
         template <int N>
-        using make_int_sequence = make_integer_sequence<int, N>;
+        using make_int_sequence = std::make_integer_sequence<int, N>;
 
         template <typename... Ts>
         using int_sequence_for = make_int_sequence<(int)sizeof...(Ts)>;
 
         // Type-casted index sequence.
         template <class P, size_t... Is>
-        inline P indexes_from(index_sequence<Is...>) noexcept
+        inline P indexes_from(std::index_sequence<Is...>) noexcept
         {
             return { static_cast<typename P::value_type>(Is)... };
         }
@@ -334,34 +276,7 @@ namespace xsimd
         template <class P>
         inline P make_sequence_as_batch() noexcept
         {
-            return indexes_from<P>(make_index_sequence<P::size>());
-        }
-    }
-
-    /***********************************
-     * Backport of std::get from C++14 *
-     ***********************************/
-
-    namespace detail
-    {
-        template <class T, class... Types, size_t I, size_t... Is>
-        inline const T& get_impl(const std::tuple<Types...>& t, std::is_same<T, T>, index_sequence<I, Is...>) noexcept
-        {
-            return std::get<I>(t);
-        }
-
-        template <class T, class U, class... Types, size_t I, size_t... Is>
-        inline const T& get_impl(const std::tuple<Types...>& t, std::is_same<T, U>, index_sequence<I, Is...>) noexcept
-        {
-            using tuple_elem = typename std::tuple_element<I + 1, std::tuple<Types...>>::type;
-            return get_impl<T>(t, std::is_same<T, tuple_elem>(), index_sequence<Is...>());
-        }
-
-        template <class T, class... Types>
-        inline const T& get(const std::tuple<Types...>& t) noexcept
-        {
-            using tuple_elem = typename std::tuple_element<0, std::tuple<Types...>>::type;
-            return get_impl<T>(t, std::is_same<T, tuple_elem>(), make_index_sequence<sizeof...(Types)>());
+            return indexes_from<P>(std::make_index_sequence<P::size>());
         }
     }
 
@@ -406,7 +321,7 @@ namespace xsimd
         // std::array constructor from scalar value ("broadcast")
         template <typename T, std::size_t... Is>
         inline constexpr std::array<T, sizeof...(Is)>
-        array_from_scalar_impl(const T& scalar, index_sequence<Is...>) noexcept
+        array_from_scalar_impl(const T& scalar, std::index_sequence<Is...>) noexcept
         {
             // You can safely ignore this silly ternary, the "scalar" is all
             // that matters. The rest is just a dirty workaround...
@@ -417,13 +332,13 @@ namespace xsimd
         inline constexpr std::array<T, N>
         array_from_scalar(const T& scalar) noexcept
         {
-            return array_from_scalar_impl(scalar, make_index_sequence<N>());
+            return array_from_scalar_impl(scalar, std::make_index_sequence<N>());
         }
 
         // std::array constructor from C-style pointer (handled as an array)
         template <typename T, std::size_t... Is>
         inline constexpr std::array<T, sizeof...(Is)>
-        array_from_pointer_impl(const T* c_array, index_sequence<Is...>) noexcept
+        array_from_pointer_impl(const T* c_array, std::index_sequence<Is...>) noexcept
         {
             return std::array<T, sizeof...(Is)> { c_array[Is]... };
         }
@@ -432,7 +347,7 @@ namespace xsimd
         inline constexpr std::array<T, N>
         array_from_pointer(const T* c_array) noexcept
         {
-            return array_from_pointer_impl(c_array, make_index_sequence<N>());
+            return array_from_pointer_impl(c_array, std::make_index_sequence<N>());
         }
     }
 
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 3ba805556..ee32f3f5e 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -60,11 +60,11 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "GNU"
                 endif()
                 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
             else()
-                CHECK_CXX_COMPILER_FLAG("-std=c++11" HAS_CPP11_FLAG)
-                if (NOT HAS_CPP11_FLAG)
-                    message(FATAL_ERROR "Unsupported compiler -- xsimd requires C++11 support!")
+                CHECK_CXX_COMPILER_FLAG("-std=c++14" HAS_CPP14_FLAG)
+                if (NOT HAS_CPP14_FLAG)
+                    message(FATAL_ERROR "Unsupported compiler -- xsimd requires C++14 support!")
                 else()
-                    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+                    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
                 endif()
             endif()
         endif()
diff --git a/test/check_inline_specifier.sh b/test/check_inline_specifier.sh
index 2169a80ed..1ccdda130 100755
--- a/test/check_inline_specifier.sh
+++ b/test/check_inline_specifier.sh
@@ -20,7 +20,7 @@ sed -r -n '/^####/,$ p' < $0 > $query_file
 
 log_file=`mktemp -t`
 
-clang-query --extra-arg "-std=c++11" --extra-arg="-I$top_srcdir/include" -f $query_file $top_srcdir/include/xsimd/xsimd.hpp -- | tee $log_file
+clang-query --extra-arg "-std=c++14" --extra-arg="-I$top_srcdir/include" -f $query_file $top_srcdir/include/xsimd/xsimd.hpp -- | tee $log_file
 
 { grep -E '^0 matches.' $log_file && failed=0 ; } || failed=1
 
diff --git a/test/test_batch.cpp b/test/test_batch.cpp
index 744fdc15b..9c81aacab 100644
--- a/test/test_batch.cpp
+++ b/test/test_batch.cpp
@@ -850,7 +850,7 @@ struct batch_test
     }
 
     template <size_t N>
-    typename std::enable_if<4 <= N>::type test_common_horizontal_operations(std::integral_constant<size_t, N>) const
+    std::enable_if_t<4 <= N> test_common_horizontal_operations(std::integral_constant<size_t, N>) const
     {
         // reduce common
         {
diff --git a/test/test_batch_bool.cpp b/test/test_batch_bool.cpp
index 03b848c9d..db2fad599 100644
--- a/test/test_batch_bool.cpp
+++ b/test/test_batch_bool.cpp
@@ -249,7 +249,7 @@ struct batch_bool_test
 
     // Small masks: safe to compare numeric masks at compile time
     template <class B>
-    struct xsimd_ct_mask_checker<B, typename std::enable_if<(B::size <= 31)>::type>
+    struct xsimd_ct_mask_checker<B, std::enable_if_t<(B::size <= 31)>>
     {
         static constexpr std::size_t sum_indices(uint64_t bits, std::size_t index, std::size_t remaining)
         {
@@ -410,7 +410,7 @@ struct batch_bool_test
 
     // Large masks: avoid calling mask() in constant expressions
     template <class B>
-    struct xsimd_ct_mask_checker<B, typename std::enable_if<(B::size > 31)>::type>
+    struct xsimd_ct_mask_checker<B, std::enable_if_t<(B::size > 31)>>
     {
         static void run() { }
     };
diff --git a/test/test_batch_cast.cpp b/test/test_batch_cast.cpp
index d5c0dc376..4efae9a03 100644
--- a/test/test_batch_cast.cpp
+++ b/test/test_batch_cast.cpp
@@ -18,14 +18,14 @@
 namespace detail
 {
     template <class T_out, class T_in>
-    inline typename std::enable_if<std::is_unsigned<T_in>::value && std::is_integral<T_out>::value, bool>::type
+    inline std::enable_if_t<std::is_unsigned<T_in>::value && std::is_integral<T_out>::value, bool>
     is_convertible(T_in value)
     {
         return static_cast<uint64_t>(value) <= static_cast<uint64_t>(std::numeric_limits<T_out>::max());
     }
 
     template <class T_out, class T_in>
-    inline typename std::enable_if<std::is_integral<T_in>::value && std::is_signed<T_in>::value && std::is_integral<T_out>::value && std::is_signed<T_out>::value, bool>::type
+    inline std::enable_if_t<std::is_integral<T_in>::value && std::is_signed<T_in>::value && std::is_integral<T_out>::value && std::is_signed<T_out>::value, bool>
     is_convertible(T_in value)
     {
         int64_t signed_value = static_cast<int64_t>(value);
@@ -33,21 +33,21 @@ namespace detail
     }
 
     template <class T_out, class T_in>
-    inline typename std::enable_if<std::is_integral<T_in>::value && std::is_signed<T_in>::value && std::is_unsigned<T_out>::value, bool>::type
+    inline std::enable_if_t<std::is_integral<T_in>::value && std::is_signed<T_in>::value && std::is_unsigned<T_out>::value, bool>
     is_convertible(T_in value)
     {
         return value >= 0 && is_convertible<T_out>(static_cast<uint64_t>(value));
     }
 
     template <class T_out, class T_in>
-    inline typename std::enable_if<std::is_floating_point<T_in>::value && std::is_integral<T_out>::value, bool>::type
+    inline std::enable_if_t<std::is_floating_point<T_in>::value && std::is_integral<T_out>::value, bool>
     is_convertible(T_in value)
     {
         return value < static_cast<T_in>(std::numeric_limits<T_out>::max()) && value >= static_cast<T_in>(std::numeric_limits<T_out>::lowest());
     }
 
     template <class T_out, class T_in>
-    inline typename std::enable_if<std::is_floating_point<T_out>::value, bool>::type
+    inline std::enable_if_t<std::is_floating_point<T_out>::value, bool>
     is_convertible(T_in)
     {
         return true;
@@ -207,7 +207,7 @@ struct batch_cast_test
 
 #if 0 && XSIMD_X86_INSTR_SET >= XSIMD_X86_AVX_VERSION
     template <size_t Align = A>
-    typename std::enable_if<Align >= 32>::type test_cast_sizeshift1() const
+    std::enable_if_t<Align >:type test_cast_sizeshift1() const
     {
         for (const auto& test_value : int_test_values)
         {
@@ -264,14 +264,14 @@ struct batch_cast_test
     }
 
     template <size_t Align = A>
-    typename std::enable_if<Align < 32>::type test_cast_sizeshift1() const
+    std::enable_if_t<Align < 32>::type test_cast_sizeshift1() const
     {
     }
 #endif
 
-#if 0 && XSIMD_X86_INSTR_SET >= XSIMD_X86_AVX512_VERSION
+#if 0 && XSIMD_X86_INSTR_SET > D_X86_AVX512_VERSION
     template <size_t Align = A>
-    typename std::enable_if<Align >= 64>::type test_cast_sizeshift2() const
+    std::enable_if_t<Align >:type test_cast_sizeshift2() const
     {
         for (const auto& test_value : int_test_values)
         {
@@ -314,7 +314,7 @@ struct batch_cast_test
     }
 
     template <size_t Align = A>
-    typename std::enable_if<Align < 64>::type test_cast_sizeshift2() const
+    std::enable_if_t<Align < 64>::type test_cast_sizeshift2() const
     {
     }
 #endif
@@ -382,7 +382,7 @@ TEST_CASE_TEMPLATE("[xsimd cast tests]", B, CONVERSION_TYPES)
     }
 }
 #endif
-#if 0 && XSIMD_X86_INSTR_SET >= XSIMD_X86_AVX_VERSION
+#if 0 && XSIMD_X86_INSTR_SET > D_X86_AVX_VERSION
 TYPED_TEST(batch_cast_test, cast_sizeshift1)
 {
     this->test_cast_sizeshift1();
diff --git a/test/test_batch_int.cpp b/test/test_batch_int.cpp
index 3b58e0548..fec1f27c6 100644
--- a/test/test_batch_int.cpp
+++ b/test/test_batch_int.cpp
@@ -203,7 +203,7 @@ struct batch_int_test
 
     batch_int_test()
     {
-        using signed_value_type = typename std::make_signed<value_type>::type;
+        using signed_value_type = std::make_signed_t<value_type>;
         for (size_t i = 0; i < size; ++i)
         {
             bool negative_lhs = std::is_signed<value_type>::value && (i % 2 == 1);
diff --git a/test/test_complex_trigonometric.cpp b/test/test_complex_trigonometric.cpp
index a48611054..87c5a7812 100644
--- a/test/test_complex_trigonometric.cpp
+++ b/test/test_complex_trigonometric.cpp
@@ -176,13 +176,13 @@ struct complex_trigonometric_test
         CHECK_EQ(diff, 0);
     }
 
-    template <class T, typename std::enable_if<!std::is_same<T, float>::value, int>::type = 0>
+    template <class T, std::enable_if_t<!std::is_same<T, float>::value, int> = 0>
     void test_conditional_tan()
     {
         test_tan_impl();
     }
 
-    template <class T, typename std::enable_if<std::is_same<T, float>::value, int>::type = 0>
+    template <class T, std::enable_if_t<std::is_same<T, float>::value, int> = 0>
     void test_conditional_tan()
     {
 #if (XSIMD_ARM_INSTR_SET >= XSIMD_ARM7_NEON_VERSION)
diff --git a/test/test_conversion.cpp b/test/test_conversion.cpp
index 0861cd7ea..53423b73b 100644
--- a/test/test_conversion.cpp
+++ b/test/test_conversion.cpp
@@ -206,7 +206,7 @@ struct sign_conversion_test
 {
 
     using unsigned_type = T;
-    using signed_type = typename std::make_signed<T>::type;
+    using signed_type = std::make_signed_t<T>;
 
     void test_to_signed()
     {
diff --git a/test/test_utils.hpp b/test/test_utils.hpp
index 9d700dd58..0da0c6f12 100644
--- a/test/test_utils.hpp
+++ b/test/test_utils.hpp
@@ -186,25 +186,25 @@ namespace detail
     {
         // define some overloads here as integer versions do not exist for msvc
         template <class T>
-        inline typename std::enable_if<!std::is_integral<T>::value, bool>::type isinf(const T& c)
+        inline std::enable_if_t<!std::is_integral<T>::value, bool> isinf(const T& c)
         {
             return std::isinf(c);
         }
 
         template <class T>
-        inline typename std::enable_if<std::is_integral<T>::value, bool>::type isinf(const T&)
+        inline std::enable_if_t<std::is_integral<T>::value, bool> isinf(const T&)
         {
             return false;
         }
 
         template <class T>
-        inline typename std::enable_if<!std::is_integral<T>::value, bool>::type isnan(const T& c)
+        inline std::enable_if_t<!std::is_integral<T>::value, bool> isnan(const T& c)
         {
             return std::isnan(c);
         }
 
         template <class T>
-        inline typename std::enable_if<std::is_integral<T>::value, bool>::type isnan(const T&)
+        inline std::enable_if_t<std::is_integral<T>::value, bool> isnan(const T&)
         {
             return false;
         }
@@ -545,15 +545,11 @@ namespace xsimd
      * Enable metafunctions *
      ************************/
 
-    // Backport of C++14 std::enable_if
-    template <bool B, class T = void>
-    using enable_if_t = typename std::enable_if<B, T>::type;
-
     template <class T, class R>
-    using enable_integral_t = enable_if_t<std::is_integral<T>::value, R>;
+    using enable_integral_t = std::enable_if_t<std::is_integral<T>::value, R>;
 
     template <class T, class R>
-    using enable_floating_point_t = enable_if_t<std::is_floating_point<T>::value, R>;
+    using enable_floating_point_t = std::enable_if_t<std::is_floating_point<T>::value, R>;
 
     namespace mpl
     {
diff --git a/test/test_xsimd_api.cpp b/test/test_xsimd_api.cpp
index 2e62c292c..2c177b009 100644
--- a/test/test_xsimd_api.cpp
+++ b/test/test_xsimd_api.cpp
@@ -618,7 +618,7 @@ struct xsimd_api_float_types_functions
     {
         value_type val(3.3);
         int res;
-        typename std::conditional<std::is_floating_point<T>::value, int, xsimd::as_integer_t<T>>::type vres;
+        std::conditional_t<std::is_floating_point<T>::value, int, xsimd::as_integer_t<T>> vres;
         CHECK_EQ(extract(xsimd::frexp(T(val), vres)), std::frexp(val, &res));
         CHECK_EQ(extract(vres), res);
     }
@@ -647,7 +647,7 @@ struct xsimd_api_float_types_functions
     {
         value_type val0(4);
         xsimd::as_integer_t<value_type> val1(2);
-        using exponent_type = typename std::conditional<std::is_scalar<T>::value, int, xsimd::as_integer_t<T>>::type;
+        using exponent_type = std::conditional_t<std::is_scalar<T>::value, int, xsimd::as_integer_t<T>>;
         CHECK_EQ(extract(xsimd::ldexp(T(val0), exponent_type(val1))), std::ldexp(val0, static_cast<int>(val1)));
     }
     void test_lgamma()