cuda-cccl 0.3.0__cp311-cp311-manylinux_2_24_aarch64.whl → 0.3.2__cp311-cp311-manylinux_2_24_aarch64.whl

cuda/cccl/headers/include/cuda/__iterator/transform_output_iterator.h

@@ -30,6 +30,7 @@
 #include <cuda/std/__functional/invoke.h>
 #include <cuda/std/__iterator/concepts.h>
 #include <cuda/std/__iterator/iterator_traits.h>
+#include <cuda/std/__ranges/compressed_movable_box.h>
 #include <cuda/std/__ranges/concepts.h>
 #include <cuda/std/__ranges/movable_box.h>
 #include <cuda/std/__type_traits/conditional.h>
@@ -41,6 +42,7 @@
 #include <cuda/std/__type_traits/is_object.h>
 #include <cuda/std/__type_traits/is_reference.h>
 #include <cuda/std/__type_traits/remove_cvref.h>
+#include <cuda/std/__utility/declval.h>
 #include <cuda/std/__utility/forward.h>
 #include <cuda/std/__utility/move.h>
 
@@ -144,10 +146,30 @@ class transform_output_iterator
   static_assert(::cuda::std::is_object_v<_Fn>,
                 "cuda::transform_output_iterator requires that _Fn is a function object");
 
-public:
-  _Iter __current_{};
-  ::cuda::std::ranges::__movable_box<_Fn> __func_{};
+  // Not a base because then the friend operators would be ambiguous
+  ::cuda::std::__compressed_movable_box<_Iter, _Fn> __store_;
+
+  [[nodiscard]] _CCCL_API constexpr _Iter& __iter() noexcept
+  {
+    return __store_.template __get<0>();
+  }
+
+  [[nodiscard]] _CCCL_API constexpr const _Iter& __iter() const noexcept
+  {
+    return __store_.template __get<0>();
+  }
+
+  [[nodiscard]] _CCCL_API constexpr _Fn& __func() noexcept
+  {
+    return __store_.template __get<1>();
+  }
 
+  [[nodiscard]] _CCCL_API constexpr const _Fn& __func() const noexcept
+  {
+    return __store_.template __get<1>();
+  }
+
+public:
   using iterator_concept = ::cuda::std::conditional_t<
     ::cuda::std::__has_random_access_traversal<_Iter>,
     ::cuda::std::random_access_iterator_tag,
@@ -163,19 +185,13 @@ public:
   using reference         = void;
 
   //! @brief Default constructs a @c transform_output_iterator with a value initialized iterator and functor
-#if _CCCL_HAS_CONCEPTS()
-  _CCCL_EXEC_CHECK_DISABLE
-  _CCCL_HIDE_FROM_ABI transform_output_iterator()
-    requires ::cuda::std::default_initializable<_Iter> && ::cuda::std::default_initializable<_Fn>
-  = default;
-#else // ^^^ _CCCL_HAS_CONCEPTS() ^^^ / vvv !_CCCL_HAS_CONCEPTS() vvv
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_TEMPLATE(class _Iter2 = _Iter, class _Fn2 = _Fn)
   _CCCL_REQUIRES(::cuda::std::default_initializable<_Iter2> _CCCL_AND ::cuda::std::default_initializable<_Fn2>)
   _CCCL_API constexpr transform_output_iterator() noexcept(
     ::cuda::std::is_nothrow_default_constructible_v<_Iter2> && ::cuda::std::is_nothrow_default_constructible_v<_Fn2>)
+      : __store_()
   {}
-#endif // ^^^ !_CCCL_HAS_CONCEPTS() ^^^
 
   //! @brief Constructs a @c transform_output_iterator with a given iterator and output functor
   //! @param __iter The iterator to transform
@@ -183,35 +199,34 @@ public:
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_API constexpr transform_output_iterator(_Iter __iter, _Fn __func) noexcept(
     ::cuda::std::is_nothrow_move_constructible_v<_Iter> && ::cuda::std::is_nothrow_move_constructible_v<_Fn>)
