cuda-cccl 0.3.0__cp310-cp310-manylinux_2_24_aarch64.whl → 0.3.2__cp310-cp310-manylinux_2_24_aarch64.whl

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

@@ -28,6 +28,7 @@
 #include <cuda/std/__concepts/totally_ordered.h>
 #include <cuda/std/__iterator/iterator_traits.h>
 #include <cuda/std/__mdspan/submdspan_helper.h>
+#include <cuda/std/__ranges/compressed_movable_box.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>
@@ -57,12 +58,32 @@ private:
   static_assert(::cuda::std::__integer_like<_Stride> || ::cuda::std::__integral_constant_like<_Stride>,
                 "The stride of a strided_iterator must either be an integer-like or integral-constant-like.");
 
-  _Iter __iter_{};
-  _Stride __stride_{};
-
   template <class, class>
   friend class strided_iterator;
 
+  // Not a base because then the friend operators would be ambiguous
+  ::cuda::std::__compressed_movable_box<_Iter, _Stride> __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 _Stride& __stride() noexcept
+  {
+    return __store_.template __get<1>();
+  }
+
+  [[nodiscard]] _CCCL_API constexpr const _Stride& __stride() const noexcept
+  {
+    return __store_.template __get<1>();
+  }
+
 public:
   using iterator_concept  = ::cuda::std::random_access_iterator_tag;
   using iterator_category = ::cuda::std::random_access_iterator_tag;
@@ -78,7 +99,12 @@ public:
   //! @note _Iter must be default initializable because it is a random_access_iterator and thereby semiregular
   //!       _Stride must be integer-like or integral_constant_like which requires default constructability
   _CCCL_EXEC_CHECK_DISABLE
-  _CCCL_HIDE_FROM_ABI strided_iterator() = default;
+  _CCCL_TEMPLATE(class _Iter2 = _Iter, class _Stride2 = _Stride)
+  _CCCL_REQUIRES(::cuda::std::default_initializable<_Iter2> _CCCL_AND ::cuda::std::default_initializable<_Stride2>)
+  _CCCL_API constexpr strided_iterator() noexcept(::cuda::std::is_nothrow_default_constructible_v<_Iter2>
+                                                  && ::cuda::std::is_nothrow_default_constructible_v<_Stride2>)
+      : __store_()
+  {}
 
   //! @brief Constructs a @c strided_iterator from a base iterator
   //! @param __iter The base iterator
@@ -90,8 +116,7 @@ public:
   _CCCL_REQUIRES(::cuda::std::__integral_constant_like<_Stride2>)
   _CCCL_API constexpr explicit strided_iterator(_Iter __iter) noexcept(
     ::cuda::std::is_nothrow_move_constructible_v<_Iter> && ::cuda::std::is_nothrow_default_constructible_v<_Stride2>)
-      : __iter_(::cuda::std::move(__iter))
-      , __stride_()
+      : __store_(::cuda::std::move(__iter))
   {}
 
   //! @brief Constructs a @c strided_iterator from a base iterator and a stride
@@ -100,21 +125,20 @@ public:
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_API constexpr explicit strided_iterator(_Iter __iter, _Stride __stride) noexcept(
     ::cuda::std::is_nothrow_move_constructible_v<_Iter> && ::cuda::std::is_nothrow_move_constructible_v<_Stride>)
-      : __iter_(::cuda::std::move(__iter))
-      , __stride_(::cuda::std::move(__stride))
+      : __store_(::cuda::std::move(__iter), ::cuda::std::move(__stride))
   {}
 
   //! @brief Returns a const reference to the stored iterator
   [[nodiscard]] _CCCL_API constexpr const _Iter& base() const& noexcept
   {
-    return __iter_;
+    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(__iter_);
+    return ::cuda::std::move(__iter());
   }
 
   static constexpr bool __noexcept_stride =
