Replace is_same<>::value with is_same_v<>

cpp/benchmarks/common/generate_benchmark_input.cpp

@@ -171,7 +171,7 @@ struct random_value_fn<T, typename std::enable_if_t<cudf::is_fixed_point<T>()>>
 template <typename T>
 struct random_value_fn<
   T,
-  typename std::enable_if_t<!std::is_same<T, bool>::value && cudf::is_numeric<T>()>> {
+  typename std::enable_if_t<!std::is_same_v<T, bool> && cudf::is_numeric<T>()>> {
   T const lower_bound;
   T const upper_bound;
   distribution_fn<T> dist;
@@ -194,7 +194,7 @@ struct random_value_fn<
  * @brief Creates an boolean value with given probability of returning `true`.
  */
 template <typename T>
-struct random_value_fn<T, typename std::enable_if_t<std::is_same<T, bool>::value>> {
+struct random_value_fn<T, typename std::enable_if_t<std::is_same_v<T, bool>>> {
   std::bernoulli_distribution b_dist;
 
   random_value_fn(distribution_params<bool> const& desc) : b_dist{desc.probability_true} {}
@@ -235,7 +235,7 @@ struct stored_as {
 
 // Use `int8_t` for bools because that's how they're stored in columns
 template <typename T>
-struct stored_as<T, typename std::enable_if_t<std::is_same<T, bool>::value>> {
+struct stored_as<T, typename std::enable_if_t<std::is_same_v<T, bool>>> {
   using type = int8_t;
 };
 

cpp/benchmarks/common/generate_benchmark_input.hpp

@@ -77,7 +77,7 @@ distribution_id default_distribution_id()
 }
 
 template <typename T,
-          std::enable_if_t<!std::is_same<T, bool>::value && std::is_unsigned<T>::value &&
+          std::enable_if_t<!std::is_same_v<T, bool> && std::is_unsigned<T>::value &&
                            cudf::is_numeric<T>()>* = nullptr>
 distribution_id default_distribution_id()
 {
@@ -130,7 +130,7 @@ struct distribution_params;
 template <typename T>
 struct distribution_params<
   T,
-  typename std::enable_if_t<!std::is_same<T, bool>::value && cudf::is_numeric<T>()>> {
+  typename std::enable_if_t<!std::is_same_v<T, bool> && cudf::is_numeric<T>()>> {
   distribution_id id;
   T lower_bound;
   T upper_bound;
@@ -140,7 +140,7 @@ struct distribution_params<
  * @brief Booleans are parameterized with the probability of getting `true` value.
  */
 template <typename T>
-struct distribution_params<T, typename std::enable_if_t<std::is_same<T, bool>::value>> {
+struct distribution_params<T, typename std::enable_if_t<std::is_same_v<T, bool>>> {
   double probability_true;
 };
 
@@ -158,8 +158,7 @@ struct distribution_params<T, typename std::enable_if_t<cudf::is_chrono<T>()>> {
  * @brief Strings are parameterized by the distribution of their length, as an integral value.
  */
 template <typename T>
-struct distribution_params<T,
-                           typename std::enable_if_t<std::is_same<T, cudf::string_view>::value>> {
+struct distribution_params<T, typename std::enable_if_t<std::is_same_v<T, cudf::string_view>>> {
   distribution_params<uint32_t> length_params;
 };
 
@@ -168,7 +167,7 @@ struct distribution_params<T,
  * the element type.
  */
 template <typename T>
-struct distribution_params<T, typename std::enable_if_t<std::is_same<T, cudf::list_view>::value>> {
+struct distribution_params<T, typename std::enable_if_t<std::is_same_v<T, cudf::list_view>>> {
   cudf::type_id element_type;
   distribution_params<uint32_t> length_params;
   cudf::size_type max_depth;
@@ -224,9 +223,9 @@ class data_profile {
   cudf::size_type avg_run_length = 4;
 
  public:
-  template <typename T,
-            typename std::enable_if_t<!std::is_same<T, bool>::value && std::is_integral<T>::value,
-                                      T>* = nullptr>
+  template <
+    typename T,
+    typename std::enable_if_t<!std::is_same_v<T, bool> && std::is_integral<T>::value, T>* = nullptr>
   distribution_params<T> get_distribution_params() const
   {
     auto it = int_params.find(cudf::type_to_id<T>());
@@ -252,7 +251,7 @@ class data_profile {
     }
   }
 
-  template <typename T, std::enable_if_t<std::is_same<T, bool>::value>* = nullptr>
+  template <typename T, std::enable_if_t<std::is_same_v<T, bool>>* = nullptr>
   distribution_params<T> get_distribution_params() const
   {
     return distribution_params<T>{bool_probability};
@@ -272,13 +271,13 @@ class data_profile {
     }
   }
 
-  template <typename T, std::enable_if_t<std::is_same<T, cudf::string_view>::value>* = nullptr>
+  template <typename T, std::enable_if_t<std::is_same_v<T, cudf::string_view>>* = nullptr>
   distribution_params<T> get_distribution_params() const
   {
     return string_dist_desc;
   }
 
-  template <typename T, std::enable_if_t<std::is_same<T, cudf::list_view>::value>* = nullptr>
+  template <typename T, std::enable_if_t<std::is_same_v<T, cudf::list_view>>* = nullptr>
   distribution_params<T> get_distribution_params() const
   {
     return list_dist_desc;

cpp/include/cudf/ast/detail/operators.hpp

@@ -295,8 +295,8 @@ struct operator_functor<ast_operator::MOD> {
 
   template <typename LHS,
             typename RHS,
-            typename CommonType = std::common_type_t<LHS, RHS>,
-            std::enable_if_t<std::is_same<CommonType, float>::value>* = nullptr>
+            typename CommonType                                  = std::common_type_t<LHS, RHS>,
+            std::enable_if_t<std::is_same_v<CommonType, float>>* = nullptr>
   CUDA_DEVICE_CALLABLE auto operator()(LHS lhs, RHS rhs)
     -> decltype(fmodf(static_cast<CommonType>(lhs), static_cast<CommonType>(rhs)))
   {
@@ -305,8 +305,8 @@ struct operator_functor<ast_operator::MOD> {
 
   template <typename LHS,
             typename RHS,
-            typename CommonType = std::common_type_t<LHS, RHS>,
-            std::enable_if_t<std::is_same<CommonType, double>::value>* = nullptr>
+            typename CommonType                                   = std::common_type_t<LHS, RHS>,
+            std::enable_if_t<std::is_same_v<CommonType, double>>* = nullptr>
   CUDA_DEVICE_CALLABLE auto operator()(LHS lhs, RHS rhs)
     -> decltype(fmod(static_cast<CommonType>(lhs), static_cast<CommonType>(rhs)))
   {
@@ -334,8 +334,8 @@ struct operator_functor<ast_operator::PYMOD> {
 
   template <typename LHS,
             typename RHS,
-            typename CommonType = std::common_type_t<LHS, RHS>,
-            std::enable_if_t<std::is_same<CommonType, float>::value>* = nullptr>
+            typename CommonType                                  = std::common_type_t<LHS, RHS>,
+            std::enable_if_t<std::is_same_v<CommonType, float>>* = nullptr>
   CUDA_DEVICE_CALLABLE auto operator()(LHS lhs, RHS rhs)
     -> decltype(fmodf(fmodf(static_cast<CommonType>(lhs), static_cast<CommonType>(rhs)) +
                         static_cast<CommonType>(rhs),
@@ -348,8 +348,8 @@ struct operator_functor<ast_operator::PYMOD> {
 
   template <typename LHS,
             typename RHS,
-            typename CommonType = std::common_type_t<LHS, RHS>,
-            std::enable_if_t<std::is_same<CommonType, double>::value>* = nullptr>
+            typename CommonType                                   = std::common_type_t<LHS, RHS>,
+            std::enable_if_t<std::is_same_v<CommonType, double>>* = nullptr>
   CUDA_DEVICE_CALLABLE auto operator()(LHS lhs, RHS rhs)
     -> decltype(fmod(fmod(static_cast<CommonType>(lhs), static_cast<CommonType>(rhs)) +
                        static_cast<CommonType>(rhs),

cpp/include/cudf/column/column_device_view.cuh

@@ -95,13 +95,13 @@ class alignas(16) column_device_view_base {
    *`data<T>()`.
    *
    * This function will only participate in overload resolution if `is_rep_layout_compatible<T>()`
-   * or `std::is_same<T,void>::value` are true.
+   * or `std::is_same_v<T,void>` are true.
    *
    * @tparam The type to cast to
    * @return T const* Typed pointer to underlying data
    */
   template <typename T = void,
-            CUDF_ENABLE_IF(std::is_same<T, void>::value or is_rep_layout_compatible<T>())>
+            CUDF_ENABLE_IF(std::is_same_v<T, void> or is_rep_layout_compatible<T>())>
   __host__ __device__ T const* head() const noexcept
   {
     return static_cast<T const*>(_data);
@@ -350,7 +350,7 @@ class alignas(16) column_device_view : public detail::column_device_view_base {
    * @param element_index Position of the desired string element
    * @return string_view instance representing this element at this index
    */
-  template <typename T, CUDF_ENABLE_IF(std::is_same<T, string_view>::value)>
+  template <typename T, CUDF_ENABLE_IF(std::is_same_v<T, string_view>)>
   __device__ T element(size_type element_index) const noexcept
   {
     size_type index = element_index + offset();  // account for this view's _offset
@@ -411,7 +411,7 @@ class alignas(16) column_device_view : public detail::column_device_view_base {
    * @param element_index Position of the desired element
    * @return dictionary32 instance representing this element at this index
    */
-  template <typename T, CUDF_ENABLE_IF(std::is_same<T, dictionary32>::value)>
+  template <typename T, CUDF_ENABLE_IF(std::is_same_v<T, dictionary32>)>
   __device__ T element(size_type element_index) const noexcept
   {
     size_type index    = element_index + offset();  // account for this view's _offset
@@ -429,7 +429,7 @@ class alignas(16) column_device_view : public detail::column_device_view_base {
    * @param element_index Position of the desired element
    * @return numeric::decimal32 representing the element at this index
    */
-  template <typename T, CUDF_ENABLE_IF(std::is_same<T, numeric::decimal32>::value)>
+  template <typename T, CUDF_ENABLE_IF(std::is_same_v<T, numeric::decimal32>)>
   __device__ T element(size_type element_index) const noexcept
   {
     using namespace numeric;
@@ -447,7 +447,7 @@ class alignas(16) column_device_view : public detail::column_device_view_base {
    * @param element_index Position of the desired element
    * @return numeric::decimal64 representing the element at this index
    */
-  template <typename T, CUDF_ENABLE_IF(std::is_same<T, numeric::decimal64>::value)>
+  template <typename T, CUDF_ENABLE_IF(std::is_same_v<T, numeric::decimal64>)>
   __device__ T element(size_type element_index) const noexcept
   {
     using namespace numeric;
@@ -931,7 +931,7 @@ class alignas(16) mutable_column_device_view : public detail::column_device_view
    * the specified type.
    *
    * This function will only participate in overload resolution if `is_rep_layout_compatible<T>()`
-   * or `std::is_same<T,void>::value` are true.
+   * or `std::is_same_v<T,void>` are true.
    *
    * @note If `offset() == 0`, then `head<T>() == data<T>()`
    *
@@ -943,7 +943,7 @@ class alignas(16) mutable_column_device_view : public detail::column_device_view
    * @return T* Typed pointer to underlying data
    */
   template <typename T = void,
-            CUDF_ENABLE_IF(std::is_same<T, void>::value or is_rep_layout_compatible<T>())>
+            CUDF_ENABLE_IF(std::is_same_v<T, void> or is_rep_layout_compatible<T>())>
   __host__ __device__ T* head() const noexcept
   {
     return const_cast<T*>(detail::column_device_view_base::head<T>());
@@ -1361,13 +1361,13 @@ struct pair_rep_accessor {
   }
 
  private:
-  template <typename R, std::enable_if_t<std::is_same<R, rep_type>::value, void>* = nullptr>
+  template <typename R, std::enable_if_t<std::is_same_v<R, rep_type>, void>* = nullptr>
   CUDA_DEVICE_CALLABLE auto get_rep(cudf::size_type i) const
   {
     return col.element<R>(i);
   }
 
-  template <typename R, std::enable_if_t<not std::is_same<R, rep_type>::value, void>* = nullptr>
+  template <typename R, std::enable_if_t<not std::is_same_v<R, rep_type>, void>* = nullptr>
   CUDA_DEVICE_CALLABLE auto get_rep(cudf::size_type i) const
   {
     return col.element<R>(i).value();

cpp/include/cudf/column/column_view.hpp

@@ -58,13 +58,13 @@ class column_view_base {
    *`data<T>()`.
    *
    * This function will only participate in overload resolution if `is_rep_layout_compatible<T>()`
-   * or `std::is_same<T,void>::value` are true.
+   * or `std::is_same_v<T,void>` are true.
    *
    * @tparam The type to cast to
    * @return T const* Typed pointer to underlying data
    */
   template <typename T = void,
-            CUDF_ENABLE_IF(std::is_same<T, void>::value or is_rep_layout_compatible<T>())>
+            CUDF_ENABLE_IF(std::is_same_v<T, void> or is_rep_layout_compatible<T>())>
   T const* head() const noexcept
   {
     return static_cast<T const*>(_data);
@@ -452,7 +452,7 @@ class mutable_column_view : public detail::column_view_base {
    * the specified type.
    *
    * This function will only participate in overload resolution if `is_rep_layout_compatible<T>()`
-   * or `std::is_same<T,void>::value` are true.
+   * or `std::is_same_v<T,void>` are true.
    *
    * @note If `offset() == 0`, then `head<T>() == data<T>()`
    *
@@ -463,7 +463,7 @@ class mutable_column_view : public detail::column_view_base {
    * @return T* Typed pointer to underlying data
    */
   template <typename T = void,
-            CUDF_ENABLE_IF(std::is_same<T, void>::value or is_rep_layout_compatible<T>())>
+            CUDF_ENABLE_IF(std::is_same_v<T, void> or is_rep_layout_compatible<T>())>
   T* head() const noexcept
   {
     return const_cast<T*>(detail::column_view_base::head<T>());

cpp/include/cudf/detail/copy.hpp

@@ -44,8 +44,8 @@ namespace detail {
 template <typename ColumnView>
 ColumnView slice(ColumnView const& input, cudf::size_type begin, cudf::size_type end)
 {
-  static_assert(std::is_same<ColumnView, cudf::column_view>::value or
-                  std::is_same<ColumnView, cudf::mutable_column_view>::value,
+  static_assert(std::is_same_v<ColumnView, cudf::column_view> or
+                  std::is_same_v<ColumnView, cudf::mutable_column_view>,
                 "slice can be performed only on column_view and mutable_column_view");
   CUDF_EXPECTS(begin >= 0, "Invalid beginning of range.");
   CUDF_EXPECTS(end >= begin, "Invalid end of range.");

cpp/include/cudf/detail/copy_if.cuh

@@ -214,12 +214,12 @@ struct DeviceType<T, std::enable_if_t<cudf::is_timestamp<T>()>> {
 };
 
 template <typename T>
-struct DeviceType<T, std::enable_if_t<std::is_same<numeric::decimal32, T>::value>> {
+struct DeviceType<T, std::enable_if_t<std::is_same_v<numeric::decimal32, T>>> {
   using type = typename cudf::device_storage_type_t<T>;
 };
 
 template <typename T>
-struct DeviceType<T, std::enable_if_t<std::is_same<numeric::decimal64, T>::value>> {
+struct DeviceType<T, std::enable_if_t<std::is_same_v<numeric::decimal64, T>>> {
   using type = typename cudf::device_storage_type_t<T>;
 };
 

cpp/include/cudf/detail/reduction.cuh

@@ -109,7 +109,7 @@ std::unique_ptr<scalar> reduce(InputIterator d_in,
 template <typename Op,
           typename InputIterator,
           typename OutputType = typename thrust::iterator_value<InputIterator>::type,
-          typename std::enable_if_t<std::is_same<OutputType, string_view>::value>* = nullptr>
+          typename std::enable_if_t<std::is_same_v<OutputType, string_view>>* = nullptr>
 std::unique_ptr<scalar> reduce(InputIterator d_in,
                                cudf::size_type num_items,
                                op::simple_op<Op> sop,

cpp/include/cudf/detail/utilities/device_operators.cuh

@@ -94,8 +94,8 @@ struct DeviceMin {
 
   template <
     typename T,
-    typename std::enable_if_t<!std::is_same<T, cudf::string_view>::value &&
-                              !cudf::is_dictionary<T>() && !cudf::is_fixed_point<T>()>* = nullptr>
+    typename std::enable_if_t<!std::is_same_v<T, cudf::string_view> && !cudf::is_dictionary<T>() &&
+                              !cudf::is_fixed_point<T>()>* = nullptr>
   static constexpr T identity()
   {
     return std::numeric_limits<T>::max();
@@ -109,8 +109,7 @@ struct DeviceMin {
   }
 
   // @brief identity specialized for string_view
-  template <typename T,
-            typename std::enable_if_t<std::is_same<T, cudf::string_view>::value>* = nullptr>
+  template <typename T, typename std::enable_if_t<std::is_same_v<T, cudf::string_view>>* = nullptr>
   CUDA_HOST_DEVICE_CALLABLE static constexpr T identity()
   {
     return string_view::max();
@@ -133,8 +132,8 @@ struct DeviceMax {
 
   template <
     typename T,
-    typename std::enable_if_t<!std::is_same<T, cudf::string_view>::value &&
-                              !cudf::is_dictionary<T>() && !cudf::is_fixed_point<T>()>* = nullptr>
+    typename std::enable_if_t<!std::is_same_v<T, cudf::string_view> && !cudf::is_dictionary<T>() &&
+                              !cudf::is_fixed_point<T>()>* = nullptr>
   static constexpr T identity()
   {
     return std::numeric_limits<T>::lowest();
@@ -147,8 +146,7 @@ struct DeviceMax {
     return std::numeric_limits<T>::lowest();
   }
 
-  template <typename T,
-            typename std::enable_if_t<std::is_same<T, cudf::string_view>::value>* = nullptr>
+  template <typename T, typename std::enable_if_t<std::is_same_v<T, cudf::string_view>>* = nullptr>
   CUDA_HOST_DEVICE_CALLABLE static constexpr T identity()
   {
     return string_view::min();

cpp/include/cudf/fixed_point/fixed_point.hpp

@@ -48,7 +48,7 @@ enum class Radix : int32_t { BASE_2 = 2, BASE_10 = 10 };
 template <typename T>
 constexpr inline auto is_supported_representation_type()
 {
-  return cuda::std::is_same<T, int32_t>::value || cuda::std::is_same<T, int64_t>::value;
+  return cuda::std::is_same_v<T, int32_t> || cuda::std::is_same_v<T, int64_t>;
 }
 
 template <typename T>
@@ -74,7 +74,7 @@ namespace detail {
 template <typename Rep,
           Radix Base,
           typename T,
-          typename cuda::std::enable_if_t<(cuda::std::is_same<int32_t, T>::value &&
+          typename cuda::std::enable_if_t<(cuda::std::is_same_v<int32_t, T> &&
                                            is_supported_representation_type<Rep>())>* = nullptr>
 CUDA_HOST_DEVICE_CALLABLE Rep ipow(T exponent)
 {

cpp/include/cudf/lists/list_device_view.cuh

@@ -271,13 +271,13 @@ class list_device_view {
     }
 
    private:
-    template <typename R, std::enable_if_t<std::is_same<R, rep_type>::value, void>* = nullptr>
+    template <typename R, std::enable_if_t<std::is_same_v<R, rep_type>, void>* = nullptr>
     CUDA_DEVICE_CALLABLE rep_type get_rep(cudf::size_type i) const
     {
       return list.element<R>(i);
     }
 
-    template <typename R, std::enable_if_t<not std::is_same<R, rep_type>::value, void>* = nullptr>
+    template <typename R, std::enable_if_t<not std::is_same_v<R, rep_type>, void>* = nullptr>
     CUDA_DEVICE_CALLABLE rep_type get_rep(cudf::size_type i) const
     {
       return list.element<R>(i).value();

cpp/include/cudf/lists/lists_column_view.hpp

@@ -56,7 +56,7 @@ class lists_column_view : private column_view {
   using column_view::null_mask;
   using column_view::offset;
   using column_view::size;
-  static_assert(std::is_same<offset_type, size_type>::value,
+  static_assert(std::is_same_v<offset_type, size_type>,
                 "offset_type is expected to be the same as size_type.");
   using offset_iterator = offset_type const*;