diff --git a/aten/src/ATen/cpu/vec/vec256/vec256_convert.h b/aten/src/ATen/cpu/vec/vec256/vec256_convert.h
index 858d87a5d83f..d5910f957b6d 100644
--- a/aten/src/ATen/cpu/vec/vec256/vec256_convert.h
+++ b/aten/src/ATen/cpu/vec/vec256/vec256_convert.h
@@ -271,9 +271,9 @@ struct VecConvert<
     1,
     int64_t,
     2,
-    typename std::enable_if<
+    std::enable_if_t<
         std::is_same_v<dst_t, int8_t> ||
-        std::is_same_v<dst_t, uint8_t>>::type> {
+        std::is_same_v<dst_t, uint8_t>>> {
   static inline VectorizedN<dst_t, 1> apply(
       const VectorizedN<int64_t, 2>& src) {
     return VecConvert<dst_t, 1, int32_t, 1>::apply(
diff --git a/aten/src/ATen/cpu/vec/vec256/zarch/vec256_zarch.h b/aten/src/ATen/cpu/vec/vec256/zarch/vec256_zarch.h
index 4ca57363ee4b..a85112f54a1e 100644
--- a/aten/src/ATen/cpu/vec/vec256/zarch/vec256_zarch.h
+++ b/aten/src/ATen/cpu/vec/vec256/zarch/vec256_zarch.h
@@ -2868,7 +2868,7 @@ std::pair<Vectorized<int64_t>, Vectorized<int64_t>> inline deinterleave2<
 }
 
 template <typename T>
-typename std::enable_if<std::is_same<T, uint8_t>::value, at::vec::Vectorized<float>>::type
+std::enable_if_t<std::is_same_v<T, uint8_t>, at::vec::Vectorized<float>>
 inline convert_int8_to_float(const Vectorized<T> &src) {
   // Note: this function only convert inputs number of elements equal to at::vec::Vectorized<float>.size()
   // Only handle first 64 bits
@@ -2878,7 +2878,7 @@ inline convert_int8_to_float(const Vectorized<T> &src) {
 }
 
 template <typename T>
-typename std::enable_if<std::is_same<T, uint8_t>::value, at::vec::Vectorized<T>>::type
+std::enable_if_t<std::is_same_v<T, uint8_t>, at::vec::Vectorized<T>>
 inline convert_float_to_int8(const Vectorized<float> &src) {
   constexpr auto min_val = std::numeric_limits<T>::min();
   constexpr auto max_val = std::numeric_limits<T>::max();
diff --git a/aten/src/ATen/cpu/vec/vec512/vec512_convert.h b/aten/src/ATen/cpu/vec/vec512/vec512_convert.h
index cfb4ddb13732..af4801cccf48 100644
--- a/aten/src/ATen/cpu/vec/vec512/vec512_convert.h
+++ b/aten/src/ATen/cpu/vec/vec512/vec512_convert.h
@@ -281,9 +281,9 @@ struct VecConvert<
     1,
     int64_t,
     2,
-    typename std::enable_if<
+    std::enable_if_t<
         std::is_same_v<dst_t, int8_t> ||
-        std::is_same_v<dst_t, uint8_t>>::type> {
+        std::is_same_v<dst_t, uint8_t>>> {
   static inline VectorizedN<dst_t, 1> apply(
       const VectorizedN<int64_t, 2>& src) {
     return VecConvert<dst_t, 1, int32_t, 1>::apply(
diff --git a/aten/src/ATen/cpu/vec/vec512/vec512_mask.h b/aten/src/ATen/cpu/vec/vec512/vec512_mask.h
index cdb433af2525..d32e1da1cf72 100644
--- a/aten/src/ATen/cpu/vec/vec512/vec512_mask.h
+++ b/aten/src/ATen/cpu/vec/vec512/vec512_mask.h
@@ -84,9 +84,9 @@ struct VecMaskLoad<
     dst_n,
     mask_t,
     dst_n,
-    typename std::enable_if<
+    std::enable_if_t<
         std::is_same_v<data_t, BFloat16> ||
-        std::is_same_v<data_t, Half>>::type> {
+        std::is_same_v<data_t, Half>>> {
   static inline VectorizedN<data_t, dst_n> apply(
       const data_t* ptr,
       const VecMask<mask_t, dst_n>& vec_mask) {
@@ -151,9 +151,9 @@ struct VecMaskLoad<
     1,
     mask_t,
     1,
-    typename std::enable_if<
+    std::enable_if_t<
         std::is_same_v<data_t, int8_t> ||
-        std::is_same_v<data_t, uint8_t>>::type> {
+        std::is_same_v<data_t, uint8_t>>> {
   static inline VectorizedN<data_t, 1> apply(
       const data_t* ptr,
       const VecMask<mask_t, 1>& vec_mask) {
@@ -173,9 +173,9 @@ struct VecMaskLoad<
     2,
     mask_t,
     1,
-    typename std::enable_if<
+    std::enable_if_t<
         std::is_same_v<data_t, int64_t> ||
-        std::is_same_v<data_t, double>>::type> {
+        std::is_same_v<data_t, double>>> {
   static inline VectorizedN<data_t, 2> apply(
       const data_t* ptr,
       const VecMask<mask_t, 1>& vec_mask) {
diff --git a/aten/src/ATen/native/EmbeddingBag.cpp b/aten/src/ATen/native/EmbeddingBag.cpp
index fbff571fecec..58dc1b991d26 100644
--- a/aten/src/ATen/native/EmbeddingBag.cpp
+++ b/aten/src/ATen/native/EmbeddingBag.cpp
@@ -106,7 +106,7 @@ bool is_fast_path(const Tensor& src, const std::optional<Tensor>& scale, Tensor&
 // index_add (using add_indices as the index), without creating an intermediary
 // tensor to hold the selected embeddings
 template <typename data_t, typename index_t>
-static typename std::enable_if<std::is_same<data_t, double>::value, void>::type
+static std::enable_if_t<std::is_same_v<data_t, double>, void>
 index_select_add(
     const Tensor& select_indices,
     const Tensor& add_indices,
@@ -184,10 +184,9 @@ void fbgemm_spmdm_report_error_(
 } // namespace
 
 template <typename data_t, typename index_t>
-typename std::enable_if<
-    std::is_same<data_t, at::Half>::value ||
-        std::is_same<data_t, at::BFloat16>::value,
-    void>::type
+std::enable_if_t<
+    std::is_same_v<data_t, at::Half> || std::is_same_v<data_t, at::BFloat16>,
+    void>
 index_select_add(
     const Tensor& select_indices,
     const Tensor& add_indices,
@@ -366,7 +365,7 @@ index_select_add(
   }
 }
 template<typename data_t, typename index_t>
-typename std::enable_if<std::is_same<data_t, float>::value, void>::type
+std::enable_if_t<std::is_same_v<data_t, float>, void>
 index_select_add(const Tensor &select_indices,
                              const Tensor &add_indices,
                              const Tensor &src,
@@ -493,7 +492,7 @@ index_select_add(const Tensor &select_indices,
 // mul (scaling by per_sample_weights)
 // index_add (using add_indices as the index)
 template <typename data_t, typename index_t>
-static typename std::enable_if<std::is_same<data_t, double>::value, void>::type
+static std::enable_if_t<std::is_same_v<data_t, double>, void>
 index_select_scale_add(
     const Tensor& select_indices,
     const Tensor& add_indices,
@@ -548,10 +547,9 @@ index_select_scale_add(
 }
 
 template <typename data_t, typename index_t>
-typename std::enable_if<
-    std::is_same<data_t, at::Half>::value ||
-        std::is_same<data_t, at::BFloat16>::value,
-    void>::type
+std::enable_if_t<
+    std::is_same_v<data_t, at::Half> || std::is_same_v<data_t, at::BFloat16>,
+    void>
 index_select_scale_add(
     const Tensor& select_indices,
     const Tensor& add_indices,
@@ -741,7 +739,7 @@ index_select_scale_add(
   }
 }
 template<typename data_t, typename index_t>
-typename std::enable_if<std::is_same<data_t, float>::value, void>::type
+std::enable_if_t<std::is_same_v<data_t, float>, void>
 index_select_scale_add(const Tensor &select_indices,
                                           const Tensor &add_indices,
                                           const Tensor &scale,
diff --git a/aten/src/ATen/native/Pow.h b/aten/src/ATen/native/Pow.h
index 76ddda846a59..f0e03b13f8f2 100644
--- a/aten/src/ATen/native/Pow.h
+++ b/aten/src/ATen/native/Pow.h
@@ -23,7 +23,7 @@ namespace native {
 // e.g. since 2**-1==0.5, the truncated integral result is zero. 1**negative_exponent is the
 // only non-zero result.
 template <class T,
-  typename std::enable_if<std::is_integral<T>::value, T>::type* = nullptr>
+  std::enable_if_t<std::is_integral_v<T>, T>* = nullptr>
 inline HOST_DEVICE __ubsan_ignore_signed_int_overflow__ T powi_impl(T a, T b) {
   T result = 1;
   while (b) {
@@ -37,13 +37,13 @@ inline HOST_DEVICE __ubsan_ignore_signed_int_overflow__ T powi_impl(T a, T b) {
 }
 
 template <class T,
-  typename std::enable_if<std::is_integral<T>::value && !std::is_signed<T>::value, T>::type* = nullptr>
+  std::enable_if_t<std::is_integral_v<T> && !std::is_signed_v<T>, T>* = nullptr>
 inline HOST_DEVICE T powi(T a, T b) {
   return powi_impl(a, b);
 }
 
 template <class T,
-  typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value, T>::type* = nullptr>
+  std::enable_if_t<std::is_integral_v<T> && std::is_signed_v<T>, T>* = nullptr>
 inline HOST_DEVICE T powi(T a, T b) {
   if ( b < 0 ) {
       if ( a == 1 ) {
diff --git a/aten/src/ATen/native/ReduceOps.cpp b/aten/src/ATen/native/ReduceOps.cpp
index e9201df2f336..766fa7f8d981 100644
--- a/aten/src/ATen/native/ReduceOps.cpp
+++ b/aten/src/ATen/native/ReduceOps.cpp
@@ -753,11 +753,11 @@ Tensor cumprod_backward(const Tensor& grad, const Tensor& input, int64_t dim, co
 namespace {
 #ifdef _MSC_VER
 template<typename T>
-inline typename std::enable_if<std::is_integral<T>::value, bool>::type isnan_(T x) {
+inline std::enable_if_t<std::is_integral_v<T>, bool> isnan_(T x) {
   return false;
 }
 template<typename T>
-inline typename std::enable_if<!std::is_integral<T>::value, bool>::type isnan_(T x) {
+inline std::enable_if_t<!std::is_integral_v<T>, bool> isnan_(T x) {
   return std::isnan(x);
 }
 #else
diff --git a/aten/src/ATen/native/cpu/BlasKernel.cpp b/aten/src/ATen/native/cpu/BlasKernel.cpp
index dd0375698219..d2475093bdd7 100644
--- a/aten/src/ATen/native/cpu/BlasKernel.cpp
+++ b/aten/src/ATen/native/cpu/BlasKernel.cpp
@@ -96,7 +96,7 @@ auto sum(int64_t N, Func f) {
 }
 
 template <typename scalar_t, typename opmath_t>
-typename std::enable_if<std::is_same<scalar_t, opmath_t>::value, void>::type
+std::enable_if_t<std::is_same_v<scalar_t, opmath_t>, void>
 gemm_notrans_(
     int64_t m,
     int64_t n,
@@ -132,7 +132,7 @@ gemm_notrans_(
 
 // std::is_same<scalar_t, at::BFloat16> || std::is_same<scalar_t, at::Half>
 template <typename scalar_t, typename opmath_t>
-typename std::enable_if<!std::is_same<scalar_t, opmath_t>::value, void>::type
+std::enable_if_t<!std::is_same_v<scalar_t, opmath_t>, void>
 gemm_notrans_(
     int64_t m,
     int64_t n,
@@ -222,7 +222,7 @@ void gemm_transb_impl(
 }
 
 template <typename scalar_t, typename opmath_t>
-typename std::enable_if<std::is_same<scalar_t, opmath_t>::value, void>::type
+std::enable_if_t<std::is_same_v<scalar_t, opmath_t>, void>
 gemm_transb_(
     TransposeType transb,
     int64_t m,
@@ -244,7 +244,7 @@ gemm_transb_(
 
 // std::is_same<scalar_t, at::BFloat16> || std::is_same<scalar_t, at::Half>
 template <typename scalar_t, typename opmath_t>
-typename std::enable_if<!std::is_same<scalar_t, opmath_t>::value, void>::type
+std::enable_if_t<!std::is_same_v<scalar_t, opmath_t>, void>
 gemm_transb_(
     TransposeType transb,
     int64_t m,
diff --git a/aten/src/ATen/native/cpu/FusedAdagradKernel.cpp b/aten/src/ATen/native/cpu/FusedAdagradKernel.cpp
index e19915e0a4f2..24f04111f12c 100644
--- a/aten/src/ATen/native/cpu/FusedAdagradKernel.cpp
+++ b/aten/src/ATen/native/cpu/FusedAdagradKernel.cpp
@@ -12,10 +12,10 @@ namespace at::native {
 namespace{
 
 template <typename scalar_t, typename opmath_t>
-typename std::enable_if<
-    std::is_same<scalar_t, Half>::value || std::is_same<scalar_t, BFloat16>::value,
-    void>::
-    type inline adagrad_math(
+std::enable_if_t<
+    std::is_same_v<scalar_t, Half> || std::is_same_v<scalar_t, BFloat16>,
+    void>
+    inline adagrad_math(
   scalar_t* param_ptr,
   scalar_t* grad_ptr,
   scalar_t* state_sum_ptr,
@@ -81,10 +81,10 @@ typename std::enable_if<
 
 
 template <typename scalar_t, typename opmath_t>
-typename std::enable_if<
-    std::is_same<scalar_t, float>::value || std::is_same<scalar_t, double>::value,
-    void>::
-    type inline adagrad_math(
+std::enable_if_t<
+    std::is_same_v<scalar_t, float> || std::is_same_v<scalar_t, double>,
+    void>
+    inline adagrad_math(
   scalar_t* param_ptr,
   scalar_t* grad_ptr,
   scalar_t* state_sum_ptr,
diff --git a/aten/src/ATen/native/cpu/FusedAdamKernel.cpp b/aten/src/ATen/native/cpu/FusedAdamKernel.cpp
index 239cdc3b37ac..f583e089c6c0 100644
--- a/aten/src/ATen/native/cpu/FusedAdamKernel.cpp
+++ b/aten/src/ATen/native/cpu/FusedAdamKernel.cpp
@@ -12,10 +12,10 @@ namespace at::native {
 namespace{
 
 template <typename scalar_t, typename opmath_t, ADAM_MODE adam_mode>
-typename std::enable_if<
-    std::is_same<scalar_t, Half>::value || std::is_same<scalar_t, BFloat16>::value,
-    void>::
-    type inline adam_math(
+std::enable_if_t<
+    std::is_same_v<scalar_t, Half> || std::is_same_v<scalar_t, BFloat16>,
+    void>
+    inline adam_math(
   scalar_t* param_ptr,
   scalar_t* exp_avg_ptr,
   scalar_t* exp_avg_sq_ptr,
@@ -155,10 +155,10 @@ typename std::enable_if<
 
 
 template <typename scalar_t, typename opmath_t, ADAM_MODE adam_mode>
-typename std::enable_if<
-    std::is_same<scalar_t, float>::value || std::is_same<scalar_t, double>::value,
-    void>::
-    type inline adam_math(
+std::enable_if_t<
+    std::is_same_v<scalar_t, float> || std::is_same_v<scalar_t, double>,
+    void>
+    inline adam_math(
   scalar_t* param_ptr,
   scalar_t* exp_avg_ptr,
   scalar_t* exp_avg_sq_ptr,
diff --git a/aten/src/ATen/native/cpu/FusedSGDKernel.cpp b/aten/src/ATen/native/cpu/FusedSGDKernel.cpp
index 95e96ff5cf55..023feeb16fe0 100644
--- a/aten/src/ATen/native/cpu/FusedSGDKernel.cpp
+++ b/aten/src/ATen/native/cpu/FusedSGDKernel.cpp
@@ -12,10 +12,10 @@ namespace at::native {
 namespace{
 
 template <typename scalar_t, typename opmath_t>
-typename std::enable_if<
-    std::is_same<scalar_t, Half>::value || std::is_same<scalar_t, BFloat16>::value,
-    void>::
-    type inline sgd_math(
+std::enable_if_t<
+    std::is_same_v<scalar_t, Half> || std::is_same_v<scalar_t, BFloat16>,
+    void>
+    inline sgd_math(
   scalar_t* param_ptr,
   scalar_t* grad_ptr,
   scalar_t* momentum_buf_ptr,
@@ -104,10 +104,10 @@ typename std::enable_if<
 
 
 template <typename scalar_t, typename opmath_t>
-typename std::enable_if<
-    std::is_same<scalar_t, float>::value || std::is_same<scalar_t, double>::value,
-    void>::
-    type inline sgd_math(
+std::enable_if_t<
+    std::is_same_v<scalar_t, float> || std::is_same_v<scalar_t, double>,
+    void>
+    inline sgd_math(
   scalar_t* param_ptr,
   scalar_t* grad_ptr,
   scalar_t* momentum_buf_ptr,
diff --git a/aten/src/ATen/native/cpu/IsContiguous.h b/aten/src/ATen/native/cpu/IsContiguous.h
index ddbbb6fb8f5a..02d8f5dd78e4 100644
--- a/aten/src/ATen/native/cpu/IsContiguous.h
+++ b/aten/src/ATen/native/cpu/IsContiguous.h
@@ -31,14 +31,16 @@ struct IsContiguous<0, -1, traits, s> {
 };
 
 // output and all inputs are contiguous
-template <typename traits,
-    typename std::enable_if<std::is_void<typename traits::result_type>::value>::type* = nullptr>
+template <
+    typename traits,
+    std::enable_if_t<std::is_void_v<typename traits::result_type>>* =
+        nullptr>
 static inline bool is_contiguous(const int64_t* strides) {
   return IsContiguous<traits::arity, traits::arity - 1, traits>::eval(strides);
 }
 
 template <typename traits,
-    typename std::enable_if<!std::is_void<typename traits::result_type>::value>::type* = nullptr>
+    std::enable_if_t<!std::is_void_v<typename traits::result_type>>* = nullptr>
 static inline bool is_contiguous(const int64_t* strides) {
   return IsContiguous<traits::arity, traits::arity, traits>::eval(strides);
 }
@@ -46,14 +48,14 @@ static inline bool is_contiguous(const int64_t* strides) {
 // input at `s` is scalar (stride 0); output and other inputs are contiguous
 // NB: output is typically at strides[0] so first input corresponds to s=1
 template <typename traits, int s,
-    typename std::enable_if<std::is_void<typename traits::result_type>::value>::type* = nullptr>
+    std::enable_if_t<std::is_void_v<typename traits::result_type>>* = nullptr>
 static inline bool is_contiguous_scalar(const int64_t* strides) {
   static_assert(s > 0 && s <= traits::arity, "scalar argument index out of bounds");
   return IsContiguous<traits::arity, traits::arity - 1, traits, s>::eval(strides);
 }
 
 template <typename traits, int s,
-    typename std::enable_if<!std::is_void<typename traits::result_type>::value>::type* = nullptr>
+    std::enable_if_t<!std::is_void_v<typename traits::result_type>>* = nullptr>
 static inline bool is_contiguous_scalar(const int64_t* strides) {
   static_assert(s > 0 && s <= traits::arity, "scalar argument index out of bounds");
   return IsContiguous<traits::arity, traits::arity, traits, s>::eval(strides);
diff --git a/aten/src/ATen/native/cpu/MaxPoolKernel.cpp b/aten/src/ATen/native/cpu/MaxPoolKernel.cpp
index c752106130fe..15b784f05521 100644
--- a/aten/src/ATen/native/cpu/MaxPoolKernel.cpp
+++ b/aten/src/ATen/native/cpu/MaxPoolKernel.cpp
@@ -64,7 +64,7 @@ vec::Vectorized<int64_t> is_nan_vec<int64_t>(vec::Vectorized<int64_t> vec) {
 
 template <typename scalar_t, typename opmath_t>
 inline
-typename std::enable_if<std::is_same<scalar_t, opmath_t>::value, void>::type
+std::enable_if_t<std::is_same_v<scalar_t, opmath_t>, void>
 compute_internal(
   const scalar_t* input_data,
   scalar_t* out_data,
@@ -139,7 +139,7 @@ compute_internal(
 // std::is_same<scalar_t, at::BFloat16> || std::is_same<scalar_t, at::Half>
 template <typename scalar_t, typename opmath_t>
 inline
-typename std::enable_if<!std::is_same<scalar_t, opmath_t>::value, void>::type
+std::enable_if_t<!std::is_same_v<scalar_t, opmath_t>, void>
 compute_internal(
   const scalar_t* input_data,
   scalar_t* out_data,
diff --git a/aten/src/ATen/native/cpu/Reduce.h b/aten/src/ATen/native/cpu/Reduce.h
index 4e512119d3fe..aeec6a3fda7e 100644
--- a/aten/src/ATen/native/cpu/Reduce.h
+++ b/aten/src/ATen/native/cpu/Reduce.h
@@ -129,13 +129,13 @@ static void set_results(const res_t result, const TensorIteratorBase &iter, cons
 }
 
 template<typename traits, std::size_t i = 0, typename... tuple_t>
-inline typename std::enable_if<i == sizeof...(tuple_t), std::size_t>::type
+inline std::enable_if_t<i == sizeof...(tuple_t), std::size_t>
 for_each_in_tuple(const std::tuple<tuple_t...>& /*t*/, const TensorIteratorBase& /*iter*/, const int /*num_outputs*/) {
   return i;
 }
 
 template<typename traits, std::size_t i = 0, typename... tuple_t>
-inline typename std::enable_if<i < sizeof...(tuple_t), std::size_t>::type
+inline std::enable_if_t<i < sizeof...(tuple_t), std::size_t>
 for_each_in_tuple(const std::tuple<tuple_t...>& t, const TensorIteratorBase &iter, const int num_outputs) {
   if (i < (size_t)num_outputs) {
     set_result<traits>(i, std::get<i>(t), iter, num_outputs);
diff --git a/aten/src/ATen/native/cpu/ReduceUtils.h b/aten/src/ATen/native/cpu/ReduceUtils.h
index 8c6424f8b0ea..fd7c4a2750a6 100644
--- a/aten/src/ATen/native/cpu/ReduceUtils.h
+++ b/aten/src/ATen/native/cpu/ReduceUtils.h
@@ -106,7 +106,7 @@ inline void _init(scalar_t* self_ptr, at::opmath_type<scalar_t>* buffer_ptr, int
 }
 
 template <typename scalar_t>
-inline typename std::enable_if<!std::is_same<scalar_t, Vec2>::value, scalar_t>::type
+inline std::enable_if_t<!std::is_same_v<scalar_t, Vec2>, scalar_t>
 _max(const scalar_t& x, const scalar_t& y) {
   return at::_isnan(y) ? y : std::max(x, y);
 }
@@ -118,14 +118,14 @@ inline Vectorized<scalar_t> _max(const Vectorized<scalar_t>& x, const Vectorized
 }
 
 template <typename vec_t>
-inline typename std::enable_if<std::is_same<vec_t, Vec2>::value, Vec2>::type
+inline std::enable_if_t<std::is_same_v<vec_t, Vec2>, Vec2>
 _max(const vec_t& x, const vec_t& y) {
   // vec::maximum propagates NaN
   return maximum(x, y);
 }
 
 template <typename scalar_t>
-inline typename std::enable_if<!std::is_same<scalar_t, Vec2>::value, scalar_t>::type
+inline std::enable_if_t<!std::is_same_v<scalar_t, Vec2>, scalar_t>
 _min(const scalar_t& x, const scalar_t& y) {
   return at::_isnan(y) ? y : std::min(x, y);
 }
@@ -137,7 +137,7 @@ inline Vectorized<scalar_t> _min(const Vectorized<scalar_t>& x, const Vectorized
 }
 
 template <typename vec_t>
-inline typename std::enable_if<std::is_same<vec_t, Vec2>::value, Vec2>::type
+inline std::enable_if_t<std::is_same_v<vec_t, Vec2>, Vec2>
 _min(const vec_t& x, const vec_t& y) {
   // vec::minimum propagates NaN
   return minimum(x, y);
diff --git a/aten/src/ATen/native/cpu/group_norm_kernel.cpp b/aten/src/ATen/native/cpu/group_norm_kernel.cpp
index f6b7f2a5d481..0aee364b49d8 100644
--- a/aten/src/ATen/native/cpu/group_norm_kernel.cpp
+++ b/aten/src/ATen/native/cpu/group_norm_kernel.cpp
@@ -85,8 +85,8 @@ void GroupNormKernelImplInternal(
 }
 
 template <typename T>
-typename std::enable_if<std::is_same<T, at::opmath_type<T>>::value,
-  std::tuple<T, T>>::type
+std::enable_if_t<std::is_same_v<T, at::opmath_type<T>>,
+  std::tuple<T, T>>
 ColumnwiseMoments(
     const T* X_data,
     int64_t HxW,
@@ -118,8 +118,8 @@ ColumnwiseMoments(
 
 // std::is_same<T, at::BFloat16> || std::is_same<T, at::Half>
 template <typename T>
-typename std::enable_if<!std::is_same<T, at::opmath_type<T>>::value,
-  std::tuple<at::opmath_type<T>, at::opmath_type<T>>>::type
+std::enable_if_t<!std::is_same_v<T, at::opmath_type<T>>,
+  std::tuple<at::opmath_type<T>, at::opmath_type<T>>>
 ColumnwiseMoments(
     const T* X_data,
     int64_t HxW,
@@ -160,7 +160,7 @@ ColumnwiseMoments(
 }
 
 template <typename T, typename opmath_t>
-inline typename std::enable_if<std::is_same<T, opmath_t>::value, void>::type
+inline std::enable_if_t<std::is_same_v<T, opmath_t>, void>
 CalcMeanVar(
   const T* X_ptr,
   opmath_t* mean_ptr,
@@ -183,7 +183,7 @@ CalcMeanVar(
 
 // std::is_same<T, at::BFloat16> || std::is_same<T, at::Half>
 template <typename T, typename opmath_t>
-inline typename std::enable_if<!std::is_same<T, opmath_t>::value, void>::type
+inline std::enable_if_t<!std::is_same_v<T, opmath_t>, void>
 CalcMeanVar(
   const T* X_ptr,
   opmath_t* mean_ptr,
@@ -227,7 +227,7 @@ CalcMeanVar(
 }
 
 template <typename T, typename opmath_t>
-inline typename std::enable_if<std::is_same<T, opmath_t>::value, void>::type
+inline std::enable_if_t<std::is_same_v<T, opmath_t>, void>
 ApplyScaleBias(
   T* Y_ptr,
   const T* X_ptr,
@@ -246,7 +246,7 @@ ApplyScaleBias(
 
 // std::is_same<T, at::BFloat16> || std::is_same<T, at::Half>
 template <typename T, typename opmath_t>
-inline typename std::enable_if<!std::is_same<T, opmath_t>::value, void>::type
+inline std::enable_if_t<!std::is_same_v<T, opmath_t>, void>
 ApplyScaleBias(
   T* Y_ptr,
   const T* X_ptr,
@@ -529,7 +529,7 @@ void GroupNormKernelImpl(
 
 
 template <typename T, typename opmath_t>
-typename std::enable_if<std::is_same<T, opmath_t>::value, void>::type
+std::enable_if_t<std::is_same_v<T, opmath_t>, void>
 ComputeInternalGradients(
     int64_t N,
     int64_t C,
@@ -556,7 +556,7 @@ ComputeInternalGradients(
 }
 
 template <typename T, typename opmath_t>
-typename std::enable_if<!std::is_same<T, opmath_t>::value, void>::type
+std::enable_if_t<!std::is_same_v<T, opmath_t>, void>
 ComputeInternalGradients(
     int64_t N,
     int64_t C,
@@ -603,7 +603,7 @@ ComputeInternalGradients(
 }
 
 template <typename PT, typename opmath_t>
-inline typename std::enable_if<std::is_same<PT, opmath_t>::value, void>::type
+inline std::enable_if_t<std::is_same_v<PT, opmath_t>, void>
 CalcDsDb(
     const opmath_t* ds_ptr,
     const opmath_t* db_ptr,
@@ -626,7 +626,7 @@ CalcDsDb(
 }
 
 template <typename PT, typename opmath_t>
-inline typename std::enable_if<!std::is_same<PT, opmath_t>::value, void>::type
+inline std::enable_if_t<!std::is_same_v<PT, opmath_t>, void>
 CalcDsDb(
     const opmath_t* ds_ptr,
     const opmath_t* db_ptr,
@@ -708,7 +708,7 @@ void GroupNormInputBackward(
 }
 
 template <typename PT, typename opmath_t>
-typename std::enable_if<std::is_same<PT, opmath_t>::value, void>::type
+std::enable_if_t<std::is_same_v<PT, opmath_t>, void>
 GammaBackward(
     int64_t N,
     int64_t C,
@@ -755,7 +755,7 @@ GammaBackward(
 }
 
 template <typename PT, typename opmath_t>
-typename std::enable_if<!std::is_same<PT, opmath_t>::value, void>::type
+std::enable_if_t<!std::is_same_v<PT, opmath_t>, void>
 GammaBackward(
     int64_t N,
     int64_t C,
@@ -817,7 +817,7 @@ GammaBackward(
 }
 
 template <typename PT, typename opmath_t>
-typename std::enable_if<std::is_same<PT, opmath_t>::value, void>::type
+std::enable_if_t<std::is_same_v<PT, opmath_t>, void>
 BetaBackward(int64_t N, int64_t C, const opmath_t* db, PT* dbeta) {
   using Vec = at::vec::Vectorized<PT>;
   constexpr int64_t K = Vec::size();
@@ -841,7 +841,7 @@ BetaBackward(int64_t N, int64_t C, const opmath_t* db, PT* dbeta) {
 }
 
 template <typename PT, typename opmath_t>
-typename std::enable_if<!std::is_same<PT, opmath_t>::value, void>::type
+std::enable_if_t<!std::is_same_v<PT, opmath_t>, void>
 BetaBackward(int64_t N, int64_t C, const opmath_t* db, PT* dbeta) {
   using Vec = at::vec::Vectorized<PT>;
   using fVec = at::vec::Vectorized<opmath_t>;
@@ -937,7 +937,7 @@ void GroupNormBackwardKernelImplInternal(
 }
 
 template <typename T, typename opmath_t>
-inline typename std::enable_if<std::is_same<T, opmath_t>::value, void>::type
+inline std::enable_if_t<std::is_same_v<T, opmath_t>, void>
 DsDbRowwiseMomentsChannelsLast(
   const T* dY_ptr,
   const T* X_ptr,
@@ -972,7 +972,7 @@ DsDbRowwiseMomentsChannelsLast(
 }
 
 template <typename T, typename opmath_t>
-inline typename std::enable_if<!std::is_same<T, opmath_t>::value, void>::type
+inline std::enable_if_t<!std::is_same_v<T, opmath_t>, void>
 DsDbRowwiseMomentsChannelsLast(
   const T* dY_ptr,
   const T* X_ptr,
@@ -1024,10 +1024,10 @@ DsDbRowwiseMomentsChannelsLast(
 }
 
 template <typename T>
-inline typename std::enable_if<std::is_same<T, at::opmath_type<T>>::value,
+inline std::enable_if_t<std::is_same_v<T, at::opmath_type<T>>,
   std::tuple<
   vec::Vectorized<T>,
-  vec::Vectorized<T>>>::type
+  vec::Vectorized<T>>>
 load_util(const T* data_ptr, int64_t n) {
   using Vec = vec::Vectorized<T>;
   auto vec0 = Vec::loadu(data_ptr, n > Vec::size() ? Vec::size() : n);
@@ -1037,11 +1037,11 @@ load_util(const T* data_ptr, int64_t n) {
 }
 
 template <typename T>
-inline typename std::enable_if<!std::is_same<T, at::opmath_type<T>>::value,
+inline std::enable_if_t<!std::is_same_v<T, at::opmath_type<T>>,
   std::tuple<
     vec::Vectorized<at::opmath_type<T>>,
     vec::Vectorized<at::opmath_type<T>>>
-    >::type
+    >
 load_util(const T* data_ptr, int64_t n) {
   using Vec = vec::Vectorized<T>;
   auto vec = Vec::loadu(data_ptr, n);
@@ -1049,7 +1049,7 @@ load_util(const T* data_ptr, int64_t n) {
 }
 
 template <typename T, typename PT, typename opmath_t>
-inline typename std::enable_if<std::is_same<T, opmath_t>::value, void>::type
+inline std::enable_if_t<std::is_same_v<T, opmath_t>, void>
 ApplyInputGradientsChannelsLastColMov(
   const T* dY_data,
   const T* X_data,
@@ -1097,7 +1097,7 @@ ApplyInputGradientsChannelsLastColMov(
 }
 
 template <typename T, typename PT, typename opmath_t>
-inline typename std::enable_if<!std::is_same<T, opmath_t>::value, void>::type
+inline std::enable_if_t<!std::is_same_v<T, opmath_t>, void>
 ApplyInputGradientsChannelsLastColMov(
     const T* dY_data,
     const T* X_data,
@@ -1154,7 +1154,7 @@ ApplyInputGradientsChannelsLastColMov(
 }
 
 template <typename T, typename PT, typename opmath_t>
-inline typename std::enable_if<std::is_same<T, opmath_t>::value, void>::type
+inline std::enable_if_t<std::is_same_v<T, opmath_t>, void>
 ApplyInputGradientsChannelsLastRowMov(
   const T* dY_data,
   const T* X_data,
@@ -1190,7 +1190,7 @@ ApplyInputGradientsChannelsLastRowMov(
 }
 
 template <typename T, typename PT, typename opmath_t>
-inline typename std::enable_if<!std::is_same<T, opmath_t>::value, void>::type
+inline std::enable_if_t<!std::is_same_v<T, opmath_t>, void>
 ApplyInputGradientsChannelsLastRowMov(
     const T* dY_data,
     const T* X_data,
diff --git a/torch/csrc/cuda/GdsFile.cpp b/torch/csrc/cuda/GdsFile.cpp
index b95b86b3374f..945da3be6510 100644
--- a/torch/csrc/cuda/GdsFile.cpp
+++ b/torch/csrc/cuda/GdsFile.cpp
@@ -12,8 +12,7 @@ namespace {
 // filesystem error and a negative CUfileOpError enum value otherwise).
 template <
     class T,
-    typename std::enable_if<std::is_integral<T>::value, std::nullptr_t>::type =
-        nullptr>
+    std::enable_if_t<std::is_integral_v<T>, std::nullptr_t> = nullptr>
 std::string cuGDSFileGetErrorString(T status) {
   status = std::abs(status);
   return IS_CUFILE_ERR(status) ? std::string(CUFILE_ERRSTR(status))
@@ -24,8 +23,7 @@ std::string cuGDSFileGetErrorString(T status) {
 // CUfileError_t
 template <
     class T,
-    typename std::enable_if<!std::is_integral<T>::value, std::nullptr_t>::type =
-        nullptr>
+    std::enable_if_t<!std::is_integral_v<T>, std::nullptr_t> = nullptr>
 std::string cuGDSFileGetErrorString(T status) {
   std::string errStr = cuGDSFileGetErrorString(static_cast<int>(status.err));
   if (IS_CUDA_ERR(status))
diff --git a/torch/csrc/distributed/c10d/CUDASymmetricMemory-inl.h b/torch/csrc/distributed/c10d/CUDASymmetricMemory-inl.h
index 36b3591bbdba..0515dc9fca75 100644
--- a/torch/csrc/distributed/c10d/CUDASymmetricMemory-inl.h
+++ b/torch/csrc/distributed/c10d/CUDASymmetricMemory-inl.h
@@ -418,9 +418,8 @@ __device__ __inline__ Vec<Alignment> add_vec(
 // With world_size specialization: perform balanced load from all peers before
 // performing reduction.
 template <typename T, int alignment, int k_world_size>
-__device__ inline
-    typename std::enable_if<(k_world_size > 0), Vec<alignment>>::type
-    load_and_reduce(T** ptrs, size_t rank, size_t world_size, size_t offset) {
+__device__ inline std::enable_if_t<(k_world_size > 0), Vec<alignment>>
+load_and_reduce(T** ptrs, size_t rank, size_t world_size, size_t offset) {
   Vec<alignment> vecs[k_world_size];
 #pragma unroll k_world_size
   for (size_t step = 0; step < k_world_size; ++step) {
@@ -438,9 +437,8 @@ __device__ inline
 // Without world_size specialization: perform ordered (unbalanced) load and
 // accumulate on each load.
 template <typename T, int alignment, int k_world_size>
-__device__ inline
-    typename std::enable_if<(k_world_size <= 0), Vec<alignment>>::type
-    load_and_reduce(T** ptrs, size_t rank, size_t world_size, size_t offset) {
+__device__ inline std::enable_if_t<(k_world_size <= 0), Vec<alignment>>
+load_and_reduce(T** ptrs, size_t rank, size_t world_size, size_t offset) {
   Vec<alignment> acc{};
   for (size_t step = 0; step < world_size; ++step) {
     auto vec = ld_vec<alignment>(ptrs[step] + offset);
diff --git a/torch/csrc/jit/tensorexpr/cpp_intrinsics.h b/torch/csrc/jit/tensorexpr/cpp_intrinsics.h
index caeeed693ff3..3149335ea30f 100644
--- a/torch/csrc/jit/tensorexpr/cpp_intrinsics.h
+++ b/torch/csrc/jit/tensorexpr/cpp_intrinsics.h
@@ -8,13 +8,13 @@ constexpr auto cpp_intrinsics_definition = R"(
 namespace std {
 
 template <typename T,
-          typename std::enable_if<std::is_floating_point<T>::value, int>::type = 0>
+          std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
 T rsqrt(T v) {
   return 1.0f / std::sqrt(v);
 }
 
 template <typename T,
-          typename std::enable_if<std::is_floating_point<T>::value, int>::type = 0>
+          std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
 T frac(T v) {
   T intpart;
   return std::modf(v, &intpart);
diff --git a/torch/csrc/jit/tensorexpr/llvm_codegen.cpp b/torch/csrc/jit/tensorexpr/llvm_codegen.cpp
index a9f24139e029..5fe52a0ff9e0 100644
--- a/torch/csrc/jit/tensorexpr/llvm_codegen.cpp
+++ b/torch/csrc/jit/tensorexpr/llvm_codegen.cpp
@@ -1075,14 +1075,16 @@ void LLVMCodeGenImpl::visit(const CompareSelectPtr& v) {
 }
 
 template <typename T>
-typename std::enable_if<std::is_integral<T>::value, llvm::Value*>::type
-getFromType(llvm::Type* type, T value) {
+std::enable_if_t<std::is_integral_v<T>, llvm::Value*> getFromType(
+    llvm::Type* type,
+    T value) {
   return llvm::ConstantInt::get(type, value, std::is_signed<T>::value);
 }
 
 template <typename T>
-typename std::enable_if<std::is_floating_point<T>::value, llvm::Value*>::type
-getFromType(llvm::Type* type, T value) {
+std::enable_if_t<std::is_floating_point_v<T>, llvm::Value*> getFromType(
+    llvm::Type* type,
+    T value) {
   return llvm::ConstantFP::get(type, value);
 }