@@ -124,32 +148,33 @@ public:
   _CCCL_EXEC_CHECK_DISABLE
   [[nodiscard]] _CCCL_API constexpr difference_type stride() const noexcept(__noexcept_stride)
   {
-    return static_cast<difference_type>(::cuda::std::__de_ice(__stride_));
+    return static_cast<difference_type>(::cuda::std::__de_ice(__stride()));
   }
 
   //! @brief Dereferences the stored base iterator
   _CCCL_EXEC_CHECK_DISABLE
-  [[nodiscard]] _CCCL_API constexpr decltype(auto) operator*() noexcept(noexcept(*__iter_))
+  [[nodiscard]] _CCCL_API constexpr decltype(auto) operator*() noexcept(noexcept(*::cuda::std::declval<_Iter&>()))
   {
-    return *__iter_;
+    return *__iter();
   }
 
   //! @brief Dereferences the stored base iterator
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_TEMPLATE(class _Iter2 = _Iter)
   _CCCL_REQUIRES(::cuda::std::__dereferenceable<const _Iter2>)
-  [[nodiscard]] _CCCL_API constexpr decltype(auto) operator*() const noexcept(noexcept(*__iter_))
+  [[nodiscard]] _CCCL_API constexpr decltype(auto) operator*() const
+    noexcept(noexcept(*::cuda::std::declval<const _Iter2&>()))
   {
-    return *__iter_;
+    return *__iter();
   }
 
   //! @brief Subscripts the stored base iterator with a given offset times the stride
   //! @param __n The offset
   _CCCL_EXEC_CHECK_DISABLE
   [[nodiscard]] _CCCL_API constexpr decltype(auto)
-  operator[](difference_type __n) noexcept(__noexcept_stride && noexcept(__iter_[__n]))
+  operator[](difference_type __n) noexcept(__noexcept_stride && noexcept(::cuda::std::declval<_Iter&>()[__n]))
   {
-    return __iter_[__n * stride()];
+    return __iter()[__n * stride()];
   }
 
   //! @brief Subscripts the stored base iterator with a given offset times the stride
@@ -158,47 +183,49 @@ public:
   _CCCL_TEMPLATE(class _Iter2 = _Iter)
   _CCCL_REQUIRES(::cuda::std::__dereferenceable<const _Iter2>)
   [[nodiscard]] _CCCL_API constexpr decltype(auto) operator[](difference_type __n) const
-    noexcept(__noexcept_stride && noexcept(__iter_[__n]))
+    noexcept(__noexcept_stride && noexcept(::cuda::std::declval<const _Iter2&>()[__n]))
   {
-    return __iter_[__n * stride()];
+    return __iter()[__n * stride()];
   }
 
   //! @brief Increments the stored base iterator by the stride
-  // Note: we cannot use __iter_ += stride() in the noexcept clause because that breaks gcc < 9
+  // Note: we cannot use __iter() += stride() in the noexcept clause because that breaks gcc < 9
   _CCCL_EXEC_CHECK_DISABLE
-  _CCCL_API constexpr strided_iterator& operator++() noexcept(__noexcept_stride && noexcept(__iter_ += 1))
+  _CCCL_API constexpr strided_iterator&
+  operator++() noexcept(__noexcept_stride && noexcept(::cuda::std::declval<_Iter&>() += 1))
   {
-    __iter_ += stride();
+    __iter() += stride();
     return *this;
   }
 
   //! @brief Increments the stored base iterator by the stride
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_API constexpr auto operator++(int) noexcept(
-    noexcept(__noexcept_stride && noexcept(__iter_ += 1))
+    noexcept(__noexcept_stride && noexcept(::cuda::std::declval<_Iter&>() += 1))
     && ::cuda::std::is_nothrow_copy_constructible_v<_Iter> && ::cuda::std::is_nothrow_copy_constructible_v<_Stride>)
   {
     auto __tmp = *this;
-    __iter_ += stride();
+    __iter() += stride();
     return __tmp;
   }
 
   //! @brief Decrements the stored base iterator by the stride
   _CCCL_EXEC_CHECK_DISABLE
