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/__tuple_dir/sfinae_helpers.h

@@ -21,21 +21,9 @@
 #endif // no system header
 
 #include <cuda/std/__fwd/tuple.h>
-#include <cuda/std/__tuple_dir/make_tuple_types.h>
-#include <cuda/std/__tuple_dir/tuple_element.h>
-#include <cuda/std/__tuple_dir/tuple_like_ext.h>
-#include <cuda/std/__tuple_dir/tuple_size.h>
-#include <cuda/std/__tuple_dir/tuple_types.h>
-#include <cuda/std/__type_traits/enable_if.h>
-#include <cuda/std/__type_traits/integral_constant.h>
-#include <cuda/std/__type_traits/is_assignable.h>
-#include <cuda/std/__type_traits/is_constructible.h>
-#include <cuda/std/__type_traits/is_convertible.h>
 #include <cuda/std/__type_traits/is_copy_assignable.h>
 #include <cuda/std/__type_traits/is_move_assignable.h>
 #include <cuda/std/__type_traits/is_same.h>
-#include <cuda/std/__type_traits/remove_cvref.h>
-#include <cuda/std/__type_traits/remove_reference.h>
 #include <cuda/std/cstddef>
 
 #include <cuda/std/__cccl/prologue.h>
@@ -48,98 +36,6 @@ struct __all_dummy;
 template <bool... _Pred>
 using __all = is_same<__all_dummy<_Pred...>, __all_dummy<((void) _Pred, true)...>>;
 
-struct __tuple_sfinae_base
-{
-  template <class, class>
-  struct __test_size : false_type
-  {};
-
-  template <class... _Tp, class... _Up>
-  struct __test_size<__tuple_types<_Tp...>, __tuple_types<_Up...>> : bool_constant<sizeof...(_Tp) == sizeof...(_Up)>
-  {};
-
-  template <template <class, class...> class, class _Tp, class _Up, bool = __test_size<_Tp, _Up>::value>
-  struct __test : false_type
-  {};
-
-  template <template <class, class...> class _Trait, class... _LArgs, class... _RArgs>
-  struct __test<_Trait, __tuple_types<_LArgs...>, __tuple_types<_RArgs...>, true>
-      : __all<_Trait<_LArgs, _RArgs>::value...>
-  {};
-
-  template <class _FromArgs, class _ToArgs>
-  using __constructible = __test<is_constructible, _ToArgs, _FromArgs>;
-  template <class _FromArgs, class _ToArgs>
-  using __convertible = __test<is_convertible, _FromArgs, _ToArgs>;
-  template <class _FromArgs, class _ToArgs>
-  using __assignable = __test<is_assignable, _ToArgs, _FromArgs>;
-};
-
-// __tuple_convertible
-
-template <class _Tp, class _Up, bool = __tuple_like_ext<remove_reference_t<_Tp>>, bool = __tuple_like_ext<_Up>>
-struct __tuple_convertible : public false_type
-{};
-
-template <class _Tp, class _Up>
-struct __tuple_convertible<_Tp, _Up, true, true>
-    : public __tuple_sfinae_base::__convertible<__make_tuple_types_t<_Tp>, __make_tuple_types_t<_Up>>
-{};
-
-// __tuple_constructible
-
-template <class _Tp, class _Up, bool = __tuple_like_ext<remove_reference_t<_Tp>>, bool = __tuple_like_ext<_Up>>
-struct __tuple_constructible : public false_type
-{};
-
-template <class _Tp, class _Up>
-struct __tuple_constructible<_Tp, _Up, true, true>
-    : public __tuple_sfinae_base::__constructible<__make_tuple_types_t<_Tp>, __make_tuple_types_t<_Up>>
-{};
-
-// __tuple_assignable
-
-template <class _Tp, class _Up, bool = __tuple_like_ext<remove_reference_t<_Tp>>, bool = __tuple_like_ext<_Up>>
-struct __tuple_assignable : public false_type
-{};
-
-template <class _Tp, class _Up>
-struct __tuple_assignable<_Tp, _Up, true, true>
-    : public __tuple_sfinae_base::__assignable<__make_tuple_types_t<_Tp>, __make_tuple_types_t<_Up&>>
-{};
-
-template <size_t _Ip, class... _Tp>
-struct _CCCL_TYPE_VISIBILITY_DEFAULT tuple_element<_Ip, tuple<_Tp...>>
-{
-  using type _CCCL_NODEBUG_ALIAS = tuple_element_t<_Ip, __tuple_types<_Tp...>>;
-};
-
-template <bool _IsTuple, class _SizeTrait, size_t _Expected>
-struct __tuple_like_with_size_imp : false_type
-{};
-
-template <class _SizeTrait, size_t _Expected>
-struct __tuple_like_with_size_imp<true, _SizeTrait, _Expected> : integral_constant<bool, _SizeTrait::value == _Expected>
-{};
-
-template <class _Tuple, size_t _ExpectedSize, class _RawTuple = remove_cvref_t<_Tuple>>
-using __tuple_like_with_size _CCCL_NODEBUG_ALIAS =
-  __tuple_like_with_size_imp<__tuple_like_ext<_RawTuple>, tuple_size<_RawTuple>, _ExpectedSize>;
-
-struct _CCCL_TYPE_VISIBILITY_DEFAULT __check_tuple_constructor_fail
-{
-  template <int&...>
-  using __enable_explicit_default = false_type;
-  template <int&...>
-  using __enable_implicit_default = false_type;
-  template <class...>
-  using __enable_explicit = false_type;
-  template <class...>
-  using __enable_implicit = false_type;
-  template <class...>
-  using __enable_assign = false_type;
-};
-
 enum class __smf_availability
 {
   __trivial,
@@ -147,62 +43,6 @@ enum class __smf_availability
   __deleted,
 };
 
