diff --git a/libcudacxx/include/cuda/__argument/argument.h b/libcudacxx/include/cuda/__argument/argument.h
index fb514d22648..1e3c3dca247 100644
--- a/libcudacxx/include/cuda/__argument/argument.h
+++ b/libcudacxx/include/cuda/__argument/argument.h
@@ -26,7 +26,10 @@
 #include <cuda/std/__algorithm/min_element.h>
 #include <cuda/std/__cccl/assert.h>
 #include <cuda/std/__iterator/readable_traits.h>
+#include <cuda/std/__ranges/concepts.h>
+#include <cuda/std/__ranges/empty.h>
 #include <cuda/std/__type_traits/is_arithmetic.h>
+#include <cuda/std/__type_traits/is_array.h>
 #include <cuda/std/__type_traits/is_integer.h>
 #include <cuda/std/__type_traits/is_integral.h>
 #include <cuda/std/__type_traits/is_same.h>
@@ -75,23 +78,12 @@ template <class _Tp>
 using __element_type_of_t = typename __element_type_of<::cuda::std::remove_cvref_t<_Tp>>::type;
 
 // =====================================================================
-// __is_sequence_v / __is_single_value_v
+// __is_sequence_v
 // =====================================================================
 
 template <class _Tp>
 inline constexpr bool __is_sequence_v =
-  !::cuda::std::is_same_v<::cuda::std::remove_cvref_t<_Tp>, __element_type_of_t<_Tp>>;
-
-template <class _Tp>
-inline constexpr bool __is_single_value_v = !__is_sequence_v<_Tp>;
-
-template <class _Tp, class = void>
-inline constexpr bool __is_iterable_v = false;
-
-template <class _Tp>
-inline constexpr bool __is_iterable_v<_Tp,
-                                      ::cuda::std::void_t<decltype(::cuda::std::declval<const _Tp&>().begin()),
-                                                          decltype(::cuda::std::declval<const _Tp&>().end())>> = true;
+  ::cuda::std::is_array_v<::cuda::std::remove_cvref_t<_Tp>> || ::cuda::std::ranges::range<_Tp>;
 
 // =====================================================================
 // __constant
@@ -121,7 +113,9 @@ struct __constant_sequence
   using value_type     = ::cuda::std::remove_cvref_t<decltype(_Value)>;
   using __element_type = __element_type_of_t<value_type>;
 
-  static_assert(__is_sequence_v<value_type>, "constant sequence arguments must have a distinct element type");
+  static_assert(__is_sequence_v<value_type>, "The value type of __constant_sequence must be a range or an array");
+  static_assert(!::cuda::std::ranges::__empty::__fn{}(_Value),
+                "The value type of __constant_sequence must be a non-empty sequence");
 
   [[nodiscard]] _CCCL_API static constexpr value_type value() noexcept
   {
@@ -129,130 +123,6 @@ struct __constant_sequence
   }
 };
 
