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/__variant/visit.h

@@ -0,0 +1,148 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_STD___VARIANT_VISIT_H
+#define _CUDA_STD___VARIANT_VISIT_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/__fwd/variant.h>
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/void_t.h>
+#include <cuda/std/__utility/declval.h>
+#include <cuda/std/__utility/forward.h>
+#include <cuda/std/__utility/move.h>
+#include <cuda/std/__utility/unreachable.h>
+#include <cuda/std/__variant/bad_variant_access.h>
+#include <cuda/std/__variant/get.h>
+#include <cuda/std/__variant/variant.h>
+#include <cuda/std/__variant/variant_visit.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+struct __variant_binary_visitor
+{
+  template <class _BinaryOp, class _LeftVariant, class _RightVariant>
+  [[nodiscard]] _CCCL_API static constexpr auto
+  __visit(const size_t __index_, _BinaryOp&& __op, const _LeftVariant& __lhs, const _RightVariant& __rhs)
+  {
+    return __visit(integral_constant<size_t, variant_size_v<_LeftVariant> - 1>{},
+                   __index_,
+                   ::cuda::std::forward<_BinaryOp>(__op),
+                   __lhs,
+                   __rhs);
+  }
+
+private:
+  template <size_t _CurrentIndex, class _BinaryOp, class _LeftVariant, class _RightVariant>
+  [[nodiscard]] _CCCL_API static constexpr auto
+  __visit(integral_constant<size_t, _CurrentIndex>,
+          const size_t __index_,
+          _BinaryOp&& __op,
+          const _LeftVariant& __lhs,
+          const _RightVariant& __rhs)
+  {
+    if (__index_ == _CurrentIndex)
+    {
+      return __op(::cuda::std::get<_CurrentIndex>(__lhs), ::cuda::std::get<_CurrentIndex>(__rhs));
+    }
+    return __visit(
+      integral_constant<size_t, _CurrentIndex - 1>{}, __index_, ::cuda::std::forward<_BinaryOp>(__op), __lhs, __rhs);
+  }
+
+  template <class _BinaryOp, class _LeftVariant, class _RightVariant>
+  [[nodiscard]] _CCCL_API static constexpr auto
+  __visit(integral_constant<size_t, 0>,
+          const size_t __index_,
+          _BinaryOp&& __op,
+          const _LeftVariant& __lhs,
+          const _RightVariant& __rhs)
+  {
+    if (__index_ == 0)
+    {
+      return __op(::cuda::std::get<0>(__lhs), ::cuda::std::get<0>(__rhs));
+    }
+    // We already checked that every variant has a value, so we should never reach this line
+#if _CCCL_COMPILER(MSVC) // MSVC needs this to be wrapped in a function or it will error
+    ::cuda::std::unreachable();
+#else // ^^^ _CCCL_COMPILER(MSVC) ^^^ / vvv !_CCCL_COMPILER(MSVC) vvv
+    _CCCL_UNREACHABLE();
+#endif // !_CCCL_COMPILER(MSVC)
+  }
+};
+
+template <class... _Types>
+[[nodiscard]] _CCCL_API constexpr variant<_Types...>& __as_variant(variant<_Types...>& __vs) noexcept
+{
+  return __vs;
+}
+
+template <class... _Types>
+[[nodiscard]] _CCCL_API constexpr const variant<_Types...>& __as_variant(const variant<_Types...>& __vs) noexcept
+{
+  return __vs;
+}
+
+template <class... _Types>
+[[nodiscard]] _CCCL_API constexpr variant<_Types...>&& __as_variant(variant<_Types...>&& __vs) noexcept
+{
+  return ::cuda::std::move(__vs);
+}
+
+template <class... _Types>
+[[nodiscard]] _CCCL_API constexpr const variant<_Types...>&& __as_variant(const variant<_Types...>&& __vs) noexcept
+{
+  return ::cuda::std::move(__vs);
+}
+
+template <class... _Vs>
+_CCCL_API constexpr void __throw_if_valueless(_Vs&&... __vs)
+{
+  [[maybe_unused]] int __unused[] = {
+    (::cuda::std::__as_variant(__vs).valueless_by_exception() ? ::cuda::std::__throw_bad_variant_access() : void(),
+     0)...,
+    0};
+}
+
+template <class _Visitor,
+          class... _Vs,
+          typename = void_t<decltype(::cuda::std::__as_variant(::cuda::std::declval<_Vs>()))...>>
+_CCCL_API constexpr decltype(auto) visit(_Visitor&& __visitor, _Vs&&... __vs)
+{
+  using __variant_detail::__visitation::__variant;
+  ::cuda::std::__throw_if_valueless(::cuda::std::forward<_Vs>(__vs)...);
+  return __variant::__visit_value(::cuda::std::forward<_Visitor>(__visitor), ::cuda::std::forward<_Vs>(__vs)...);
+}
+
+template <class _Rp,
+          class _Visitor,
+          class... _Vs,
+          typename = void_t<decltype(::cuda::std::__as_variant(::cuda::std::declval<_Vs>()))...>>
+_CCCL_API constexpr _Rp visit(_Visitor&& __visitor, _Vs&&... __vs)
+{
+  using __variant_detail::__visitation::__variant;
+  ::cuda::std::__throw_if_valueless(::cuda::std::forward<_Vs>(__vs)...);
+  return __variant::__visit_value<_Rp>(::cuda::std::forward<_Visitor>(__visitor), ::cuda::std::forward<_Vs>(__vs)...);
+}
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___VARIANT_VISIT_H

