cuda-cccl 0.3.2__cp313-cp313-manylinux_2_24_aarch64.whl → 0.3.4__cp313-cp313-manylinux_2_24_aarch64.whl

cuda/cccl/headers/include/cuda/std/{detail/libcxx/include/stdexcept → __exception/throw_error.h}

@@ -9,8 +9,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _LIBCUDACXX_STDEXCEPT
-#define _LIBCUDACXX_STDEXCEPT
+#ifndef _CUDA_STD___EXCEPTION_THROW_ERROR_H
+#define _CUDA_STD___EXCEPTION_THROW_ERROR_H
 
 #include <cuda/std/detail/__config>
 
@@ -117,4 +117,4 @@ _CCCL_END_NAMESPACE_CUDA_STD
 
 #include <cuda/std/__cccl/epilogue.h>
 
-#endif // _LIBCUDACXX_STDEXCEPT
+#endif // _CUDA_STD___EXCEPTION_THROW_ERROR_H

cuda/cccl/headers/include/cuda/std/__expected/expected.h

@@ -24,6 +24,7 @@
 #include <cuda/std/__expected/expected_base.h>
 #include <cuda/std/__expected/unexpect.h>
 #include <cuda/std/__expected/unexpected.h>
+#include <cuda/std/__fwd/expected.h>
 #include <cuda/std/__memory/addressof.h>
 #include <cuda/std/__memory/construct_at.h>
 #include <cuda/std/__type_traits/conjunction.h>
@@ -66,29 +67,14 @@
 
 _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