-// =====================================================================
-// __assert_in_range
-// =====================================================================
-
-template <class _To, class _From>
-_CCCL_API constexpr void __assert_in_range([[maybe_unused]] _From __val) noexcept
-{
-  if constexpr (::cuda::std::__cccl_is_cv_integer_v<_To> && ::cuda::std::__cccl_is_cv_integer_v<_From>)
-  {
-    _CCCL_ASSERT(::cuda::std::in_range<::cuda::std::remove_cv_t<_To>>(__val),
-                 "runtime bound value overflows the element type");
-  }
-}
-
-template <class _To, class _From>
-[[nodiscard]] _CCCL_API constexpr _To __runtime_bound_cast(_From __val) noexcept
-{
-  __assert_in_range<_To>(__val);
-  return static_cast<_To>(__val);
-}
-
-template <class _To, auto _Value>
-_CCCL_API constexpr bool __static_bound_in_range() noexcept
-{
-  using _RawTo   = ::cuda::std::remove_cv_t<_To>;
-  using _RawFrom = ::cuda::std::remove_cv_t<decltype(_Value)>;
-
-  if constexpr (::cuda::std::__cccl_is_integer_v<_RawTo> && ::cuda::std::__cccl_is_integer_v<_RawFrom>)
-  {
-    return ::cuda::std::in_range<_RawTo>(_Value);
-  }
-  else if constexpr (::cuda::std::is_arithmetic_v<_RawTo> && ::cuda::std::is_arithmetic_v<_RawFrom>)
-  {
-    return static_cast<_RawFrom>(static_cast<_RawTo>(_Value)) == _Value;
-  }
-  else
-  {
-    return true;
-  }
-}
-
-template <class _ElementType, class _StaticBounds>
-inline constexpr bool __valid_static_bounds_v = true;
-
-template <class _ElementType, auto _Lowest, auto _Highest>
-inline constexpr bool __valid_static_bounds_v<_ElementType, __static_bounds<_Lowest, _Highest>> =
-  __static_bound_in_range<_ElementType, _Lowest>() && __static_bound_in_range<_ElementType, _Highest>();
-
-template <class _ElementType, class _StaticBounds>
-_CCCL_API constexpr _ElementType __wrapper_static_lowest() noexcept
-{
-  if constexpr (::cuda::std::is_same_v<_StaticBounds, __no_bounds>)
-  {
-    return ::cuda::std::numeric_limits<_ElementType>::lowest();
-  }
-  else
-  {
-    return static_cast<_ElementType>(_StaticBounds::lower());
-  }
-}
-
-template <class _ElementType, class _StaticBounds>
-_CCCL_API constexpr _ElementType __wrapper_static_highest() noexcept
-{
-  if constexpr (::cuda::std::is_same_v<_StaticBounds, __no_bounds>)
-  {
-    return (::cuda::std::numeric_limits<_ElementType>::max)();
-  }
-  else
-  {
-    return static_cast<_ElementType>(_StaticBounds::upper());
-  }
-}
-
-template <class _ElementType, class _StaticBounds>
-_CCCL_API constexpr _ElementType __effective_lowest(__runtime_bounds<_ElementType> __runtime_bounds) noexcept
-{
-  auto __static_lowest = __wrapper_static_lowest<_ElementType, _StaticBounds>();
-  return __static_lowest > __runtime_bounds.lower() ? __static_lowest : __runtime_bounds.lower();
-}
-
-template <class _ElementType, class _StaticBounds>
-_CCCL_API constexpr _ElementType __effective_highest(__runtime_bounds<_ElementType> __runtime_bounds) noexcept
-{
-  auto __static_highest = __wrapper_static_highest<_ElementType, _StaticBounds>();
-  return __static_highest < __runtime_bounds.upper() ? __static_highest : __runtime_bounds.upper();
-}
-
-template <class _ElementType, class _StaticBounds>
-_CCCL_API constexpr bool __has_bounds_intersection(__runtime_bounds<_ElementType> __runtime_bounds) noexcept
-{
-  return __effective_lowest<_ElementType, _StaticBounds>(__runtime_bounds)
-      <= __effective_highest<_ElementType, _StaticBounds>(__runtime_bounds);
-}
-
-template <class _ElementType, class _StaticBounds>
-_CCCL_API constexpr void __validate_bounds_intersection(__runtime_bounds<_ElementType> __runtime_bounds) noexcept
-{
-  static_assert(__valid_static_bounds_v<_ElementType, _StaticBounds>,
-                "static argument bounds cannot be represented by the element type");
-  _CCCL_VERIFY((__has_bounds_intersection<_ElementType, _StaticBounds>(__runtime_bounds)),
-               "static and runtime argument bounds do not intersect");
-}
-
-template <class _ElementType, class _StaticBounds>
-_CCCL_API constexpr void __validate_static_element_bounds([[maybe_unused]] const _ElementType& __val) noexcept
-{
-  if constexpr (!::cuda::std::is_same_v<_StaticBounds, __no_bounds>)
-  {
-    _CCCL_ASSERT((__val >= __wrapper_static_lowest<_ElementType, _StaticBounds>()),
-                 "immediate argument value is below static lowest bound");
-    _CCCL_ASSERT((__val <= __wrapper_static_highest<_ElementType, _StaticBounds>()),
-                 "immediate argument value is above static highest bound");
-  }
-}
-
-template <class _ElementType>
-_CCCL_API constexpr void __validate_runtime_element_bounds(
-  [[maybe_unused]] const _ElementType& __val, [[maybe_unused]] __runtime_bounds<_ElementType> __runtime_bounds) noexcept
-{
-  _CCCL_ASSERT((__val >= __runtime_bounds.lower()), "immediate argument value is below runtime lower bound");
-  _CCCL_ASSERT((__val <= __runtime_bounds.upper()), "immediate argument value is above runtime upper bound");
-}
-
 // =====================================================================
 // __immediate
 // =====================================================================
