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/__utility/pair.h

@@ -660,25 +660,25 @@ template <>
 struct __get_pair<0>
 {
   template <class _T1, class _T2>
-  static _CCCL_API constexpr _T1& get(pair<_T1, _T2>& __p) noexcept
+  [[nodiscard]] _CCCL_API static constexpr _T1& get(pair<_T1, _T2>& __p) noexcept
   {
     return __p.first;
   }
 
   template <class _T1, class _T2>
-  static _CCCL_API constexpr const _T1& get(const pair<_T1, _T2>& __p) noexcept
+  [[nodiscard]] _CCCL_API static constexpr const _T1& get(const pair<_T1, _T2>& __p) noexcept
   {
     return __p.first;
   }
 
   template <class _T1, class _T2>
-  static _CCCL_API constexpr _T1&& get(pair<_T1, _T2>&& __p) noexcept
+  [[nodiscard]] _CCCL_API static constexpr _T1&& get(pair<_T1, _T2>&& __p) noexcept
   {
     return ::cuda::std::forward<_T1>(__p.first);
   }
 
   template <class _T1, class _T2>
-  static _CCCL_API constexpr const _T1&& get(const pair<_T1, _T2>&& __p) noexcept
+  [[nodiscard]] _CCCL_API static constexpr const _T1&& get(const pair<_T1, _T2>&& __p) noexcept
   {
     return ::cuda::std::forward<const _T1>(__p.first);
   }
@@ -688,98 +688,98 @@ template <>
 struct __get_pair<1>
 {
   template <class _T1, class _T2>
-  static _CCCL_API constexpr _T2& get(pair<_T1, _T2>& __p) noexcept
+  [[nodiscard]] _CCCL_API static constexpr _T2& get(pair<_T1, _T2>& __p) noexcept
   {
     return __p.second;
   }
 
   template <class _T1, class _T2>
-  static _CCCL_API constexpr const _T2& get(const pair<_T1, _T2>& __p) noexcept
+  [[nodiscard]] _CCCL_API static constexpr const _T2& get(const pair<_T1, _T2>& __p) noexcept
   {
     return __p.second;
   }
 
   template <class _T1, class _T2>
-  static _CCCL_API constexpr _T2&& get(pair<_T1, _T2>&& __p) noexcept
+  [[nodiscard]] _CCCL_API static constexpr _T2&& get(pair<_T1, _T2>&& __p) noexcept
   {
     return ::cuda::std::forward<_T2>(__p.second);
   }
 
   template <class _T1, class _T2>
-  static _CCCL_API constexpr const _T2&& get(const pair<_T1, _T2>&& __p) noexcept
+  [[nodiscard]] _CCCL_API static constexpr const _T2&& get(const pair<_T1, _T2>&& __p) noexcept
   {
     return ::cuda::std::forward<const _T2>(__p.second);
   }
 };
 
 template <size_t _Ip, class _T1, class _T2>
-_CCCL_API constexpr tuple_element_t<_Ip, pair<_T1, _T2>>& get(pair<_T1, _T2>& __p) noexcept
+[[nodiscard]] _CCCL_API constexpr tuple_element_t<_Ip, pair<_T1, _T2>>& get(pair<_T1, _T2>& __p) noexcept
 {
   return __get_pair<_Ip>::get(__p);
 }
 
 template <size_t _Ip, class _T1, class _T2>
-_CCCL_API constexpr const tuple_element_t<_Ip, pair<_T1, _T2>>& get(const pair<_T1, _T2>& __p) noexcept
+[[nodiscard]] _CCCL_API constexpr const tuple_element_t<_Ip, pair<_T1, _T2>>& get(const pair<_T1, _T2>& __p) noexcept
 {
   return __get_pair<_Ip>::get(__p);
 }
 
 template <size_t _Ip, class _T1, class _T2>
-_CCCL_API constexpr tuple_element_t<_Ip, pair<_T1, _T2>>&& get(pair<_T1, _T2>&& __p) noexcept
+[[nodiscard]] _CCCL_API constexpr tuple_element_t<_Ip, pair<_T1, _T2>>&& get(pair<_T1, _T2>&& __p) noexcept
 {
   return __get_pair<_Ip>::get(::cuda::std::move(__p));
 }
 
 template <size_t _Ip, class _T1, class _T2>
-_CCCL_API constexpr const tuple_element_t<_Ip, pair<_T1, _T2>>&& get(const pair<_T1, _T2>&& __p) noexcept
+[[nodiscard]] _CCCL_API constexpr const tuple_element_t<_Ip, pair<_T1, _T2>>&& get(const pair<_T1, _T2>&& __p) noexcept
 {
   return __get_pair<_Ip>::get(::cuda::std::move(__p));
 }
 
 template <class _T1, class _T2>
-_CCCL_API constexpr _T1& get(pair<_T1, _T2>& __p) noexcept
+[[nodiscard]] _CCCL_API constexpr _T1& get(pair<_T1, _T2>& __p) noexcept
 {
   return __get_pair<0>::get(__p);
 }
 
 template <class _T1, class _T2>
-_CCCL_API constexpr _T1 const& get(pair<_T1, _T2> const& __p) noexcept
+[[nodiscard]] _CCCL_API constexpr _T1 const& get(pair<_T1, _T2> const& __p) noexcept
 {
   return __get_pair<0>::get(__p);
 }
 
 template <class _T1, class _T2>
-_CCCL_API constexpr _T1&& get(pair<_T1, _T2>&& __p) noexcept
+[[nodiscard]] _CCCL_API constexpr _T1&& get(pair<_T1, _T2>&& __p) noexcept
 {
   return __get_pair<0>::get(::cuda::std::move(__p));
 }
 
 template <class _T1, class _T2>
-_CCCL_API constexpr _T1 const&& get(pair<_T1, _T2> const&& __p) noexcept
+[[nodiscard]] _CCCL_API constexpr _T1 const&& get(pair<_T1, _T2> const&& __p) noexcept
 {
   return __get_pair<0>::get(::cuda::std::move(__p));
 }
 
 template <class _T1, class _T2>
-_CCCL_API constexpr _T1& get(pair<_T2, _T1>& __p) noexcept
+[[nodiscard]] _CCCL_API constexpr _T1& get(pair<_T2, _T1>& __p) noexcept
 {
   return __get_pair<1>::get(__p);
 }
 
 template <class _T1, class _T2>
-_CCCL_API constexpr _T1 const& get(pair<_T2, _T1> const& __p) noexcept
+[[nodiscard]] _CCCL_API constexpr _T1 const& get(pair<_T2, _T1> const& __p) noexcept
 {
   return __get_pair<1>::get(__p);
 }
 
 template <class _T1, class _T2>
-_CCCL_API constexpr _T1&& get(pair<_T2, _T1>&& __p) noexcept
+[[nodiscard]] _CCCL_API constexpr _T1&& get(pair<_T2, _T1>&& __p) noexcept
 {
   return __get_pair<1>::get(::cuda::std::move(__p));
 }
 
 template <class _T1, class _T2>
-_CCCL_API constexpr _T1 const&& get(pair<_T2, _T1> const&& __p) noexcept
+[[nodiscard]] _CCCL_API constexpr _T1 const&& get(pair<_T2, _T1> const&& __p) noexcept
 {
   return __get_pair<1>::get(::cuda::std::move(__p));
 }

cuda/cccl/headers/include/cuda/std/__utility/rel_ops.h

@@ -29,7 +29,6 @@ _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
 namespace rel_ops
 {
-
 template <class _Tp>
 _CCCL_API inline bool operator!=(const _Tp& __x, const _Tp& __y)
 {
@@ -53,7 +52,6 @@ _CCCL_API inline bool operator>=(const _Tp& __x, const _Tp& __y)
 {
   return !(__x < __y);
 }
-
 } // namespace rel_ops
 
 _CCCL_END_NAMESPACE_CUDA_STD

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

@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_BAD_VARIANT_ACCESS_H
+#define _CUDA_STD___VARIANT_BAD_VARIANT_ACCESS_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/__exception/terminate.h>
+
+#if _CCCL_HAS_EXCEPTIONS()
+
+#  ifdef __cpp_lib_variant
+#    include <variant>
+#  else // ^^^ __cpp_lib_variant ^^^ / vvv !__cpp_lib_variant vvv
+#    include <exception>
+#  endif // !__cpp_lib_variant
+#endif // _CCCL_HAS_EXCEPTIONS()
+
+#include <cuda/std/__cccl/prologue.h>
+
+#if _CCCL_HAS_EXCEPTIONS()
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD_NOVERSION
+
+#  ifdef __cpp_lib_variant
+
+using ::std::bad_variant_access;
+
+#  else // ^^^ __cpp_lib_variant ^^^ / vvv !__cpp_lib_variant vvv
+class _CCCL_TYPE_VISIBILITY_DEFAULT bad_variant_access : public ::std::exception
+{
+public:
+  const char* what() const noexcept override
+  {
+    return "bad access to cuda::std::variant";
+  }
+};
+#  endif // !__cpp_lib_variant
+
+_CCCL_END_NAMESPACE_CUDA_STD_NOVERSION
+
+#endif // _CCCL_HAS_EXCEPTIONS()
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+[[noreturn]] _CCCL_API inline void __throw_bad_variant_access()
+{
+#if _CCCL_HAS_EXCEPTIONS()
+  NV_IF_ELSE_TARGET(NV_IS_HOST, (throw ::cuda::std::bad_variant_access();), (::cuda::std::terminate();))
+#else // ^^^ !_CCCL_HAS_EXCEPTIONS() ^^^ / vvv _CCCL_HAS_EXCEPTIONS() vvv
+  ::cuda::std::terminate();
+#endif // _CCCL_HAS_EXCEPTIONS()
+}
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___VARIANT_BAD_VARIANT_ACCESS_H

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

@@ -0,0 +1,207 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_COMPARISON_H
+#define _CUDA_STD___VARIANT_COMPARISON_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/operations.h>
+#include <cuda/std/__fwd/variant.h>
+#include <cuda/std/__type_traits/is_convertible.h>
+#include <cuda/std/__utility/forward.h>
+#include <cuda/std/__variant/variant.h>
+#include <cuda/std/__variant/visit.h>
+
+// [variant.syn]
+#if _LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
+#  include <cuda/std/compare>
+#endif // _LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+template <class _Operator>
+struct __convert_to_bool
+{
+  template <class _T1, class _T2>
+  [[nodiscard]] _CCCL_API constexpr bool operator()(_T1&& __t1, _T2&& __t2) const
+  {
+    static_assert(
+      is_convertible_v<decltype(_Operator{}(::cuda::std::forward<_T1>(__t1), ::cuda::std::forward<_T2>(__t2))), bool>,
+      "the relational operator does not return a type which is "
+      "implicitly convertible to bool");
+    return _Operator{}(::cuda::std::forward<_T1>(__t1), ::cuda::std::forward<_T2>(__t2));
+  }
+};
+
+template <class... _Types>
+[[nodiscard]] _CCCL_API constexpr bool operator==(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs)
+{
+  const auto __index_ = __lhs.index();
+  if (__index_ != __rhs.index())
+  {
+    return false;
+  }
+  if (__lhs.valueless_by_exception())
+  {
+    return true;
+  }
+
+  return __variant_binary_visitor::__visit(__index_, __convert_to_bool<equal_to<>>{}, __lhs, __rhs);
+}
+
+#if _LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
+
+template <class... _Types>
+  requires(three_way_comparable<_Types> && ...)
+[[nodiscard]] _CCCL_API constexpr common_comparison_category_t<compare_three_way_result_t<_Types>...>
+operator<=>(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs)
+{
+  using __result_t = common_comparison_category_t<compare_three_way_result_t<_Types>...>;
+  if (__lhs.valueless_by_exception() && __rhs.valueless_by_exception())
+  {
+    return strong_ordering::equal;
+  }
+  if (__lhs.valueless_by_exception())
+  {
+    return strong_ordering::less;
+  }
+  if (__rhs.valueless_by_exception())
+  {
+    return strong_ordering::greater;
+  }
+  if (auto __c = __lhs.index() <=> __rhs.index(); __c != 0)
+  {
+    return __c;
+  }
+  auto __three_way = []<class _Type>(const _Type& __v, const _Type& __w) -> __result_t {
+    return __v <=> __w;
+  };
+  return __variant_binary_visitor::__visit(__lhs.index(), __three_way, __lhs, __rhs);
+}
+
+#endif // _LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
+
+template <class... _Types>
+[[nodiscard]] _CCCL_API constexpr bool operator!=(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs)
+{
+  if (__lhs.index() != __rhs.index())
+  {
+    return true;
+  }
+  if (__lhs.valueless_by_exception())
+  {
+    return false;
+  }
+  return __variant_binary_visitor::__visit(__lhs.index(), __convert_to_bool<not_equal_to<>>{}, __lhs, __rhs);
+}
+
+template <class... _Types>
+[[nodiscard]] _CCCL_API constexpr bool operator<(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs)
+{
+  if (__rhs.valueless_by_exception())
+  {
+    return false;
+  }
+  if (__lhs.valueless_by_exception())
+  {
+    return true;
+  }
+  if (__lhs.index() < __rhs.index())
+  {
+    return true;
+  }
+  if (__lhs.index() > __rhs.index())
+  {
+    return false;
+  }
+  return __variant_binary_visitor::__visit(__lhs.index(), __convert_to_bool<less<>>{}, __lhs, __rhs);
+}
+
+template <class... _Types>
+[[nodiscard]] _CCCL_API constexpr bool operator>(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs)
+{
+  if (__lhs.valueless_by_exception())
+  {
+    return false;
+  }
+  if (__rhs.valueless_by_exception())
+  {
+    return true;
+  }
+  if (__lhs.index() > __rhs.index())
+  {
+    return true;
+  }
+  if (__lhs.index() < __rhs.index())
+  {
+    return false;
+  }
+  return __variant_binary_visitor::__visit(__lhs.index(), __convert_to_bool<greater<>>{}, __lhs, __rhs);
+}
+
+template <class... _Types>
+[[nodiscard]] _CCCL_API constexpr bool operator<=(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs)
+{
+  if (__lhs.valueless_by_exception())
+  {
+    return true;
+  }
+  if (__rhs.valueless_by_exception())
+  {
+    return false;
+  }
+  if (__lhs.index() < __rhs.index())
+  {
+    return true;
+  }
+  if (__lhs.index() > __rhs.index())
+  {
+    return false;
+  }
+  return __variant_binary_visitor::__visit(__lhs.index(), __convert_to_bool<less_equal<>>{}, __lhs, __rhs);
+}
+
+template <class... _Types>
+[[nodiscard]] _CCCL_API constexpr bool operator>=(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs)
+{
+  if (__rhs.valueless_by_exception())
+  {
+    return true;
+  }
+  if (__lhs.valueless_by_exception())
+  {
+    return false;
+  }
+  if (__lhs.index() > __rhs.index())
+  {
+    return true;
+  }
+  if (__lhs.index() < __rhs.index())
+  {
+    return false;
+  }
+  return __variant_binary_visitor::__visit(__lhs.index(), __convert_to_bool<greater_equal<>>{}, __lhs, __rhs);
+}
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___VARIANT_COMPARISON_H

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

@@ -0,0 +1,192 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_GET_H
+#define _CUDA_STD___VARIANT_GET_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/get.h>
+#include <cuda/std/__fwd/variant.h>
+#include <cuda/std/__memory/addressof.h>
+#include <cuda/std/__tuple_dir/get.h>
+#include <cuda/std/__type_traits/add_pointer.h>
+#include <cuda/std/__type_traits/is_void.h>
+#include <cuda/std/__utility/forward.h>
+#include <cuda/std/__utility/move.h>
+#include <cuda/std/__variant/bad_variant_access.h>
+#include <cuda/std/__variant/variant.h>
+#include <cuda/std/__variant/variant_access.h>
+#include <cuda/std/__variant/variant_match.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA_STD
+
+template <size_t _Ip, class... _Types>
+[[nodiscard]] _CCCL_API constexpr bool __holds_alternative(const variant<_Types...>& __v) noexcept
+{
+  return __v.index() == _Ip;
+}
+
+template <class _Tp, class... _Types>
+[[nodiscard]] _CCCL_API constexpr bool holds_alternative(const variant<_Types...>& __v) noexcept
+{
+  return ::cuda::std::__holds_alternative<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+}
+
+template <size_t _Ip, class _Vp>
+[[nodiscard]] _CCCL_API constexpr auto&& __generic_get(_Vp&& __v)
+{
+  using __variant_detail::__access::__variant;
+  if (!::cuda::std::__holds_alternative<_Ip>(__v))
+  {
+    ::cuda::std::__throw_bad_variant_access();
+  }
+  return __variant::__get_alt<_Ip>(::cuda::std::forward<_Vp>(__v)).__value;
+}
+
+template <size_t _Ip, class... _Types>
+[[nodiscard]] _CCCL_API constexpr variant_alternative_t<_Ip, variant<_Types...>>& get(variant<_Types...>& __v)
+{
+  static_assert(_Ip < sizeof...(_Types), "");
+  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>, "");
+  return ::cuda::std::__generic_get<_Ip>(__v);
+}
+
+template <size_t _Ip, class... _Types>
+[[nodiscard]] _CCCL_API constexpr variant_alternative_t<_Ip, variant<_Types...>>&& get(variant<_Types...>&& __v)
+{
+  static_assert(_Ip < sizeof...(_Types), "");
+  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>, "");
+  return ::cuda::std::__generic_get<_Ip>(::cuda::std::move(__v));
+}
+
+template <size_t _Ip, class... _Types>
+[[nodiscard]] _CCCL_API constexpr const variant_alternative_t<_Ip, variant<_Types...>>&
+get(const variant<_Types...>& __v)
+{
+  static_assert(_Ip < sizeof...(_Types), "");
+  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>, "");
+  return ::cuda::std::__generic_get<_Ip>(__v);
+}
+
+template <size_t _Ip, class... _Types>
+[[nodiscard]] _CCCL_API constexpr const variant_alternative_t<_Ip, variant<_Types...>>&&
+get(const variant<_Types...>&& __v)
+{
+  static_assert(_Ip < sizeof...(_Types), "");
+  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>, "");
+  return ::cuda::std::__generic_get<_Ip>(::cuda::std::move(__v));
+}
+
+template <class _Tp, class... _Types>
+[[nodiscard]] _CCCL_API constexpr _Tp& get(variant<_Types...>& __v)
+{
+  static_assert(!is_void_v<_Tp>, "");
+  return ::cuda::std::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+}
+
+template <class _Tp, class... _Types>
+[[nodiscard]] _CCCL_API constexpr _Tp&& get(variant<_Types...>&& __v)
+{
+  static_assert(!is_void_v<_Tp>, "");
+  return ::cuda::std::get<__find_exactly_one_t<_Tp, _Types...>::value>(::cuda::std::move(__v));
+}
+
+template <class _Tp, class... _Types>
+[[nodiscard]] _CCCL_API constexpr const _Tp& get(const variant<_Types...>& __v)
+{
+  static_assert(!is_void_v<_Tp>, "");
+  return ::cuda::std::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+}
+
+template <class _Tp, class... _Types>
+[[nodiscard]] _CCCL_API constexpr const _Tp&& get(const variant<_Types...>&& __v)
+{
+  static_assert(!is_void_v<_Tp>, "");
+  return ::cuda::std::get<__find_exactly_one_t<_Tp, _Types...>::value>(::cuda::std::move(__v));
+}
+
+template <size_t _Ip, class _Vp>
+[[nodiscard]] _CCCL_API constexpr auto* __generic_get_if(_Vp* __v) noexcept
+{
+  using __variant_detail::__access::__variant;
+  return __v && ::cuda::std::__holds_alternative<_Ip>(*__v)
+         ? ::cuda::std::addressof(__variant::__get_alt<_Ip>(*__v).__value)
+         : nullptr;
+}
+
+template <size_t _Ip, class... _Types>
+[[nodiscard]] _CCCL_API constexpr add_pointer_t<variant_alternative_t<_Ip, variant<_Types...>>>
+get_if(variant<_Types...>* __v) noexcept
+{
+  static_assert(_Ip < sizeof...(_Types), "");
+  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>, "");
+  return ::cuda::std::__generic_get_if<_Ip>(__v);
+}
+
+template <size_t _Ip, class... _Types>
+[[nodiscard]] _CCCL_API constexpr add_pointer_t<const variant_alternative_t<_Ip, variant<_Types...>>>
+get_if(const variant<_Types...>* __v) noexcept
+{
+  static_assert(_Ip < sizeof...(_Types), "");
+  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>, "");
+  return ::cuda::std::__generic_get_if<_Ip>(__v);
+}
+
+template <class _Tp, class... _Types>
+[[nodiscard]] _CCCL_API constexpr add_pointer_t<_Tp> get_if(variant<_Types...>* __v) noexcept
+{
+  static_assert(!is_void_v<_Tp>, "");
+  return ::cuda::std::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+}
+
+template <class _Tp, class... _Types>
+[[nodiscard]] _CCCL_API constexpr add_pointer_t<const _Tp> get_if(const variant<_Types...>* __v) noexcept
+{
+  static_assert(!is_void_v<_Tp>, "");
+  return ::cuda::std::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+}
+
+// __unchecked_get is the same as ::cuda::std::get, except, it is UB to use it
+// with the wrong type whereas ::cuda::std::get will throw or returning nullptr.
+// This makes it faster than ::cuda::std::get.
+template <size_t _Ip, class _Vp>
+[[nodiscard]] _CCCL_API constexpr auto&& __unchecked_get(_Vp&& __v) noexcept
+{
+  using __variant_detail::__access::__variant;
+  return __variant::__get_alt<_Ip>(::cuda::std::forward<_Vp>(__v)).__value;
+}
+
+template <class _Tp, class... _Types>
+[[nodiscard]] _CCCL_API constexpr auto&& __unchecked_get(const variant<_Types...>& __v) noexcept
+{
+  return ::cuda::std::__unchecked_get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+}
+
+template <class _Tp, class... _Types>
+[[nodiscard]] _CCCL_API constexpr auto&& __unchecked_get(variant<_Types...>& __v) noexcept
+{
+  return ::cuda::std::__unchecked_get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+}
+
+_CCCL_END_NAMESPACE_CUDA_STD
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___VARIANT_GET_H