[libc++][ranges][NFC] Move iterator classes out of `lazy_split_view` and `zip_view`.

[var-const]

Summary

This is part of the work to make it possible specialize traits types for
a view, like __segmented_iterator_traits.

[ldionne]

Do you know whether those are the last ones?

[philnik]

In D142521#4079004, @ldionne wrote:

Do you know whether those are the last ones?

They should be. I've listed the ones that didn't have the iterator outside the class a few weeks ago and these are the last ones.

[var-const]

There is a GCC failure on the CI that exposed two interesting issues:

1. (Found by @huixie90) Moving iterator classes out of the view class can lead to a noticeable difference in behavior. What was previously template parameters of the view (but not the iterator) becomes template parameters of the iterator. This can add more namespaces and associated classes via ADL when doing overload resolution for the iterator. A Godbolt demo from @huixie90: https://godbolt.org/z/sEzjnnEeK

2. There is a divergence in behavior between GCC on one side and Clang and MSVC on the other side (https://godbolt.org/z/bbxv75aE7):

template <class T>
concept Foo = requires(T val) {
  val == val;
};

template <class T>
struct Bar {};
template <class T>
bool operator==(const Bar<T>&, const Bar<T>&); // Overload 1

template <class T>
requires Foo<Bar<T>>
bool operator==(const Bar<T>&, int); // Overload 2

static_assert(Foo<Bar<int>>);

In this example, Clang and MSVC would not instantiate overload 2 of operator== when evaluating the Foo concept. GCC, on the other hand, instantiates overload 2 which leads to infinite recursion since overload 2 depends on Foo.

[var-const]

We ended up deciding to move iterators back into classes -- abandoning in favor of https://reviews.llvm.org/D143324.

libcxx/include/__ranges/lazy_split_view.h

 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
 namespace ranges {
 
 template <auto> struct __require_constant;
 
+template <bool, class, class> struct __lazy_split_view_outer_iterator;
+template <bool, class, class> struct __lazy_split_view_inner_iterator;
+
 template <class _Range>
 concept __tiny_range =
   sized_range<_Range> &&
   requires { typename __require_constant<remove_reference_t<_Range>::size()>; } &&
   (remove_reference_t<_Range>::size() <= 1);
 
 template <input_range _View, forward_range _Pattern>
   requires view<_View> && view<_Pattern> &&
            indirectly_comparable<iterator_t<_View>, iterator_t<_Pattern>, ranges::equal_to> &&
            (forward_range<_View> || __tiny_range<_Pattern>)
 class lazy_split_view : public view_interface<lazy_split_view<_View, _Pattern>> {
 
   _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
   _LIBCPP_NO_UNIQUE_ADDRESS _Pattern __pattern_ = _Pattern();
 
   using _MaybeCurrent = _If<!forward_range<_View>, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
   _LIBCPP_NO_UNIQUE_ADDRESS _MaybeCurrent __current_ = _MaybeCurrent();
 
-  template <bool> struct __outer_iterator;
-  template <bool> struct __inner_iterator;
+  template <bool, class, class> friend struct __lazy_split_view_outer_iterator;
+  template <bool, class, class> friend struct __lazy_split_view_inner_iterator;
+
+  template <bool _Const> using __outer_iterator = __lazy_split_view_outer_iterator<_Const, _View, _Pattern>;
+  template <bool _Const> using __inner_iterator = __lazy_split_view_inner_iterator<_Const, _View, _Pattern>;
 
 public:
   _LIBCPP_HIDE_FROM_ABI
   lazy_split_view()
     requires default_initializable<_View> && default_initializable<_Pattern> = default;
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr lazy_split_view(_View __base, _Pattern __pattern)
public:
   constexpr auto end() const {
     if constexpr (forward_range<_View> && forward_range<const _View> && common_range<const _View>) {
       return __outer_iterator<true>{*this, ranges::end(__base_)};
     } else {
       return default_sentinel;
     }
   }
 
-private:
+};
 
-  template <class>
-  struct __outer_iterator_category {};
+struct __lazy_split_view_outer_iterator_category {};
 
-  template <forward_range _Tp>
-  struct __outer_iterator_category<_Tp> {
-    using iterator_category = input_iterator_tag;
-  };
+struct __lazy_split_view_outer_iterator_category<_Tp> {
 
-  template <bool _Const>
-  struct __outer_iterator : __outer_iterator_category<__maybe_const<_Const, _View>> {
-  private:
-    template <bool>
-    friend struct __inner_iterator;
-    friend __outer_iterator<true>;
+template <bool _Const, class _View, class _Pattern>
+struct __lazy_split_view_outer_iterator : __lazy_split_view_outer_iterator_category<__maybe_const<_Const, _View>> {
+  template <bool, class, class>
+  friend struct __lazy_split_view_inner_iterator;
+  friend __lazy_split_view_outer_iterator<true, _View, _Pattern>;
 
-    using _Parent = __maybe_const<_Const, lazy_split_view>;
-    using _Base = __maybe_const<_Const, _View>;
+  using _Parent = __maybe_const<_Const, lazy_split_view<_View, _Pattern>>;
+  template <bool _OtherConst>
+  using __outer_iterator = __lazy_split_view_outer_iterator<_OtherConst, _View, _Pattern>;
+  template <bool _OtherConst>
+  using __inner_iterator = __lazy_split_view_inner_iterator<_OtherConst, _View, _Pattern>;
 
-    _Parent* __parent_ = nullptr;
-    using _MaybeCurrent = _If<forward_range<_View>, iterator_t<_Base>, __empty_cache>;
-    _LIBCPP_NO_UNIQUE_ADDRESS _MaybeCurrent __current_ = _MaybeCurrent();
-    bool __trailing_empty_ = false;
 
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto& __current() noexcept {
-      if constexpr (forward_range<_View>) {
-        return __current_;
-      } else {
-        return *__parent_->__current_;
-      }
-    }
 
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr const auto& __current() const noexcept {
-      if constexpr (forward_range<_View>) {
-        return __current_;
-      } else {
-        return *__parent_->__current_;
-      }
-    }
 
-    // Workaround for the GCC issue that doesn't allow calling `__parent_->__base_` from friend functions (because
-    // `__base_` is private).
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto& __parent_base() const noexcept {
-      return __parent_->__base_;
-    }
 
-  public:
-    // using iterator_category = inherited;
-    using iterator_concept = conditional_t<forward_range<_Base>, forward_iterator_tag, input_iterator_tag>;
-    using difference_type = range_difference_t<_Base>;
 
-    struct value_type : view_interface<value_type> {
-    private:
-      __outer_iterator __i_ = __outer_iterator();
+    __lazy_split_view_outer_iterator __i_ = __lazy_split_view_outer_iterator();
 
-    public:
-      _LIBCPP_HIDE_FROM_ABI
-      value_type() = default;
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr explicit value_type(__outer_iterator __i)
-        : __i_(std::move(__i)) {}
+    constexpr explicit value_type(__lazy_split_view_outer_iterator __i)
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __inner_iterator<_Const> begin() const { return __inner_iterator<_Const>{__i_}; }
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr default_sentinel_t end() const noexcept { return default_sentinel; }
-    };
+    constexpr __inner_iterator<_Const> begin() const {
+      return __inner_iterator<_Const>{__i_};
+    }
 
-    _LIBCPP_HIDE_FROM_ABI
-    __outer_iterator() = default;
+  __lazy_split_view_outer_iterator() = default;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit __outer_iterator(_Parent& __parent)
-      requires (!forward_range<_Base>)
-      : __parent_(std::addressof(__parent)) {}
+  constexpr explicit __lazy_split_view_outer_iterator(_Parent& __parent)
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __outer_iterator(_Parent& __parent, iterator_t<_Base> __current)
-      requires forward_range<_Base>
-      : __parent_(std::addressof(__parent)), __current_(std::move(__current)) {}
+  constexpr __lazy_split_view_outer_iterator(_Parent& __parent, iterator_t<_Base> __current)
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __outer_iterator(__outer_iterator<!_Const> __i)
-      requires _Const && convertible_to<iterator_t<_View>, iterator_t<_Base>>
-      : __parent_(__i.__parent_), __current_(std::move(__i.__current_)) {}
+  constexpr __lazy_split_view_outer_iterator(__outer_iterator<!_Const> __i)
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr value_type operator*() const { return value_type{*this}; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __outer_iterator& operator++() {
-      const auto __end = ranges::end(__parent_->__base_);
-      if (__current() == __end) {
-        __trailing_empty_ = false;
-        return *this;
-      }
+  constexpr __lazy_split_view_outer_iterator& operator++() {
 
-      const auto [__pbegin, __pend] = ranges::subrange{__parent_->__pattern_};
-      if (__pbegin == __pend) {
-        // Empty pattern: split on every element in the input range
-        ++__current();
 
-      } else if constexpr (__tiny_range<_Pattern>) {
-        // One-element pattern: we can use `ranges::find`.
-        __current() = ranges::find(std::move(__current()), __end, *__pbegin);
-        if (__current() != __end) {
-          // Make sure we point to after the separator we just found.
-          ++__current();
-          if (__current() == __end)
-            __trailing_empty_ = true;
-        }
 
-      } else {
-        // General case for n-element pattern.
-        do {
-          const auto [__b, __p] = ranges::mismatch(__current(), __end, __pbegin, __pend);
-          if (__p == __pend) {
-            __current() = __b;
-            if (__current() == __end) {
-              __trailing_empty_ = true;
-            }
-            break; // The pattern matched; skip it.
-          }
-        } while (++__current() != __end);
-      }
 
-      return *this;
-    }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr decltype(auto) operator++(int) {
-      if constexpr (forward_range<_Base>) {
-        auto __tmp = *this;
-        ++*this;
-        return __tmp;
 
-      } else {
-        ++*this;
-      }
-    }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(const __outer_iterator& __x, const __outer_iterator& __y)
-      requires forward_range<_Base> {
-      return __x.__current_ == __y.__current_ && __x.__trailing_empty_ == __y.__trailing_empty_;
-    }
+  friend constexpr bool operator==(const __lazy_split_view_outer_iterator& __x,
+                                   const __lazy_split_view_outer_iterator& __y)
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(const __outer_iterator& __x, default_sentinel_t) {
-      _LIBCPP_ASSERT(__x.__parent_, "Cannot call comparison on a default-constructed iterator.");
-      return __x.__current() == ranges::end(__x.__parent_base()) && !__x.__trailing_empty_;
-    }
-  };
+  friend constexpr bool operator==(const __lazy_split_view_outer_iterator& __x, default_sentinel_t) {
 
-  template <class>
-  struct __inner_iterator_category {};
+struct __lazy_split_view_inner_iterator_category {};
 
-  template <forward_range _Tp>
-  struct __inner_iterator_category<_Tp> {
-    using iterator_category = _If<
-      derived_from<typename iterator_traits<iterator_t<_Tp>>::iterator_category, forward_iterator_tag>,
-      forward_iterator_tag,
-      typename iterator_traits<iterator_t<_Tp>>::iterator_category
-    >;
-  };
+struct __lazy_split_view_inner_iterator_category<_Tp> {
 
-  template <bool _Const>
-  struct __inner_iterator : __inner_iterator_category<__maybe_const<_Const, _View>> {
-  private:
-    using _Base = __maybe_const<_Const, _View>;
-    // Workaround for a GCC issue.
-    static constexpr bool _OuterConst = _Const;
-    __outer_iterator<_Const> __i_ = __outer_iterator<_OuterConst>();
-    bool __incremented_ = false;
+template <bool _Const, class _View, class _Pattern>
+struct __lazy_split_view_inner_iterator : __lazy_split_view_inner_iterator_category<__maybe_const<_Const, _View>> {
+  template <bool _OtherConst>
+  using __outer_iterator = __lazy_split_view_outer_iterator<_Const, _View, _Pattern>;
 
-    // Note: these private functions are necessary because GCC doesn't allow calls to private members of `__i_` from
-    // free functions that are friends of `inner-iterator`.
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr bool __is_done() const {
-      _LIBCPP_ASSERT(__i_.__parent_, "Cannot call comparison on a default-constructed iterator.");
 
-      auto [__pcur, __pend] = ranges::subrange{__i_.__parent_->__pattern_};
-      auto __end = ranges::end(__i_.__parent_->__base_);
 
-      if constexpr (__tiny_range<_Pattern>) {
-        const auto& __cur = __i_.__current();
-        if (__cur == __end)
-          return true;
-        if (__pcur == __pend)
-          return __incremented_;
 
-        return *__cur == *__pcur;
 
-      } else {
-        auto __cur = __i_.__current();
-        if (__cur == __end)
-          return true;
-        if (__pcur == __pend)
-          return __incremented_;
 
-        do {
-          if (*__cur != *__pcur)
-            return false;
-          if (++__pcur == __pend)
-            return true;
-        } while (++__cur != __end);
 
-        return false;
-      }
-    }
 
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto& __outer_current() noexcept {
-      return __i_.__current();
-    }
 
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr const auto& __outer_current() const noexcept {
-      return __i_.__current();
-    }
 
-  public:
-    // using iterator_category = inherited;
-    using iterator_concept = typename __outer_iterator<_Const>::iterator_concept;
-    using value_type = range_value_t<_Base>;
-    using difference_type = range_difference_t<_Base>;
 
-    _LIBCPP_HIDE_FROM_ABI
-    __inner_iterator() = default;
+  __lazy_split_view_inner_iterator() = default;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit __inner_iterator(__outer_iterator<_Const> __i)
-      : __i_(std::move(__i)) {}
+  constexpr explicit __lazy_split_view_inner_iterator(__outer_iterator<_Const> __i)
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr const iterator_t<_Base>& base() const& noexcept { return __i_.__current(); }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr iterator_t<_Base> base() &&
-      requires forward_range<_View> { return std::move(__i_.__current()); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr decltype(auto) operator*() const { return *__i_.__current(); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __inner_iterator& operator++() {
-      __incremented_ = true;
+  constexpr __lazy_split_view_inner_iterator& operator++() {
 
-      if constexpr (!forward_range<_Base>) {
-        if constexpr (_Pattern::size() == 0) {
-          return *this;
-        }
-      }
 
-      ++__i_.__current();
-      return *this;
-    }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr decltype(auto) operator++(int) {
-      if constexpr (forward_range<_Base>) {
-        auto __tmp = *this;
-        ++*this;
-        return __tmp;
 
-      } else {
-        ++*this;
-      }
-    }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(const __inner_iterator& __x, const __inner_iterator& __y)
-      requires forward_range<_Base> {
-      return __x.__outer_current() == __y.__outer_current();
-    }
+  friend constexpr bool operator==(const __lazy_split_view_inner_iterator& __x,
+                                   const __lazy_split_view_inner_iterator& __y)
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(const __inner_iterator& __x, default_sentinel_t) {
-      return __x.__is_done();
-    }
+  friend constexpr bool operator==(const __lazy_split_view_inner_iterator& __x, default_sentinel_t) {
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr decltype(auto) iter_move(const __inner_iterator& __i)
-        noexcept(noexcept(ranges::iter_move(__i.__outer_current()))) {
-      return ranges::iter_move(__i.__outer_current());
-    }
+  friend constexpr decltype(auto) iter_move(const __lazy_split_view_inner_iterator& __i)
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr void iter_swap(const __inner_iterator& __x, const __inner_iterator& __y)
-        noexcept(noexcept(ranges::iter_swap(__x.__outer_current(), __y.__outer_current())))
-        requires indirectly_swappable<iterator_t<_Base>> {
-      ranges::iter_swap(__x.__outer_current(), __y.__outer_current());
-    }
-  };
+  friend constexpr void iter_swap(const __lazy_split_view_inner_iterator& __x,
+                                  const __lazy_split_view_inner_iterator& __y)
 
-};
-
 template <class _Range, class _Pattern>
 lazy_split_view(_Range&&, _Pattern&&) -> lazy_split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
 
 template <input_range _Range>
 lazy_split_view(_Range&&, range_value_t<_Range>)
   -> lazy_split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
 
 namespace views {

libcxx/include/__ranges/zip_view.h

 
 // abs in cstdlib is not constexpr
 // TODO : remove __abs once P0533R9 is implemented.
 template <class _Tp>
 _LIBCPP_HIDE_FROM_ABI constexpr _Tp __abs(_Tp __t) {
   return __t < 0 ? -__t : __t;
 }
 
+template <bool, class...> class __zip_view_iterator;
+template <bool, class...> class __zip_view_sentinel;
+
 template <input_range... _Views>
   requires(view<_Views> && ...) && (sizeof...(_Views) > 0)
 class zip_view : public view_interface<zip_view<_Views...>> {
 
   _LIBCPP_NO_UNIQUE_ADDRESS tuple<_Views...> __views_;
 
-  template <bool>
-  class __iterator;
+  template <bool _Const>
+  using __iterator = __zip_view_iterator<_Const, _Views...>;
 
-  template <bool>
-  class __sentinel;
+  template <bool _Const>
+  using __sentinel = __zip_view_sentinel<_Const, _Views...>;
 
 public:
   _LIBCPP_HIDE_FROM_ABI
   zip_view() = default;
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr explicit zip_view(_Views... __views) : __views_(std::move(__views)...) {}
 

 struct __zip_view_iterator_category_base {};
 
 template <bool _Const, class... _Views>
   requires __zip_all_forward<_Const, _Views...>
 struct __zip_view_iterator_category_base<_Const, _Views...> {
   using iterator_category = input_iterator_tag;
 };
 
-template <input_range... _Views>
-  requires(view<_Views> && ...) && (sizeof...(_Views) > 0)
-template <bool _Const>
-class zip_view<_Views...>::__iterator : public __zip_view_iterator_category_base<_Const, _Views...> {
+template <bool _Const, class... _Views>
+class __zip_view_iterator : public __zip_view_iterator_category_base<_Const, _Views...> {
 
   __tuple_or_pair<iterator_t<__maybe_const<_Const, _Views>>...> __current_;
 
   _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit __iterator(__tuple_or_pair<iterator_t<__maybe_const<_Const, _Views>>...> __current)
+  constexpr explicit __zip_view_iterator(__tuple_or_pair<iterator_t<__maybe_const<_Const, _Views>>...> __current)
       : __current_(std::move(__current)) {}
 
-  template <bool>
-  friend class zip_view<_Views...>::__iterator;
+  template <bool, class...>
+  friend class __zip_view_iterator;
 
-  template <bool>
-  friend class zip_view<_Views...>::__sentinel;
+  template <bool, class...>
+  friend class __zip_view_sentinel;
 
   friend class zip_view<_Views...>;
 
 public:
   using iterator_concept = decltype(__get_zip_view_iterator_tag<_Const, _Views...>());
   using value_type = __tuple_or_pair<range_value_t<__maybe_const<_Const, _Views>>...>;
   using difference_type = common_type_t<range_difference_t<__maybe_const<_Const, _Views>>...>;
 
   _LIBCPP_HIDE_FROM_ABI
-  __iterator() = default;
+  __zip_view_iterator() = default;
 
   _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator(__iterator<!_Const> __i)
+  constexpr __zip_view_iterator(__zip_view_iterator<!_Const, _Views...> __i)
     requires _Const && (convertible_to<iterator_t<_Views>, iterator_t<__maybe_const<_Const, _Views>>> && ...)
   : __current_(std::move(__i.__current_)) {}
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr auto operator*() const {
     return ranges::__tuple_transform([](auto& __i) -> decltype(auto) { return *__i; }, __current_);
   }
 
   _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator++() {
+  constexpr __zip_view_iterator& operator++() {
     ranges::__tuple_for_each([](auto& __i) { ++__i; }, __current_);
     return *this;
   }
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr void operator++(int) { ++*this; }
 
   _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator operator++(int)
+  constexpr __zip_view_iterator operator++(int)
     requires __zip_all_forward<_Const, _Views...> {
     auto __tmp = *this;
     ++*this;
     return __tmp;
   }
 
   _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator--()
+  constexpr __zip_view_iterator& operator--()
     requires __zip_all_bidirectional<_Const, _Views...> {
     ranges::__tuple_for_each([](auto& __i) { --__i; }, __current_);
     return *this;
   }
 
   _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator operator--(int)
+  constexpr __zip_view_iterator operator--(int)
     requires __zip_all_bidirectional<_Const, _Views...> {
     auto __tmp = *this;
     --*this;
     return __tmp;
   }
 
   _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator+=(difference_type __x)
+  constexpr __zip_view_iterator& operator+=(difference_type __x)
     requires __zip_all_random_access<_Const, _Views...> {
     ranges::__tuple_for_each([&]<class _Iter>(_Iter& __i) { __i += iter_difference_t<_Iter>(__x); }, __current_);
     return *this;
   }
 
   _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator-=(difference_type __x)
+  constexpr __zip_view_iterator& operator-=(difference_type __x)
     requires __zip_all_random_access<_Const, _Views...> {
     ranges::__tuple_for_each([&]<class _Iter>(_Iter& __i) { __i -= iter_difference_t<_Iter>(__x); }, __current_);
     return *this;
   }
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr auto operator[](difference_type __n) const
     requires __zip_all_random_access<_Const, _Views...> {
     return ranges::__tuple_transform(
         [&]<class _Iter>(_Iter& __i) -> decltype(auto) { return __i[iter_difference_t<_Iter>(__n)]; }, __current_);
   }
 
   _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
+  friend constexpr bool operator==(const __zip_view_iterator& __x, const __zip_view_iterator& __y)
     requires(equality_comparable<iterator_t<__maybe_const<_Const, _Views>>> && ...) {
     if constexpr (__zip_all_bidirectional<_Const, _Views...>) {
       return __x.__current_ == __y.__current_;
     } else {
       return ranges::__tuple_any_equals(__x.__current_, __y.__current_);
     }
   }
 
   _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
+  friend constexpr bool operator<(const __zip_view_iterator& __x, const __zip_view_iterator& __y)
     requires __zip_all_random_access<_Const, _Views...> {
     return __x.__current_ < __y.__current_;
   }
 
   _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
+  friend constexpr bool operator>(const __zip_view_iterator& __x, const __zip_view_iterator& __y)
     requires __zip_all_random_access<_Const, _Views...> {
     return __y < __x;
   }
 
   _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
+  friend constexpr bool operator<=(const __zip_view_iterator& __x, const __zip_view_iterator& __y)
     requires __zip_all_random_access<_Const, _Views...> {
     return !(__y < __x);
   }
 
   _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
+  friend constexpr bool operator>=(const __zip_view_iterator& __x, const __zip_view_iterator& __y)
     requires __zip_all_random_access<_Const, _Views...> {
     return !(__x < __y);
   }
 
   _LIBCPP_HIDE_FROM_ABI
-  friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
+  friend constexpr auto operator<=>(const __zip_view_iterator& __x, const __zip_view_iterator& __y)
     requires __zip_all_random_access<_Const, _Views...> &&
              (three_way_comparable<iterator_t<__maybe_const<_Const, _Views>>> && ...) {
     return __x.__current_ <=> __y.__current_;
   }
 
   _LIBCPP_HIDE_FROM_ABI
-  friend constexpr __iterator operator+(const __iterator& __i, difference_type __n)
+  friend constexpr __zip_view_iterator operator+(const __zip_view_iterator& __i, difference_type __n)
     requires __zip_all_random_access<_Const, _Views...> {
     auto __r = __i;
     __r += __n;
     return __r;
   }
 
   _LIBCPP_HIDE_FROM_ABI
-  friend constexpr __iterator operator+(difference_type __n, const __iterator& __i)
+  friend constexpr __zip_view_iterator operator+(difference_type __n, const __zip_view_iterator& __i)
     requires __zip_all_random_access<_Const, _Views...> {
     return __i + __n;
   }
 
   _LIBCPP_HIDE_FROM_ABI
-  friend constexpr __iterator operator-(const __iterator& __i, difference_type __n)
+  friend constexpr __zip_view_iterator operator-(const __zip_view_iterator& __i, difference_type __n)
     requires __zip_all_random_access<_Const, _Views...> {
     auto __r = __i;
     __r -= __n;
     return __r;
   }
 
   _LIBCPP_HIDE_FROM_ABI
-  friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
+  friend constexpr difference_type operator-(const __zip_view_iterator& __x, const __zip_view_iterator& __y)
     requires(sized_sentinel_for<iterator_t<__maybe_const<_Const, _Views>>, iterator_t<__maybe_const<_Const, _Views>>> &&
              ...) {
     const auto __diffs = ranges::__tuple_zip_transform(minus<>(), __x.__current_, __y.__current_);
     return std::apply(
         [](auto... __ds) {
           return ranges::min({difference_type(__ds)...},
                              [](auto __a, auto __b) { return ranges::__abs(__a) < ranges::__abs(__b); });
         },
         __diffs);
   }
 
   _LIBCPP_HIDE_FROM_ABI
-  friend constexpr auto iter_move(const __iterator& __i) noexcept(
+  friend constexpr auto iter_move(const __zip_view_iterator& __i) noexcept(
       (noexcept(ranges::iter_move(std::declval<const iterator_t<__maybe_const<_Const, _Views>>&>())) && ...) &&
       (is_nothrow_move_constructible_v<range_rvalue_reference_t<__maybe_const<_Const, _Views>>> && ...)) {
     return ranges::__tuple_transform(ranges::iter_move, __i.__current_);
   }
 
   _LIBCPP_HIDE_FROM_ABI
-  friend constexpr void iter_swap(const __iterator& __l, const __iterator& __r) noexcept(
+  friend constexpr void iter_swap(const __zip_view_iterator& __l, const __zip_view_iterator& __r) noexcept(
       (noexcept(ranges::iter_swap(std::declval<const iterator_t<__maybe_const<_Const, _Views>>&>(),
                                   std::declval<const iterator_t<__maybe_const<_Const, _Views>>&>())) &&
        ...))
     requires(indirectly_swappable<iterator_t<__maybe_const<_Const, _Views>>> && ...) {
     ranges::__tuple_zip_for_each(ranges::iter_swap, __l.__current_, __r.__current_);
   }
 };
 
-template <input_range... _Views>
-  requires(view<_Views> && ...) && (sizeof...(_Views) > 0)
-template <bool _Const>
-class zip_view<_Views...>::__sentinel {
+template <bool _Const, class... _Views>
+class __zip_view_sentinel {
 
   __tuple_or_pair<sentinel_t<__maybe_const<_Const, _Views>>...> __end_;
 
   _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit __sentinel(__tuple_or_pair<sentinel_t<__maybe_const<_Const, _Views>>...> __end) : __end_(__end) {}
+  constexpr explicit __zip_view_sentinel(__tuple_or_pair<sentinel_t<__maybe_const<_Const, _Views>>...> __end)
+    : __end_(__end) {}
 
   friend class zip_view<_Views...>;
+  template <bool, class...>
+  friend class __zip_view_sentinel;
+
+  template <bool _OtherConst>
+  using __iterator = __zip_view_iterator<_OtherConst, _Views...>;
 
   // hidden friend cannot access private member of iterator because they are friends of friends
   template <bool _OtherConst>
   _LIBCPP_HIDE_FROM_ABI static constexpr decltype(auto)
-  __iter_current(zip_view<_Views...>::__iterator<_OtherConst> const& __it) {
+  __iter_current(__iterator<_OtherConst> const& __it) {
     return (__it.__current_);
   }
 
 public:
   _LIBCPP_HIDE_FROM_ABI
-  __sentinel() = default;
+  __zip_view_sentinel() = default;
 
   _LIBCPP_HIDE_FROM_ABI
-  constexpr __sentinel(__sentinel<!_Const> __i)
+  constexpr __zip_view_sentinel(__zip_view_sentinel<!_Const, _Views...> __i)
     requires _Const && (convertible_to<sentinel_t<_Views>, sentinel_t<__maybe_const<_Const, _Views>>> && ...)
   : __end_(std::move(__i.__end_)) {}
 
   template <bool _OtherConst>
     requires(sentinel_for<sentinel_t<__maybe_const<_Const, _Views>>, iterator_t<__maybe_const<_OtherConst, _Views>>> &&
              ...)
-  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator<_OtherConst>& __x,
+                                                         const __zip_view_sentinel& __y) {
     return ranges::__tuple_any_equals(__iter_current(__x), __y.__end_);
   }
 
   template <bool _OtherConst>
     requires(
         sized_sentinel_for<sentinel_t<__maybe_const<_Const, _Views>>, iterator_t<__maybe_const<_OtherConst, _Views>>> &&
         ...)
   _LIBCPP_HIDE_FROM_ABI friend constexpr common_type_t<range_difference_t<__maybe_const<_OtherConst, _Views>>...>
-  operator-(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+  operator-(const __iterator<_OtherConst>& __x, const __zip_view_sentinel& __y) {
     const auto __diffs = ranges::__tuple_zip_transform(minus<>(), __iter_current(__x), __y.__end_);
     return std::apply(
         [](auto... __ds) {
           using _Diff = common_type_t<range_difference_t<__maybe_const<_OtherConst, _Views>>...>;
           return ranges::min({_Diff(__ds)...},
                              [](auto __a, auto __b) { return ranges::__abs(__a) < ranges::__abs(__b); });
         },
         __diffs);
   }
 
   template <bool _OtherConst>
     requires(
         sized_sentinel_for<sentinel_t<__maybe_const<_Const, _Views>>, iterator_t<__maybe_const<_OtherConst, _Views>>> &&
         ...)
   _LIBCPP_HIDE_FROM_ABI friend constexpr common_type_t<range_difference_t<__maybe_const<_OtherConst, _Views>>...>
-  operator-(const __sentinel& __y, const __iterator<_OtherConst>& __x) {
+  operator-(const __zip_view_sentinel& __y, const __iterator<_OtherConst>& __x) {
     return -(__x - __y);
   }
 };
 
 template <class... _Views>
 inline constexpr bool enable_borrowed_range<zip_view<_Views...>> = (enable_borrowed_range<_Views> && ...);
 
 namespace views {