-  _CCCL_API constexpr strided_iterator& operator--() noexcept(__noexcept_stride && noexcept(__iter_ -= 1))
+  _CCCL_API constexpr strided_iterator&
+  operator--() noexcept(__noexcept_stride && noexcept(::cuda::std::declval<_Iter&>() -= 1))
   {
-    __iter_ -= stride();
+    __iter() -= stride();
     return *this;
   }
 
   //! @brief Decrements the stored base iterator by the stride
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_API constexpr strided_iterator operator--(int) noexcept(
-    noexcept(__noexcept_stride && noexcept(__iter_ -= 1))
+    noexcept(__noexcept_stride && noexcept(::cuda::std::declval<_Iter&>() -= 1))
     && ::cuda::std::is_nothrow_copy_constructible_v<_Iter> && ::cuda::std::is_nothrow_copy_constructible_v<_Stride>)
   {
     auto __tmp = *this;
-    __iter_ -= stride();
+    __iter() -= stride();
     return __tmp;
   }
 
@@ -207,9 +234,9 @@ public:
   //! @note Increments the base iterator by @c __n times the stride
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_API constexpr strided_iterator&
-  operator+=(difference_type __n) noexcept(__noexcept_stride && noexcept(__iter_ += 1))
+  operator+=(difference_type __n) noexcept(__noexcept_stride && noexcept(::cuda::std::declval<_Iter&>() += 1))
   {
-    __iter_ += stride() * __n;
+    __iter() += stride() * __n;
     return *this;
   }
 
@@ -218,10 +245,10 @@ public:
   //! @param __n The number of steps to increment
   _CCCL_EXEC_CHECK_DISABLE
   [[nodiscard]] _CCCL_API friend constexpr strided_iterator
-  operator+(strided_iterator __iter, difference_type __n) noexcept(noexcept(__iter_ += __n))
+  operator+(const strided_iterator& __iter, difference_type __n) noexcept(
+    ::cuda::std::is_nothrow_copy_constructible_v<_Iter> && noexcept(::cuda::std::declval<const _Iter&>() + __n))
   {
-    __iter += __n;
-    return __iter;
+    return strided_iterator{__iter.__iter() + __iter.stride() * __n, __iter.__stride()};
   }
 
   //! @brief Returns a copy of a @c strided_iterator incremented by a given number of steps
@@ -229,9 +256,10 @@ public:
   //! @param __iter The @c strided_iterator to advance
   _CCCL_EXEC_CHECK_DISABLE
   [[nodiscard]] _CCCL_API friend constexpr strided_iterator
-  operator+(difference_type __n, strided_iterator __iter) noexcept(noexcept(__iter_ + __n))
+  operator+(difference_type __n, const strided_iterator& __iter) noexcept(
+    ::cuda::std::is_nothrow_copy_constructible_v<_Iter> && noexcept(::cuda::std::declval<const _Iter&>() + __n))
   {
-    return __iter + __n;
+    return strided_iterator{__iter.__iter() + __iter.stride() * __n, __iter.__stride()};
   }
 
   //! @brief Decrements a @c strided_iterator by a given number of steps
@@ -239,9 +267,9 @@ public:
   //! @note Decrements the base iterator by @c __n times the stride
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_API constexpr strided_iterator&
-  operator-=(difference_type __n) noexcept(__noexcept_stride && noexcept(__iter_ -= 1))
+  operator-=(difference_type __n) noexcept(__noexcept_stride && noexcept(::cuda::std::declval<_Iter&>() -= 1))
   {
-    __iter_ -= stride() * __n;
+    __iter() -= stride() * __n;
     return *this;
   }
 
@@ -250,21 +278,25 @@ public:
   //! @param __iter The @c strided_iterator to decrement
   _CCCL_EXEC_CHECK_DISABLE
   [[nodiscard]] _CCCL_API friend constexpr strided_iterator
