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

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

@@ -23,6 +23,7 @@
 
 #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/is_nothrow_copy_constructible.h>
 #include <cuda/std/__type_traits/is_nothrow_move_constructible.h>
@@ -64,8 +65,28 @@ class constant_iterator
 private:
   static_assert(::cuda::std::__integer_like<_Index>, "The index type of cuda::constant_iterator must be integer-like!");
 
-  ::cuda::std::ranges::__movable_box<_Tp> __value_{::cuda::std::in_place};
-  _Index __index_ = 0;
+  // Not a base because then the friend operators would be ambiguous
+  ::cuda::std::__compressed_movable_box<_Index, _Tp> __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 _Tp& __value() noexcept
+  {
+    return __store_.template __get<1>();
+  }
+
+  [[nodiscard]] _CCCL_API constexpr const _Tp& __value() const noexcept
+  {
+    return __store_.template __get<1>();
+  }
 
 public:
   using iterator_concept  = ::cuda::std::random_access_iterator_tag;
@@ -78,22 +99,17 @@ public:
   using reference = _Tp;
   using pointer   = void;
 
-#if _CCCL_HAS_CONCEPTS()
-  _CCCL_HIDE_FROM_ABI constant_iterator()
-    requires ::cuda::std::default_initializable<_Tp>
-  = default;
-#else // ^^^ _CCCL_HAS_CONCEPTS() ^^^ / vvv !_CCCL_HAS_CONCEPTS() vvv
   _CCCL_TEMPLATE(class _Tp2 = _Tp)
   _CCCL_REQUIRES(::cuda::std::default_initializable<_Tp2>)
-  _CCCL_API constexpr constant_iterator() noexcept(::cuda::std::is_nothrow_default_constructible_v<_Tp2>) {}
-#endif // !_CCCL_HAS_CONCEPTS()
+  _CCCL_API constexpr constant_iterator() noexcept(::cuda::std::is_nothrow_default_constructible_v<_Tp2>)
+      : __store_()
+  {}
 
   //! @brief Creates a @c constant_iterator from a value. The index is set to zero
   //! @param __value The value to store in the @c constant_iterator
   _CCCL_EXEC_CHECK_DISABLE
   _CCCL_API constexpr constant_iterator(_Tp __value) noexcept(::cuda::std::is_nothrow_move_constructible_v<_Tp>)
-      : __value_(::cuda::std::in_place, ::cuda::std::move(__value))
-      , __index_()
+      : __store_(0, ::cuda::std::move(__value))
   {}
 
   //! @brief Creates @c constant_iterator from a value and an index
@@ -104,32 +120,31 @@ public:
   _CCCL_REQUIRES(::cuda::std::__integer_like<_Index2>)
   _CCCL_API constexpr explicit constant_iterator(_Tp __value, _Index2 __index) noexcept(
     ::cuda::std::is_nothrow_move_constructible_v<_Tp>)
-      : __value_(::cuda::std::in_place, ::cuda::std::move(__value))
-      , __index_(static_cast<_Index>(__index))
+      : __store_(static_cast<_Index>(__index), ::cuda::std::move(__value))
   {}
 
   //! @brief Returns a the current index
   [[nodiscard]] _CCCL_API constexpr difference_type index() const noexcept
   {
-    return static_cast<difference_type>(__index_);
+    return static_cast<difference_type>(__index());
   }
 
   //! @brief Returns a const reference to the stored value
   [[nodiscard]] _CCCL_API constexpr const _Tp& operator*() const noexcept
   {
-    return *__value_;
+    return __value();
   }
 
   //! @brief Returns a const reference to the stored value
   [[nodiscard]] _CCCL_API constexpr const _Tp& operator[](difference_type) const noexcept
   {
-    return *__value_;
+    return __value();
   }
 
   //! @brief Increments the stored index
   _CCCL_API constexpr constant_iterator& operator++() noexcept
   {
-    ++__index_;
+    ++__index();
     return *this;
   }
 
@@ -147,9 +162,9 @@ public:
   {
     if constexpr (::cuda::std::is_signed_v<_Index>)
     {
-      _CCCL_ASSERT(__index_ > 0, "The index must be greater than or equal to 0");
+      _CCCL_ASSERT(__index() > 0, "The index must be greater than or equal to 0");
     }
-    --__index_;
+    --__index();
     return *this;
   }
 