-      : __current_(::cuda::std::move(__iter))
-      , __func_(::cuda::std::in_place, ::cuda::std::move(__func))
+      : __store_(::cuda::std::move(__iter), ::cuda::std::move(__func))
   {}
 
   //! @brief Returns a const reference to the stored iterator
   [[nodiscard]] _CCCL_API constexpr const _Iter& base() const& noexcept
   {
-    return __current_;
+    return __iter();
   }
 
   //! @brief Extracts the stored iterator
   _CCCL_EXEC_CHECK_DISABLE
   [[nodiscard]] _CCCL_API constexpr _Iter base() && noexcept(::cuda::std::is_nothrow_move_constructible_v<_Iter>)
   {
-    return ::cuda::std::move(__current_);
+    return ::cuda::std::move(__iter());
   }
 
   //! @brief Returns a proxy that transforms the input upon assignment
   _CCCL_EXEC_CHECK_DISABLE
   [[nodiscard]] _CCCL_API constexpr auto operator*() const noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter>)
   {
-    return __transform_output_proxy{__current_, const_cast<_Fn&>(*__func_)};
+    return __transform_output_proxy{__iter(), const_cast<_Fn&>(__func())};
   }
 
   //! @brief Returns a proxy that transforms the input upon assignment
   _CCCL_EXEC_CHECK_DISABLE
   [[nodiscard]] _CCCL_API constexpr auto operator*() noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter>)
   {
-    return __transform_output_proxy{__current_, *__func_};
+    return __transform_output_proxy{__iter(), __func()};
   }
 
   //! @brief Subscripts the @c transform_output_iterator
@@ -221,9 +236,10 @@ public:
   _CCCL_TEMPLATE(class _Iter2 = _Iter)
   _CCCL_REQUIRES(::cuda::std::__iter_can_subscript<_Iter2>)
   [[nodiscard]] _CCCL_API constexpr auto operator[](difference_type __n) const
-    noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter2> && noexcept(__current_ + __n))
+    noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter2>
+             && noexcept(::cuda::std::declval<const _Iter2&>() + __n))
   {
-    return __transform_output_proxy{__current_ + __n, const_cast<_Fn&>(*__func_)};
+    return __transform_output_proxy{__iter() + __n, const_cast<_Fn&>(__func())};
   }
 
   //! @brief Subscripts the @c transform_output_iterator
@@ -233,22 +249,22 @@ public:
   _CCCL_TEMPLATE(class _Iter2 = _Iter)
   _CCCL_REQUIRES(::cuda::std::__iter_can_subscript<_Iter2>)
   [[nodiscard]] _CCCL_API constexpr auto operator[](difference_type __n) noexcept(
-    ::cuda::std::is_nothrow_copy_constructible_v<_Iter2> && noexcept(__current_ + __n))
+    ::cuda::std::is_nothrow_copy_constructible_v<_Iter2> && noexcept(::cuda::std::declval<_Iter2&>() + __n))
   {
-    return __transform_output_proxy{__current_ + __n, const_cast<_Fn&>(*__func_)};
+    return __transform_output_proxy{__iter() + __n, const_cast<_Fn&>(__func())};
   }
 
   //! @brief Increments the stored iterator
   _CCCL_EXEC_CHECK_DISABLE
-  _CCCL_API constexpr transform_output_iterator& operator++() noexcept(noexcept(++__current_))
+  _CCCL_API constexpr transform_output_iterator& operator++() noexcept(noexcept(++::cuda::std::declval<_Iter&>()))
   {
-    ++__current_;
+    ++__iter();
     return *this;
   }
 
   //! @brief Increments the stored iterator
   _CCCL_EXEC_CHECK_DISABLE
-  _CCCL_API constexpr auto operator++(int) noexcept(noexcept(++__current_))
+  _CCCL_API constexpr auto operator++(int) noexcept(noexcept(++::cuda::std::declval<_Iter&>()))
   {
     if constexpr (::cuda::std::__has_forward_traversal<_Iter> || ::cuda::std::output_iterator<_Iter, value_type>)
     {
@@ -258,7 +274,7 @@ public:
     }
     else
     {
-      ++__current_;
+      ++__iter();
     }
   }
 