-  operator-(strided_iterator __iter, difference_type __n) noexcept(noexcept(__iter_ -= __n))
+  operator-(const strided_iterator& __iter, difference_type __n) noexcept(
+    ::cuda::std::is_nothrow_copy_constructible_v<_Iter> && noexcept(::cuda::std::declval<const _Iter&>() - __n))
   {
-    __iter -= __n;
-    return __iter;
+    return strided_iterator{__iter.__iter() - __iter.stride() * __n, __iter.__stride()};
   }
 
+  template <class _Iter2, class _OtherIter>
+  static constexpr bool __noexcept_difference =
+    noexcept(::cuda::std::declval<const _Iter2&>() - ::cuda::std::declval<const _OtherIter&>());
+
   //! @brief Returns distance between two @c strided_iterator's in units of the stride
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_TEMPLATE(class _OtherIter, class _OtherStride)
   _CCCL_REQUIRES(::cuda::std::sized_sentinel_for<_OtherIter, _Iter>)
   [[nodiscard]] _CCCL_API friend constexpr difference_type
-  operator-(const strided_iterator& __x, const strided_iterator<_OtherIter, _OtherStride>& __y) noexcept(
-    noexcept(::cuda::std::declval<_Iter>() - ::cuda::std::declval<_OtherIter>()))
+  operator-(const strided_iterator& __x, const strided_iterator<_OtherIter, _OtherStride>& __y) //
+    noexcept(__noexcept_difference<_Iter, _OtherIter>)
   {
-    const difference_type __diff = __x.__iter_ - __y.base();
+    const difference_type __diff = __x.__iter() - __y.base();
     _CCCL_ASSERT(__x.stride() == __y.stride(), "Taking the difference of two strided_iterators with different stride");
     _CCCL_ASSERT(__diff % __x.stride() == 0, "Underlying iterator difference must be divisible by the stride");
     return __diff / __x.stride();
@@ -278,7 +310,7 @@ public:
   operator==(const strided_iterator& __x, const strided_iterator<_OtherIter, _OtherStride>& __y) noexcept(
     noexcept(::cuda::std::declval<const _Iter&>() == ::cuda::std::declval<const _OtherIter&>()))
   {
-    return __x.__iter_ == __y.base();
+    return __x.__iter() == __y.base();
   }
 
 #if _CCCL_STD_VER <= 2017
@@ -290,7 +322,7 @@ public:
   operator!=(const strided_iterator& __x, const strided_iterator<_OtherIter, _OtherStride>& __y) noexcept(
     noexcept(::cuda::std::declval<const _Iter&>() == ::cuda::std::declval<const _OtherIter&>()))
   {
-    return __x.__iter_ != __y.base();
+    return __x.__iter() != __y.base();
   }
 #endif // _CCCL_STD_VER <= 2017
 
@@ -304,7 +336,7 @@ public:
   operator<=>(const strided_iterator& __x, const strided_iterator<_OtherIter, _OtherStride>& __y) noexcept(
     noexcept(::cuda::std::declval<const _Iter&>() <=> ::cuda::std::declval<const _OtherIter&>()))
   {
-    return __x.__iter_ <=> __y.base();
+    return __x.__iter() <=> __y.base();
   }
 #else // ^^^ _LIBCUDACXX_HAS_SPACESHIP_OPERATOR() ^^^ / vvv !_LIBCUDACXX_HAS_SPACESHIP_OPERATOR() vvv
 
@@ -316,7 +348,7 @@ public:
   operator<(const strided_iterator& __x, const strided_iterator<_OtherIter, _OtherStride>& __y) noexcept(
     noexcept(::cuda::std::declval<const _Iter&>() < ::cuda::std::declval<const _OtherIter&>()))
   {
-    return __x.__iter_ < __y.base();
+    return __x.__iter() < __y.base();
   }
 
   //! @brief Compares two @c strided_iterator's for greater than by comparing the stored iterators

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()
 };