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/variant_constraints.h

@@ -0,0 +1,135 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_VARIANT_CONSTRAINTS_H
+#define _CUDA_STD___VARIANT_VARIANT_CONSTRAINTS_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/__tuple_dir/get.h>
+#include <cuda/std/__tuple_dir/sfinae_helpers.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_move_constructible.h>
+#include <cuda/std/__type_traits/is_nothrow_assignable.h>
+#include <cuda/std/__type_traits/is_nothrow_constructible.h>
+#include <cuda/std/__type_traits/is_nothrow_move_constructible.h>
+#include <cuda/std/__type_traits/is_swappable.h>
+#include <cuda/std/__variant/variant_match.h>
+#include <cuda/std/initializer_list>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+namespace __find_detail
+{
+template <class _Tp, class... _Types>
+_CCCL_API constexpr size_t __find_index()
+{
+  constexpr bool __matches[] = {is_same_v<_Tp, _Types>...};
+  size_t __result            = __not_found;
+  for (size_t __i = 0; __i < sizeof...(_Types); ++__i)
+  {
+    if (__matches[__i])
+    {
+      if (__result != __not_found)
+      {
+        return __ambiguous;
+      }
+      __result = __i;
+    }
+  }
+  return __result;
+}
+
+template <class _Tp, class... _Types>
+using __find_unambiguous_index_sfinae =
+  enable_if_t<::cuda::std::__find_detail::__find_index<_Tp, _Types...>()
+                != __not_found&& ::cuda::std::__find_detail::__find_index<_Tp, _Types...>() != __ambiguous,
+              integral_constant<size_t, ::cuda::std::__find_detail::__find_index<_Tp, _Types...>()>>;
+} // namespace __find_detail
+
+namespace __variant_detail
+{
+struct __invalid_variant_constraints
+{
+  static constexpr bool __constructible         = false;
+  static constexpr bool __nothrow_constructible = false;
+  static constexpr bool __assignable            = false;
+  static constexpr bool __nothrow_assignable    = false;
+};
+
+template <class... _Types>
+struct __variant_constraints
+{
+  template <class _Arg, class _Tp = __best_match_t<_Arg, _Types...>>
+  struct __match_construct
+  {
+    static constexpr size_t _Ip = __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value;
+
+    static constexpr bool __constructible         = is_constructible_v<_Tp, _Arg>;
+    static constexpr bool __nothrow_constructible = is_nothrow_constructible_v<_Tp, _Arg>;
+  };
+
+  template <size_t _Ip, class... _Args>
+  struct __variadic_construct
+  {
+    using _Tp = variant_alternative_t<_Ip, variant<_Types...>>;
+
+    static constexpr bool __constructible         = is_constructible_v<_Tp, _Args...>;
+    static constexpr bool __nothrow_constructible = is_nothrow_constructible_v<_Tp, _Args...>;
+  };
+
+  template <size_t _Ip, class _Up, class... _Args>
+  struct __variadic_ilist_construct
+  {
+    using _Tp = variant_alternative_t<_Ip, variant<_Types...>>;
+
+    static constexpr bool __constructible         = is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>;
+    static constexpr bool __nothrow_constructible = is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>;
+  };
+
+  template <class _Arg, class _Tp = __best_match_t<_Arg, _Types...>>
+  struct __match_assign
+  {
+    static constexpr size_t _Ip = __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value;
+
+    static constexpr bool __assignable = is_assignable_v<_Tp&, _Arg> && is_constructible_v<_Tp, _Arg>;
+    static constexpr bool __nothrow_assignable =
+      is_nothrow_assignable_v<_Tp&, _Arg> && is_nothrow_constructible_v<_Tp, _Arg>;
+  };
+
+  template <bool>
+  struct __swappable
+  {
+    static constexpr bool __is_swappable_v = ((is_move_constructible_v<_Types> && is_swappable_v<_Types>) && ...);
+
+    static constexpr bool __is_nothrow_swappable_v =
+      ((is_nothrow_move_constructible_v<_Types> && is_nothrow_swappable_v<_Types>) && ...);
+  };
+};
+} // namespace __variant_detail
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___VARIANT_VARIANT_CONSTRAINTS_H