-template <bool _CanCopy>
-struct __sfinae_copy_base
-{};
-template <>
-struct __sfinae_copy_base<false>
-{
-  _CCCL_HIDE_FROM_ABI __sfinae_copy_base()                                     = default;
-  __sfinae_copy_base(__sfinae_copy_base const&)                                = delete;
-  _CCCL_HIDE_FROM_ABI __sfinae_copy_base(__sfinae_copy_base&&)                 = default;
-  _CCCL_HIDE_FROM_ABI __sfinae_copy_base& operator=(__sfinae_copy_base const&) = default;
-  _CCCL_HIDE_FROM_ABI __sfinae_copy_base& operator=(__sfinae_copy_base&&)      = default;
-};
-
-template <bool _CanCopy, bool _CanMove>
-struct __sfinae_move_base : __sfinae_copy_base<_CanCopy>
-{};
-template <bool _CanCopy>
-struct __sfinae_move_base<_CanCopy, false> : __sfinae_copy_base<_CanCopy>
-{
-  _CCCL_HIDE_FROM_ABI __sfinae_move_base()                                     = default;
-  _CCCL_HIDE_FROM_ABI __sfinae_move_base(__sfinae_move_base const&)            = default;
-  __sfinae_move_base(__sfinae_move_base&&)                                     = delete;
-  _CCCL_HIDE_FROM_ABI __sfinae_move_base& operator=(__sfinae_move_base const&) = default;
-  _CCCL_HIDE_FROM_ABI __sfinae_move_base& operator=(__sfinae_move_base&&)      = default;
-};
-
-template <bool _CanCopy, bool _CanMove, bool _CanCopyAssign>
-struct __sfinae_copy_assign_base : __sfinae_move_base<_CanCopy, _CanMove>
-{};
-template <bool _CanCopy, bool _CanMove>
-struct __sfinae_copy_assign_base<_CanCopy, _CanMove, false> : __sfinae_move_base<_CanCopy, _CanMove>
-{
-  _CCCL_HIDE_FROM_ABI __sfinae_copy_assign_base()                                       = default;
-  _CCCL_HIDE_FROM_ABI __sfinae_copy_assign_base(__sfinae_copy_assign_base const&)       = default;
-  _CCCL_HIDE_FROM_ABI __sfinae_copy_assign_base(__sfinae_copy_assign_base&&)            = default;
-  __sfinae_copy_assign_base& operator=(__sfinae_copy_assign_base const&)                = delete;
-  _CCCL_HIDE_FROM_ABI __sfinae_copy_assign_base& operator=(__sfinae_copy_assign_base&&) = default;
-};
-
-template <bool _CanCopy, bool _CanMove, bool _CanCopyAssign, bool _CanMoveAssign>
-struct __sfinae_move_assign_base : __sfinae_copy_assign_base<_CanCopy, _CanMove, _CanCopyAssign>
-{};
-template <bool _CanCopy, bool _CanMove, bool _CanCopyAssign>
-struct __sfinae_move_assign_base<_CanCopy, _CanMove, _CanCopyAssign, false>
-    : __sfinae_copy_assign_base<_CanCopy, _CanMove, _CanCopyAssign>
-{
-  _CCCL_HIDE_FROM_ABI __sfinae_move_assign_base()                                            = default;
-  _CCCL_HIDE_FROM_ABI __sfinae_move_assign_base(__sfinae_move_assign_base const&)            = default;
-  _CCCL_HIDE_FROM_ABI __sfinae_move_assign_base(__sfinae_move_assign_base&&)                 = default;
-  _CCCL_HIDE_FROM_ABI __sfinae_move_assign_base& operator=(__sfinae_move_assign_base const&) = default;
-  __sfinae_move_assign_base& operator=(__sfinae_move_assign_base&&)                          = delete;
-};
-
-template <bool _CanCopy, bool _CanMove, bool _CanCopyAssign, bool _CanMoveAssign>
-using __sfinae_base = __sfinae_move_assign_base<_CanCopy, _CanMove, _CanCopyAssign, _CanMoveAssign>;
-
 // We need to synthesize the copy / move assignment if it would be implicitly deleted as a member of a class
 // In that case _Tp would be copy assignable but _TestSynthesizeAssignment<_Tp> would not
 // This happens e.g for reference types

