cuda-cccl 0.3.1__cp313-cp313-manylinux_2_24_aarch64.whl → 0.3.2__cp313-cp313-manylinux_2_24_aarch64.whl

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

@@ -24,12 +24,14 @@
 #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/movable_box.h>
 #include <cuda/std/__type_traits/conditional.h>
 #include <cuda/std/__type_traits/is_nothrow_copy_constructible.h>
 #include <cuda/std/__type_traits/is_nothrow_default_constructible.h>
 #include <cuda/std/__type_traits/is_nothrow_move_constructible.h>
 #include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__type_traits/is_signed.h>
 #include <cuda/std/__type_traits/remove_cvref.h>
 #include <cuda/std/__utility/forward.h>
 #include <cuda/std/__utility/move.h>
@@ -113,8 +115,30 @@ template <class _Fn, class _Index>
 class tabulate_output_iterator
 {
 private:
-  ::cuda::std::ranges::__movable_box<_Fn> __func_;
-  _Index __index_ = 0;
+  // Not a base because then the friend operators would be ambiguous
+  ::cuda::std::__compressed_movable_box<_Index, _Fn> __store_;
+
+  [[nodiscard]] _CCCL_API constexpr _Index& __index() noexcept
+  {
+    return __store_.template __get<0>();
+  }
+
+  [[nodiscard]] _CCCL_API constexpr const _Index& __index() 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>();
+  }
+
+  static_assert(::cuda::std::is_signed_v<_Index>, "tabulate_output_iterator: _Index must be a signed integer");
 
 public:
   using iterator_concept  = ::cuda::std::random_access_iterator_tag;
@@ -124,45 +148,39 @@ public:
   using pointer           = void;
   using reference         = void;
 
-#if _CCCL_HAS_CONCEPTS()
-  _CCCL_EXEC_CHECK_DISABLE
-  _CCCL_HIDE_FROM_ABI tabulate_output_iterator()
-    requires ::cuda::std::default_initializable<_Fn>
-  = default;
-#else // ^^^ _CCCL_HAS_CONCEPTS() ^^^ / vvv !_CCCL_HAS_CONCEPTS() vvv
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_TEMPLATE(class _Fn2 = _Fn)
   _CCCL_REQUIRES(::cuda::std::default_initializable<_Fn2>)
-  _CCCL_API constexpr tabulate_output_iterator() noexcept(::cuda::std::is_nothrow_default_constructible_v<_Fn2>) {}
-#endif // ^^^ !_CCCL_HAS_CONCEPTS() ^^^
+  _CCCL_API constexpr tabulate_output_iterator() noexcept(::cuda::std::is_nothrow_default_constructible_v<_Fn2>)
+      : __store_()
+  {}
 
   //! @brief Constructs a @c tabulate_output_iterator with a given functor and an optional index
   //! @param __func the output function
   //! @param __index the position in the output sequence
   _CCCL_API constexpr tabulate_output_iterator(_Fn __func, _Index __index = 0) noexcept(
     ::cuda::std::is_nothrow_move_constructible_v<_Fn>)
-      : __func_(::cuda::std::in_place, ::cuda::std::move(__func))
-      , __index_(__index)
+      : __store_(__index, ::cuda::std::move(__func))
   {}
 
   //! @brief Returns the stored index
   [[nodiscard]] _CCCL_API constexpr difference_type index() const noexcept
   {
-    return __index_;
+    return __index();
   }
 
   //! @brief Dereferences the @c tabulate_output_iterator
   //! @returns A proxy that applies the stored function and index on assignment
   [[nodiscard]] _CCCL_API constexpr auto operator*() const noexcept
   {
-    return __tabulate_proxy<_Fn, _Index>{const_cast<_Fn&>(*__func_), __index_};
+    return __tabulate_proxy<_Fn, _Index>{const_cast<_Fn&>(__func()), __index()};
   }
 
   //! @brief Dereferences the @c tabulate_output_iterator
   //! @returns A proxy that applies the stored function and index on assignment
   [[nodiscard]] _CCCL_API constexpr auto operator*() noexcept
   {
-    return __tabulate_proxy<_Fn, _Index>{*__func_, __index_};
+    return __tabulate_proxy<_Fn, _Index>{__func(), __index()};
   }
 
   //! @brief Subscripts the @c tabulate_output_iterator with a given offset