cuda/cccl/headers/include/cuda/std/__variant/variant_match.h

@@ -0,0 +1,126 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_VARIANT_MATCH_H
+#define _CUDA_STD___VARIANT_VARIANT_MATCH_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/invoke.h>
+#include <cuda/std/__tuple_dir/tuple_indices.h>
+#include <cuda/std/__type_traits/conditional.h>
+#include <cuda/std/__type_traits/enable_if.h>
+#include <cuda/std/__type_traits/is_arithmetic.h>
+#include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__type_traits/remove_cvref.h>
+#include <cuda/std/__type_traits/type_identity.h>
+#include <cuda/std/__utility/integer_sequence.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+namespace __variant_detail
+{
+struct __no_narrowing_check
+{
+  template <class _Dest, class _Source>
+  using _Apply = type_identity<_Dest>;
+};
+
+struct __narrowing_check
+{
+  template <class _Dest, class _Source, bool = __cccl_internal::__is_non_narrowing_convertible<_Dest, _Source>::value>
+  struct __narrowing_check_impl
+  {};
+
+  template <class _Dest, class _Source>
+  struct __narrowing_check_impl<_Dest, _Source, true>
+  {
+    using type = type_identity<_Dest>;
+  };
+
+  template <class _Dest, class _Source>
+  using _Apply _CCCL_NODEBUG_ALIAS = typename __narrowing_check_impl<_Dest, _Source>::type;
+};
+
+template <class _Dest, class _Source>
+using __check_for_narrowing _CCCL_NODEBUG_ALIAS = typename conditional_t<
+#ifdef _LIBCUDACXX_ENABLE_NARROWING_CONVERSIONS_IN_VARIANT
+  false &&
+#endif // _LIBCUDACXX_ENABLE_NARROWING_CONVERSIONS_IN_VARIANT
+    is_arithmetic_v<_Dest>,
+  __narrowing_check,
+  __no_narrowing_check>::template _Apply<_Dest, _Source>;
+
+template <class _Tp, size_t _Idx>
+struct __overload
+{
+  template <class _Up>
+  _CCCL_API inline auto operator()(_Tp, _Up&&) const -> __check_for_narrowing<_Tp, _Up>;
+};
+
+template <class _Tp, size_t>
+struct __overload_bool
+{
+  template <class _Up, class _Ap = remove_cvref_t<_Up>>
+  _CCCL_API inline auto operator()(bool, _Up&&) const -> enable_if_t<is_same_v<_Ap, bool>, type_identity<_Tp>>;
+};
+
+template <size_t _Idx>
+struct __overload<bool, _Idx> : __overload_bool<bool, _Idx>
+{};
+template <size_t _Idx>
+struct __overload<bool const, _Idx> : __overload_bool<bool const, _Idx>
+{};
+template <size_t _Idx>
+struct __overload<bool volatile, _Idx> : __overload_bool<bool volatile, _Idx>
+{};
+template <size_t _Idx>
+struct __overload<bool const volatile, _Idx> : __overload_bool<bool const volatile, _Idx>
+{};
+
+template <class... _Bases>
+struct __all_overloads : _Bases...
+{
+  _CCCL_API inline void operator()() const;
+  using _Bases::operator()...;
+};
+
+template <class IdxSeq>
+struct __make_overloads_imp;
+
+template <size_t... _Idx>
+struct __make_overloads_imp<__tuple_indices<_Idx...>>
+{
+  template <class... _Types>
+  using _Apply _CCCL_NODEBUG_ALIAS = __all_overloads<__overload<_Types, _Idx>...>;
+};
+
+template <class... _Types>
+using _MakeOverloads _CCCL_NODEBUG_ALIAS =
+  typename __make_overloads_imp<__make_indices_imp<sizeof...(_Types), 0>>::template _Apply<_Types...>;
+
+template <class _Tp, class... _Types>
+using __best_match_t = typename invoke_result_t<_MakeOverloads<_Types...>, _Tp, _Tp>::type;
+} // namespace __variant_detail
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___VARIANT_VARIANT_MATCH_H

