diff --git a/include/cuco/detail/traits.hpp b/include/cuco/detail/traits.hpp
index 313f95430..87cb61c63 100644
--- a/include/cuco/detail/traits.hpp
+++ b/include/cuco/detail/traits.hpp
@@ -24,6 +24,15 @@
 
 namespace cuco::detail {
 
+template <typename T, typename = void>
+struct is_bitwise_comparable_impl : std::false_type {
+};
+
+template <typename T>
+struct is_bitwise_comparable_impl<T, std::enable_if_t<std::has_unique_object_representations_v<T>>>
+  : std::true_type {
+};
+
 template <typename T, typename = void>
 struct is_std_pair_like : cuda::std::false_type {
 };
diff --git a/include/cuco/pair.cuh b/include/cuco/pair.cuh
index 0a804cc04..0f1a863f5 100644
--- a/include/cuco/pair.cuh
+++ b/include/cuco/pair.cuh
@@ -18,6 +18,7 @@
 
 #include <cuco/detail/traits.hpp>
 #include <cuco/detail/utils.cuh>
+#include <cuco/utility/traits.hpp>
 
 #include <thrust/device_reference.h>
 #include <thrust/tuple.h>
@@ -141,6 +142,16 @@ template <class T1, class T2, class U1, class U2>
 __host__ __device__ constexpr bool operator==(cuco::pair<T1, T2> const& lhs,
                                               cuco::pair<U1, U2> const& rhs) noexcept;
 
+/**
+ * @brief A pair of bitwise comparable types is also bitwise comparable
+ */
+template <typename First, typename Second>
+struct is_bitwise_comparable<pair<First, Second>>
+  : std::integral_constant<bool,
+                           is_bitwise_comparable_v<First> && is_bitwise_comparable_v<Second> &&
+                             sizeof(pair<First, Second>) == sizeof(First) + sizeof(Second)> {
+};
+
 }  // namespace cuco
 
 #include <cuco/detail/pair.inl>
diff --git a/include/cuco/utility/traits.hpp b/include/cuco/utility/traits.hpp
index 1a6252dcb..bd2a187dc 100644
--- a/include/cuco/utility/traits.hpp
+++ b/include/cuco/utility/traits.hpp
@@ -16,8 +16,7 @@
 
 #pragma once
 
-#include <thrust/device_reference.h>
-#include <thrust/tuple.h>
+#include <cuco/detail/traits.hpp>
 
 #include <type_traits>
 
@@ -36,15 +35,10 @@ namespace cuco {
  * if a `NaN` bit pattern were used as the empty sentinel value, it may not compare bitwise equal to
  * other `NaN` bit patterns.
  *
+ * @note By default, only types with unique object representations are allowed
  */
-template <typename T, typename = void>
-struct is_bitwise_comparable : std::false_type {
-};
-
-/// By default, only types with unique object representations are allowed
 template <typename T>
-struct is_bitwise_comparable<T, std::enable_if_t<std::has_unique_object_representations_v<T>>>
-  : std::true_type {
+struct is_bitwise_comparable : detail::is_bitwise_comparable_impl<T> {
 };
 
 template <typename T>