@@ -266,9 +282,9 @@ public:
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_TEMPLATE(class _Iter2 = _Iter)
   _CCCL_REQUIRES(::cuda::std::__iter_can_decrement<_Iter2>)
-  _CCCL_API constexpr transform_output_iterator& operator--() noexcept(noexcept(--__current_))
+  _CCCL_API constexpr transform_output_iterator& operator--() noexcept(noexcept(--::cuda::std::declval<_Iter2&>()))
   {
-    --__current_;
+    --__iter();
     return *this;
   }
 
@@ -276,8 +292,8 @@ public:
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_TEMPLATE(class _Iter2 = _Iter)
   _CCCL_REQUIRES(::cuda::std::__iter_can_decrement<_Iter2>)
-  _CCCL_API constexpr transform_output_iterator
-  operator--(int) noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter> && noexcept(--__current_))
+  _CCCL_API constexpr transform_output_iterator operator--(int) noexcept(
+    ::cuda::std::is_nothrow_copy_constructible_v<_Iter> && noexcept(--::cuda::std::declval<_Iter2&>()))
   {
     auto __tmp = *this;
     --*this;
@@ -289,9 +305,10 @@ public:
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_TEMPLATE(class _Iter2 = _Iter)
   _CCCL_REQUIRES(::cuda::std::__iter_can_plus_equal<_Iter2>)
-  _CCCL_API constexpr transform_output_iterator& operator+=(difference_type __n) noexcept(noexcept(__current_ += __n))
+  _CCCL_API constexpr transform_output_iterator&
+  operator+=(difference_type __n) noexcept(noexcept(::cuda::std::declval<_Iter2&>() += __n))
   {
-    __current_ += __n;
+    __iter() += __n;
     return *this;
   }
 
@@ -301,12 +318,12 @@ public:
   _CCCL_EXEC_CHECK_DISABLE
   template <class _Iter2 = _Iter>
   [[nodiscard]] _CCCL_API friend constexpr auto
-  operator+(const transform_output_iterator& __iter,
-            difference_type __n) noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter2>
-                                          && noexcept(::cuda::std::declval<const _Iter2&>() + difference_type{}))
-    _CCCL_TRAILING_REQUIRES(transform_output_iterator)(::cuda::std::__iter_can_plus<_Iter2>)
+  operator+(const transform_output_iterator& __iter, difference_type __n) //
+    noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter2>
+             && noexcept(::cuda::std::declval<const _Iter2&>() + difference_type{}))
+      _CCCL_TRAILING_REQUIRES(transform_output_iterator)(::cuda::std::__iter_can_plus<_Iter2>)
   {
-    return transform_output_iterator{__iter.__current_ + __n, *__iter.__func_};
+    return transform_output_iterator{__iter.__iter() + __n, __iter.__func()};
   }
 
   //! @brief Returns a copy of a @c transform_output_iterator incremented by a given number of elements
@@ -320,7 +337,7 @@ public:
     && noexcept(::cuda::std::declval<const _Iter2&>() + difference_type{}))
     _CCCL_TRAILING_REQUIRES(transform_output_iterator)(::cuda::std::__iter_can_plus<_Iter2>)
   {
-    return transform_output_iterator{__iter.__current_ + __n, *__iter.__func_};
+    return transform_output_iterator{__iter.__iter() + __n, __iter.__func()};
   }
 
   //! @brief Decrements the @c transform_output_iterator by a given number of elements
@@ -328,9 +345,10 @@ public:
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_TEMPLATE(class _Iter2 = _Iter)
   _CCCL_REQUIRES(::cuda::std::__iter_can_minus_equal<_Iter2>)
-  _CCCL_API constexpr transform_output_iterator& operator-=(difference_type __n) noexcept(noexcept(__current_ -= __n))
+  _CCCL_API constexpr transform_output_iterator&
+  operator-=(difference_type __n) noexcept(noexcept(::cuda::std::declval<_Iter2&>() -= __n))
   {
-    __current_ -= __n;
+    __iter() -= __n;
     return *this;
   }
 