@@ -170,7 +188,7 @@ public:
   //! @returns A proxy that applies the stored function and index on assignment
   [[nodiscard]] _CCCL_API constexpr auto operator[](difference_type __n) const noexcept
   {
-    return __tabulate_proxy<_Fn, _Index>{const_cast<_Fn&>(*__func_), __index_ + __n};
+    return __tabulate_proxy<_Fn, _Index>{const_cast<_Fn&>(__func()), __index() + __n};
   }
 
   //! @brief Subscripts the @c tabulate_output_iterator with a given offset
@@ -178,13 +196,13 @@ public:
   //! @returns A proxy that applies the stored function and index on assignment
   [[nodiscard]] _CCCL_API constexpr auto operator[](difference_type __n) noexcept
   {
-    return __tabulate_proxy<_Fn, _Index>{*__func_, __index_ + __n};
+    return __tabulate_proxy<_Fn, _Index>{__func(), __index() + __n};
   }
 
   //! @brief Increments the @c tabulate_output_iterator by incrementing the stored index
   _CCCL_API constexpr tabulate_output_iterator& operator++() noexcept
   {
-    ++__index_;
+    ++__index();
     return *this;
   }
 
@@ -193,14 +211,14 @@ public:
   operator++(int) noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Fn>)
   {
     tabulate_output_iterator __tmp = *this;
-    ++__index_;
+    ++__index();
     return __tmp;
   }
 
   //! @brief Decrements the @c tabulate_output_iterator by decrementing the stored index
   _CCCL_API constexpr tabulate_output_iterator& operator--() noexcept
   {
-    --__index_;
+    --__index();
     return *this;
   }
 
@@ -209,56 +227,61 @@ public:
   operator--(int) noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Fn>)
   {
     tabulate_output_iterator __tmp = *this;
-    --__index_;
+    --__index();
     return __tmp;
   }
 
   //! @brief Returns a copy of this @c tabulate_output_iterator advanced a given number of elements
   //! @param __n The number of elements to advance
-  [[nodiscard]] _CCCL_API constexpr tabulate_output_iterator operator+(difference_type __n) const
+  template <int = 0> // Template because compiler will complain about non-literal return type if _Fn is not a literal
+  [[nodiscard]] _CCCL_API friend constexpr tabulate_output_iterator
+  operator+(const tabulate_output_iterator& __iter, difference_type __n) //
     noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Fn>)
   {
-    return tabulate_output_iterator{*__func_, __index_ + __n};
+    return tabulate_output_iterator{__iter.__func(), __iter.__index() + __n};
   }
 
   //! @brief Returns a copy of a @c tabulate_output_iterator advanced a given number of elements
   //! @param __n The number of elements to advance
   //! @param __iter The original @c tabulate_output_iterator
+  template <int = 0> // Template because compiler will complain about non-literal return type if _Fn is not a literal
   [[nodiscard]] _CCCL_API friend constexpr tabulate_output_iterator
   operator+(difference_type __n, const tabulate_output_iterator& __iter) //
     noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Fn>)
   {
-    return __iter + __n;
+    return tabulate_output_iterator{__iter.__func(), __iter.__index() + __n};
   }
 
   //! @brief Advances the @c tabulate_output_iterator by a given number of elements
   //! @param __n The number of elements to advance
   _CCCL_API constexpr tabulate_output_iterator& operator+=(difference_type __n) noexcept
   {
-    __index_ += __n;
+    __index() += __n;
     return *this;
   }
 
   //! @brief Returns a copy of this @c tabulate_output_iterator decremented a given number of elements
   //! @param __n The number of elements to decremented