cuda/cccl/headers/include/cuda/std/__tuple_dir/structured_bindings.h

@@ -23,13 +23,7 @@
 _CCCL_DIAG_PUSH
 _CCCL_DIAG_SUPPRESS_CLANG("-Wmismatched-tags")
 
-#if !_CCCL_COMPILER(NVRTC)
-// Fetch utility to get primary template for ::std::tuple_size necessary for the specialization of
-// ::std::tuple_size<cuda::std::tuple> to enable structured bindings.
-// See https://github.com/NVIDIA/libcudacxx/issues/316
-#  include <utility>
-#endif // !_CCCL_COMPILER(NVRTC)
-
+#include <cuda/__fwd/complex.h>
 #include <cuda/std/__fwd/array.h>
 #include <cuda/std/__fwd/complex.h>
 #include <cuda/std/__fwd/pair.h>
@@ -37,7 +31,10 @@ _CCCL_DIAG_SUPPRESS_CLANG("-Wmismatched-tags")
 #include <cuda/std/__fwd/tuple.h>
 #include <cuda/std/__tuple_dir/tuple_element.h>
 #include <cuda/std/__tuple_dir/tuple_size.h>
+#include <cuda/std/__type_traits/enable_if.h>
 #include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_const.h>
+#include <cuda/std/__type_traits/is_volatile.h>
 
 // This is a workaround for the fact that structured bindings require that the specializations of
 // `tuple_size` and `tuple_element` reside in namespace std (https://eel.is/c++draft/dcl.struct.bind#4).
@@ -45,171 +42,168 @@ _CCCL_DIAG_SUPPRESS_CLANG("-Wmismatched-tags")
 
 #include <cuda/std/__cccl/prologue.h>
 