@@ -340,23 +358,30 @@ public:
   _CCCL_EXEC_CHECK_DISABLE
   template <class _Iter2 = _Iter>
   [[nodiscard]] _CCCL_API friend constexpr auto
-  operator-(const transform_output_iterator& __iter,
-            difference_type __n) noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter2>
-                                          && noexcept(::cuda::std::declval<const _Iter2&>() - difference_type{}))
-    _CCCL_TRAILING_REQUIRES(transform_output_iterator)(::cuda::std::__iter_can_minus<_Iter2>)
+  operator-(const transform_output_iterator& __iter, difference_type __n) //
+    noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter2>
+             && noexcept(::cuda::std::declval<const _Iter2&>() - difference_type{}))
+      _CCCL_TRAILING_REQUIRES(transform_output_iterator)(::cuda::std::__iter_can_minus<_Iter2>)
   {
-    return transform_output_iterator{__iter.__current_ - __n, *__iter.__func_};
+    return transform_output_iterator{__iter.__iter() - __n, __iter.__func()};
   }
 
+  template <class _Iter2>
+  static constexpr bool __can_difference =
+    (::cuda::std::__has_random_access_traversal<_Iter2> || ::cuda::std::sized_sentinel_for<_Iter2, _Iter2>);
+
+  template <class _Iter2>
+  static constexpr bool __noexcept_difference =
+    noexcept(::cuda::std::declval<const _Iter2&>() - ::cuda::std::declval<const _Iter2&>());
+
   //! @brief Returns the distance between two @c transform_output_iterator
   _CCCL_EXEC_CHECK_DISABLE
   template <class _Iter2 = _Iter>
-  [[nodiscard]] _CCCL_API friend constexpr auto
-  operator-(const transform_output_iterator& __lhs, const transform_output_iterator& __rhs) noexcept(
-    noexcept(::cuda::std::declval<const _Iter2&>() - ::cuda::std::declval<const _Iter2&>()))
-    _CCCL_TRAILING_REQUIRES(difference_type)(::cuda::std::sized_sentinel_for<_Iter2, _Iter2>)
+  [[nodiscard]] _CCCL_API friend constexpr auto operator-(const transform_output_iterator& __lhs,
+                                                          const transform_output_iterator& __rhs) //
+    noexcept(__noexcept_difference<_Iter2>) _CCCL_TRAILING_REQUIRES(difference_type)(__can_difference<_Iter2>)
   {
-    return __lhs.__current_ - __rhs.__current_;
+    return __lhs.__iter() - __rhs.__iter();
   }
 
   //! @brief Compares two @c transform_output_iterator for equality by comparing the stored iterators
@@ -367,7 +392,7 @@ public:
     noexcept(::cuda::std::declval<const _Iter2&>() == ::cuda::std::declval<const _Iter2&>()))
     _CCCL_TRAILING_REQUIRES(bool)(::cuda::std::equality_comparable<_Iter2>)
   {
-    return __lhs.__current_ == __rhs.__current_;
+    return __lhs.__iter() == __rhs.__iter();
   }
 
 #if _CCCL_STD_VER <= 2017
@@ -379,7 +404,7 @@ public:
     noexcept(::cuda::std::declval<const _Iter2&>() != ::cuda::std::declval<const _Iter2&>()))
     _CCCL_TRAILING_REQUIRES(bool)(::cuda::std::equality_comparable<_Iter2>)
   {
-    return __lhs.__current_ != __rhs.__current_;
+    return __lhs.__iter() != __rhs.__iter();
   }
 #endif // _CCCL_STD_VER <= 2017
 