-  [[nodiscard]] _CCCL_API constexpr tabulate_output_iterator operator-(difference_type __n) const
+  template <int = 0> // Template because compiler will complain about non-literal return type if _Fn is not a literal
+  [[nodiscard]] _CCCL_API friend constexpr tabulate_output_iterator
+  operator-(const tabulate_output_iterator& __iter, difference_type __n) //
     noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Fn>)
   {
-    return tabulate_output_iterator{*__func_, __index_ - __n};
+    return tabulate_output_iterator{__iter.__func(), __iter.__index() - __n};
   }
 
   //! @brief Returns the distance between two @c tabulate_output_iterator 's
   [[nodiscard]] _CCCL_API friend constexpr difference_type
   operator-(const tabulate_output_iterator& __lhs, const tabulate_output_iterator& __rhs) noexcept
   {
-    return __rhs.__index_ - __lhs.__index_;
+    return __rhs.__index() - __lhs.__index();
   }
 
   //! @brief Decrements the @c tabulate_output_iterator by a given number of elements
   //! @param __n The number of elements to decrement
   _CCCL_API constexpr tabulate_output_iterator& operator-=(difference_type __n) noexcept
   {
-    __index_ -= __n;
+    __index() -= __n;
     return *this;
   }
 
@@ -266,7 +289,7 @@ public:
   [[nodiscard]] _CCCL_API friend constexpr bool
   operator==(const tabulate_output_iterator& __lhs, const tabulate_output_iterator& __rhs) noexcept
   {
-    return __lhs.__index_ == __rhs.__index_;
+    return __lhs.__index() == __rhs.__index();
   }
 
 #if _CCCL_STD_VER <= 2017
@@ -274,7 +297,7 @@ public:
   [[nodiscard]] _CCCL_API friend constexpr bool
   operator!=(const tabulate_output_iterator& __lhs, const tabulate_output_iterator& __rhs) noexcept
   {
-    return __lhs.__index_ != __rhs.__index_;
+    return __lhs.__index() != __rhs.__index();
   }
 #endif // _CCCL_STD_VER <= 2017
 
@@ -283,35 +306,35 @@ public:
   [[nodiscard]] _CCCL_API friend constexpr strong_ordering
   operator<=>(const tabulate_output_iterator& __lhs, const tabulate_output_iterator& __rhs) noexcept
   {
-    return __lhs.__index_ <=> __rhs.__index_;
+    return __lhs.__index() <=> __rhs.__index();
   }
 #else // ^^^ _LIBCUDACXX_HAS_SPACESHIP_OPERATOR() ^^^ / vvv !_LIBCUDACXX_HAS_SPACESHIP_OPERATOR() vvv
   //! @brief Compares two @c tabulate_output_iterator for less than by comparing their indices
   [[nodiscard]] _CCCL_API friend constexpr bool
   operator<(const tabulate_output_iterator& __lhs, const tabulate_output_iterator& __rhs) noexcept
   {
-    return __lhs.__index_ < __rhs.__index_;
+    return __lhs.__index() < __rhs.__index();
   }
 
   //! @brief Compares two @c tabulate_output_iterator for less equal by comparing their indices
   [[nodiscard]] _CCCL_API friend constexpr bool
   operator<=(const tabulate_output_iterator& __lhs, const tabulate_output_iterator& __rhs) noexcept
   {
-    return __lhs.__index_ <= __rhs.__index_;
+    return __lhs.__index() <= __rhs.__index();
   }
 
   //! @brief Compares two @c tabulate_output_iterator for greater than by comparing their indices
   [[nodiscard]] _CCCL_API friend constexpr bool
   operator>(const tabulate_output_iterator& __lhs, const tabulate_output_iterator& __rhs) noexcept
   {
-    return __lhs.__index_ > __rhs.__index_;
+    return __lhs.__index() > __rhs.__index();
   }
 
   //! @brief Compares two @c tabulate_output_iterator for greater equal by comparing their indices
   [[nodiscard]] _CCCL_API friend constexpr bool
   operator>=(const tabulate_output_iterator& __lhs, const tabulate_output_iterator& __rhs) noexcept
   {
-    return __lhs.__index_ >= __rhs.__index_;
+    return __lhs.__index() >= __rhs.__index();
   }
 #endif // !_LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
 };