@@ -168,9 +183,9 @@ public:
   {
     if constexpr (::cuda::std::is_signed_v<_Index>)
     {
-      _CCCL_ASSERT(__index_ + __n >= 0, "The index must be greater than or equal to 0");
+      _CCCL_ASSERT(__index() + __n >= 0, "The index must be greater than or equal to 0");
     }
-    __index_ += static_cast<_Index>(__n);
+    __index() += static_cast<_Index>(__n);
     return *this;
   }
 
@@ -200,9 +215,9 @@ public:
   {
     if constexpr (::cuda::std::is_signed_v<_Index>)
     {
-      _CCCL_ASSERT(__index_ - __n >= 0, "The index must be greater than or equal to 0");
+      _CCCL_ASSERT(__index() - __n >= 0, "The index must be greater than or equal to 0");
     }
-    __index_ -= static_cast<_Index>(__n);
+    __index() -= static_cast<_Index>(__n);
     return *this;
   }
 
@@ -220,14 +235,14 @@ public:
   [[nodiscard]] _CCCL_API friend constexpr difference_type
   operator-(const constant_iterator& __lhs, const constant_iterator& __rhs) noexcept
   {
-    return static_cast<difference_type>(__lhs.__index_) - static_cast<difference_type>(__rhs.__index_);
+    return static_cast<difference_type>(__lhs.__index()) - static_cast<difference_type>(__rhs.__index());
   }
 
   //! @brief Compares two @c constant_iterator for equality by comparing the index in the sequence
   [[nodiscard]] _CCCL_API friend constexpr bool
   operator==(const constant_iterator& __lhs, const constant_iterator& __rhs) noexcept
   {
-    return __lhs.__index_ == __rhs.__index_;
+    return __lhs.__index() == __rhs.__index();
   }
 
 #if _CCCL_STD_VER <= 2017
@@ -235,7 +250,7 @@ public:
   [[nodiscard]] _CCCL_API friend constexpr bool
   operator!=(const constant_iterator& __lhs, const constant_iterator& __rhs) noexcept
   {
-    return __lhs.__index_ != __rhs.__index_;
+    return __lhs.__index() != __rhs.__index();
   }
 #endif // _CCCL_STD_VER <= 2017
 
@@ -244,32 +259,32 @@ public:
   [[nodiscard]] _CCCL_API friend constexpr auto
   operator<=>(const constant_iterator& __lhs, const constant_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 constant_iterator for less than by comparing the index in the sequence
   [[nodiscard]] _CCCL_API friend constexpr bool
   operator<(const constant_iterator& __lhs, const constant_iterator& __rhs) noexcept
   {
-    return __lhs.__index_ < __rhs.__index_;
+    return __lhs.__index() < __rhs.__index();
   }
   //! @brief Compares two @c constant_iterator for less equal by comparing the index in the sequence
   [[nodiscard]] _CCCL_API friend constexpr bool
   operator<=(const constant_iterator& __lhs, const constant_iterator& __rhs) noexcept
   {
-    return __lhs.__index_ <= __rhs.__index_;
+    return __lhs.__index() <= __rhs.__index();
   }
   //! @brief Compares two @c constant_iterator for greater than by comparing the index in the sequence
   [[nodiscard]] _CCCL_API friend constexpr bool
   operator>(const constant_iterator& __lhs, const constant_iterator& __rhs) noexcept
   {
-    return __lhs.__index_ > __rhs.__index_;
+    return __lhs.__index() > __rhs.__index();
   }
   //! @brief Compares two @c constant_iterator for greater equal by comparing the index in the sequence
   [[nodiscard]] _CCCL_API friend constexpr bool
   operator>=(const constant_iterator& __lhs, const constant_iterator& __rhs) noexcept
   {
-    return __lhs.__index_ >= __rhs.__index_;
+    return __lhs.__index() >= __rhs.__index();
   }
 #endif // !_LIBCUDACXX_HAS_NO_SPACESHIP_OPERATOR()
 };

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