@@ -393,7 +418,7 @@ public:
     _CCCL_TRAILING_REQUIRES(bool)(
       ::cuda::std::__has_random_access_traversal<_Iter2>&& ::cuda::std::three_way_comparable<_Iter2>)
   {
-    return __lhs.__current_ <=> __rhs.__current_;
+    return __lhs.__iter() <=> __rhs.__iter();
   }
 #else // ^^^ _LIBCUDACXX_HAS_SPACESHIP_OPERATOR() ^^^ / vvv !_LIBCUDACXX_HAS_SPACESHIP_OPERATOR() vvv
   //! @brief Compares two @c transform_output_iterator for less than by comparing the stored iterators
@@ -404,7 +429,7 @@ public:
     noexcept(::cuda::std::declval<const _Iter2&>() < ::cuda::std::declval<const _Iter2&>()))
     _CCCL_TRAILING_REQUIRES(bool)(::cuda::std::__has_random_access_traversal<_Iter2>)
   {
-    return __lhs.__current_ < __rhs.__current_;
+    return __lhs.__iter() < __rhs.__iter();
   }
 
   //! @brief Compares two @c transform_output_iterator for greater than by comparing the stored iterators
@@ -415,7 +440,7 @@ public:
     noexcept(::cuda::std::declval<const _Iter2&>() < ::cuda::std::declval<const _Iter2&>()))
     _CCCL_TRAILING_REQUIRES(bool)(::cuda::std::__has_random_access_traversal<_Iter2>)
   {
-    return __lhs.__current_ > __rhs.__current_;
+    return __lhs.__iter() > __rhs.__iter();
   }
 
   //! @brief Compares two @c transform_output_iterator for less equal by comparing the stored iterators
@@ -426,7 +451,7 @@ public:
     noexcept(::cuda::std::declval<const _Iter2&>() < ::cuda::std::declval<const _Iter2&>()))
     _CCCL_TRAILING_REQUIRES(bool)(::cuda::std::__has_random_access_traversal<_Iter2>)
   {
-    return __lhs.__current_ <= __rhs.__current_;
+    return __lhs.__iter() <= __rhs.__iter();
   }
 
   //! @brief Compares two @c transform_output_iterator for greater equal by comparing the stored iterators
@@ -437,7 +462,7 @@ public:
     noexcept(::cuda::std::declval<const _Iter2&>() < ::cuda::std::declval<const _Iter2&>()))
     _CCCL_TRAILING_REQUIRES(bool)(::cuda::std::__has_random_access_traversal<_Iter2>)
   {
-    return __lhs.__current_ >= __rhs.__current_;
+    return __lhs.__iter() >= __rhs.__iter();
   }
 #endif // !_LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
 };

cuda/cccl/headers/include/cuda/__iterator/zip_common.h