@@ -332,7 +202,7 @@ struct __immediate_sequence
 
   _CCCL_API constexpr void __validate_value() const noexcept
   {
-    if constexpr (__is_iterable_v<_Arg> && ::cuda::std::is_arithmetic_v<__element_type>)
+    if constexpr (__is_sequence_v<_Arg> && ::cuda::std::is_arithmetic_v<__element_type>)
     {
       for (const auto& __a : __arg_)
       {
@@ -616,46 +486,6 @@ template <class _Arg, class _StaticBounds>
   return ::cuda::std::move(__arg.__arg_);
 }
 
-template <auto _Value>
-_CCCL_API constexpr auto __constant_compute_lowest() noexcept
-{
-  return _Value;
-}
-
-template <auto _Value>
-_CCCL_API constexpr auto __constant_compute_highest() noexcept
-{
-  return _Value;
-}
-
-template <auto _Value>
-_CCCL_API constexpr auto __constant_sequence_compute_lowest() noexcept
-{
-  using _ElementType = __element_type_of_t<::cuda::std::remove_cvref_t<decltype(_Value)>>;
-  auto __first       = _Value.begin();
-  auto __last        = _Value.end();
-
-  if (__first == __last)
-  {
-    return ::cuda::std::numeric_limits<_ElementType>::lowest();
-  }
-  return static_cast<_ElementType>(*::cuda::std::min_element(__first, __last));
-}
-
-template <auto _Value>
-_CCCL_API constexpr auto __constant_sequence_compute_highest() noexcept
-{
-  using _ElementType = __element_type_of_t<::cuda::std::remove_cvref_t<decltype(_Value)>>;
-  auto __first       = _Value.begin();
-  auto __last        = _Value.end();
-
-  if (__first == __last)
-  {
-    return (::cuda::std::numeric_limits<_ElementType>::max)();
-  }
-  return static_cast<_ElementType>(*::cuda::std::max_element(__first, __last));
-}
-
 // =====================================================================
 // __traits
 // =====================================================================
@@ -671,7 +501,7 @@ struct __traits_impl
   using element_type                    = __element_type_of_t<_Tp>;
   static constexpr bool is_constant     = false;
   static constexpr bool is_deferred     = false;
-  static constexpr bool is_single_value = __is_single_value_v<_Tp>;
+  static constexpr bool is_single_value = !__is_sequence_v<_Tp>;
   static constexpr element_type lowest  = ::cuda::std::numeric_limits<element_type>::lowest();
   static constexpr element_type highest = (::cuda::std::numeric_limits<element_type>::max)();
 };
@@ -684,8 +514,8 @@ struct __traits_impl<__constant<_Value>>
   static constexpr bool is_constant     = true;
   static constexpr bool is_deferred     = false;
   static constexpr bool is_single_value = true;
-  static constexpr element_type lowest  = __constant_compute_lowest<_Value>();
-  static constexpr element_type highest = __constant_compute_highest<_Value>();
+  static constexpr element_type lowest  = _Value;
+  static constexpr element_type highest = _Value;
 };
 
 template <class _Arg, class _StaticBounds>
@@ -712,8 +542,8 @@ struct __traits_impl<__constant_sequence<_Value>>
   static constexpr bool is_constant     = true;
   static constexpr bool is_deferred     = false;
   static constexpr bool is_single_value = false;
-  static constexpr element_type lowest  = __constant_sequence_compute_lowest<_Value>();
-  static constexpr element_type highest = __constant_sequence_compute_highest<_Value>();
+  static constexpr element_type lowest  = *::cuda::std::min_element(_Value.begin(), _Value.end());
+  static constexpr element_type highest = *::cuda::std::max_element(_Value.begin(), _Value.end());
 };
 
 template <class _Arg, class _StaticBounds>
@@ -781,13 +611,13 @@ _CCCL_REQUIRES((!__is_wrapper_v<::cuda::std::remove_cv_t<_Tp>>) )
 template <auto _Value>
 [[nodiscard]] _CCCL_API constexpr auto __lowest_(__constant<_Value>) noexcept
 {
-  return __constant_compute_lowest<_Value>();
+  return _Value;
 }
 
 template <auto _Value>
 [[nodiscard]] _CCCL_API constexpr auto __lowest_(__constant_sequence<_Value>) noexcept
 {
-  return __constant_sequence_compute_lowest<_Value>();
+  return *::cuda::std::min_element(_Value.begin(), _Value.end());
 }
 
 template <class _Arg, class _StaticBounds>