-namespace std
-{
-#if _CCCL_COMPILER(NVRTC)
-template <class... _Tp>
+_CCCL_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
 struct tuple_size;
 
-template <size_t _Ip, class... _Tp>
-struct tuple_element;
-#endif // _CCCL_COMPILER(NVRTC)
+#if _CCCL_COMPILER(NVRTC)
 
-template <class _Tp, size_t _Size>
-struct tuple_size<::cuda::std::array<_Tp, _Size>> : ::cuda::std::tuple_size<::cuda::std::array<_Tp, _Size>>
+template <class _Tp>
+struct tuple_size<
+  ::cuda::std::__enable_if_tuple_size_imp<const _Tp,
+                                          ::cuda::std::enable_if_t<!::cuda::std::is_volatile_v<_Tp>>,
+                                          ::cuda::std::integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
+    : public ::cuda::std::integral_constant<size_t, tuple_size<_Tp>::value>
 {};
 
-template <class _Tp, size_t _Size>
-struct tuple_size<const ::cuda::std::array<_Tp, _Size>> : ::cuda::std::tuple_size<::cuda::std::array<_Tp, _Size>>
+template <class _Tp>
+struct tuple_size<
+  ::cuda::std::__enable_if_tuple_size_imp<volatile _Tp,
+                                          ::cuda::std::enable_if_t<!::cuda::std::is_const_v<_Tp>>,
+                                          ::cuda::std::integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
+    : public ::cuda::std::integral_constant<size_t, tuple_size<_Tp>::value>
 {};
 
-template <class _Tp, size_t _Size>
-struct tuple_size<volatile ::cuda::std::array<_Tp, _Size>> : ::cuda::std::tuple_size<::cuda::std::array<_Tp, _Size>>
+template <class _Tp>
+struct tuple_size<
+  ::cuda::std::__enable_if_tuple_size_imp<const volatile _Tp,
+                                          ::cuda::std::integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
+    : public ::cuda::std::integral_constant<size_t, tuple_size<_Tp>::value>
 {};
+#endif // _CCCL_COMPILER(NVRTC)
+
+template <size_t _Ip, class _Tp>
+struct tuple_element;
+
+#if _CCCL_COMPILER(NVRTC)
+template <size_t _Ip, class _Tp>
+struct tuple_element<_Ip, const _Tp>
+{
+  using type _CCCL_NODEBUG_ALIAS = const typename tuple_element<_Ip, _Tp>::type;
+};
+
+template <size_t _Ip, class _Tp>
+struct tuple_element<_Ip, volatile _Tp>
+{
+  using type _CCCL_NODEBUG_ALIAS = volatile typename tuple_element<_Ip, _Tp>::type;
+};
+
+template <size_t _Ip, class _Tp>
+struct tuple_element<_Ip, const volatile _Tp>
+{
+  using type _CCCL_NODEBUG_ALIAS = const volatile typename tuple_element<_Ip, _Tp>::type;
+};
+#endif // _CCCL_COMPILER(NVRTC)
 
 template <class _Tp, size_t _Size>
-struct tuple_size<const volatile ::cuda::std::array<_Tp, _Size>>
-    : ::cuda::std::tuple_size<::cuda::std::array<_Tp, _Size>>
-{};
+struct tuple_size<::cuda::std::array<_Tp, _Size>>
+{
+  static constexpr size_t value = _Size;
+};
 
 template <size_t _Ip, class _Tp, size_t _Size>
 struct tuple_element<_Ip, ::cuda::std::array<_Tp, _Size>>
-    : ::cuda::std::tuple_element<_Ip, ::cuda::std::array<_Tp, _Size>>
-{};
+{
+  static_assert(_Ip < _Size, "Index out of bounds in std::tuple_element<> (std::array)");
+  using type = _Tp;
+};
 
-template <size_t _Ip, class _Tp, size_t _Size>
-struct tuple_element<_Ip, const ::cuda::std::array<_Tp, _Size>>
-    : ::cuda::std::tuple_element<_Ip, const ::cuda::std::array<_Tp, _Size>>
-{};
+template <class _Tp>
+struct tuple_size<::cuda::complex<_Tp>>
+{
+  static constexpr size_t value = 2;
+};
 
-template <size_t _Ip, class _Tp, size_t _Size>
-struct tuple_element<_Ip, volatile ::cuda::std::array<_Tp, _Size>>
-    : ::cuda::std::tuple_element<_Ip, volatile ::cuda::std::array<_Tp, _Size>>
-{};
+template <class _Tp>
+struct tuple_element<0, ::cuda::complex<_Tp>>
+{
+  using type = _Tp;
+};
 
-template <size_t _Ip, class _Tp, size_t _Size>
-struct tuple_element<_Ip, const volatile ::cuda::std::array<_Tp, _Size>>
-    : ::cuda::std::tuple_element<_Ip, const volatile ::cuda::std::array<_Tp, _Size>>
-{};
+template <class _Tp>
+struct tuple_element<1, ::cuda::complex<_Tp>>
+{
+  using type = _Tp;
+};
 
 template <class _Tp>
-struct tuple_size<::cuda::std::complex<_Tp>> : ::cuda::std::tuple_size<::cuda::std::complex<_Tp>>
-{};
+struct tuple_size<::cuda::std::complex<_Tp>>
+{
+  static constexpr size_t value = 2;
+};
 
-template <size_t _Ip, class _Tp>
-struct tuple_element<_Ip, ::cuda::std::complex<_Tp>> : ::cuda::std::tuple_element<_Ip, ::cuda::std::complex<_Tp>>
-{};
+template <class _Tp>
+struct tuple_element<0, ::cuda::std::complex<_Tp>>
+{
+  using type = _Tp;
+};
 
-template <class _Tp, class _Up>
-struct tuple_size<::cuda::std::pair<_Tp, _Up>> : ::cuda::std::tuple_size<::cuda::std::pair<_Tp, _Up>>
-{};
+template <class _Tp>
+struct tuple_element<1, ::cuda::std::complex<_Tp>>
+{
+  using type = _Tp;
+};
 
 template <class _Tp, class _Up>
-struct tuple_size<const ::cuda::std::pair<_Tp, _Up>> : ::cuda::std::tuple_size<::cuda::std::pair<_Tp, _Up>>
-{};
+struct tuple_size<::cuda::std::pair<_Tp, _Up>>
+{
+  static constexpr size_t value = 2;
+};
 
 template <class _Tp, class _Up>
-struct tuple_size<volatile ::cuda::std::pair<_Tp, _Up>> : ::cuda::std::tuple_size<::cuda::std::pair<_Tp, _Up>>
-{};
+struct tuple_element<0, ::cuda::std::pair<_Tp, _Up>>
+{
+  using type = _Tp;
+};
 
 template <class _Tp, class _Up>
-struct tuple_size<const volatile ::cuda::std::pair<_Tp, _Up>> : ::cuda::std::tuple_size<::cuda::std::pair<_Tp, _Up>>
-{};
-
-template <size_t _Ip, class _Tp, class _Up>
-struct tuple_element<_Ip, ::cuda::std::pair<_Tp, _Up>> : ::cuda::std::tuple_element<_Ip, ::cuda::std::pair<_Tp, _Up>>
-{};
-
-template <size_t _Ip, class _Tp, class _Up>
-struct tuple_element<_Ip, const ::cuda::std::pair<_Tp, _Up>>
-    : ::cuda::std::tuple_element<_Ip, const ::cuda::std::pair<_Tp, _Up>>
-{};
-
-template <size_t _Ip, class _Tp, class _Up>
-struct tuple_element<_Ip, volatile ::cuda::std::pair<_Tp, _Up>>
-    : ::cuda::std::tuple_element<_Ip, volatile ::cuda::std::pair<_Tp, _Up>>
-{};
-
-template <size_t _Ip, class _Tp, class _Up>
-struct tuple_element<_Ip, const volatile ::cuda::std::pair<_Tp, _Up>>
-    : ::cuda::std::tuple_element<_Ip, const volatile ::cuda::std::pair<_Tp, _Up>>
-{};
-
-template <class... _Tp>
-struct tuple_size<::cuda::std::tuple<_Tp...>> : ::cuda::std::tuple_size<::cuda::std::tuple<_Tp...>>
-{};
-
-template <class... _Tp>
-struct tuple_size<const ::cuda::std::tuple<_Tp...>> : ::cuda::std::tuple_size<::cuda::std::tuple<_Tp...>>
-{};
-
-template <class... _Tp>
-struct tuple_size<volatile ::cuda::std::tuple<_Tp...>> : ::cuda::std::tuple_size<::cuda::std::tuple<_Tp...>>
-{};
+struct tuple_element<1, ::cuda::std::pair<_Tp, _Up>>
+{
+  using type = _Up;
+};
 
 template <class... _Tp>
-struct tuple_size<const volatile ::cuda::std::tuple<_Tp...>> : ::cuda::std::tuple_size<::cuda::std::tuple<_Tp...>>
-{};
+struct tuple_size<::cuda::std::tuple<_Tp...>>
+{
+  static constexpr size_t value = sizeof...(_Tp);
+};
 
 template <size_t _Ip, class... _Tp>
 struct tuple_element<_Ip, ::cuda::std::tuple<_Tp...>> : ::cuda::std::tuple_element<_Ip, ::cuda::std::tuple<_Tp...>>
 {};
 
-template <size_t _Ip, class... _Tp>
-struct tuple_element<_Ip, const ::cuda::std::tuple<_Tp...>>
-    : ::cuda::std::tuple_element<_Ip, const ::cuda::std::tuple<_Tp...>>
-{};
-
-template <size_t _Ip, class... _Tp>
-struct tuple_element<_Ip, volatile ::cuda::std::tuple<_Tp...>>
-    : ::cuda::std::tuple_element<_Ip, volatile ::cuda::std::tuple<_Tp...>>
-{};
-
-template <size_t _Ip, class... _Tp>
-struct tuple_element<_Ip, const volatile ::cuda::std::tuple<_Tp...>>
-    : ::cuda::std::tuple_element<_Ip, const volatile ::cuda::std::tuple<_Tp...>>
-{};
-
 template <class _Ip, class _Sp, ::cuda::std::ranges::subrange_kind _Kp>
 struct tuple_size<::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
-    : ::cuda::std::tuple_size<::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
-{};
+{
+  static constexpr size_t value = 2;
+};
 
 template <class _Ip, class _Sp, ::cuda::std::ranges::subrange_kind _Kp>
-struct tuple_size<const ::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
-    : ::cuda::std::tuple_size<::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
-{};
+struct tuple_element<0, ::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
+{
+  using type = _Ip;
+};
 
 template <class _Ip, class _Sp, ::cuda::std::ranges::subrange_kind _Kp>
-struct tuple_size<volatile ::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
-    : ::cuda::std::tuple_size<::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
-{};
+struct tuple_element<1, ::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
+{
+  using type = _Sp;
+};
 
 template <class _Ip, class _Sp, ::cuda::std::ranges::subrange_kind _Kp>
-struct tuple_size<const volatile ::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
-    : ::cuda::std::tuple_size<::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
-{};
-
-template <size_t _Idx, class _Ip, class _Sp, ::cuda::std::ranges::subrange_kind _Kp>
-struct tuple_element<_Idx, ::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
-    : ::cuda::std::tuple_element<_Idx, ::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
-{};
-
-template <size_t _Idx, class _Ip, class _Sp, ::cuda::std::ranges::subrange_kind _Kp>
-struct tuple_element<_Idx, const ::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
-    : ::cuda::std::tuple_element<_Idx, const ::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
-{};
+struct tuple_element<0, const ::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
+{
+  using type = _Ip;
+};
 
-template <size_t _Idx, class _Ip, class _Sp, ::cuda::std::ranges::subrange_kind _Kp>
-struct tuple_element<_Idx, volatile ::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
-    : ::cuda::std::tuple_element<_Idx, volatile ::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
-{};
+template <class _Ip, class _Sp, ::cuda::std::ranges::subrange_kind _Kp>
+struct tuple_element<1, const ::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
+{
+  using type = _Sp;
+};
 
-template <size_t _Idx, class _Ip, class _Sp, ::cuda::std::ranges::subrange_kind _Kp>
-struct tuple_element<_Idx, const volatile ::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
-    : ::cuda::std::tuple_element<_Idx, const volatile ::cuda::std::ranges::subrange<_Ip, _Sp, _Kp>>
-{};
-} // namespace std
+_CCCL_END_NAMESPACE_STD
 
 #include <cuda/std/__cccl/epilogue.h>
 