-template <class _Tp, class _Err>
-class expected;
-
 namespace __expected
 {
 template <class _Tp, class _Err>
 inline constexpr bool __valid_expected =
   !is_reference_v<_Tp> && !is_function_v<_Tp> && !is_same_v<remove_cv_t<_Tp>, in_place_t>
-  && !is_same_v<remove_cv_t<_Tp>, unexpect_t> && !__unexpected::__is_unexpected<remove_cv_t<_Tp>>
+  && !is_same_v<remove_cv_t<_Tp>, unexpect_t> && !__is_cuda_std_unexpected<remove_cv_t<_Tp>>
   && __unexpected::__valid_unexpected<_Err>;
 
-template <class _Tp>
-inline constexpr bool __is_expected = false;
-
-template <class _Tp, class _Err>
-inline constexpr bool __is_expected<expected<_Tp, _Err>> = true;
-
-template <class _Tp>
-inline constexpr bool __is_expected_nonvoid = __is_expected<_Tp>;
-
-template <class _Err>
-inline constexpr bool __is_expected_nonvoid<expected<void, _Err>> = false;
-
 template <class _Tp, class _Err>
 inline constexpr bool __can_swap =
   is_swappable_v<_Tp> && is_swappable_v<_Err> && is_move_constructible_v<_Tp> && is_move_constructible_v<_Err>
@@ -225,7 +211,7 @@ public:
 
   _CCCL_TEMPLATE(class _Up = _Tp)
   _CCCL_REQUIRES((!is_same_v<remove_cvref_t<_Up>, in_place_t>) _CCCL_AND(!is_same_v<expected, remove_cvref_t<_Up>>)
-                   _CCCL_AND(!__unexpected::__is_unexpected<remove_cvref_t<_Up>>)
+                   _CCCL_AND(!__is_cuda_std_unexpected<remove_cvref_t<_Up>>)
                      _CCCL_AND is_constructible_v<_Tp, _Up> _CCCL_AND is_convertible_v<_Up, _Tp>)
   _CCCL_API constexpr expected(_Up&& __u) noexcept(is_nothrow_constructible_v<_Tp, _Up>) // strengthened
       : __base(in_place, ::cuda::std::forward<_Up>(__u))
@@ -233,7 +219,7 @@ public:
 
   _CCCL_TEMPLATE(class _Up = _Tp)
   _CCCL_REQUIRES((!is_same_v<remove_cvref_t<_Up>, in_place_t>) _CCCL_AND(!is_same_v<expected, remove_cvref_t<_Up>>)
-                   _CCCL_AND(!__unexpected::__is_unexpected<remove_cvref_t<_Up>>)
+                   _CCCL_AND(!__is_cuda_std_unexpected<remove_cvref_t<_Up>>)
                      _CCCL_AND is_constructible_v<_Tp, _Up> _CCCL_AND(!is_convertible_v<_Up, _Tp>))
   _CCCL_API constexpr explicit expected(_Up&& __u) noexcept(is_nothrow_constructible_v<_Tp, _Up>) // strengthened
       : __base(in_place, ::cuda::std::forward<_Up>(__u))
@@ -324,11 +310,10 @@ public:
   // [expected.object.assign], assignment
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_TEMPLATE(class _Up = _Tp)
-  _CCCL_REQUIRES(
-    (!is_same_v<expected, remove_cvref_t<_Up>>) _CCCL_AND(!__unexpected::__is_unexpected<remove_cvref_t<_Up>>)
-      _CCCL_AND is_constructible_v<_Tp, _Up> _CCCL_AND is_assignable_v<_Tp&, _Up> _CCCL_AND(
-        is_nothrow_constructible_v<_Tp, _Up> || is_nothrow_move_constructible_v<_Tp>
-        || is_nothrow_move_constructible_v<_Err>))
+  _CCCL_REQUIRES((!is_same_v<expected, remove_cvref_t<_Up>>) _CCCL_AND(!__is_cuda_std_unexpected<remove_cvref_t<_Up>>)
+                   _CCCL_AND is_constructible_v<_Tp, _Up> _CCCL_AND is_assignable_v<_Tp&, _Up> _CCCL_AND(
+                     is_nothrow_constructible_v<_Tp, _Up> || is_nothrow_move_constructible_v<_Tp>
+                     || is_nothrow_move_constructible_v<_Err>))
   _CCCL_API inline _CCCL_CONSTEXPR_CXX20 expected& operator=(_Up&& __v)
   {
     if (this->__has_val_)
@@ -600,7 +585,7 @@ public:
   {
     using _Res = remove_cvref_t<invoke_result_t<_Fun, _Tp&>>;
 
-    static_assert(__expected::__is_expected<_Res>, "Result of f(value()) must be a specialization of std::expected");
+    static_assert(__is_cuda_std_expected_v<_Res>, "Result of f(value()) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Res::error_type, _Err>,
                   "The error type of the result of f(value()) must be the same as that of std::expected");
 
@@ -620,7 +605,7 @@ public:
   {
     using _Res = remove_cvref_t<invoke_result_t<_Fun, const _Tp&>>;
 
-    static_assert(__expected::__is_expected<_Res>, "Result of f(value()) must be a specialization of std::expected");
+    static_assert(__is_cuda_std_expected_v<_Res>, "Result of f(value()) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Res::error_type, _Err>,
                   "The error type of the result of f(value()) must be the same as that of std::expected");
 
@@ -640,7 +625,7 @@ public:
   {
     using _Res = remove_cvref_t<invoke_result_t<_Fun, _Tp>>;
 
-    static_assert(__expected::__is_expected<_Res>, "Result of f(value()) must be a specialization of std::expected");
+    static_assert(__is_cuda_std_expected_v<_Res>, "Result of f(value()) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Res::error_type, _Err>,
                   "The error type of the result of f(value()) must be the same as that of std::expected");
 
@@ -660,7 +645,7 @@ public:
   {
     using _Res = remove_cvref_t<invoke_result_t<_Fun, const _Tp>>;
 
-    static_assert(__expected::__is_expected<_Res>, "Result of f(value()) must be a specialization of std::expected");
+    static_assert(__is_cuda_std_expected_v<_Res>, "Result of f(value()) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Res::error_type, _Err>,
                   "The error type of the result of f(value()) must be the same as that of std::expected");
 
@@ -680,7 +665,7 @@ public:
   {
     using _Res = remove_cvref_t<invoke_result_t<_Fun, _Err&>>;
 
-    static_assert(__expected::__is_expected<_Res>,
+    static_assert(__is_cuda_std_expected_v<_Res>,
                   "Result of std::expected::or_else must be a specialization of std::expected");
     static_assert(is_same_v<typename _Res::value_type, _Tp>,
                   "The value type of the result of std::expected::or_else must be the same as that of std::expected");
@@ -701,7 +686,7 @@ public:
   {
     using _Res = remove_cvref_t<invoke_result_t<_Fun, const _Err&>>;
 
-    static_assert(__expected::__is_expected<_Res>,
+    static_assert(__is_cuda_std_expected_v<_Res>,
                   "Result of std::expected::or_else must be a specialization of std::expected");
     static_assert(is_same_v<typename _Res::value_type, _Tp>,
                   "The value type of the result of std::expected::or_else must be the same as that of std::expected");
@@ -722,7 +707,7 @@ public:
   {
     using _Res = remove_cvref_t<invoke_result_t<_Fun, _Err>>;
 
-    static_assert(__expected::__is_expected<_Res>,
+    static_assert(__is_cuda_std_expected_v<_Res>,
                   "Result of std::expected::or_else must be a specialization of std::expected");
     static_assert(is_same_v<typename _Res::value_type, _Tp>,
                   "The value type of the result of std::expected::or_else must be the same as that of std::expected");
@@ -743,7 +728,7 @@ public:
   {
     using _Res = remove_cvref_t<invoke_result_t<_Fun, const _Err>>;
 
-    static_assert(__expected::__is_expected<_Res>,
+    static_assert(__is_cuda_std_expected_v<_Res>,
                   "Result of std::expected::or_else must be a specialization of std::expected");
     static_assert(is_same_v<typename _Res::value_type, _Tp>,
                   "The value type of the result of std::expected::or_else must be the same as that of std::expected");
@@ -1111,7 +1096,7 @@ public:
 
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_TEMPLATE(class _T2)
-  _CCCL_REQUIRES((!__expected::__is_expected_nonvoid<_T2>) )
+  _CCCL_REQUIRES((!__is_cuda_std_expected_nonvoid_v<_T2>) )
   friend _CCCL_API constexpr bool operator==(const expected& __x, const _T2& __v)
   {
     return __x.__has_val_ && static_cast<bool>(__x.__union_.__val_ == __v);
@@ -1119,21 +1104,21 @@ public:
 #if _CCCL_STD_VER < 2020
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_TEMPLATE(class _T2)
-  _CCCL_REQUIRES((!__expected::__is_expected_nonvoid<_T2>) )
+  _CCCL_REQUIRES((!__is_cuda_std_expected_nonvoid_v<_T2>) )
   friend _CCCL_API constexpr bool operator==(const _T2& __v, const expected& __x)
   {
     return __x.__has_val_ && static_cast<bool>(__x.__union_.__val_ == __v);
   }
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_TEMPLATE(class _T2)
-  _CCCL_REQUIRES((!__expected::__is_expected_nonvoid<_T2>) )
+  _CCCL_REQUIRES((!__is_cuda_std_expected_nonvoid_v<_T2>) )
   friend _CCCL_API constexpr bool operator!=(const expected& __x, const _T2& __v)
   {
     return !__x.__has_val_ || static_cast<bool>(__x.__union_.__val_ != __v);
   }
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_TEMPLATE(class _T2)
-  _CCCL_REQUIRES((!__expected::__is_expected_nonvoid<_T2>) )
+  _CCCL_REQUIRES((!__is_cuda_std_expected_nonvoid_v<_T2>) )
   friend _CCCL_API constexpr bool operator!=(const _T2& __v, const expected& __x)
   {
     return !__x.__has_val_ || static_cast<bool>(__x.__union_.__val_ != __v);
@@ -1461,7 +1446,7 @@ public:
   {
     using _Res = remove_cvref_t<invoke_result_t<_Fun>>;
 
-    static_assert(__expected::__is_expected<_Res>, "Result of f(value()) must be a specialization of std::expected");
+    static_assert(__is_cuda_std_expected_v<_Res>, "Result of f(value()) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Res::error_type, _Err>,
                   "The error type of the result of f(value()) must be the same as that of std::expected");
 
@@ -1481,7 +1466,7 @@ public:
   {
     using _Res = remove_cvref_t<invoke_result_t<_Fun>>;
 
-    static_assert(__expected::__is_expected<_Res>, "Result of f(value()) must be a specialization of std::expected");
+    static_assert(__is_cuda_std_expected_v<_Res>, "Result of f(value()) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Res::error_type, _Err>,
                   "The error type of the result of f(value()) must be the same as that of std::expected");
 
@@ -1501,7 +1486,7 @@ public:
   {
     using _Res = remove_cvref_t<invoke_result_t<_Fun>>;
 
-    static_assert(__expected::__is_expected<_Res>, "Result of f(value()) must be a specialization of std::expected");
+    static_assert(__is_cuda_std_expected_v<_Res>, "Result of f(value()) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Res::error_type, _Err>,
                   "The error type of the result of f(value()) must be the same as that of std::expected");
 
@@ -1521,7 +1506,7 @@ public:
   {
     using _Res = remove_cvref_t<invoke_result_t<_Fun>>;
 
-    static_assert(__expected::__is_expected<_Res>, "Result of f(value()) must be a specialization of std::expected");
+    static_assert(__is_cuda_std_expected_v<_Res>, "Result of f(value()) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Res::error_type, _Err>,
                   "The error type of the result of f(value()) must be the same as that of std::expected");
 
@@ -1540,7 +1525,7 @@ public:
   {
     using _Res = remove_cvref_t<invoke_result_t<_Fun, _Err&>>;
 
-    static_assert(__expected::__is_expected<_Res>,
+    static_assert(__is_cuda_std_expected_v<_Res>,
                   "Result of std::expected::or_else must be a specialization of std::expected");
     static_assert(is_same_v<typename _Res::value_type, void>,
                   "The value type of the result of std::expected::or_else must be the same as that of std::expected");
@@ -1560,7 +1545,7 @@ public:
   {
     using _Res = remove_cvref_t<invoke_result_t<_Fun, const _Err&>>;
 
-    static_assert(__expected::__is_expected<_Res>,
+    static_assert(__is_cuda_std_expected_v<_Res>,
                   "Result of std::expected::or_else must be a specialization of std::expected");
     static_assert(is_same_v<typename _Res::value_type, void>,
                   "The value type of the result of std::expected::or_else must be the same as that of std::expected");
@@ -1580,7 +1565,7 @@ public:
   {
     using _Res = remove_cvref_t<invoke_result_t<_Fun, _Err>>;
 
-    static_assert(__expected::__is_expected<_Res>,
+    static_assert(__is_cuda_std_expected_v<_Res>,
                   "Result of std::expected::or_else must be a specialization of std::expected");
     static_assert(is_same_v<typename _Res::value_type, void>,
                   "The value type of the result of std::expected::or_else must be the same as that of std::expected");
@@ -1600,7 +1585,7 @@ public:
   {
     using _Res = remove_cvref_t<invoke_result_t<_Fun, const _Err>>;
 
-    static_assert(__expected::__is_expected<_Res>,
+    static_assert(__is_cuda_std_expected_v<_Res>,
                   "Result of std::expected::or_else must be a specialization of std::expected");
     static_assert(is_same_v<typename _Res::value_type, void>,
                   "The value type of the result of std::expected::or_else must be the same as that of std::expected");

cuda/cccl/headers/include/cuda/std/__expected/unexpected.h

@@ -21,6 +21,7 @@
 #endif // no system header
 
 #include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__fwd/unexpected.h>
 #include <cuda/std/__type_traits/integral_constant.h>
 #include <cuda/std/__type_traits/is_array.h>
 #include <cuda/std/__type_traits/is_const.h>
@@ -40,20 +41,11 @@
 
 _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
-template <class _Err>
-class unexpected;
-
 namespace __unexpected
 {
-template <class _Tp>
-inline constexpr bool __is_unexpected = false;
-
-template <class _Err>
-inline constexpr bool __is_unexpected<unexpected<_Err>> = true;
-
 template <class _Tp>
 inline constexpr bool __valid_unexpected =
-  is_object_v<_Tp> && !is_array_v<_Tp> && !__is_unexpected<_Tp> && !is_const_v<_Tp> && !is_volatile_v<_Tp>;
+  is_object_v<_Tp> && !is_array_v<_Tp> && !__is_cuda_std_unexpected<_Tp> && !is_const_v<_Tp> && !is_volatile_v<_Tp>;
 } // namespace __unexpected
 
 // [expected.un.general]

cuda/cccl/headers/include/cuda/std/__format/format_arg_store.h

@@ -100,8 +100,8 @@ template <class _Context, class _Tp>
     __ret = __fmt_arg_t::__const_char_type_ptr;
   }
   // todo: add std::string and std::string_view support
-  // - add `|| __cccl_is_std_string_view_v<_Tp> || __cccl_is_std_string_v<_Tp>` to the condition
-  else if constexpr (__cccl_is_string_view_v<_Tp>)
+  // - add `|| __is_std_basic_string_view_v<_Tp> || __is_std_basic_string_v<_Tp>` to the condition
+  else if constexpr (__is_cuda_std_basic_string_view_v<_Tp>)
   {
     __ret = (is_same_v<_CtxCharT, typename _Tp::value_type>) ? __fmt_arg_t::__string_view : __ret;
   }

cuda/cccl/headers/include/cuda/std/__functional/bind.h

@@ -29,6 +29,7 @@
 #  include <cuda/std/__functional/reference_wrapper.h>
 #  include <cuda/std/__functional/weak_result_type.h>
 #  include <cuda/std/__fwd/get.h>
+#  include <cuda/std/__fwd/reference_wrapper.h>
 #  include <cuda/std/__tuple_dir/tuple_element.h>
 #  include <cuda/std/__tuple_dir/tuple_indices.h>
 #  include <cuda/std/__tuple_dir/tuple_size.h>
@@ -40,6 +41,7 @@
 #  include <cuda/std/__type_traits/is_convertible.h>
 #  include <cuda/std/__type_traits/is_same.h>
 #  include <cuda/std/__type_traits/is_void.h>
+#  include <cuda/std/__type_traits/remove_cv.h>
 #  include <cuda/std/__type_traits/remove_cvref.h>
 #  include <cuda/std/__type_traits/remove_reference.h>
 #  include <cuda/std/__utility/forward.h>
@@ -68,7 +70,6 @@ inline constexpr size_t is_placeholder_v = is_placeholder<_Tp>::value;
 
 namespace placeholders
 {
-
 template <int _Np>
 struct __ph
 {};
@@ -83,7 +84,6 @@ inline constexpr __ph<7> _7{};
 inline constexpr __ph<8> _8{};
 inline constexpr __ph<9> _9{};
 inline constexpr __ph<10> _10{};
-
 } // namespace placeholders
 
 template <int _Np>
@@ -130,9 +130,9 @@ __mu(_Ti&, _Uj& __uj)
 }
 
 template <class _Ti, class _Uj>
-_CCCL_API inline enable_if_t<
-  !is_bind_expression<_Ti>::value && is_placeholder<_Ti>::value == 0 && !__cccl_is_reference_wrapper_v<_Ti>,
-  _Ti&>
+_CCCL_API inline enable_if_t<!is_bind_expression<_Ti>::value && is_placeholder<_Ti>::value == 0
+                               && !__is_cuda_std_reference_wrapper_v<remove_cv_t<_Ti>>,
+                             _Ti&>
 __mu(_Ti& __ti, _Uj&)
 {
   return __ti;
@@ -180,7 +180,7 @@ template <class _Ti, class _TupleUj>
 struct __mu_return
     : public __mu_return_impl<
         _Ti,
-        __cccl_is_reference_wrapper_v<_Ti>,
+        __is_cuda_std_reference_wrapper_v<remove_cv_t<_Ti>>,
         is_bind_expression<_Ti>::value,
         0 < is_placeholder<_Ti>::value && is_placeholder<_Ti>::value <= tuple_size<_TupleUj>::value,
         _TupleUj>

cuda/cccl/headers/include/cuda/std/__functional/function.h

@@ -71,7 +71,6 @@ class _CCCL_TYPE_VISIBILITY_DEFAULT function; // undefined
 
 namespace __function
 {
-
 template <class _Rp>
 struct __maybe_derive_from_unary_function
 {};
@@ -119,12 +118,10 @@ _CCCL_API inline bool __not_null(_Rp (^__p)(_Args...))
   return __p;
 }
 #  endif
-
 } // namespace __function
 
 namespace __function
 {
-
 // __alloc_func holds a functor and an allocator.
 
 template <class _Fp, class _Ap, class _FB>
@@ -406,8 +403,8 @@ public:
     if (__function::__not_null(__f))
     {
       _FunAlloc __af(__a);
-      if (sizeof(_Fun) <= sizeof(__buf_)
-          && is_nothrow_copy_constructible_v<_Fp> && is_nothrow_copy_constructible_v<_FunAlloc>)
+      if constexpr (sizeof(_Fun) <= sizeof(__buf_)
+                    && is_nothrow_copy_constructible_v<_Fp> && is_nothrow_copy_constructible_v<_FunAlloc>)
       {
         __f_ = ::new ((void*) &__buf_) _Fun(::cuda::std::move(__f), _Alloc(__af));
       }
@@ -982,7 +979,6 @@ public:
 };
 
 #  endif // _LIBCUDACXX_HAS_EXTENSION_BLOCKS
-
 } // namespace __function
 
 template <class _Rp, class... _ArgTypes>

cuda/cccl/headers/include/cuda/std/__functional/invoke.h

@@ -22,6 +22,7 @@
 #endif // no system header
 
 #include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__fwd/reference_wrapper.h>
 #include <cuda/std/__type_traits/decay.h>
 #include <cuda/std/__type_traits/enable_if.h>
 #include <cuda/std/__type_traits/integral_constant.h>
@@ -29,7 +30,6 @@
 #include <cuda/std/__type_traits/is_core_convertible.h>
 #include <cuda/std/__type_traits/is_member_function_pointer.h>
 #include <cuda/std/__type_traits/is_member_object_pointer.h>
-#include <cuda/std/__type_traits/is_reference_wrapper.h>
 #include <cuda/std/__type_traits/is_same.h>
 #include <cuda/std/__type_traits/is_void.h>
 #include <cuda/std/__type_traits/nat.h>
@@ -67,7 +67,7 @@ using __enable_if_bullet1 = enable_if_t<is_member_function_pointer_v<_DecayFp> &
 
 template <class _Fp, class _A0, class _DecayFp = decay_t<_Fp>, class _DecayA0 = decay_t<_A0>>
 using __enable_if_bullet2 =
-  enable_if_t<is_member_function_pointer_v<_DecayFp> && __cccl_is_reference_wrapper_v<_DecayA0>>;
+  enable_if_t<is_member_function_pointer_v<_DecayFp> && __is_cuda_std_reference_wrapper_v<_DecayA0>>;
 
 template <class _Fp,
           class _A0,
@@ -75,7 +75,7 @@ template <class _Fp,
           class _DecayA0 = decay_t<_A0>,
           class _ClassT  = __member_pointer_class_type_t<_DecayFp>>
 using __enable_if_bullet3 = enable_if_t<is_member_function_pointer_v<_DecayFp> && !is_base_of_v<_ClassT, _DecayA0>
-                                        && !__cccl_is_reference_wrapper_v<_DecayA0>>;
+                                        && !__is_cuda_std_reference_wrapper_v<_DecayA0>>;
 
 template <class _Fp,
           class _A0,
@@ -86,7 +86,7 @@ using __enable_if_bullet4 = enable_if_t<is_member_object_pointer_v<_DecayFp> &&
 
 template <class _Fp, class _A0, class _DecayFp = decay_t<_Fp>, class _DecayA0 = decay_t<_A0>>
 using __enable_if_bullet5 =
-  enable_if_t<is_member_object_pointer_v<_DecayFp> && __cccl_is_reference_wrapper_v<_DecayA0>>;
+  enable_if_t<is_member_object_pointer_v<_DecayFp> && __is_cuda_std_reference_wrapper_v<_DecayA0>>;
 
 template <class _Fp,
           class _A0,
@@ -94,7 +94,7 @@ template <class _Fp,
           class _DecayA0 = decay_t<_A0>,
           class _ClassT  = __member_pointer_class_type_t<_DecayFp>>
 using __enable_if_bullet6 = enable_if_t<is_member_object_pointer_v<_DecayFp> && !is_base_of_v<_ClassT, _DecayA0>
-                                        && !__cccl_is_reference_wrapper_v<_DecayA0>>;
+                                        && !__is_cuda_std_reference_wrapper_v<_DecayA0>>;
 
 // __invoke forward declarations
 

cuda/cccl/headers/include/cuda/std/__fwd/allocator.h

@@ -41,6 +41,11 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 template <class _Tp>
 class _CCCL_TYPE_VISIBILITY_DEFAULT allocator;
 
+template <class _Tp>
+inline constexpr bool __is_cuda_std_allocator_v = false;
+template <class _Tp>
+inline constexpr bool __is_cuda_std_allocator_v<allocator<_Tp>> = true;
+
 _CCCL_END_NAMESPACE_CUDA_STD
 
 #include <cuda/std/__cccl/epilogue.h>

cuda/cccl/headers/include/cuda/std/__fwd/array.h

@@ -30,10 +30,10 @@ template <class _Tp, size_t _Size>
 struct _CCCL_TYPE_VISIBILITY_DEFAULT array;
 
 template <class _Tp>
-inline constexpr bool __is_std_array_v = false;
+inline constexpr bool __is_cuda_std_array_v = false;
 
 template <class _Tp, size_t _Sz>
-inline constexpr bool __is_std_array_v<array<_Tp, _Sz>> = true;
+inline constexpr bool __is_cuda_std_array_v<array<_Tp, _Sz>> = true;
 
 _CCCL_END_NAMESPACE_CUDA_STD
 

cuda/cccl/headers/include/cuda/std/__fwd/char_traits.h

@@ -55,6 +55,18 @@ template <>
 struct char_traits<wchar_t>;
 #endif // _CCCL_HAS_WCHAR_T()
 
+template <class _Tp>
+inline constexpr bool __is_std_char_traits_v = false;
+#if _CCCL_HAS_HOST_STD_LIB()
+template <class _Tp>
+inline constexpr bool __is_std_char_traits_v<::std::char_traits<_Tp>> = true;
+#endif // _CCCL_HAS_HOST_STD_LIB()
+
+template <class _Tp>
+inline constexpr bool __is_cuda_std_char_traits_v = false;
+template <class _Tp>
+inline constexpr bool __is_cuda_std_char_traits_v<char_traits<_Tp>> = true;
+
 _CCCL_END_NAMESPACE_CUDA_STD
 
 #include <cuda/std/__cccl/epilogue.h>

cuda/cccl/headers/include/cuda/std/__fwd/expected.h

@@ -0,0 +1,46 @@
+//===---------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _CUDA_STD___FWD_EXPECTED_H
+#define _CUDA_STD___FWD_EXPECTED_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+template <class _Tp, class _Err>
+class _CCCL_TYPE_VISIBILITY_DEFAULT expected;
+
+template <class _Tp>
+inline constexpr bool __is_cuda_std_expected_v = false;
+
+template <class _Tp, class _Err>
+inline constexpr bool __is_cuda_std_expected_v<expected<_Tp, _Err>> = true;
+
+template <class _Tp>
+inline constexpr bool __is_cuda_std_expected_nonvoid_v = __is_cuda_std_expected_v<_Tp>;
+
+template <class _Err>
+inline constexpr bool __is_cuda_std_expected_nonvoid_v<expected<void, _Err>> = false;
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___FWD_EXPECTED_H

cuda/cccl/headers/include/cuda/std/__fwd/get.h

@@ -34,52 +34,52 @@
 _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 template <size_t _Ip, class... _Tp>
-_CCCL_API constexpr tuple_element_t<_Ip, tuple<_Tp...>>& get(tuple<_Tp...>&) noexcept;
+[[nodiscard]] _CCCL_API constexpr tuple_element_t<_Ip, tuple<_Tp...>>& get(tuple<_Tp...>&) noexcept;
 
 template <size_t _Ip, class... _Tp>
-_CCCL_API constexpr const tuple_element_t<_Ip, tuple<_Tp...>>& get(const tuple<_Tp...>&) noexcept;
+[[nodiscard]] _CCCL_API constexpr const tuple_element_t<_Ip, tuple<_Tp...>>& get(const tuple<_Tp...>&) noexcept;
 
 template <size_t _Ip, class... _Tp>
-_CCCL_API constexpr tuple_element_t<_Ip, tuple<_Tp...>>&& get(tuple<_Tp...>&&) noexcept;
+[[nodiscard]] _CCCL_API constexpr tuple_element_t<_Ip, tuple<_Tp...>>&& get(tuple<_Tp...>&&) noexcept;
 
 template <size_t _Ip, class... _Tp>
-_CCCL_API constexpr const tuple_element_t<_Ip, tuple<_Tp...>>&& get(const tuple<_Tp...>&&) noexcept;
+[[nodiscard]] _CCCL_API constexpr const tuple_element_t<_Ip, tuple<_Tp...>>&& get(const tuple<_Tp...>&&) noexcept;
 
 template <size_t _Ip, class _T1, class _T2>
-_CCCL_API constexpr tuple_element_t<_Ip, pair<_T1, _T2>>& get(pair<_T1, _T2>&) noexcept;
+[[nodiscard]] _CCCL_API constexpr tuple_element_t<_Ip, pair<_T1, _T2>>& get(pair<_T1, _T2>&) noexcept;
 
 template <size_t _Ip, class _T1, class _T2>
-_CCCL_API constexpr const tuple_element_t<_Ip, pair<_T1, _T2>>& get(const pair<_T1, _T2>&) noexcept;
+[[nodiscard]] _CCCL_API constexpr const tuple_element_t<_Ip, pair<_T1, _T2>>& get(const pair<_T1, _T2>&) noexcept;
 
 template <size_t _Ip, class _T1, class _T2>
-_CCCL_API constexpr tuple_element_t<_Ip, pair<_T1, _T2>>&& get(pair<_T1, _T2>&&) noexcept;
+[[nodiscard]] _CCCL_API constexpr tuple_element_t<_Ip, pair<_T1, _T2>>&& get(pair<_T1, _T2>&&) noexcept;
 
 template <size_t _Ip, class _T1, class _T2>
-_CCCL_API constexpr const tuple_element_t<_Ip, pair<_T1, _T2>>&& get(const pair<_T1, _T2>&&) noexcept;
+[[nodiscard]] _CCCL_API constexpr const tuple_element_t<_Ip, pair<_T1, _T2>>&& get(const pair<_T1, _T2>&&) noexcept;
 
 template <size_t _Ip, class _Tp, size_t _Size>
-_CCCL_API constexpr _Tp& get(array<_Tp, _Size>&) noexcept;
+[[nodiscard]] _CCCL_API constexpr _Tp& get(array<_Tp, _Size>&) noexcept;
 
 template <size_t _Ip, class _Tp, size_t _Size>
-_CCCL_API constexpr const _Tp& get(const array<_Tp, _Size>&) noexcept;
+[[nodiscard]] _CCCL_API constexpr const _Tp& get(const array<_Tp, _Size>&) noexcept;
 
 template <size_t _Ip, class _Tp, size_t _Size>
-_CCCL_API constexpr _Tp&& get(array<_Tp, _Size>&&) noexcept;
+[[nodiscard]] _CCCL_API constexpr _Tp&& get(array<_Tp, _Size>&&) noexcept;
 
 template <size_t _Ip, class _Tp, size_t _Size>
-_CCCL_API constexpr const _Tp&& get(const array<_Tp, _Size>&&) noexcept;
+[[nodiscard]] _CCCL_API constexpr const _Tp&& get(const array<_Tp, _Size>&&) noexcept;
 
 template <size_t _Ip, class _Tp>
-_CCCL_API constexpr _Tp& get(complex<_Tp>&) noexcept;
+[[nodiscard]] _CCCL_API constexpr _Tp& get(complex<_Tp>&) noexcept;
 
 template <size_t _Ip, class _Tp>
-_CCCL_API constexpr _Tp&& get(complex<_Tp>&&) noexcept;
+[[nodiscard]] _CCCL_API constexpr _Tp&& get(complex<_Tp>&&) noexcept;
 
 template <size_t _Ip, class _Tp>
-_CCCL_API constexpr const _Tp& get(const complex<_Tp>&) noexcept;
+[[nodiscard]] _CCCL_API constexpr const _Tp& get(const complex<_Tp>&) noexcept;
 
 template <size_t _Ip, class _Tp>
-_CCCL_API constexpr const _Tp&& get(const complex<_Tp>&&) noexcept;
+[[nodiscard]] _CCCL_API constexpr const _Tp&& get(const complex<_Tp>&&) noexcept;
 
 _CCCL_END_NAMESPACE_CUDA_STD
 
@@ -101,12 +101,11 @@ _CCCL_API constexpr auto get(const subrange<_Iter, _Sent, _Kind>& __subrange);
 template <size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
   requires(_Index < 2)
 #else // ^^^ C++20 ^^^ / vvv C++17 vvv
-template <
-  size_t _Index,
-  class _Iter,
-  class _Sent,
-  subrange_kind _Kind,
-  enable_if_t<_Index<2, int> = 0>
+template <size_t _Index,
+          class _Iter,
+          class _Sent,
+          subrange_kind _Kind,
+          enable_if_t<_Index<2, int> = 0>
 #endif // ^^^ !_CCCL_HAS_CONCEPTS() ^^^
 _CCCL_API constexpr auto get(subrange<_Iter, _Sent, _Kind>&& __subrange);