@@ -831,13 +661,13 @@ _CCCL_REQUIRES((!__is_wrapper_v<::cuda::std::remove_cv_t<_Tp>>) )
 template <auto _Value>
 [[nodiscard]] _CCCL_API constexpr auto __highest_(__constant<_Value>) noexcept
 {
-  return __constant_compute_highest<_Value>();
+  return _Value;
 }
 
 template <auto _Value>
 [[nodiscard]] _CCCL_API constexpr auto __highest_(__constant_sequence<_Value>) noexcept
 {
-  return __constant_sequence_compute_highest<_Value>();
+  return *::cuda::std::max_element(_Value.begin(), _Value.end());
 }
 
 template <class _Arg, class _StaticBounds>
diff --git a/libcudacxx/include/cuda/__argument/argument_bounds.h b/libcudacxx/include/cuda/__argument/argument_bounds.h
index 11c46c74417..46dd22c370c 100644
--- a/libcudacxx/include/cuda/__argument/argument_bounds.h
+++ b/libcudacxx/include/cuda/__argument/argument_bounds.h
@@ -22,8 +22,11 @@
 #endif // no system header
 
 #include <cuda/std/__cccl/assert.h>
+#include <cuda/std/__type_traits/is_extended_arithmetic.h>
 #include <cuda/std/__type_traits/is_same.h>
 #include <cuda/std/__type_traits/remove_cv.h>
+#include <cuda/std/__type_traits/remove_cvref.h>
+#include <cuda/std/__utility/cmp.h>
 #include <cuda/std/limits>
 
 #include <cuda/std/__cccl/prologue.h>
@@ -136,12 +139,135 @@ template <class _Tp>
 }
 
 template <class _Tp>
-inline constexpr bool __is_static_bounds_cv_v = __is_static_bounds_v<::cuda::std::remove_cv_t<_Tp>>;
+inline constexpr bool __is_static_bounds_cv_v = __is_static_bounds_v<::cuda::std::remove_cvref_t<_Tp>>;
 template <class _Tp>
-inline constexpr bool __is_runtime_bounds_cv_v = __is_runtime_bounds_v<::cuda::std::remove_cv_t<_Tp>>;
+inline constexpr bool __is_runtime_bounds_cv_v = __is_runtime_bounds_v<::cuda::std::remove_cvref_t<_Tp>>;
 template <class _Tp>
 inline constexpr bool __is_bounds_v = __is_static_bounds_cv_v<_Tp> || __is_runtime_bounds_cv_v<_Tp>;
 