cuda/cccl/headers/include/cuda/std/array

@@ -25,6 +25,7 @@
 #include <cuda/std/__algorithm/lexicographical_compare.h>
 #include <cuda/std/__algorithm/swap_ranges.h>
 #include <cuda/std/__concepts/concept_macros.h>
+#include <cuda/std/__exception/throw_error.h>
 #include <cuda/std/__iterator/reverse_iterator.h>
 #include <cuda/std/__tuple_dir/sfinae_helpers.h>
 #include <cuda/std/__type_traits/conditional.h>
@@ -41,7 +42,6 @@
 #include <cuda/std/__utility/move.h>
 #include <cuda/std/__utility/unreachable.h>
 #include <cuda/std/cstdint>
-#include <cuda/std/detail/libcxx/include/stdexcept>
 #include <cuda/std/limits>
 
 // standard-mandated includes

cuda/cccl/headers/include/cuda/std/atomic

@@ -95,7 +95,7 @@ struct atomic_ref : public __atomic_ref_impl<_Tp>
 
   static constexpr size_t required_alignment = sizeof(_Tp);
 
-  static constexpr bool is_always_lock_free = sizeof(_Tp) <= 8;
+  static constexpr bool is_always_lock_free = __atomic_ref_impl<_Tp>::is_always_lock_free;
 
   _CCCL_API inline explicit atomic_ref(_Tp& __ref)
       : __atomic_ref_impl<_Tp>(__ref)

cuda/cccl/headers/include/cuda/std/bitset

@@ -26,20 +26,20 @@
 #include <cuda/std/__algorithm/fill.h>
 #include <cuda/std/__algorithm/find.h>
 #include <cuda/std/__bit/reference.h>
+#include <cuda/std/__exception/throw_error.h>
 #include <cuda/std/__functional/hash.h>
 #include <cuda/std/__functional/unary_function.h>
 #include <cuda/std/__string/char_traits.h>
 #include <cuda/std/__type_traits/is_char_like_type.h>
 #include <cuda/std/climits>
 #include <cuda/std/cstddef>
-#include <cuda/std/detail/libcxx/include/stdexcept>
 #include <cuda/std/string_view>
 #include <cuda/std/version>
 
 // standard-mandated includes
 
 // [bitset.syn]
-#include <cuda/std/detail/libcxx/include/iosfwd>
+#include <cuda/std/__fwd/ios.h>
 #if defined(_LIBCUDACXX_HAS_STRING)
 #  include <cuda/std/string>
 #endif // _LIBCUDACXX_HAS_STRING