cuda/cccl/headers/include/cuda/std/__tuple_dir/tie.h

@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___TUPLE_TIE_H
+#define _CUDA_STD___TUPLE_TIE_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/__functional/unwrap_ref.h>
+#include <cuda/std/__tuple_dir/tuple.h>
+#include <cuda/std/__type_traits/is_nothrow_constructible.h>
+#include <cuda/std/__utility/forward.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+template <class... _Tp>
+[[nodiscard]] _CCCL_API constexpr tuple<_Tp&...> tie(_Tp&... __t) noexcept
+{
+  return tuple<_Tp&...>(__t...);
+}
+
+template <class... _Tp>
+[[nodiscard]] _CCCL_API constexpr tuple<unwrap_ref_decay_t<_Tp>...>
+make_tuple(_Tp&&... __t) noexcept(is_nothrow_constructible_v<tuple<unwrap_ref_decay_t<_Tp>...>, _Tp...>)
+{
+  return tuple<unwrap_ref_decay_t<_Tp>...>(::cuda::std::forward<_Tp>(__t)...);
+}
+
+template <class... _Tp>
+[[nodiscard]] _CCCL_API constexpr tuple<_Tp&&...> forward_as_tuple(_Tp&&... __t) noexcept
+{
+  return tuple<_Tp&&...>(::cuda::std::forward<_Tp>(__t)...);
+}
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___TUPLE_TIE_H