+// =====================================================================
+// __assert_in_range
+// =====================================================================
+
+template <class _To, class _From>
+_CCCL_API constexpr void __assert_in_range([[maybe_unused]] _From __val) noexcept
+{
+  if constexpr (::cuda::std::__cccl_is_integer_v<_To> && ::cuda::std::__cccl_is_integer_v<_From>)
+  {
+    _CCCL_ASSERT(::cuda::std::in_range<_To>(__val), "runtime bound value overflows the element type");
+  }
+}
+
+template <class _To, class _From>
+[[nodiscard]] _CCCL_API constexpr _To __runtime_bound_cast(_From __val) noexcept
+{
+  __assert_in_range<_To>(__val);
+  return static_cast<_To>(__val);
+}
+
+template <class _To, auto _Value>
+_CCCL_API constexpr bool __static_bound_in_range() noexcept
+{
+  using _From = decltype(_Value);
+
+  if constexpr (::cuda::std::__cccl_is_integer_v<_To> && ::cuda::std::__cccl_is_integer_v<_From>)
+  {
+    return ::cuda::std::in_range<_To>(_Value);
+  }
+  else if constexpr (::cuda::std::is_arithmetic_v<_To> && ::cuda::std::is_arithmetic_v<_From>)
+  {
+    return static_cast<_From>(static_cast<_To>(_Value)) == _Value;
+  }
+  else
+  {
+    return true;
+  }
+}
+
+template <class _ElementType, class _StaticBounds>
+inline constexpr bool __valid_static_bounds_v = true;
+
+template <class _ElementType, auto _Lowest, auto _Highest>
+inline constexpr bool __valid_static_bounds_v<_ElementType, __static_bounds<_Lowest, _Highest>> =
+  ::cuda::__argument::__static_bound_in_range<_ElementType, _Lowest>()
+  && ::cuda::__argument::__static_bound_in_range<_ElementType, _Highest>();
+
+template <class _ElementType, class _StaticBounds>
+_CCCL_API constexpr _ElementType __wrapper_static_lowest() noexcept
+{
+  if constexpr (::cuda::std::is_same_v<_StaticBounds, __no_bounds>)
+  {
+    return ::cuda::std::numeric_limits<_ElementType>::lowest();
+  }
+  else
+  {
+    return static_cast<_ElementType>(_StaticBounds::lower());
+  }
+}
+
+template <class _ElementType, class _StaticBounds>
+_CCCL_API constexpr _ElementType __wrapper_static_highest() noexcept
+{
+  if constexpr (::cuda::std::is_same_v<_StaticBounds, __no_bounds>)
+  {
+    return (::cuda::std::numeric_limits<_ElementType>::max)();
+  }
+  else
+  {
+    return static_cast<_ElementType>(_StaticBounds::upper());
+  }
+}
+
+template <class _ElementType, class _StaticBounds>
+_CCCL_API constexpr _ElementType __effective_lowest(__runtime_bounds<_ElementType> __runtime_bounds) noexcept
+{
+  auto __static_lowest = ::cuda::__argument::__wrapper_static_lowest<_ElementType, _StaticBounds>();
+  return __static_lowest > __runtime_bounds.lower() ? __static_lowest : __runtime_bounds.lower();
+}
+
+template <class _ElementType, class _StaticBounds>
+_CCCL_API constexpr _ElementType __effective_highest(__runtime_bounds<_ElementType> __runtime_bounds) noexcept
+{
+  auto __static_highest = ::cuda::__argument::__wrapper_static_highest<_ElementType, _StaticBounds>();
+  return __static_highest < __runtime_bounds.upper() ? __static_highest : __runtime_bounds.upper();
+}
+
+template <class _ElementType, class _StaticBounds>
+_CCCL_API constexpr bool __valid_argument_bounds(__runtime_bounds<_ElementType> __runtime_bounds) noexcept
+{
+  return ::cuda::__argument::__effective_lowest<_ElementType, _StaticBounds>(__runtime_bounds)
+      <= ::cuda::__argument::__effective_highest<_ElementType, _StaticBounds>(__runtime_bounds);
+}
+
+template <class _ElementType, class _StaticBounds>
+_CCCL_API constexpr void __validate_bounds_intersection(__runtime_bounds<_ElementType> __runtime_bounds) noexcept
+{
+  static_assert(__valid_static_bounds_v<_ElementType, _StaticBounds>,
+                "static argument bounds cannot be represented by the element type");
+  _CCCL_VERIFY((::cuda::__argument::__valid_argument_bounds<_ElementType, _StaticBounds>(__runtime_bounds)),
+               "static and runtime argument bounds do not intersect");
+}
+
+template <class _ElementType, class _StaticBounds>
+_CCCL_API constexpr void __validate_static_element_bounds([[maybe_unused]] const _ElementType& __val) noexcept
+{
+  if constexpr (!::cuda::std::is_same_v<_StaticBounds, __no_bounds>)
+  {
+    _CCCL_ASSERT((__val >= ::cuda::__argument::__wrapper_static_lowest<_ElementType, _StaticBounds>()),
+                 "immediate argument value is below static lowest bound");
+    _CCCL_ASSERT((__val <= ::cuda::__argument::__wrapper_static_highest<_ElementType, _StaticBounds>()),
+                 "immediate argument value is above static highest bound");
+  }
+}
+
+template <class _ElementType>
+_CCCL_API constexpr void __validate_runtime_element_bounds(
+  [[maybe_unused]] const _ElementType& __val, [[maybe_unused]] __runtime_bounds<_ElementType> __runtime_bounds) noexcept
+{
+  _CCCL_ASSERT((__val >= __runtime_bounds.lower()), "immediate argument value is below runtime lower bound");
+  _CCCL_ASSERT((__val <= __runtime_bounds.upper()), "immediate argument value is above runtime upper bound");
+}
+
 _CCCL_END_NAMESPACE_CUDA_ARGUMENT
 
 #include <cuda/std/__cccl/epilogue.h>