@@ -799,18 +799,10 @@ public:
     return *this;
   }
 
-  // element access:
-#ifdef _LIBCUDACXX_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL
-  _CCCL_API constexpr bool operator[](size_t __p) const
-  {
-    return base::__make_ref(__p);
-  }
-#else
   _CCCL_API constexpr const_reference operator[](size_t __p) const
   {
     return base::__make_ref(__p);
   }
-#endif
   _CCCL_API constexpr reference operator[](size_t __p)
   {
     return base::__make_ref(__p);

cuda/cccl/headers/include/cuda/std/detail/libcxx/include/__config

@@ -39,9 +39,9 @@ extern "C++" {
 #  endif
 
 #  if !_CCCL_COMPILER(NVRTC)
-#    define _LIBCUDACXX_PREFERRED_ALIGNOF(_T) __alignof(_T)
+#    define _LIBCUDACXX_PREFERRED_ALIGNOF(_Tp) __alignof(_Tp)
 #  else // ^^^ !_CCCL_COMPILER(NVRTC) ^^^ / vvv _CCCL_COMPILER(NVRTC) vvv
-#    define _LIBCUDACXX_PREFERRED_ALIGNOF(_T) alignof(_T)
+#    define _LIBCUDACXX_PREFERRED_ALIGNOF(_Tp) alignof(_Tp)
 #  endif // ^^^^ _CCCL_COMPILER(NVRTC) ^^^
 
 #  if _CCCL_COMPILER(MSVC)
@@ -119,11 +119,11 @@ extern "C++" {
 #    define _LIBCUDACXX_HAS_MSVC_ATOMIC_IMPL
 #  endif
 
-#  define _LIBCUDACXX_ATOMIC_UNSAFE_AUTOMATIC_STORAGE
 // Enable bypassing automatic storage checks in atomics when using CTK 12.2 and below and if NDEBUG is defined.
-// #  if _CCCL_CUDACC_BELOW(12, 2) && !defined(NDEBUG)
-// #    define _LIBCUDACXX_ATOMIC_UNSAFE_AUTOMATIC_STORAGE
-// #  endif // _CCCL_CUDACC_BELOW(12, 2)
+// A compiler bug prevents the safe use of `__is_local` and PTX spacep until after 13.0.
+#  if _CCCL_CUDACC_BELOW(13, 1) && !defined(NDEBUG)
+#    define _LIBCUDACXX_ATOMIC_UNSAFE_AUTOMATIC_STORAGE
+#  endif // _CCCL_CUDACC_BELOW(13, 1)
 
 // CUDA Atomics supersede host atomics in order to insert the host/device dispatch layer
 #  if _CCCL_HAS_CUDA_COMPILER() || _CCCL_COMPILER(NVHPC)

cuda/cccl/headers/include/cuda/std/detail/libcxx/include/algorithm

@@ -1710,11 +1710,8 @@ nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomA
 }
 
 #endif
-_CCCL_END_NAMESPACE_CUDA_STD
 
-#if defined(_LIBCUDACXX_HAS_PARALLEL_ALGORITHMS) && _CCCL_STD_VER >= 2017
-#  include <__pstl_algorithm>
-#endif
+_CCCL_END_NAMESPACE_CUDA_STD
 
 #include <cuda/std/__cccl/epilogue.h>
 

cuda/cccl/headers/include/cuda/std/detail/libcxx/include/chrono

@@ -42,8 +42,8 @@ public:
 template <class Rep, class Period = ratio<1>>
 class duration
 {
-    static_assert(!__is_duration_v<Rep>, "A duration representation can not be a duration");
-    static_assert(__is_ratio_v<Period>, "Second template parameter of duration must be a std::ratio");
+    static_assert(!__is_cuda_std_duration_v<Rep>, "A duration representation can not be a duration");
+    static_assert(__is_cuda_std_ratio_v<Period>, "Second template parameter of duration must be a std::ratio");
     static_assert(Period::num > 0, "duration period must be positive");
 public:
     typedef Rep rep;
@@ -883,7 +883,6 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 namespace chrono
 {
-
 class weekday_indexed;
 class weekday_last;
 
@@ -2253,7 +2252,7 @@ template <class _Duration>
 class hh_mm_ss
 {
 private:
-  static_assert(__is_duration_v<_Duration>, "template parameter of hh_mm_ss must be a std::chrono::duration");
+  static_assert(__is_cuda_std_duration_v<_Duration>, "template parameter of hh_mm_ss must be a std::chrono::duration");
   using __CommonType = typename common_type<_Duration, chrono::seconds>::type;
 
   _CCCL_API static constexpr uint64_t __pow10(unsigned __exp)
@@ -2359,7 +2358,6 @@ _CCCL_API constexpr hours make24(const hours& __h, bool __is_pm) noexcept
     return __h == hours(12) ? hours(0) : __h;
   }
 }
-
 } // namespace chrono
 
 // GCC 5 and 6 warn (and then error) on us using the standard reserved UDL names,
@@ -2382,7 +2380,6 @@ inline namespace literals
 {
 inline namespace chrono_literals
 {
-
 _CCCL_API constexpr chrono::hours operator""h(unsigned long long __h)
 {
   return chrono::hours(static_cast<chrono::hours::rep>(__h));

cuda/cccl/headers/include/cuda/std/functional

@@ -50,7 +50,7 @@
 #include <cuda/std/__functional/unary_negate.h>
 #include <cuda/std/__functional/unwrap_ref.h>
 #include <cuda/std/__functional/weak_result_type.h>
-#include <cuda/std/detail/libcxx/include/iosfwd> // for forward declarations of vector and string
+#include <cuda/std/__fwd/string.h>
 #include <cuda/std/version>
 
 #endif // _CUDA_STD_FUNCTIONAL

cuda/cccl/headers/include/cuda/std/initializer_list

@@ -28,7 +28,15 @@
 #include <cuda/std/__cccl/prologue.h>
 
 _CCCL_BEGIN_NAMESPACE_CUDA_STD
+
 using ::std::initializer_list;
+
+template <class _Tp>
+inline constexpr bool __is_cuda_std_initializer_list = false;
+
+template <class _Ep>
+inline constexpr bool __is_cuda_std_initializer_list<initializer_list<_Ep>> = true;
+
 _CCCL_END_NAMESPACE_CUDA_STD
 
 #include <cuda/std/__cccl/epilogue.h>

cuda/cccl/headers/include/cuda/std/inplace_vector

@@ -31,6 +31,7 @@
 #include <cuda/std/__algorithm/rotate.h>
 #include <cuda/std/__algorithm/swap_ranges.h>
 #include <cuda/std/__exception/terminate.h>
+#include <cuda/std/__exception/throw_error.h>
 #include <cuda/std/__iterator/advance.h>
 #include <cuda/std/__iterator/concepts.h>
 #include <cuda/std/__iterator/distance.h>
@@ -40,6 +41,7 @@
 #include <cuda/std/__memory/construct_at.h>
 #include <cuda/std/__memory/uninitialized_algorithms.h>
 #include <cuda/std/__new/bad_alloc.h>
+#include <cuda/std/__new/device_new.h>
 #include <cuda/std/__new/launder.h>
 #include <cuda/std/__ranges/access.h>
 #include <cuda/std/__ranges/concepts.h>
@@ -64,7 +66,6 @@
 #include <cuda/std/__utility/forward.h>
 #include <cuda/std/__utility/move.h>
 #include <cuda/std/cstdint>
-#include <cuda/std/detail/libcxx/include/stdexcept>
 #include <cuda/std/initializer_list>
 #include <cuda/std/limits>
 
@@ -1638,8 +1639,8 @@ public:
     return ::cuda::std::equal(__lhs.begin(), __lhs.end(), __rhs.begin(), __rhs.end());
   }
 #if _CCCL_STD_VER <= 2017
-  [[nodiscard]] _CCCL_API friend constexpr bool
-  operator!=(const inplace_vector& __lhs, const inplace_vector& __rhs) noexcept(
+  [[nodiscard]]
+  _CCCL_API friend constexpr bool operator!=(const inplace_vector& __lhs, const inplace_vector& __rhs) noexcept(
     noexcept(::cuda::std::equal(__lhs.begin(), __lhs.end(), __rhs.begin(), __rhs.end())))
   {
     return !::cuda::std::equal(__lhs.begin(), __lhs.end(), __rhs.begin(), __rhs.end());
@@ -1654,8 +1655,8 @@ public:
     return ::cuda::std::lexicographical_compare_three_way(__lhs.begin(), __lhs.end(), __rhs.begin(), __rhs.end());
   }
 #else // ^^^ _LIBCUDACXX_HAS_SPACESHIP_OPERATOR() ^^^ / vvv !_LIBCUDACXX_HAS_SPACESHIP_OPERATOR() vvv
-  [[nodiscard]] _CCCL_API friend constexpr bool
-  operator<(const inplace_vector& __lhs, const inplace_vector& __rhs) noexcept(
+  [[nodiscard]]
+  _CCCL_API friend constexpr bool operator<(const inplace_vector& __lhs, const inplace_vector& __rhs) noexcept(
     noexcept(::cuda::std::lexicographical_compare(__lhs.begin(), __lhs.end(), __rhs.begin(), __rhs.end())))
   {
     return ::cuda::std::lexicographical_compare(__lhs.begin(), __lhs.end(), __rhs.begin(), __rhs.end());

cuda/cccl/headers/include/cuda/std/iterator

@@ -21,6 +21,7 @@
 #  pragma system_header
 #endif // no system header
 
+#include <cuda/std/__fwd/string.h>
 #include <cuda/std/__iterator/access.h>
 #include <cuda/std/__iterator/advance.h>
 #include <cuda/std/__iterator/back_insert_iterator.h>
@@ -58,7 +59,6 @@
 #include <cuda/std/__iterator/sortable.h>
 #include <cuda/std/__iterator/unreachable_sentinel.h>
 #include <cuda/std/__iterator/wrap_iter.h>
-#include <cuda/std/detail/libcxx/include/iosfwd> // for forward declarations of vector and string.
 #include <cuda/std/version>
 
 // Mandated by the Standard.

cuda/cccl/headers/include/cuda/std/numbers

@@ -232,7 +232,6 @@ struct __numbers<__nv_bfloat16>
 
 namespace numbers
 {
-
 template <class _Tp>
 inline constexpr _Tp e_v = __numbers<_Tp>::__e();
 template <class _Tp>
@@ -334,7 +333,6 @@ inline constexpr double sqrt3      = __numbers<double>::__sqrt3();
 inline constexpr double inv_sqrt3  = __numbers<double>::__inv_sqrt3();
 inline constexpr double egamma     = __numbers<double>::__egamma();
 inline constexpr double phi        = __numbers<double>::__phi();
-
 } // namespace numbers
 
 _CCCL_END_NAMESPACE_CUDA_STD

cuda/cccl/headers/include/cuda/std/ratio

@@ -212,10 +212,10 @@ template <intmax_t _Num, intmax_t _Den>
 constexpr intmax_t ratio<_Num, _Den>::den;
 
 template <class _Tp>
-inline constexpr bool __is_ratio_v = false;
+inline constexpr bool __is_cuda_std_ratio_v = false;
 
 template <intmax_t _Num, intmax_t _Den>
-inline constexpr bool __is_ratio_v<ratio<_Num, _Den>> = true;
+inline constexpr bool __is_cuda_std_ratio_v<ratio<_Num, _Den>> = true;
 
 using atto  = ratio<1LL, 1000000000000000000LL>;
 using femto = ratio<1LL, 1000000000000000LL>;

cuda/cccl/headers/include/cuda/std/span

@@ -23,6 +23,7 @@
 
 #include <cuda/std/__concepts/convertible_to.h>
 #include <cuda/std/__concepts/equality_comparable.h>
+#include <cuda/std/__exception/throw_error.h>
 #include <cuda/std/__fwd/array.h>
 #include <cuda/std/__fwd/span.h>
 #include <cuda/std/__fwd/string.h>
@@ -53,7 +54,6 @@
 #include <cuda/std/__type_traits/type_identity.h>
 #include <cuda/std/array>
 #include <cuda/std/cstddef>
-#include <cuda/std/detail/libcxx/include/stdexcept>
 #include <cuda/std/initializer_list>
 #include <cuda/std/version>
 
@@ -72,7 +72,7 @@ _CCCL_CONCEPT_FRAGMENT(
     requires(::cuda::std::ranges::sized_range<_Range>),
     requires((::cuda::std::ranges::borrowed_range<_Range> || is_const_v<_ElementType>) ),
     requires((!is_array_v<remove_cvref_t<_Range>>) ),
-    requires((!__is_std_span_v<remove_cvref_t<_Range>> && !__is_std_array_v<remove_cvref_t<_Range>>) ),
+    requires((!__is_cuda_std_span_v<remove_cvref_t<_Range>> && !__is_cuda_std_array_v<remove_cvref_t<_Range>>) ),
     requires(
       is_convertible_v<remove_reference_t<::cuda::std::ranges::range_reference_t<_Range>> (*)[], _ElementType (*)[]>)));
 

cuda/cccl/headers/include/cuda/std/string_view

@@ -22,6 +22,7 @@
 
 #include <cuda/std/__algorithm/min.h>
 #include <cuda/std/__cstddef/types.h>
+#include <cuda/std/__exception/throw_error.h>
 #include <cuda/std/__functional/hash.h>
 #include <cuda/std/__functional/unary_function.h>
 #include <cuda/std/__fwd/allocator.h>
@@ -54,7 +55,6 @@
 #include <cuda/std/__type_traits/remove_cvref.h>
 #include <cuda/std/__type_traits/type_identity.h>
 #include <cuda/std/__utility/declval.h>
-#include <cuda/std/detail/libcxx/include/stdexcept>
 #include <cuda/std/limits>
 #include <cuda/std/version>
 
@@ -70,31 +70,6 @@
 
 _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
-template <class _Tp>
-inline constexpr bool __cccl_is_string_view_v = false;
-template <class _Tp>
-inline constexpr bool __cccl_is_string_view_v<const _Tp> = __cccl_is_string_view_v<_Tp>;
-template <class _Tp>
-inline constexpr bool __cccl_is_string_view_v<volatile _Tp> = __cccl_is_string_view_v<_Tp>;
-template <class _Tp>
-inline constexpr bool __cccl_is_string_view_v<const volatile _Tp> = __cccl_is_string_view_v<_Tp>;
-template <class _CharT, class _Traits>
-inline constexpr bool __cccl_is_string_view_v<basic_string_view<_CharT, _Traits>> = true;
-
-template <class _Tp>
-inline constexpr bool __cccl_is_std_string_v = false;
-#if !_CCCL_COMPILER(NVRTC)
-template <class _CharT, class _Traits, class _Alloc>
-inline constexpr bool __cccl_is_std_string_v<::std::basic_string<_CharT, _Traits, _Alloc>> = true;
-#endif // !_CCCL_COMPILER(NVRTC)
-
-template <class _Tp>
-inline constexpr bool __cccl_is_std_string_view_v = false;
-#if __cpp_lib_string_view >= 201606L
-template <class _CharT, class _Traits>
-inline constexpr bool __cccl_is_std_string_view_v<::std::basic_string_view<_CharT, _Traits>> = true;
-#endif // __cpp_lib_string_view >= 201606L
-
 template <class _Range, class _CharT, class _Traits>
 _CCCL_CONCEPT __cccl_has_basic_sv_conv_operator =
   _CCCL_REQUIRES_EXPR((_Range, _CharT, _Traits), remove_cvref_t<_Range>& __d)(
@@ -126,18 +101,25 @@ _CCCL_CONCEPT __cccl_basic_sv_compatible_range = _CCCL_REQUIRES_EXPR((_Range, _C
     requires(::cuda::std::ranges::contiguous_range<_Range>), //
     requires(::cuda::std::ranges::sized_range<_Range>), //
     requires(is_same_v<::cuda::std::ranges::range_value_t<_Range>, _CharT>), //
-    requires(!(__cccl_is_string_view_v<remove_cvref_t<_Range>>
+    requires(!(__is_cuda_std_basic_string_view_v<remove_cvref_t<_Range>>
                && __cccl_basic_sv_compatible_range_check_traits<_Range, _CharT, _Traits>) ), //
     requires(!is_convertible_v<_Range, const _CharT*>), //
     requires(!__cccl_has_basic_sv_conv_operator<_Range, _CharT, _Traits>), //
-    requires(!(__cccl_is_std_string_v<remove_cvref_t<_Range>>
+    requires(!(__is_std_basic_string_v<remove_cvref_t<_Range>>
                && (__cccl_basic_sv_compatible_range_check_traits<_Range, _CharT, _Traits>
                    || __cccl_basic_sv_compatible_range_check_traits_std_ext<_Range, _CharT, _Traits>) )), //
-    requires(!(__cccl_is_std_string_view_v<remove_cvref_t<_Range>>
+    requires(!(__is_std_basic_string_view_v<remove_cvref_t<_Range>>
                && (__cccl_basic_sv_compatible_range_check_traits<_Range, _CharT, _Traits>
                    || __cccl_basic_sv_compatible_range_check_traits_std_ext<_Range, _CharT, _Traits>) )) //
   );
 
+template <class _Traits, class _HostTraits>
+_CCCL_CONCEPT __cccl_basic_sv_is_std_to_cuda_std_char_traits = _CCCL_REQUIRES_EXPR((_Traits, _HostTraits)) //
+  ( //
+    requires(__is_cuda_std_char_traits_v<_Traits>), //
+    requires(__is_std_char_traits_v<_HostTraits>) //
+  );
+
 template <class _CharT, class _Traits>
 class _CCCL_TYPE_VISIBILITY_DEFAULT basic_string_view
 {
@@ -205,30 +187,32 @@ public:
   }
 
 #if !_CCCL_COMPILER(NVRTC)
-  _CCCL_TEMPLATE(class _Traits2 = _Traits, class _Alloc)
-  _CCCL_REQUIRES(is_same_v<_Traits2, char_traits<_CharT>>)
-  _CCCL_HOST_API constexpr basic_string_view(
-    const ::std::basic_string<_CharT, ::std::char_traits<_CharT>, _Alloc>& __sv) noexcept
+  _CCCL_TEMPLATE(class _Traits2, class _Alloc)
+  _CCCL_REQUIRES(__cccl_basic_sv_is_std_to_cuda_std_char_traits<_Traits, _Traits2>)
+  _CCCL_HOST_API constexpr basic_string_view(const ::std::basic_string<_CharT, _Traits2, _Alloc>& __sv) noexcept
       : __data_{__sv.data()}
       , __size_{__sv.size()}
   {}
 
-  template <class _Alloc>
-  _CCCL_HOST_API constexpr basic_string_view(const ::std::basic_string<_CharT, _Traits, _Alloc>& __sv) noexcept
+  _CCCL_TEMPLATE(class _Traits2, class _Alloc)
+  _CCCL_REQUIRES(is_same_v<_Traits, _Traits2>)
+  _CCCL_HOST_API constexpr basic_string_view(const ::std::basic_string<_CharT, _Traits2, _Alloc>& __sv) noexcept
       : __data_{__sv.data()}
       , __size_{__sv.size()}
   {}
 #endif // !_CCCL_COMPILER(NVRTC)
 
 #if __cpp_lib_string_view >= 201606L
-  _CCCL_TEMPLATE(class _Traits2 = _Traits)
-  _CCCL_REQUIRES(is_same_v<_Traits2, char_traits<_CharT>>)
-  _CCCL_HOST_API constexpr basic_string_view(::std::basic_string_view<_CharT> __s) noexcept
+  _CCCL_TEMPLATE(class _Traits2)
+  _CCCL_REQUIRES(__cccl_basic_sv_is_std_to_cuda_std_char_traits<_Traits, _Traits2>)
+  _CCCL_HOST_API constexpr basic_string_view(const ::std::basic_string_view<_CharT, _Traits2>& __s) noexcept
       : __data_{__s.data()}
       , __size_{__s.size()}
   {}
 
-  _CCCL_HOST_API constexpr basic_string_view(::std::basic_string_view<_CharT, _Traits> __s) noexcept
+  _CCCL_TEMPLATE(class _Traits2)
+  _CCCL_REQUIRES(is_same_v<_Traits, _Traits2>)
+  _CCCL_HOST_API constexpr basic_string_view(const ::std::basic_string_view<_CharT, _Traits2>& __s) noexcept
       : __data_{__s.data()}
       , __size_{__s.size()}
   {}
@@ -889,7 +873,6 @@ inline namespace literals
 {
 inline namespace string_view_literals
 {
-
 _CCCL_API constexpr basic_string_view<char> operator""sv(const char* __str, size_t __len) noexcept
 {
   return basic_string_view<char>{__str, __len};
@@ -907,7 +890,7 @@ _CCCL_API constexpr basic_string_view<char8_t> operator""sv(const char8_t* __str
 {
   return basic_string_view<char8_t>{__str, __len};
 }
-#endif // _LIBCUDACXX_HAS_CHAR8_T()
+#endif // _CCCL_HAS_CHAR8_T()
 
 _CCCL_API constexpr basic_string_view<char16_t> operator""sv(const char16_t* __str, size_t __len) noexcept
 {
@@ -918,7 +901,6 @@ _CCCL_API constexpr basic_string_view<char32_t> operator""sv(const char32_t* __s
 {
   return basic_string_view<char32_t>{__str, __len};
 }
-
 } // namespace string_view_literals
 } // namespace literals
 

cuda/cccl/headers/include/cuda/std/tuple

@@ -21,6 +21,23 @@
 #  pragma system_header
 #endif // no system header
 
-#include <cuda/std/detail/libcxx/include/tuple>
+#include <cuda/std/__tuple_dir/apply.h>
+#include <cuda/std/__tuple_dir/get.h>
+#include <cuda/std/__tuple_dir/ignore.h>
+#include <cuda/std/__tuple_dir/structured_bindings.h>
+#include <cuda/std/__tuple_dir/tie.h>
+#include <cuda/std/__tuple_dir/tuple.h>
+#include <cuda/std/__tuple_dir/tuple_cat.h>
+#include <cuda/std/__tuple_dir/tuple_element.h>
+#include <cuda/std/__tuple_dir/tuple_size.h>
+#include <cuda/std/__tuple_dir/vector_types.h>
+
+// standard-mandated includes
+#include <cuda/std/version>
+
+// [tuple.syn]
+#if _LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
+#  include <cuda/std/compare>
+#endif // _LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
 
 #endif // _CUDA_STD_TUPLE

cuda/cccl/headers/include/cuda/std/type_traits

@@ -112,7 +112,6 @@
 #include <cuda/std/__type_traits/is_polymorphic.h>
 #include <cuda/std/__type_traits/is_primary_template.h>
 #include <cuda/std/__type_traits/is_reference.h>
-#include <cuda/std/__type_traits/is_reference_wrapper.h>
 #include <cuda/std/__type_traits/is_referenceable.h>
 #include <cuda/std/__type_traits/is_same.h>
 #include <cuda/std/__type_traits/is_scalar.h>

cuda/cccl/headers/include/cuda/std/variant

@@ -20,6 +20,13 @@
 #  pragma system_header
 #endif // no system header
 
-#include <cuda/std/detail/libcxx/include/variant>
+#include <cuda/std/__utility/monostate.h>
+#include <cuda/std/__variant/bad_variant_access.h>
+#include <cuda/std/__variant/comparison.h>
+#include <cuda/std/__variant/get.h>
+#include <cuda/std/__variant/hash.h>
+#include <cuda/std/__variant/variant.h>
+#include <cuda/std/__variant/visit.h>
+#include <cuda/std/version>
 
 #endif //_CUDA_STD_VARIANT