@@ -0,0 +1,148 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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___ITERATOR_ZIP_COMMON_H
+#define _CUDA___ITERATOR_ZIP_COMMON_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/__fwd/zip_iterator.h>
+#include <cuda/std/__fwd/pair.h>
+#include <cuda/std/__fwd/tuple.h>
+#include <cuda/std/__iterator/concepts.h>
+#include <cuda/std/__iterator/iter_move.h>
+#include <cuda/std/__iterator/iter_swap.h>
+#include <cuda/std/__iterator/iterator_traits.h>
+#include <cuda/std/__type_traits/is_nothrow_default_constructible.h>
+#include <cuda/std/__type_traits/is_nothrow_move_constructible.h>
+#include <cuda/std/__utility/declval.h>
+
+#include <cuda/std/__cccl/prologue.h>
+
+_CCCL_BEGIN_NAMESPACE_CUDA
+
+template <class... _Iterators>
+struct __zip_iter_constraints
+{
+  static constexpr bool __all_forward       = (::cuda::std::__has_forward_traversal<_Iterators> && ...);
+  static constexpr bool __all_bidirectional = (::cuda::std::__has_bidirectional_traversal<_Iterators> && ...);
+  static constexpr bool __all_random_access = (::cuda::std::__has_random_access_traversal<_Iterators> && ...);
+
+  static constexpr bool __all_equality_comparable = (::cuda::std::equality_comparable<_Iterators> && ...);
+
+#if _LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
+  static constexpr bool __all_three_way_comparable = (::cuda::std::three_way_comparable<_Iterators> && ...);
+#endif // _LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
+
+  // Our C++17 iterators sometimes do not satisfy `sized_sentinel_for` but they should all be random_access
+  static constexpr bool __all_sized_sentinel =
+    (::cuda::std::sized_sentinel_for<_Iterators, _Iterators> && ...) || __all_random_access;
+
+  static constexpr bool __all_nothrow_iter_movable =
+    (noexcept(::cuda::std::ranges::iter_move(::cuda::std::declval<const _Iterators&>())) && ...)
+    && (::cuda::std::is_nothrow_move_constructible_v<::cuda::std::iter_rvalue_reference_t<_Iterators>> && ...);
+
+  static constexpr bool __all_indirectly_swappable = (::cuda::std::indirectly_swappable<_Iterators> && ...);
+
+  static constexpr bool __all_noexcept_swappable = (::cuda::std::__noexcept_swappable<_Iterators> && ...);
+
+  static constexpr bool __all_nothrow_move_constructible =
+    (::cuda::std::is_nothrow_move_constructible_v<_Iterators> && ...);
+
+  static constexpr bool __all_default_initializable = (::cuda::std::default_initializable<_Iterators> && ...);
+
+  static constexpr bool __all_nothrow_default_constructible =
+    (::cuda::std::is_nothrow_default_constructible_v<_Iterators> && ...);
+};
+
+template <class... _Iterators>
+[[nodiscard]] _CCCL_API _CCCL_CONSTEVAL auto __get_zip_iterator_concept()
+{
+  using _Constraints = __zip_iter_constraints<_Iterators...>;
+  if constexpr (_Constraints::__all_random_access)
+  {
+    return ::cuda::std::random_access_iterator_tag();
+  }
+  else if constexpr (_Constraints::__all_bidirectional)
+  {
+    return ::cuda::std::bidirectional_iterator_tag();
+  }
+  else if constexpr (_Constraints::__all_forward)
+  {
+    return ::cuda::std::forward_iterator_tag();
+  }
+  else
+  {
+    return ::cuda::std::input_iterator_tag();
+  }
+  _CCCL_UNREACHABLE();
+}
+
+//! @note Not static functions because nvc++ sometimes has issues with class static functions in device code
+struct __zip_op_star
+{
+  template <class... _Iterators>
+  using reference = ::cuda::std::tuple<::cuda::std::iter_reference_t<_Iterators>...>;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class... _Iterators>
+  [[nodiscard]] _CCCL_API constexpr reference<_Iterators...> operator()(const _Iterators&... __iters) const
+    noexcept(noexcept(reference<_Iterators...>{*__iters...}))
+  {
+    return reference<_Iterators...>{*__iters...};
+  }
+};
+
+struct __zip_op_increment
+{
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class... _Iterators>
+  _CCCL_API constexpr void operator()(_Iterators&... __iters) const noexcept(noexcept(((void) ++__iters, ...)))
+  {
+    ((void) ++__iters, ...);
+  }
+};
+
+struct __zip_op_decrement
+{
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class... _Iterators>
+  _CCCL_API constexpr void operator()(_Iterators&... __iters) const noexcept(noexcept(((void) --__iters, ...)))
+  {
+    ((void) --__iters, ...);
+  }
+};
+
+struct __zip_iter_move
+{
+  template <class... _Iterators>
+  using __iter_move_ret = ::cuda::std::tuple<::cuda::std::iter_rvalue_reference_t<_Iterators>...>;
+
+  _CCCL_EXEC_CHECK_DISABLE
+  template <class... _Iterators>
+  [[nodiscard]] _CCCL_API constexpr __iter_move_ret<_Iterators...> operator()(const _Iterators&... __iters) const
+    noexcept(noexcept(__iter_move_ret<_Iterators...>{::cuda::std::ranges::iter_move(__iters)...}))
+  {
+    return __iter_move_ret<_Iterators...>{::cuda::std::ranges::iter_move(__iters)...};
+  }
+};
+
+_CCCL_END_NAMESPACE_CUDA
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA___ITERATOR_ZIP_COMMON_H