cuda/cccl/headers/include/cuda/__iterator/transform_input_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>
 
@@ -153,11 +155,40 @@ public:
 template <class _InputFn, class _OutputFn, class _Iter>
 class transform_input_output_iterator
 {
-public:
-  _Iter __current_{};
-  ::cuda::std::ranges::__movable_box<_InputFn> __input_func_{};
-  ::cuda::std::ranges::__movable_box<_OutputFn> __output_func_{};
+  // Not a base because then the friend operators would be ambiguous
+  ::cuda::std::__compressed_movable_box<_Iter, _InputFn, _OutputFn> __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 _InputFn& __input_func() noexcept
+  {
+    return __store_.template __get<1>();
+  }
+
+  [[nodiscard]] _CCCL_API constexpr const _InputFn& __input_func() const noexcept
+  {
+    return __store_.template __get<1>();
+  }
+
+  [[nodiscard]] _CCCL_API constexpr _OutputFn& __output_func() noexcept
+  {
+    return __store_.template __get<2>();
+  }
+
+  [[nodiscard]] _CCCL_API constexpr const _OutputFn& __output_func() const noexcept
+  {
+    return __store_.template __get<2>();
+  }
 
+public:
   using iterator_concept = ::cuda::std::conditional_t<
     ::cuda::std::__has_random_access_traversal<_Iter>,
     ::cuda::std::random_access_iterator_tag,
@@ -183,13 +214,6 @@ public:
                 "dereferencing _Iter");
 
   //! @brief Default constructs a @c transform_input_output_iterator with a value initialized iterator and functors
-#if _CCCL_HAS_CONCEPTS()
-  _CCCL_EXEC_CHECK_DISABLE
-  _CCCL_HIDE_FROM_ABI transform_input_output_iterator()
-    requires ::cuda::std::default_initializable<_Iter> && ::cuda::std::default_initializable<_InputFn>
-            && ::cuda::std::default_initializable<_OutputFn>
-  = default;
-#else // ^^^ _CCCL_HAS_CONCEPTS() ^^^ / vvv !_CCCL_HAS_CONCEPTS() vvv
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_TEMPLATE(class _Iter2 = _Iter, class _InputFn2 = _InputFn, class _OutputFn2 = _OutputFn)
   _CCCL_REQUIRES(::cuda::std::default_initializable<_Iter2> _CCCL_AND ::cuda::std::default_initializable<_InputFn2>
@@ -198,8 +222,8 @@ public:
     ::cuda::std::is_nothrow_default_constructible_v<_Iter2>
     && ::cuda::std::is_nothrow_default_constructible_v<_InputFn2>
     && ::cuda::std::is_nothrow_default_constructible_v<_OutputFn2>)
+      : __store_()
   {}
-#endif // ^^^ !_CCCL_HAS_CONCEPTS() ^^^
 
   //! @brief Constructs a @c transform_input_output_iterator with base iterator, input functor and output functor
   //! @param __iter The iterator to transform
@@ -210,22 +234,20 @@ public:
     noexcept(::cuda::std::is_nothrow_move_constructible_v<_Iter>
              && ::cuda::std::is_nothrow_move_constructible_v<_InputFn>
              && ::cuda::std::is_nothrow_move_constructible_v<_OutputFn>)
-      : __current_(::cuda::std::move(__iter))
-      , __input_func_(::cuda::std::in_place, ::cuda::std::move(__input_func))
-      , __output_func_(::cuda::std::in_place, ::cuda::std::move(__output_func))
+      : __store_(::cuda::std::move(__iter), ::cuda::std::move(__input_func), ::cuda::std::move(__output_func))
   {}
 
   //! @brief Returns a const reference to the base iterator stored
   [[nodiscard]] _CCCL_API constexpr const _Iter& base() const& noexcept
   {
-    return __current_;
+    return __iter();
   }
 
   //! @brief Extracts the stored base 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 Dereferences the @c transform_input_output_iterator. Returns a proxy that transforms values read from the