cuda/cccl/headers/include/cuda/std/__variant/variant_traits.h

@@ -0,0 +1,184 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_VARIANT_TRAITS_H
+#define _CUDA_STD___VARIANT_VARIANT_TRAITS_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/add_const.h>
+#include <cuda/std/__type_traits/add_cv.h>
+#include <cuda/std/__type_traits/add_volatile.h>
+#include <cuda/std/__type_traits/conditional.h>
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_copy_assignable.h>
+#include <cuda/std/__type_traits/is_copy_constructible.h>
+#include <cuda/std/__type_traits/is_destructible.h>
+#include <cuda/std/__type_traits/is_move_assignable.h>
+#include <cuda/std/__type_traits/is_move_constructible.h>
+#include <cuda/std/__type_traits/is_trivially_copy_assignable.h>
+#include <cuda/std/__type_traits/is_trivially_copy_constructible.h>
+#include <cuda/std/__type_traits/is_trivially_destructible.h>
+#include <cuda/std/__type_traits/is_trivially_move_assignable.h>
+#include <cuda/std/__type_traits/is_trivially_move_constructible.h>
+#include <cuda/std/__type_traits/type_list.h>
+#include <cuda/std/initializer_list>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT variant_size<const _Tp> : variant_size<_Tp>
+{};
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT variant_size<volatile _Tp> : variant_size<_Tp>
+{};
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT variant_size<const volatile _Tp> : variant_size<_Tp>
+{};
+
+template <class... _Types>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT variant_size<variant<_Types...>> : integral_constant<size_t, sizeof...(_Types)>
+{};
+
+template <size_t _Ip, class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT variant_alternative<_Ip, const _Tp> : add_const<variant_alternative_t<_Ip, _Tp>>
+{};
+
+template <size_t _Ip, class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT
+variant_alternative<_Ip, volatile _Tp> : add_volatile<variant_alternative_t<_Ip, _Tp>>
+{};
+
+template <size_t _Ip, class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT
+variant_alternative<_Ip, const volatile _Tp> : add_cv<variant_alternative_t<_Ip, _Tp>>
+{};
+
+template <size_t _Ip, class... _Types>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT variant_alternative<_Ip, variant<_Types...>>
+{
+  static_assert(_Ip < sizeof...(_Types), "Index out of bounds in cuda::std::variant_alternative<>");
+  using type = __type_index_c<_Ip, _Types...>;
+};
+
+[[nodiscard]] _CCCL_API _CCCL_CONSTEVAL int __choose_index_type(unsigned int __num_elem) noexcept
+{
+  constexpr unsigned char __small   = static_cast<unsigned char>(-1);
+  constexpr unsigned short __medium = static_cast<unsigned short>(-1);
+  if (__num_elem < static_cast<unsigned int>(__small))
+  {
+    return 0;
+  }
+  if (__num_elem < static_cast<unsigned int>(__medium))
+  {
+    return 1;
+  }
+  return 2;
+}
+
+template <size_t _NumAlts>
+using __variant_index_t =
+  conditional_t<::cuda::std::__choose_index_type(_NumAlts) == 0,
+                unsigned char,
+                conditional_t<::cuda::std::__choose_index_type(_NumAlts) == 1, unsigned short, unsigned int>>;
+namespace __variant_detail
+{
+struct __valueless_t
+{};
+
+enum class _Trait
+{
+  _TriviallyAvailable,
+  _Available,
+  _Unavailable
+};
+
+template <typename... _Types>
+struct __traits
+{
+  [[nodiscard]] _CCCL_API static _CCCL_CONSTEVAL _Trait __common_trait(initializer_list<_Trait> __traits) noexcept
+  {
+    _Trait __result = _Trait::_TriviallyAvailable;
+    for (_Trait __t : __traits)
+    {
+      if (static_cast<int>(__t) > static_cast<int>(__result))
+      {
+        __result = __t;
+      }
+    }
+    return __result;
+  }
+
+  template <class _Type>
+  static constexpr _Trait __copy_constructible_trait_ =
+    is_trivially_copy_constructible_v<_Type> ? _Trait::_TriviallyAvailable
+    : is_copy_constructible_v<_Type>
+      ? _Trait::_Available
+      : _Trait::_Unavailable;
+
+  static constexpr _Trait __copy_constructible_trait = __common_trait({__copy_constructible_trait_<_Types>...});
+
+  template <class _Type>
+  static constexpr _Trait __move_constructible_trait_ =
+    is_trivially_move_constructible_v<_Type> ? _Trait::_TriviallyAvailable
+    : is_move_constructible_v<_Type>
+      ? _Trait::_Available
+      : _Trait::_Unavailable;
+
+  static constexpr _Trait __move_constructible_trait = __common_trait({__move_constructible_trait_<_Types>...});
+
+  template <class _Type>
+  static constexpr _Trait __copy_assignable_trait_ =
+    is_trivially_copy_assignable_v<_Type> ? _Trait::_TriviallyAvailable
+    : is_copy_assignable_v<_Type>
+      ? _Trait::_Available
+      : _Trait::_Unavailable;
+
+  static constexpr _Trait __copy_assignable_trait =
+    __common_trait({__copy_constructible_trait, __copy_assignable_trait_<_Types>...});
+
+  template <class _Type>
+  static constexpr _Trait __move_assignable_trait_ =
+    is_trivially_move_assignable_v<_Type> ? _Trait::_TriviallyAvailable
+    : is_move_assignable_v<_Type>
+      ? _Trait::_Available
+      : _Trait::_Unavailable;
+
+  static constexpr _Trait __move_assignable_trait =
+    __common_trait({__move_constructible_trait, __move_assignable_trait_<_Types>...});
+
+  template <class _Type>
+  static constexpr _Trait __destructible_trait_ =
+    is_trivially_destructible_v<_Type> ? _Trait::_TriviallyAvailable
+    : is_destructible_v<_Type>
+      ? _Trait::_Available
+      : _Trait::_Unavailable;
+
+  static constexpr _Trait __destructible_trait = __common_trait({__destructible_trait_<_Types>...});
+};
+} // namespace __variant_detail
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___VARIANT_VARIANT_TRAITS_H