diff --git a/libcudacxx/test/libcudacxx/cuda/argument/argument_bounds.pass.cpp b/libcudacxx/test/libcudacxx/cuda/argument/argument_bounds.pass.cpp
index c03b685e821..d7f394a0d74 100644
--- a/libcudacxx/test/libcudacxx/cuda/argument/argument_bounds.pass.cpp
+++ b/libcudacxx/test/libcudacxx/cuda/argument/argument_bounds.pass.cpp
@@ -82,9 +82,9 @@ TEST_FUNC constexpr bool test()
 
   // Static and runtime bounds intersection
   {
-    static_assert(cuda::__argument::__has_bounds_intersection<int, cuda::__argument::__static_bounds<1, 100>>(
+    static_assert(cuda::__argument::__valid_argument_bounds<int, cuda::__argument::__static_bounds<1, 100>>(
       cuda::__argument::__runtime_bounds<int>{50, 200}));
-    static_assert(!cuda::__argument::__has_bounds_intersection<int, cuda::__argument::__static_bounds<100, 200>>(
+    static_assert(!cuda::__argument::__valid_argument_bounds<int, cuda::__argument::__static_bounds<100, 200>>(
       cuda::__argument::__runtime_bounds<int>{0, 50}));
   }
 
diff --git a/libcudacxx/test/libcudacxx/cuda/argument/argument_traits.pass.cpp b/libcudacxx/test/libcudacxx/cuda/argument/argument_traits.pass.cpp
index cdcc6665747..36154ef2207 100644
--- a/libcudacxx/test/libcudacxx/cuda/argument/argument_traits.pass.cpp
+++ b/libcudacxx/test/libcudacxx/cuda/argument/argument_traits.pass.cpp
@@ -11,10 +11,15 @@
 #include <cuda/__argument_>
 #include <cuda/iterator>
 #include <cuda/std/array>
+#include <cuda/std/complex>
+#include <cuda/std/expected>
 #include <cuda/std/limits>
 #include <cuda/std/mdspan>
+#include <cuda/std/optional>
 #include <cuda/std/span>
+#include <cuda/std/tuple>
 #include <cuda/std/type_traits>
+#include <cuda/std/utility>
 
 #include "test_macros.h"
 
@@ -50,32 +55,32 @@ TEST_FUNC void test()
 {
   // --- __is_sequence_v / __is_single_value_v ---
 
+  // builtin and class type are not sequences
   static_assert(!cuda::__argument::__is_sequence_v<int>);
   static_assert(!cuda::__argument::__is_sequence_v<color>);
   static_assert(!cuda::__argument::__is_sequence_v<non_sequence_value>);
-  static_assert(cuda::__argument::__is_sequence_v<int*>);
-  static_assert(cuda::__argument::__is_sequence_v<cuda::counting_iterator<int>>);
+  static_assert(!cuda::__argument::__is_sequence_v<range_like<int>>);
+  static_assert(!cuda::__argument::__is_sequence_v<element_type_like<int>>);
+  static_assert(!cuda::__argument::__is_sequence_v<value_type_like<int>>);
+  static_assert(!cuda::__argument::__is_sequence_v<cuda::std::complex<float>>);
+  static_assert(!cuda::__argument::__is_sequence_v<cuda::std::pair<float, int>>);
+  static_assert(!cuda::__argument::__is_sequence_v<cuda::std::tuple<float, int>>);
+  static_assert(!cuda::__argument::__is_sequence_v<cuda::std::optional<int>>);
+  static_assert(!cuda::__argument::__is_sequence_v<cuda::std::expected<int, int>>);
+
+  // iterators are not sequences and need to be wrapped into a range
+  static_assert(!cuda::__argument::__is_sequence_v<int*>);
+  static_assert(!cuda::__argument::__is_sequence_v<cuda::counting_iterator<int>>);
+
+  // ranges and arrays are sequences
+  static_assert(cuda::__argument::__is_sequence_v<int[]>);
+  static_assert(cuda::__argument::__is_sequence_v<const int[]>);
+  static_assert(cuda::__argument::__is_sequence_v<int[42]>);
+  static_assert(cuda::__argument::__is_sequence_v<const int[42]>);
   static_assert(cuda::__argument::__is_sequence_v<cuda::std::span<int, 1>>);
   static_assert(cuda::__argument::__is_sequence_v<const cuda::std::span<int, 1>&>);
   static_assert(cuda::__argument::__is_sequence_v<cuda::std::span<int>>);
   static_assert(cuda::__argument::__is_sequence_v<cuda::std::array<int, 3>>);
-  static_assert(cuda::__argument::__is_sequence_v<range_like<int>>);
-  static_assert(cuda::__argument::__is_sequence_v<element_type_like<int>>);
-  static_assert(cuda::__argument::__is_sequence_v<value_type_like<int>>);
-
-  static_assert(cuda::__argument::__is_single_value_v<int>);
-  static_assert(cuda::__argument::__is_single_value_v<float>);
-  static_assert(cuda::__argument::__is_single_value_v<double>);
-  static_assert(cuda::__argument::__is_single_value_v<const int>);
-  static_assert(cuda::__argument::__is_single_value_v<color>);
-  static_assert(cuda::__argument::__is_single_value_v<non_sequence_value>);
-  static_assert(!cuda::__argument::__is_single_value_v<int*>);
-  static_assert(!cuda::__argument::__is_single_value_v<cuda::counting_iterator<int>>);
-  static_assert(!cuda::__argument::__is_single_value_v<cuda::std::span<int, 1>>);
-  static_assert(!cuda::__argument::__is_single_value_v<const cuda::std::span<int, 1>&>);
-  static_assert(!cuda::__argument::__is_single_value_v<cuda::std::span<int>>);
-  static_assert(!cuda::__argument::__is_single_value_v<cuda::std::span<int, 4>>);
-  static_assert(!cuda::__argument::__is_single_value_v<cuda::std::array<int, 3>>);
 
   // --- __element_type_of_t ---
 
@@ -106,7 +111,7 @@ TEST_FUNC void test()
   // --- argument_traits: is_single_value ---
 
   static_assert(cuda::__argument::__traits<int>::is_single_value);
-  static_assert(!cuda::__argument::__traits<int*>::is_single_value);
+  static_assert(cuda::__argument::__traits<int*>::is_single_value);
   static_assert(cuda::__argument::__traits<cuda::__argument::__immediate<int>>::is_single_value);
   static_assert(cuda::__argument::__traits<cuda::__argument::__immediate<int*>>::is_single_value);
   static_assert(
diff --git a/libcudacxx/test/libcudacxx/cuda/argument/dynamic_argument.pass.cpp b/libcudacxx/test/libcudacxx/cuda/argument/dynamic_argument.pass.cpp
index eac5e71aa82..c9723304774 100644
--- a/libcudacxx/test/libcudacxx/cuda/argument/dynamic_argument.pass.cpp
+++ b/libcudacxx/test/libcudacxx/cuda/argument/dynamic_argument.pass.cpp
@@ -128,7 +128,7 @@ TEST_FUNC constexpr bool test()
   // __is_single_value_v on unwrapped types
   {
     static_assert(
-      cuda::__argument::__is_single_value_v<cuda::__argument::__traits<cuda::__argument::__immediate<int>>::value_type>);
+      !cuda::__argument::__is_sequence_v<cuda::__argument::__traits<cuda::__argument::__immediate<int>>::value_type>);
     static_assert(
       !cuda::__argument::__traits<cuda::__argument::__immediate_sequence<cuda::std::span<int>>>::is_single_value);
   }
diff --git a/libcudacxx/test/libcudacxx/cuda/argument/static_argument.pass.cpp b/libcudacxx/test/libcudacxx/cuda/argument/static_argument.pass.cpp
index 7d40183070b..85ccaf1c8a0 100644
--- a/libcudacxx/test/libcudacxx/cuda/argument/static_argument.pass.cpp
+++ b/libcudacxx/test/libcudacxx/cuda/argument/static_argument.pass.cpp
@@ -113,7 +113,7 @@ TEST_FUNC void test()
   // Single value: scalar is single, sequence is not
   {
     static_assert(
-      cuda::__argument::__is_single_value_v<cuda::__argument::__traits<cuda::__argument::__constant<42>>::value_type>);
+      !cuda::__argument::__is_sequence_v<cuda::__argument::__traits<cuda::__argument::__constant<42>>::value_type>);
 #if TEST_HAS_CLASS_NTTP
     static_assert(!cuda::__argument::__traits<
                   cuda::__argument::__constant_sequence<cuda::std::array<int, 3>{1, 2, 3}>>::is_single_value);