@@ -235,7 +257,7 @@ public:
     noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter>)
   {
     return __transform_input_output_proxy{
-      __current_, const_cast<_InputFn&>(*__input_func_), const_cast<_OutputFn&>(*__output_func_)};
+      __iter(), const_cast<_InputFn&>(__input_func()), const_cast<_OutputFn&>(__output_func())};
   }
 
   //! @brief Dereferences the @c transform_input_output_iterator. Returns a proxy that transforms values read from the
@@ -243,7 +265,7 @@ public:
   _CCCL_EXEC_CHECK_DISABLE
   [[nodiscard]] _CCCL_API constexpr reference operator*() noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter>)
   {
-    return __transform_input_output_proxy{__current_, *__input_func_, *__output_func_};
+    return __transform_input_output_proxy{__iter(), __input_func(), __output_func()};
   }
 
   //! @brief Subscripts the @c transform_input_output_iterator. Returns a proxy that transforms values read from the
@@ -254,10 +276,11 @@ public:
   _CCCL_TEMPLATE(class _Iter2 = _Iter)
   _CCCL_REQUIRES(::cuda::std::__has_random_access_traversal<_Iter2>)
   [[nodiscard]] _CCCL_API constexpr reference 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_input_output_proxy{
-      __current_ + __n, const_cast<_InputFn&>(*__input_func_), const_cast<_OutputFn&>(*__output_func_)};
+      __iter() + __n, const_cast<_InputFn&>(__input_func()), const_cast<_OutputFn&>(__output_func())};
   }
 
   //! @brief Subscripts the @c transform_input_output_iterator. Returns a proxy that transforms values read from the
@@ -268,23 +291,23 @@ public:
   _CCCL_TEMPLATE(class _Iter2 = _Iter)
   _CCCL_REQUIRES(::cuda::std::__has_random_access_traversal<_Iter2>)
   [[nodiscard]] _CCCL_API constexpr reference 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<const _Iter2&>() + __n))
   {
-    return __transform_input_output_proxy{__current_ + __n, *__input_func_, *__output_func_};
+    return __transform_input_output_proxy{__iter() + __n, __input_func(), __output_func()};
   }
 
   //! @brief Increments the stored iterator
   _CCCL_EXEC_CHECK_DISABLE