cuda/cccl/headers/include/cuda/std/__variant/variant_visit.h

@@ -0,0 +1,225 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_VARIANT_VISIT_H
+#define _CUDA_STD___VARIANT_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/__functional/invoke.h>
+#include <cuda/std/__type_traits/enable_if.h>
+#include <cuda/std/__type_traits/remove_cvref.h>
+#include <cuda/std/__utility/forward.h>
+#include <cuda/std/__utility/integer_sequence.h>
+#include <cuda/std/__variant/variant_access.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+namespace __variant_detail::__visitation
+{
+struct __variant
+{
+  // We need to guard against the final invocation where we have processed all variants
+  template <size_t _Remaining, size_t _CurrentVariant, class... _Variants, enable_if_t<_Remaining == 0, int> = 0>
+  [[nodiscard]] _CCCL_API static constexpr size_t __get_runtime_index(const _Variants&...) noexcept
+  {
+    return 0;
+  }
+
+  template <size_t _Remaining,
+            size_t _CurrentVariant,
+            class _Variant,
+            class... _OtherVariants,
+            enable_if_t<(_Remaining != 0) && (_CurrentVariant == 0), int> = 0>
+  [[nodiscard]] _CCCL_API static constexpr size_t
+  __get_runtime_index(const _Variant& __v, const _OtherVariants&...) noexcept
+  {
+    return __v.__impl_.index();
+  }
+
+  template <size_t _Remaining,
+            size_t _CurrentVariant,
+            class _Variant,
+            class... _OtherVariants,
+            enable_if_t<(_Remaining != 0) && (_CurrentVariant != 0), int> = 0>
+  [[nodiscard]] _CCCL_API static constexpr size_t
+  __get_runtime_index(const _Variant&, const _OtherVariants&... __vs) noexcept
+  {
+    return __get_runtime_index<_Remaining, _CurrentVariant - 1>(__vs...);
+  }
+
+  // Terminal function call with all indexes determined
+  template <class _Visitor, class... _Vs, size_t... _ProcessedIndices>
+  [[nodiscard]] _CCCL_API static constexpr decltype(auto) __visit_impl(
+    index_sequence<_ProcessedIndices...>, integer_sequence<size_t>, const size_t, _Visitor&& __visitor, _Vs&&... __vs)
+  {
+    return ::cuda::std::__invoke(
+      ::cuda::std::forward<_Visitor>(__visitor),
+      __access::__base::__get_alt<_ProcessedIndices>(::cuda::std::forward<_Vs>(__vs).__impl_)...);
+  }
+
+  template <size_t _CurrentIndex,
+            class _Visitor,
+            class... _Vs,
+            size_t... _ProcessedIndices,
+            size_t... _UnprocessedIndices,
+            enable_if_t<_CurrentIndex != 0, int> = 0>
+  [[nodiscard]] _CCCL_API static constexpr decltype(auto) __visit_impl(
+    index_sequence<_ProcessedIndices...>,
+    index_sequence<_CurrentIndex, _UnprocessedIndices...>,
+    const size_t __current_index,
+    _Visitor&& __visitor,
+    _Vs&&... __vs)
+  {
+    // We found the right index, move to the next variant
+    if (__current_index == _CurrentIndex)
+    {
+      const size_t __next_index =
+        __get_runtime_index<sizeof...(_UnprocessedIndices), sizeof...(_ProcessedIndices) + 1>(__vs...);
+      return __visit_impl(
+        index_sequence<_ProcessedIndices..., _CurrentIndex>{},
+        index_sequence<_UnprocessedIndices...>{},
+        __next_index,
+        ::cuda::std::forward<_Visitor>(__visitor),
+        ::cuda::std::forward<_Vs>(__vs)...);
+    }
+
+    return __visit_impl(
+      index_sequence<_ProcessedIndices...>{},
+      index_sequence<_CurrentIndex - 1, _UnprocessedIndices...>{},
+      __current_index,
+      ::cuda::std::forward<_Visitor>(__visitor),
+      ::cuda::std::forward<_Vs>(__vs)...);
+  }
+
+  _CCCL_BEGIN_NV_DIAG_SUPPRESS(940) // Suppress no return at end of function
+  // This overload is needed to tell the compiler that the recursion is indeed limited
+  template <class _Visitor, class... _Vs, size_t... _ProcessedIndices, size_t... _UnprocessedIndices>
+  [[nodiscard]] _CCCL_API static constexpr decltype(auto) __visit_impl(
+    index_sequence<_ProcessedIndices...>,
+    index_sequence<0, _UnprocessedIndices...>,
+    const size_t __current_index,
+    _Visitor&& __visitor,
+    _Vs&&... __vs)
+  {
+    // We found the right index, move to the next variant
+    if (__current_index == 0)
+    {
+      const size_t __next_index =
+        __get_runtime_index<sizeof...(_UnprocessedIndices), sizeof...(_ProcessedIndices) + 1>(__vs...);
+      return __visit_impl(
+        index_sequence<_ProcessedIndices..., 0>{},
+        index_sequence<_UnprocessedIndices...>{},
+        __next_index,
+        ::cuda::std::forward<_Visitor>(__visitor),
+        ::cuda::std::forward<_Vs>(__vs)...);
+    }
+    _CCCL_UNREACHABLE();
+  }
+  _CCCL_END_NV_DIAG_SUPPRESS() // End suppression of no return at end of function
+
+  template <class _Visitor, class... _Vs>
+  [[nodiscard]] _CCCL_API static constexpr decltype(auto) __visit_value(_Visitor&& __visitor, _Vs&&... __vs)
+  {
+    // NOTE: We use a recursive implementation strategy here. That means we can omit the manual return type checks from
+    // the common function pointer implementation, as the compiler will abort if the return types do not match.
+    const size_t __first_index = __get_runtime_index<sizeof...(_Vs), 0>(__vs...);
+    return __visit_impl(
+      integer_sequence<size_t>{},
+      index_sequence<(remove_cvref_t<_Vs>::__size() - 1)...>{},
+      __first_index,
+      __make_value_visitor(::cuda::std::forward<_Visitor>(__visitor)),
+      ::cuda::std::forward<_Vs>(__vs)...);
+  }
+
+  template <class _Rp, class _Visitor, class... _Vs>
+  [[nodiscard]] _CCCL_API static constexpr _Rp __visit_value(_Visitor&& __visitor, _Vs&&... __vs)
+  {
+    const size_t __first_index = __get_runtime_index<sizeof...(_Vs), 0>(__vs...);
+    return __visit_impl(
+      integer_sequence<size_t>{},
+      index_sequence<(remove_cvref_t<_Vs>::__size() - 1)...>{},
+      __first_index,
+      __make_value_visitor<_Rp>(::cuda::std::forward<_Visitor>(__visitor)),
+      ::cuda::std::forward<_Vs>(__vs)...);
+  }
+
+  template <class _Visitor, class... _Values>
+  _CCCL_API static constexpr void __cccl_visit_exhaustive_visitor_check()
+  {
+    static_assert(is_invocable_v<_Visitor, _Values...>, "`std::visit` requires the visitor to be exhaustive.");
+  }
+
+  template <class _Visitor>
+  struct __value_visitor
+  {
+    template <class... _Alts>
+    [[nodiscard]] _CCCL_API constexpr decltype(auto) operator()(_Alts&&... __alts) const
+    {
+      __cccl_visit_exhaustive_visitor_check<_Visitor, decltype((::cuda::std::forward<_Alts>(__alts).__value))...>();
+      return ::cuda::std::__invoke(
+        ::cuda::std::forward<_Visitor>(__visitor), ::cuda::std::forward<_Alts>(__alts).__value...);
+    }
+    _Visitor&& __visitor;
+  };
+
+  template <class _Rp, class _Visitor>
+  struct __value_visitor_return_type
+  {
+    template <class... _Alts>
+    [[nodiscard]] _CCCL_API constexpr _Rp operator()(_Alts&&... __alts) const
+    {
+      __cccl_visit_exhaustive_visitor_check<_Visitor, decltype((::cuda::std::forward<_Alts>(__alts).__value))...>();
+      return ::cuda::std::__invoke(
+        ::cuda::std::forward<_Visitor>(__visitor), ::cuda::std::forward<_Alts>(__alts).__value...);
+    }
+    _Visitor&& __visitor;
+  };
+
+  template <class _Visitor>
+  struct __value_visitor_return_type<void, _Visitor>
+  {
+    template <class... _Alts>
+    _CCCL_API constexpr void operator()(_Alts&&... __alts) const
+    {
+      __cccl_visit_exhaustive_visitor_check<_Visitor, decltype((::cuda::std::forward<_Alts>(__alts).__value))...>();
+      ::cuda::std::__invoke(::cuda::std::forward<_Visitor>(__visitor), ::cuda::std::forward<_Alts>(__alts).__value...);
+    }
+    _Visitor&& __visitor;
+  };
+
+  template <class _Visitor>
+  [[nodiscard]] _CCCL_API static constexpr auto __make_value_visitor(_Visitor&& __visitor)
+  {
+    return __value_visitor<_Visitor>{::cuda::std::forward<_Visitor>(__visitor)};
+  }
+
+  template <class _Rp, class _Visitor>
+  [[nodiscard]] _CCCL_API static constexpr auto __make_value_visitor(_Visitor&& __visitor)
+  {
+    return __value_visitor_return_type<_Rp, _Visitor>{::cuda::std::forward<_Visitor>(__visitor)};
+  }
+};
+} // namespace __variant_detail::__visitation
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___VARIANT_VARIANT_VISIT_H