-  _CCCL_API constexpr transform_input_output_iterator& operator++() noexcept(noexcept(++__current_))
+  _CCCL_API constexpr transform_input_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 transform_input_output_iterator operator++(int) noexcept(
-    noexcept(++__current_)
+    noexcept(++::cuda::std::declval<_Iter&>())
     && ::cuda::std::is_nothrow_copy_constructible_v<_Iter> && ::cuda::std::is_nothrow_copy_constructible_v<_InputFn>
     && ::cuda::std::is_nothrow_copy_constructible_v<_OutputFn>)
   {
@@ -297,9 +320,9 @@ public:
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_TEMPLATE(class _Iter2 = _Iter)
   _CCCL_REQUIRES(::cuda::std::__has_bidirectional_traversal<_Iter2>)
-  _CCCL_API constexpr transform_input_output_iterator& operator--() noexcept(noexcept(--__current_))
+  _CCCL_API constexpr transform_input_output_iterator& operator--() noexcept(noexcept(--::cuda::std::declval<_Iter2&>()))
   {
-    --__current_;
+    --__iter();
     return *this;
   }
 
@@ -307,8 +330,8 @@ public:
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_TEMPLATE(class _Iter2 = _Iter)
   _CCCL_REQUIRES(::cuda::std::__has_bidirectional_traversal<_Iter2>)
-  _CCCL_API constexpr transform_input_output_iterator
-  operator--(int) noexcept(::cuda::std::is_nothrow_copy_constructible_v<_Iter> && noexcept(--__current_))
+  _CCCL_API constexpr transform_input_output_iterator operator--(int) noexcept(
+    ::cuda::std::is_nothrow_copy_constructible_v<_Iter> && noexcept(--::cuda::std::declval<_Iter2&>()))
   {
     auto __tmp = *this;
     --*this;
@@ -321,9 +344,9 @@ public:
   _CCCL_TEMPLATE(class _Iter2 = _Iter)
   _CCCL_REQUIRES(::cuda::std::__has_random_access_traversal<_Iter2>)
   _CCCL_API constexpr transform_input_output_iterator&
-  operator+=(difference_type __n) noexcept(noexcept(__current_ += __n))
+  operator+=(difference_type __n) noexcept(noexcept(::cuda::std::declval<_Iter2&>() += __n))
   {
-    __current_ += __n;
+    __iter() += __n;
     return *this;
   }
 
@@ -338,7 +361,7 @@ public:
              && noexcept(::cuda::std::declval<const _Iter2&>() + difference_type{}))
       _CCCL_TRAILING_REQUIRES(transform_input_output_iterator)(::cuda::std::__has_random_access_traversal<_Iter2>)
   {
-    return transform_input_output_iterator{__iter.__current_ + __n, *__iter.__input_func_, *__iter.__output_func_};
+    return transform_input_output_iterator{__iter.__iter() + __n, __iter.__input_func(), __iter.__output_func()};
   }
 
   //! @brief Returns a copy of a @c transform_input_output_iterator advanced by a given number of elements
@@ -352,7 +375,7 @@ public:
     && noexcept(::cuda::std::declval<const _Iter2&>() + difference_type{}))
     _CCCL_TRAILING_REQUIRES(transform_input_output_iterator)(::cuda::std::__has_random_access_traversal<_Iter2>)
   {
-    return transform_input_output_iterator{__iter.__current_ + __n, *__iter.__input_func_, *__iter.__output_func_};
+    return transform_input_output_iterator{__iter.__iter() + __n, __iter.__input_func(), __iter.__output_func()};
   }
 
   //! @brief Decrements the @c transform_input_output_iterator by a given number of elements
@@ -361,9 +384,9 @@ public:
   _CCCL_TEMPLATE(class _Iter2 = _Iter)
   _CCCL_REQUIRES(::cuda::std::__has_random_access_traversal<_Iter2>)
   _CCCL_API constexpr transform_input_output_iterator&
-  operator-=(difference_type __n) noexcept(noexcept(__current_ -= __n))
+  operator-=(difference_type __n) noexcept(noexcept(::cuda::std::declval<_Iter2&>() -= __n))
   {
-    __current_ -= __n;
+    __iter() -= __n;
     return *this;
   }
 
@@ -378,18 +401,25 @@ public:
              && noexcept(::cuda::std::declval<const _Iter2&>() - difference_type{}))
       _CCCL_TRAILING_REQUIRES(transform_input_output_iterator)(::cuda::std::__has_random_access_traversal<_Iter2>)
   {
-    return transform_input_output_iterator{__iter.__current_ - __n, *__iter.__input_func_, *__iter.__output_func_};
+    return transform_input_output_iterator{__iter.__iter() - __n, __iter.__input_func(), __iter.__output_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_input_output_iterator
   _CCCL_EXEC_CHECK_DISABLE
   template <class _Iter2 = _Iter>
-  [[nodiscard]] _CCCL_API friend constexpr auto
-  operator-(const transform_input_output_iterator& __lhs, const transform_input_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_input_output_iterator& __lhs,
+                                                          const transform_input_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_input_output_iterator for equality by comparing the stored iterators
@@ -400,7 +430,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
@@ -412,7 +442,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
 
@@ -424,7 +454,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_input_output_iterator for greater than by comparing the stored iterators
@@ -435,7 +465,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_input_output_iterator for less equal by comparing the stored iterators
@@ -446,7 +476,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_input_output_iterator for greater equal by comparing the stored iterators
@@ -457,7 +487,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();
   }
 
 #if _LIBCUDACXX_HAS_SPACESHIP_OPERATOR()
@@ -471,7 +501,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();
   }
 #endif // !_LIBCUDACXX_HAS_NO_SPACESHIP_OPERATOR
 };