// <ranges> -*- C++ -*-
-// Copyright (C) 2019-2021 Free Software Foundation, Inc.
+// Copyright (C) 2019-2022 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#include <initializer_list>
#include <iterator>
#include <optional>
+#include <span>
#include <tuple>
#include <bits/ranges_util.h>
#include <bits/refwrap.h>
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3477. Simplify constraints for semiregular-box
- __box&
+ // 3572. copyable-box should be fully constexpr
+ constexpr __box&
operator=(const __box& __that)
noexcept(is_nothrow_copy_constructible_v<_Tp>)
requires (!copyable<_Tp>)
return *this;
}
- __box&
+ constexpr __box&
operator=(__box&& __that)
noexcept(is_nothrow_move_constructible_v<_Tp>)
requires (!movable<_Tp>)
friend constexpr _Iterator
operator+(_Iterator __i, difference_type __n)
requires __detail::__advanceable<_Winc>
- { return __i += __n; }
+ {
+ __i += __n;
+ return __i;
+ }
friend constexpr _Iterator
operator+(difference_type __n, _Iterator __i)
friend constexpr _Iterator
operator-(_Iterator __i, difference_type __n)
requires __detail::__advanceable<_Winc>
- { return __i -= __n; }
+ {
+ __i -= __n;
+ return __i;
+ }
friend constexpr difference_type
operator-(const _Iterator& __x, const _Iterator& __y)
private:
_Winc _M_value = _Winc();
+ friend iota_view;
friend _Sentinel;
};
operator-(const _Sentinel& __x, const _Iterator& __y)
requires sized_sentinel_for<_Bound, _Winc>
{ return __x._M_distance_from(__y); }
+
+ friend iota_view;
};
_Winc _M_value = _Winc();
__glibcxx_assert( bool(__value <= __bound) );
}
+ constexpr
+ iota_view(_Iterator __first, _Iterator __last)
+ requires same_as<_Winc, _Bound>
+ : iota_view(__first._M_value, __last._M_value)
+ { }
+
+ constexpr
+ iota_view(_Iterator __first, unreachable_sentinel_t __last)
+ requires same_as<_Bound, unreachable_sentinel_t>
+ : iota_view(__first._M_value, __last)
+ { }
+
+ constexpr
+ iota_view(_Iterator __first, _Sentinel __last)
+ requires (!same_as<_Winc, _Bound>) && (!same_as<_Bound, unreachable_sentinel_t>)
+ : iota_view(__first._M_value, __last._M_bound)
+ { }
+
constexpr _Iterator
begin() const { return _Iterator{_M_value}; }
struct _Single
{
template<typename _Tp>
+ [[nodiscard]]
constexpr auto
operator()(_Tp&& __e) const
noexcept(noexcept(single_view<decay_t<_Tp>>(std::forward<_Tp>(__e))))
struct _Iota
{
template<typename _Tp>
+ [[nodiscard]]
constexpr auto
operator()(_Tp&& __e) const
{ return iota_view(std::forward<_Tp>(__e)); }
template<typename _Tp, typename _Up>
+ [[nodiscard]]
constexpr auto
operator()(_Tp&& __e, _Up&& __f) const
{ return iota_view(std::forward<_Tp>(__e), std::forward<_Up>(__f)); }
= requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
} // namespace __detail
- template<movable _Val, typename _CharT, typename _Traits>
+ template<movable _Val, typename _CharT,
+ typename _Traits = char_traits<_CharT>>
requires default_initializable<_Val>
&& __detail::__stream_extractable<_Val, _CharT, _Traits>
class basic_istream_view
private:
basic_istream<_CharT, _Traits>* _M_stream;
- _Val _M_object;
+ _Val _M_object = _Val();
struct _Iterator
{
friend _Iterator;
};
- template<typename _Val, typename _CharT, typename _Traits>
- basic_istream_view<_Val, _CharT, _Traits>
- istream_view(basic_istream<_CharT, _Traits>& __s)
- { return basic_istream_view<_Val, _CharT, _Traits>{__s}; }
+ template<typename _Val>
+ using istream_view = basic_istream_view<_Val, char>;
+
+ template<typename _Val>
+ using wistream_view = basic_istream_view<_Val, wchar_t>;
+
+namespace views
+{
+ template<typename _Tp>
+ struct _Istream
+ {
+ template<typename _CharT, typename _Traits>
+ [[nodiscard]]
+ constexpr auto
+ operator()(basic_istream<_CharT, _Traits>& __e) const
+ { return basic_istream_view<_Tp, _CharT, _Traits>(__e); }
+ };
+
+ template<typename _Tp>
+ inline constexpr _Istream<_Tp> istream;
+}
// C++20 24.7 [range.adaptors] Range adaptors
// Data members using this alias should use [[no_unique_address]] so that
// they take no space when not needed.
template<bool _Present, typename _Tp>
- using __maybe_present_t = conditional_t<_Present, _Tp, _Empty>;
+ using __maybe_present_t = __conditional_t<_Present, _Tp, _Empty>;
// Alias for a type that is conditionally const.
template<bool _Const, typename _Tp>
- using __maybe_const_t = conditional_t<_Const, const _Tp, _Tp>;
+ using __maybe_const_t = __conditional_t<_Const, const _Tp, _Tp>;
} // namespace __detail
static void _S_fun(_Range&&) = delete;
public:
- template<__detail::__not_same_as<ref_view> _Tp>
+ template<__detail::__different_from<ref_view> _Tp>
requires convertible_to<_Tp, _Range&>
&& requires { _S_fun(declval<_Tp>()); }
constexpr
template<typename _Tp>
inline constexpr bool enable_borrowed_range<ref_view<_Tp>> = true;
+ template<range _Range>
+ requires movable<_Range>
+ && (!__detail::__is_initializer_list<remove_cv_t<_Range>>)
+ class owning_view : public view_interface<owning_view<_Range>>
+ {
+ private:
+ _Range _M_r = _Range();
+
+ public:
+ owning_view() requires default_initializable<_Range> = default;
+
+ constexpr
+ owning_view(_Range&& __t)
+ noexcept(is_nothrow_move_constructible_v<_Range>)
+ : _M_r(std::move(__t))
+ { }
+
+ owning_view(owning_view&&) = default;
+ owning_view& operator=(owning_view&&) = default;
+
+ constexpr _Range&
+ base() & noexcept
+ { return _M_r; }
+
+ constexpr const _Range&
+ base() const& noexcept
+ { return _M_r; }
+
+ constexpr _Range&&
+ base() && noexcept
+ { return std::move(_M_r); }
+
+ constexpr const _Range&&
+ base() const&& noexcept
+ { return std::move(_M_r); }
+
+ constexpr iterator_t<_Range>
+ begin()
+ { return ranges::begin(_M_r); }
+
+ constexpr sentinel_t<_Range>
+ end()
+ { return ranges::end(_M_r); }
+
+ constexpr auto
+ begin() const requires range<const _Range>
+ { return ranges::begin(_M_r); }
+
+ constexpr auto
+ end() const requires range<const _Range>
+ { return ranges::end(_M_r); }
+
+ constexpr bool
+ empty() requires requires { ranges::empty(_M_r); }
+ { return ranges::empty(_M_r); }
+
+ constexpr bool
+ empty() const requires requires { ranges::empty(_M_r); }
+ { return ranges::empty(_M_r); }
+
+ constexpr auto
+ size() requires sized_range<_Range>
+ { return ranges::size(_M_r); }
+
+ constexpr auto
+ size() const requires sized_range<const _Range>
+ { return ranges::size(_M_r); }
+
+ constexpr auto
+ data() requires contiguous_range<_Range>
+ { return ranges::data(_M_r); }
+
+ constexpr auto
+ data() const requires contiguous_range<const _Range>
+ { return ranges::data(_M_r); }
+ };
+
+ template<typename _Tp>
+ inline constexpr bool enable_borrowed_range<owning_view<_Tp>>
+ = enable_borrowed_range<_Tp>;
+
namespace views
{
namespace __detail
concept __can_ref_view = requires { ref_view{std::declval<_Range>()}; };
template<typename _Range>
- concept __can_subrange = requires { subrange{std::declval<_Range>()}; };
+ concept __can_owning_view = requires { owning_view{std::declval<_Range>()}; };
} // namespace __detail
struct _All : __adaptor::_RangeAdaptorClosure
else if constexpr (__detail::__can_ref_view<_Range>)
return true;
else
- return noexcept(subrange{std::declval<_Range>()});
+ return noexcept(owning_view{std::declval<_Range>()});
}
template<viewable_range _Range>
requires view<decay_t<_Range>>
|| __detail::__can_ref_view<_Range>
- || __detail::__can_subrange<_Range>
+ || __detail::__can_owning_view<_Range>
constexpr auto
- operator()(_Range&& __r) const
+ operator() [[nodiscard]] (_Range&& __r) const
noexcept(_S_noexcept<_Range>())
{
if constexpr (view<decay_t<_Range>>)
else if constexpr (__detail::__can_ref_view<_Range>)
return ref_view{std::forward<_Range>(__r)};
else
- return subrange{std::forward<_Range>(__r)};
+ return owning_view{std::forward<_Range>(__r)};
}
static constexpr bool _S_has_simple_call_op = true;
template<typename _Tp>
requires is_object_v<_Tp>
- struct __non_propagating_cache<_Tp> : protected _Optional_base<_Tp>
+ struct __non_propagating_cache<_Tp>
+ : protected _Optional_base<_Tp>
{
__non_propagating_cache() = default;
operator=(_Tp __val)
{
this->_M_reset();
- std::construct_at(std::__addressof(this->_M_payload._M_payload),
- std::in_place, std::move(__val));
- this->_M_payload._M_engaged = true;
+ this->_M_payload._M_construct(std::move(__val));
return *this;
}
+ constexpr explicit
+ operator bool() const noexcept
+ { return this->_M_is_engaged(); }
+
constexpr _Tp&
operator*() noexcept
{ return this->_M_get(); }
{ return this->_M_get(); }
template<typename _Iter>
- _Tp&
+ constexpr _Tp&
_M_emplace_deref(const _Iter& __i)
{
this->_M_reset();
- // Using _Optional_base::_M_construct to initialize from '*__i'
- // would incur an extra move due to the indirection, so we instead
- // use placement new directly.
- ::new ((void *) std::__addressof(this->_M_payload._M_payload)) _Tp(*__i);
- this->_M_payload._M_engaged = true;
+ auto __f = [] (auto& __x) { return *__x; };
+ this->_M_payload._M_apply(_Optional_func{__f}, __i);
return this->_M_get();
}
};
_M_get(const _Range&) const
{
__glibcxx_assert(false);
- return {};
+ __builtin_unreachable();
}
constexpr void
{ return __y.__equal(__x); }
};
+ _Vp _M_base = _Vp();
[[no_unique_address]] __detail::__box<_Pred> _M_pred;
[[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
- _Vp _M_base = _Vp();
public:
filter_view() requires (default_initializable<_Vp>
constexpr
filter_view(_Vp __base, _Pred __pred)
- : _M_pred(std::move(__pred)), _M_base(std::move(__base))
+ : _M_base(std::move(__base)), _M_pred(std::move(__pred))
{ }
constexpr _Vp
template<viewable_range _Range, typename _Pred>
requires __detail::__can_filter_view<_Range, _Pred>
constexpr auto
- operator()(_Range&& __r, _Pred&& __p) const
+ operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
{
return filter_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
}
friend _Sentinel<!_Const>;
};
- [[no_unique_address]] __detail::__box<_Fp> _M_fun;
_Vp _M_base = _Vp();
+ [[no_unique_address]] __detail::__box<_Fp> _M_fun;
public:
transform_view() requires (default_initializable<_Vp>
constexpr
transform_view(_Vp __base, _Fp __fun)
- : _M_fun(std::move(__fun)), _M_base(std::move(__base))
+ : _M_base(std::move(__base)), _M_fun(std::move(__fun))
{ }
constexpr _Vp
template<viewable_range _Range, typename _Fp>
requires __detail::__can_transform_view<_Range, _Fp>
constexpr auto
- operator()(_Range&& __r, _Fp&& __f) const
+ operator() [[nodiscard]] (_Range&& __r, _Fp&& __f) const
{
return transform_view(std::forward<_Range>(__r), std::forward<_Fp>(__f));
}
friend _Sentinel<!_Const>;
};
- range_difference_t<_Vp> _M_count = 0;
_Vp _M_base = _Vp();
+ range_difference_t<_Vp> _M_count = 0;
public:
take_view() requires default_initializable<_Vp> = default;
constexpr
take_view(_Vp base, range_difference_t<_Vp> __count)
- : _M_count(std::move(__count)), _M_base(std::move(base))
+ : _M_base(std::move(base)), _M_count(std::move(__count))
{ }
constexpr _Vp
{
namespace __detail
{
- template<typename _Range, typename _Tp>
+ template<typename _Range>
+ inline constexpr bool __is_empty_view = false;
+
+ template<typename _Tp>
+ inline constexpr bool __is_empty_view<empty_view<_Tp>> = true;
+
+ template<typename _Range>
+ inline constexpr bool __is_basic_string_view = false;
+
+ template<typename _CharT, typename _Traits>
+ inline constexpr bool __is_basic_string_view<basic_string_view<_CharT, _Traits>>
+ = true;
+
+ template<typename _Range>
+ inline constexpr bool __is_subrange = false;
+
+ template<typename _Iter, typename _Sent, subrange_kind _Kind>
+ inline constexpr bool __is_subrange<subrange<_Iter, _Sent, _Kind>> = true;
+
+ template<typename _Range>
+ inline constexpr bool __is_iota_view = false;
+
+ template<typename _Winc, typename _Bound>
+ inline constexpr bool __is_iota_view<iota_view<_Winc, _Bound>> = true;
+
+ template<typename _Range, typename _Dp>
concept __can_take_view
- = requires { take_view(std::declval<_Range>(), std::declval<_Tp>()); };
+ = requires { take_view(std::declval<_Range>(), std::declval<_Dp>()); };
} // namespace __detail
struct _Take : __adaptor::_RangeAdaptor<_Take>
{
- template<viewable_range _Range, typename _Tp>
- requires __detail::__can_take_view<_Range, _Tp>
+ template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
+ requires __detail::__can_take_view<_Range, _Dp>
constexpr auto
- operator()(_Range&& __r, _Tp&& __n) const
+ operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
{
- return take_view(std::forward<_Range>(__r), std::forward<_Tp>(__n));
+ using _Tp = remove_cvref_t<_Range>;
+ if constexpr (__detail::__is_empty_view<_Tp>)
+ return _Tp();
+ else if constexpr (random_access_range<_Tp>
+ && sized_range<_Tp>
+ && (std::__detail::__is_span<_Tp>
+ || __detail::__is_basic_string_view<_Tp>
+ || __detail::__is_subrange<_Tp>
+ || __detail::__is_iota_view<_Tp>))
+ {
+ __n = std::min<_Dp>(ranges::distance(__r), __n);
+ auto __begin = ranges::begin(__r);
+ auto __end = __begin + __n;
+ if constexpr (std::__detail::__is_span<_Tp>)
+ return span<typename _Tp::element_type>(__begin, __end);
+ else if constexpr (__detail::__is_basic_string_view<_Tp>)
+ return _Tp(__begin, __end);
+ else if constexpr (__detail::__is_subrange<_Tp>)
+ return subrange<iterator_t<_Tp>>(__begin, __end);
+ else
+ return iota_view(*__begin, *__end);
+ }
+ else
+ return take_view(std::forward<_Range>(__r), __n);
}
using _RangeAdaptor<_Take>::operator();
friend _Sentinel<!_Const>;
};
- [[no_unique_address]] __detail::__box<_Pred> _M_pred;
_Vp _M_base = _Vp();
+ [[no_unique_address]] __detail::__box<_Pred> _M_pred;
public:
take_while_view() requires (default_initializable<_Vp>
constexpr
take_while_view(_Vp base, _Pred __pred)
- : _M_pred(std::move(__pred)), _M_base(std::move(base))
+ : _M_base(std::move(base)), _M_pred(std::move(__pred))
{ }
constexpr _Vp
template<viewable_range _Range, typename _Pred>
requires __detail::__can_take_while_view<_Range, _Pred>
constexpr auto
- operator()(_Range&& __r, _Pred&& __p) const
+ operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
{
return take_while_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
}
class drop_view : public view_interface<drop_view<_Vp>>
{
private:
- range_difference_t<_Vp> _M_count = 0;
_Vp _M_base = _Vp();
+ range_difference_t<_Vp> _M_count = 0;
// ranges::next(begin(base), count, end(base)) is O(1) if _Vp satisfies
// both random_access_range and sized_range. Otherwise, cache its result.
constexpr
drop_view(_Vp __base, range_difference_t<_Vp> __count)
- : _M_count(__count), _M_base(std::move(__base))
+ : _M_base(std::move(__base)), _M_count(__count)
{ __glibcxx_assert(__count >= 0); }
constexpr _Vp
{
namespace __detail
{
- template<typename _Range, typename _Tp>
+ template<typename _Range, typename _Dp>
concept __can_drop_view
- = requires { drop_view(std::declval<_Range>(), std::declval<_Tp>()); };
+ = requires { drop_view(std::declval<_Range>(), std::declval<_Dp>()); };
} // namespace __detail
struct _Drop : __adaptor::_RangeAdaptor<_Drop>
{
- template<viewable_range _Range, typename _Tp>
- requires __detail::__can_drop_view<_Range, _Tp>
+ template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
+ requires __detail::__can_drop_view<_Range, _Dp>
constexpr auto
- operator()(_Range&& __r, _Tp&& __n) const
+ operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
{
- return drop_view(std::forward<_Range>(__r), std::forward<_Tp>(__n));
+ using _Tp = remove_cvref_t<_Range>;
+ if constexpr (__detail::__is_empty_view<_Tp>)
+ return _Tp();
+ else if constexpr (random_access_range<_Tp>
+ && sized_range<_Tp>
+ && (std::__detail::__is_span<_Tp>
+ || __detail::__is_basic_string_view<_Tp>
+ || __detail::__is_iota_view<_Tp>
+ || __detail::__is_subrange<_Tp>))
+ {
+ __n = std::min<_Dp>(ranges::distance(__r), __n);
+ auto __begin = ranges::begin(__r) + __n;
+ auto __end = ranges::end(__r);
+ if constexpr (std::__detail::__is_span<_Tp>)
+ return span<typename _Tp::element_type>(__begin, __end);
+ else if constexpr (__detail::__is_subrange<_Tp>)
+ {
+ if constexpr (_Tp::_S_store_size)
+ {
+ using ranges::__detail::__to_unsigned_like;
+ auto __m = ranges::distance(__r) - __n;
+ return _Tp(__begin, __end, __to_unsigned_like(__m));
+ }
+ else
+ return _Tp(__begin, __end);
+ }
+ else
+ return _Tp(__begin, __end);
+ }
+ else
+ return drop_view(std::forward<_Range>(__r), __n);
}
using _RangeAdaptor<_Drop>::operator();
class drop_while_view : public view_interface<drop_while_view<_Vp, _Pred>>
{
private:
+ _Vp _M_base = _Vp();
[[no_unique_address]] __detail::__box<_Pred> _M_pred;
[[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
- _Vp _M_base = _Vp();
public:
drop_while_view() requires (default_initializable<_Vp>
constexpr
drop_while_view(_Vp __base, _Pred __pred)
- : _M_pred(std::move(__pred)), _M_base(std::move(__base))
+ : _M_base(std::move(__base)), _M_pred(std::move(__pred))
{ }
constexpr _Vp
template<viewable_range _Range, typename _Pred>
requires __detail::__can_drop_while_view<_Range, _Pred>
constexpr auto
- operator()(_Range&& __r, _Pred&& __p) const
+ operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
{
return drop_while_view(std::forward<_Range>(__r),
std::forward<_Pred>(__p));
using _OuterCat = typename iterator_traits<_Outer_iter>::iterator_category;
using _InnerCat = typename iterator_traits<_Inner_iter>::iterator_category;
if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
- && derived_from<_InnerCat, bidirectional_iterator_tag>)
+ && derived_from<_InnerCat, bidirectional_iterator_tag>
+ && common_range<range_reference_t<_Base<_Const>>>)
return bidirectional_iterator_tag{};
else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
&& derived_from<_InnerCat, forward_iterator_tag>)
{
if constexpr (_S_ref_is_glvalue
&& bidirectional_range<_Base>
- && bidirectional_range<range_reference_t<_Base>>)
+ && bidirectional_range<range_reference_t<_Base>>
+ && common_range<range_reference_t<_Base>>)
return bidirectional_iterator_tag{};
else if constexpr (_S_ref_is_glvalue
&& forward_range<_Base>
requires _Const
&& convertible_to<iterator_t<_Vp>, _Outer_iter>
&& convertible_to<iterator_t<_InnerRange>, _Inner_iter>
- : _M_outer(std::move(__i._M_outer)), _M_inner(__i._M_inner),
+ : _M_outer(std::move(__i._M_outer)), _M_inner(std::move(__i._M_inner)),
_M_parent(__i._M_parent)
{ }
friend _Sentinel<!_Const>;
};
+ _Vp _M_base = _Vp();
[[no_unique_address]]
__detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
- _Vp _M_base = _Vp();
public:
join_view() requires default_initializable<_Vp> = default;
template<viewable_range _Range>
requires __detail::__can_join_view<_Range>
constexpr auto
- operator()(_Range&& __r) const
+ operator() [[nodiscard]] (_Range&& __r) const
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3474. Nesting join_views is broken because of CTAD
&& (remove_reference_t<_Range>::size() <= 1);
template<typename _Base>
- struct __split_view_outer_iter_cat
+ struct __lazy_split_view_outer_iter_cat
{ };
template<forward_range _Base>
- struct __split_view_outer_iter_cat<_Base>
+ struct __lazy_split_view_outer_iter_cat<_Base>
{ using iterator_category = input_iterator_tag; };
template<typename _Base>
- struct __split_view_inner_iter_cat
+ struct __lazy_split_view_inner_iter_cat
{ };
template<forward_range _Base>
- struct __split_view_inner_iter_cat<_Base>
+ struct __lazy_split_view_inner_iter_cat<_Base>
{
private:
static constexpr auto
&& indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
ranges::equal_to>
&& (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
- class split_view : public view_interface<split_view<_Vp, _Pattern>>
+ class lazy_split_view : public view_interface<lazy_split_view<_Vp, _Pattern>>
{
private:
template<bool _Const>
template<bool _Const>
struct _OuterIter
- : __detail::__split_view_outer_iter_cat<_Base<_Const>>
+ : __detail::__lazy_split_view_outer_iter_cat<_Base<_Const>>
{
private:
- using _Parent = __detail::__maybe_const_t<_Const, split_view>;
- using _Base = split_view::_Base<_Const>;
+ using _Parent = __detail::__maybe_const_t<_Const, lazy_split_view>;
+ using _Base = lazy_split_view::_Base<_Const>;
constexpr bool
__at_end() const
- { return __current() == ranges::end(_M_parent->_M_base); }
+ { return __current() == ranges::end(_M_parent->_M_base) && !_M_trailing_empty; }
- // [range.split.outer] p1
+ // [range.lazy.split.outer] p1
// Many of the following specifications refer to the notional member
// current of outer-iterator. current is equivalent to current_ if
// V models forward_range, and parent_->current_ otherwise.
_Parent* _M_parent = nullptr;
- // XXX: _M_current is present only if "V models forward_range"
[[no_unique_address]]
__detail::__maybe_present_t<forward_range<_Vp>,
iterator_t<_Base>> _M_current;
+ bool _M_trailing_empty = false;
public:
- using iterator_concept = conditional_t<forward_range<_Base>,
- forward_iterator_tag,
- input_iterator_tag>;
- // iterator_category defined in __split_view_outer_iter_cat
+ using iterator_concept = __conditional_t<forward_range<_Base>,
+ forward_iterator_tag,
+ input_iterator_tag>;
+ // iterator_category defined in __lazy_split_view_outer_iter_cat
using difference_type = range_difference_t<_Base>;
struct value_type : view_interface<value_type>
{ return _InnerIter<_Const>{_M_i}; }
constexpr default_sentinel_t
- end() const
+ end() const noexcept
{ return default_sentinel; }
};
operator++()
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 3505. split_view::outer-iterator::operator++ misspecified
+ // 3505. lazy_split_view::outer-iterator::operator++ misspecified
const auto __end = ranges::end(_M_parent->_M_base);
if (__current() == __end)
- return *this;
+ {
+ _M_trailing_empty = false;
+ return *this;
+ }
const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
if (__pbegin == __pend)
++__current();
__current() = ranges::find(std::move(__current()), __end,
*__pbegin);
if (__current() != __end)
- ++__current();
+ {
+ ++__current();
+ if (__current() == __end)
+ _M_trailing_empty = true;
+ }
}
else
do
if (__p == __pend)
{
__current() = __b;
+ if (__current() == __end)
+ _M_trailing_empty = true;
break;
}
} while (++__current() != __end);
friend constexpr bool
operator==(const _OuterIter& __x, const _OuterIter& __y)
requires forward_range<_Base>
- { return __x._M_current == __y._M_current; }
+ {
+ return __x._M_current == __y._M_current
+ && __x._M_trailing_empty == __y._M_trailing_empty;
+ }
friend constexpr bool
operator==(const _OuterIter& __x, default_sentinel_t)
template<bool _Const>
struct _InnerIter
- : __detail::__split_view_inner_iter_cat<_Base<_Const>>
+ : __detail::__lazy_split_view_inner_iter_cat<_Base<_Const>>
{
private:
- using _Base = split_view::_Base<_Const>;
+ using _Base = lazy_split_view::_Base<_Const>;
constexpr bool
__at_end() const
public:
using iterator_concept
= typename _OuterIter<_Const>::iterator_concept;
- // iterator_category defined in __split_view_inner_iter_cat
+ // iterator_category defined in __lazy_split_view_inner_iter_cat
using value_type = range_value_t<_Base>;
using difference_type = range_difference_t<_Base>;
: _M_i(std::move(__i))
{ }
- constexpr iterator_t<_Base>
- base() const& requires copyable<iterator_t<_Base>>
+ constexpr const iterator_t<_Base>&
+ base() const& noexcept
{ return _M_i_current(); }
constexpr iterator_t<_Base>
- base() &&
+ base() && requires forward_range<_Vp>
{ return std::move(_M_i_current()); }
constexpr decltype(auto)
{ ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
};
+ _Vp _M_base = _Vp();
_Pattern _M_pattern = _Pattern();
- // XXX: _M_current is "present only if !forward_range<V>"
[[no_unique_address]]
__detail::__maybe_present_t<!forward_range<_Vp>,
__detail::__non_propagating_cache<iterator_t<_Vp>>> _M_current;
- _Vp _M_base = _Vp();
public:
- split_view() requires (default_initializable<_Vp>
- && default_initializable<_Pattern>)
+ lazy_split_view() requires (default_initializable<_Vp>
+ && default_initializable<_Pattern>)
= default;
constexpr
- split_view(_Vp __base, _Pattern __pattern)
- : _M_pattern(std::move(__pattern)), _M_base(std::move(__base))
+ lazy_split_view(_Vp __base, _Pattern __pattern)
+ : _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
{ }
template<input_range _Range>
requires constructible_from<_Vp, views::all_t<_Range>>
&& constructible_from<_Pattern, single_view<range_value_t<_Range>>>
constexpr
- split_view(_Range&& __r, range_value_t<_Range> __e)
- : _M_pattern(views::single(std::move(__e))),
- _M_base(views::all(std::forward<_Range>(__r)))
+ lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
+ : _M_base(views::all(std::forward<_Range>(__r))),
+ _M_pattern(views::single(std::move(__e)))
{ }
constexpr _Vp
begin()
{
if constexpr (forward_range<_Vp>)
- return _OuterIter<__detail::__simple_view<_Vp>>{
- this, ranges::begin(_M_base)};
+ {
+ constexpr bool __simple
+ = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
+ return _OuterIter<__simple>{this, ranges::begin(_M_base)};
+ }
else
{
_M_current = ranges::begin(_M_base);
constexpr auto
end() requires forward_range<_Vp> && common_range<_Vp>
{
- return _OuterIter<__detail::__simple_view<_Vp>>{
- this, ranges::end(_M_base)};
+ constexpr bool __simple
+ = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
+ return _OuterIter<__simple>{this, ranges::end(_M_base)};
}
constexpr auto
}
};
+ template<typename _Range, typename _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
+ {
+ namespace __detail
+ {
+ template<typename _Range, typename _Pattern>
+ concept __can_lazy_split_view
+ = requires { lazy_split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
+ } // namespace __detail
+
+ struct _LazySplit : __adaptor::_RangeAdaptor<_LazySplit>
+ {
+ template<viewable_range _Range, typename _Pattern>
+ requires __detail::__can_lazy_split_view<_Range, _Pattern>
+ constexpr auto
+ operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f) const
+ {
+ return lazy_split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
+ }
+
+ using _RangeAdaptor<_LazySplit>::operator();
+ static constexpr int _S_arity = 2;
+ // The pattern argument of views::lazy_split is not always simple -- it can be
+ // a non-view range, the value category of which affects whether the call
+ // is well-formed. But a scalar or a view pattern argument is surely
+ // simple.
+ template<typename _Pattern>
+ static constexpr bool _S_has_simple_extra_args
+ = is_scalar_v<_Pattern> || (view<_Pattern>
+ && copy_constructible<_Pattern>);
+ };
+
+ inline constexpr _LazySplit lazy_split;
+ } // namespace views
+
+ template<forward_range _Vp, forward_range _Pattern>
+ requires view<_Vp> && view<_Pattern>
+ && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
+ ranges::equal_to>
+ class split_view : public view_interface<split_view<_Vp, _Pattern>>
+ {
+ private:
+ _Vp _M_base = _Vp();
+ _Pattern _M_pattern = _Pattern();
+ __detail::__non_propagating_cache<subrange<iterator_t<_Vp>>> _M_cached_begin;
+
+ struct _Iterator;
+ struct _Sentinel;
+
+ public:
+ split_view() requires (default_initializable<_Vp>
+ && default_initializable<_Pattern>)
+ = default;
+
+ constexpr
+ split_view(_Vp __base, _Pattern __pattern)
+ : _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
+ { }
+
+ template<forward_range _Range>
+ requires constructible_from<_Vp, views::all_t<_Range>>
+ && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
+ constexpr
+ split_view(_Range&& __r, range_value_t<_Range> __e)
+ : _M_base(views::all(std::forward<_Range>(__r))),
+ _M_pattern(views::single(std::move(__e)))
+ { }
+
+ constexpr _Vp
+ base() const& requires copy_constructible<_Vp>
+ { return _M_base; }
+
+ constexpr _Vp
+ base() &&
+ { return std::move(_M_base); }
+
+ constexpr _Iterator
+ begin()
+ {
+ if (!_M_cached_begin)
+ _M_cached_begin = _M_find_next(ranges::begin(_M_base));
+ return {this, ranges::begin(_M_base), *_M_cached_begin};
+ }
+
+ constexpr auto
+ end()
+ {
+ if constexpr (common_range<_Vp>)
+ return _Iterator{this, ranges::end(_M_base), {}};
+ else
+ return _Sentinel{this};
+ }
+
+ constexpr subrange<iterator_t<_Vp>>
+ _M_find_next(iterator_t<_Vp> __it)
+ {
+ auto [__b, __e] = ranges::search(subrange(__it, ranges::end(_M_base)), _M_pattern);
+ if (__b != ranges::end(_M_base) && ranges::empty(_M_pattern))
+ {
+ ++__b;
+ ++__e;
+ }
+ return {__b, __e};
+ }
+
+ private:
+ struct _Iterator
+ {
+ private:
+ split_view* _M_parent = nullptr;
+ iterator_t<_Vp> _M_cur = iterator_t<_Vp>();
+ subrange<iterator_t<_Vp>> _M_next = subrange<iterator_t<_Vp>>();
+ bool _M_trailing_empty = false;
+
+ friend struct _Sentinel;
+
+ public:
+ using iterator_concept = forward_iterator_tag;
+ using iterator_category = input_iterator_tag;
+ using value_type = subrange<iterator_t<_Vp>>;
+ using difference_type = range_difference_t<_Vp>;
+
+ _Iterator() = default;
+
+ constexpr
+ _Iterator(split_view* __parent,
+ iterator_t<_Vp> __current,
+ subrange<iterator_t<_Vp>> __next)
+ : _M_parent(__parent),
+ _M_cur(std::move(__current)),
+ _M_next(std::move(__next))
+ { }
+
+ constexpr iterator_t<_Vp>
+ base() const
+ { return _M_cur; }
+
+ constexpr value_type
+ operator*() const
+ { return {_M_cur, _M_next.begin()}; }
+
+ constexpr _Iterator&
+ operator++()
+ {
+ _M_cur = _M_next.begin();
+ if (_M_cur != ranges::end(_M_parent->_M_base))
+ {
+ _M_cur = _M_next.end();
+ if (_M_cur == ranges::end(_M_parent->_M_base))
+ {
+ _M_trailing_empty = true;
+ _M_next = {_M_cur, _M_cur};
+ }
+ else
+ _M_next = _M_parent->_M_find_next(_M_cur);
+ }
+ else
+ _M_trailing_empty = false;
+ return *this;
+ }
+
+ constexpr _Iterator
+ operator++(int)
+ {
+ auto __tmp = *this;
+ ++*this;
+ return __tmp;
+ }
+
+ friend constexpr bool
+ operator==(const _Iterator& __x, const _Iterator& __y)
+ {
+ return __x._M_cur == __y._M_cur
+ && __x._M_trailing_empty == __y._M_trailing_empty;
+ }
+ };
+
+ struct _Sentinel
+ {
+ private:
+ sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
+
+ constexpr bool
+ _M_equal(const _Iterator& __x) const
+ { return __x._M_cur == _M_end && !__x._M_trailing_empty; }
+
+ public:
+ _Sentinel() = default;
+
+ constexpr explicit
+ _Sentinel(split_view* __parent)
+ : _M_end(ranges::end(__parent->_M_base))
+ { }
+
+ friend constexpr bool
+ operator==(const _Iterator& __x, const _Sentinel& __y)
+ { return __y._M_equal(__x); }
+ };
+ };
+
template<typename _Range, typename _Pattern>
split_view(_Range&&, _Pattern&&)
-> split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
- template<input_range _Range>
+ template<forward_range _Range>
split_view(_Range&&, range_value_t<_Range>)
-> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
template<viewable_range _Range, typename _Pattern>
requires __detail::__can_split_view<_Range, _Pattern>
constexpr auto
- operator()(_Range&& __r, _Pattern&& __f) const
+ operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f) const
{
return split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
}
using _RangeAdaptor<_Split>::operator();
static constexpr int _S_arity = 2;
- // The pattern argument of views::split is not always simple -- it can be
- // a non-view range, the value category of which affects whether the call
- // is well-formed. But a scalar or a view pattern argument is surely
- // simple.
template<typename _Pattern>
static constexpr bool _S_has_simple_extra_args
- = is_scalar_v<_Pattern> || (view<_Pattern>
- && copy_constructible<_Pattern>);
+ = _LazySplit::_S_has_simple_extra_args<_Pattern>;
};
inline constexpr _Split split;
{
template<input_or_output_iterator _Iter>
constexpr auto
- operator()(_Iter __i, iter_difference_t<_Iter> __n) const
+ operator() [[nodiscard]] (_Iter __i, iter_difference_t<_Iter> __n) const
{
- if constexpr (random_access_iterator<_Iter>)
+ if constexpr (contiguous_iterator<_Iter>)
+ return span(std::__to_address(__i), __n);
+ else if constexpr (random_access_iterator<_Iter>)
return subrange(__i, __i + __n);
else
return subrange(counted_iterator(std::move(__i), __n),
: _M_base(std::move(__r))
{ }
- /* XXX: LWG 3280 didn't remove this constructor, but I think it should?
- template<viewable_range _Range>
- requires (!common_range<_Range>)
- && constructible_from<_Vp, views::all_t<_Range>>
- constexpr explicit
- common_view(_Range&& __r)
- : _M_base(views::all(std::forward<_Range>(__r)))
- { }
- */
-
constexpr _Vp
base() const& requires copy_constructible<_Vp>
{ return _M_base; }
requires __detail::__already_common<_Range>
|| __detail::__can_common_view<_Range>
constexpr auto
- operator()(_Range&& __r) const
+ operator() [[nodiscard]] (_Range&& __r) const
{
if constexpr (__detail::__already_common<_Range>)
return views::all(std::forward<_Range>(__r));
&& sized_sentinel_for<sentinel_t<_Vp>,
iterator_t<_Vp>>);
+ _Vp _M_base = _Vp();
[[no_unique_address]]
__detail::__maybe_present_t<_S_needs_cached_begin,
__detail::_CachedPosition<_Vp>>
_M_cached_begin;
- _Vp _M_base = _Vp();
public:
reverse_view() requires default_initializable<_Vp> = default;
|| __detail::__is_reversible_subrange<remove_cvref_t<_Range>>
|| __detail::__can_reverse_view<_Range>
constexpr auto
- operator()(_Range&& __r) const
+ operator() [[nodiscard]] (_Range&& __r) const
{
using _Tp = remove_cvref_t<_Range>;
if constexpr (__detail::__is_reverse_view<_Tp>)
: _M_base(std::move(base))
{ }
- constexpr const _Vp&
- base() const & noexcept
+ constexpr _Vp
+ base() const& requires copy_constructible<_Vp>
{ return _M_base; }
constexpr _Vp
_Iterator() requires default_initializable<iterator_t<_Base>> = default;
constexpr explicit
- _Iterator(iterator_t<_Base> current)
- : _M_current(std::move(current))
+ _Iterator(iterator_t<_Base> __current)
+ : _M_current(std::move(__current))
{ }
constexpr
- _Iterator(_Iterator<!_Const> i)
+ _Iterator(_Iterator<!_Const> __i)
requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
- : _M_current(std::move(i._M_current))
+ : _M_current(std::move(__i._M_current))
{ }
- constexpr iterator_t<_Base>
- base() const&
- requires copyable<iterator_t<_Base>>
+ constexpr const iterator_t<_Base>&
+ base() const& noexcept
{ return _M_current; }
constexpr iterator_t<_Base>
template<viewable_range _Range>
requires __detail::__can_elements_view<_Nm, _Range>
constexpr auto
- operator()(_Range&& __r) const
+ operator() [[nodiscard]] (_Range&& __r) const
{
return elements_view<all_t<_Range>, _Nm>{std::forward<_Range>(__r)};
}
inline constexpr auto values = elements<1>;
} // namespace views
+#if __cplusplus > 202002L
+ namespace __detail
+ {
+ template<typename... _Rs>
+ concept __zip_is_common = (sizeof...(_Rs) == 1 && (common_range<_Rs> && ...))
+ || (!(bidirectional_range<_Rs> && ...) && (common_range<_Rs> && ...))
+ || ((random_access_range<_Rs> && ...) && (sized_range<_Rs> && ...));
+
+ template<typename... _Ts>
+ struct __tuple_or_pair
+ { using type = std::tuple<_Ts...>; };
+
+ template<typename _Tp, typename _Up>
+ struct __tuple_or_pair<_Tp, _Up>
+ { using type = pair<_Tp, _Up>; };
+
+ template<typename... _Ts>
+ using __tuple_or_pair_t = typename __tuple_or_pair<_Ts...>::type;
+
+ template<typename _Fp, typename _Tuple>
+ constexpr auto
+ __tuple_transform(_Fp&& __f, _Tuple&& __tuple)
+ {
+ return std::apply([&]<typename... _Ts>(_Ts&&... __elts) {
+ return __tuple_or_pair_t<invoke_result_t<_Fp&, _Ts>...>
+ (std::__invoke(__f, std::forward<_Ts>(__elts))...);
+ }, std::forward<_Tuple>(__tuple));
+ }
+
+ template<typename _Fp, typename _Tuple>
+ constexpr void
+ __tuple_for_each(_Fp&& __f, _Tuple&& __tuple)
+ {
+ std::apply([&]<typename... _Ts>(_Ts&&... __elts) {
+ (std::__invoke(__f, std::forward<_Ts>(__elts)), ...);
+ }, std::forward<_Tuple>(__tuple));
+ }
+ } // namespace __detail
+
+ template<input_range... _Vs>
+ requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0)
+ class zip_view : public view_interface<zip_view<_Vs...>>
+ {
+ tuple<_Vs...> _M_views;
+
+ template<bool> class _Iterator;
+ template<bool> class _Sentinel;
+
+ public:
+ zip_view() = default;
+
+ constexpr explicit
+ zip_view(_Vs... __views)
+ : _M_views(std::move(__views)...)
+ { }
+
+ constexpr auto
+ begin() requires (!(__detail::__simple_view<_Vs> && ...))
+ { return _Iterator<false>(__detail::__tuple_transform(ranges::begin, _M_views)); }
+
+ constexpr auto
+ begin() const requires (range<const _Vs> && ...)
+ { return _Iterator<true>(__detail::__tuple_transform(ranges::begin, _M_views)); }
+
+ constexpr auto
+ end() requires (!(__detail::__simple_view<_Vs> && ...))
+ {
+ if constexpr (!__detail::__zip_is_common<_Vs...>)
+ return _Sentinel<false>(__detail::__tuple_transform(ranges::end, _M_views));
+ else if constexpr ((random_access_range<_Vs> && ...))
+ return begin() + iter_difference_t<_Iterator<false>>(size());
+ else
+ return _Iterator<false>(__detail::__tuple_transform(ranges::end, _M_views));
+ }
+
+ constexpr auto
+ end() const requires (range<const _Vs> && ...)
+ {
+ if constexpr (!__detail::__zip_is_common<const _Vs...>)
+ return _Sentinel<true>(__detail::__tuple_transform(ranges::end, _M_views));
+ else if constexpr ((random_access_range<const _Vs> && ...))
+ return begin() + iter_difference_t<_Iterator<true>>(size());
+ else
+ return _Iterator<true>(__detail::__tuple_transform(ranges::end, _M_views));
+ }
+
+ constexpr auto
+ size() requires (sized_range<_Vs> && ...)
+ {
+ return std::apply([](auto... sizes) {
+ using _CT = __detail::__make_unsigned_like_t<common_type_t<decltype(sizes)...>>;
+ return ranges::min({_CT(sizes)...});
+ }, __detail::__tuple_transform(ranges::size, _M_views));
+ }
+
+ constexpr auto
+ size() const requires (sized_range<const _Vs> && ...)
+ {
+ return std::apply([](auto... sizes) {
+ using _CT = __detail::__make_unsigned_like_t<common_type_t<decltype(sizes)...>>;
+ return ranges::min({_CT(sizes)...});
+ }, __detail::__tuple_transform(ranges::size, _M_views));
+ }
+ };
+
+ template<typename... _Rs>
+ zip_view(_Rs&&...) -> zip_view<views::all_t<_Rs>...>;
+
+ template<typename... _Views>
+ inline constexpr bool enable_borrowed_range<zip_view<_Views...>>
+ = (enable_borrowed_range<_Views> && ...);
+
+ namespace __detail
+ {
+ template<bool _Const, typename... _Vs>
+ concept __all_random_access
+ = (random_access_range<__maybe_const_t<_Const, _Vs>> && ...);
+
+ template<bool _Const, typename... _Vs>
+ concept __all_bidirectional
+ = (bidirectional_range<__maybe_const_t<_Const, _Vs>> && ...);
+
+ template<bool _Const, typename... _Vs>
+ concept __all_forward
+ = (forward_range<__maybe_const_t<_Const, _Vs>> && ...);
+
+ template<bool _Const, typename... _Views>
+ struct __zip_view_iter_cat
+ { };
+
+ template<bool _Const, typename... _Views>
+ requires __all_forward<_Const, _Views...>
+ struct __zip_view_iter_cat<_Const, _Views...>
+ { using iterator_category = input_iterator_tag; };
+ } // namespace __detail
+
+ template<input_range... _Vs>
+ requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0)
+ template<bool _Const>
+ class zip_view<_Vs...>::_Iterator
+ : public __detail::__zip_view_iter_cat<_Const, _Vs...>
+ {
+ __detail::__tuple_or_pair_t<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_current;
+
+ constexpr explicit
+ _Iterator(decltype(_M_current) __current)
+ : _M_current(std::move(__current))
+ { }
+
+ static auto
+ _S_iter_concept()
+ {
+ if constexpr (__detail::__all_random_access<_Const, _Vs...>)
+ return random_access_iterator_tag{};
+ else if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
+ return bidirectional_iterator_tag{};
+ else if constexpr (__detail::__all_forward<_Const, _Vs...>)
+ return forward_iterator_tag{};
+ else
+ return input_iterator_tag{};
+ }
+
+ public:
+ // iterator_category defined in __zip_view_iter_cat
+ using iterator_concept = decltype(_S_iter_concept());
+ using value_type
+ = __detail::__tuple_or_pair_t<range_value_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
+ using difference_type
+ = common_type_t<range_difference_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
+
+ _Iterator() = default;
+
+ constexpr
+ _Iterator(_Iterator<!_Const> __i)
+ requires _Const
+ && (convertible_to<iterator_t<_Vs>,
+ iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
+ : _M_current(std::move(__i._M_current))
+ { }
+
+ constexpr auto
+ operator*() const
+ {
+ auto __f = [](auto& __i) -> decltype(auto) {
+ return *__i;
+ };
+ return __detail::__tuple_transform(__f, _M_current);
+ }
+
+ constexpr _Iterator&
+ operator++()
+ {
+ __detail::__tuple_for_each([](auto& __i) { ++__i; }, _M_current);
+ return *this;
+ }
+
+ constexpr void
+ operator++(int)
+ { ++*this; }
+
+ constexpr _Iterator
+ operator++(int)
+ requires __detail::__all_forward<_Const, _Vs...>
+ {
+ auto __tmp = *this;
+ ++*this;
+ return __tmp;
+ }
+
+ constexpr _Iterator&
+ operator--()
+ requires __detail::__all_bidirectional<_Const, _Vs...>
+ {
+ __detail::__tuple_for_each([](auto& __i) { --__i; }, _M_current);
+ return *this;
+ }
+
+ constexpr _Iterator
+ operator--(int)
+ requires __detail::__all_bidirectional<_Const, _Vs...>
+ {
+ auto __tmp = *this;
+ --*this;
+ return __tmp;
+ }
+
+ constexpr _Iterator&
+ operator+=(difference_type __x)
+ requires __detail::__all_random_access<_Const, _Vs...>
+ {
+ auto __f = [&]<typename _It>(_It& __i) {
+ __i += iter_difference_t<_It>(__x);
+ };
+ __detail::__tuple_for_each(__f, _M_current);
+ return *this;
+ }
+
+ constexpr _Iterator&
+ operator-=(difference_type __x)
+ requires __detail::__all_random_access<_Const, _Vs...>
+ {
+ auto __f = [&]<typename _It>(_It& __i) {
+ __i -= iter_difference_t<_It>(__x);
+ };
+ __detail::__tuple_for_each(__f, _M_current);
+ return *this;
+ }
+
+ constexpr auto
+ operator[](difference_type __n) const
+ requires __detail::__all_random_access<_Const, _Vs...>
+ {
+ auto __f = [&]<typename _It>(_It& __i) -> decltype(auto) {
+ return __i[iter_difference_t<_It>(__n)];
+ };
+ return __detail::__tuple_transform(__f, _M_current);
+ }
+
+ friend constexpr bool
+ operator==(const _Iterator& __x, const _Iterator& __y)
+ requires (equality_comparable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
+ {
+ if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
+ return __x._M_current == __y._M_current;
+ else
+ return [&]<size_t... _Is>(index_sequence<_Is...>) {
+ return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_current)) || ...);
+ }(make_index_sequence<sizeof...(_Vs)>{});
+ }
+
+ friend constexpr bool
+ operator<(const _Iterator& __x, const _Iterator& __y)
+ requires __detail::__all_random_access<_Const, _Vs...>
+ { return __x._M_current < __y._M_current; }
+
+ friend constexpr bool
+ operator>(const _Iterator& __x, const _Iterator& __y)
+ requires __detail::__all_random_access<_Const, _Vs...>
+ { return __y < __x; }
+
+ friend constexpr bool
+ operator<=(const _Iterator& __x, const _Iterator& __y)
+ requires __detail::__all_random_access<_Const, _Vs...>
+ { return !(__y < __x); }
+
+ friend constexpr bool
+ operator>=(const _Iterator& __x, const _Iterator& __y)
+ requires __detail::__all_random_access<_Const, _Vs...>
+ { return !(__x < __y); }
+
+ friend constexpr auto
+ operator<=>(const _Iterator& __x, const _Iterator& __y)
+ requires __detail::__all_random_access<_Const, _Vs...>
+ && (three_way_comparable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
+ { return __x._M_current <=> __y._M_current; }
+
+ friend constexpr _Iterator
+ operator+(const _Iterator& __i, difference_type __n)
+ requires __detail::__all_random_access<_Const, _Vs...>
+ {
+ auto __r = __i;
+ __r += __n;
+ return __r;
+ }
+
+ friend constexpr _Iterator
+ operator+(difference_type __n, const _Iterator& __i)
+ requires __detail::__all_random_access<_Const, _Vs...>
+ {
+ auto __r = __i;
+ __r += __n;
+ return __r;
+ }
+
+ friend constexpr _Iterator
+ operator-(const _Iterator& __i, difference_type __n)
+ requires __detail::__all_random_access<_Const, _Vs...>
+ {
+ auto __r = __i;
+ __r -= __n;
+ return __r;
+ }
+
+ friend constexpr difference_type
+ operator-(const _Iterator& __x, const _Iterator& __y)
+ requires (sized_sentinel_for<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>,
+ iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
+ {
+ return [&]<size_t... _Is>(index_sequence<_Is...>) {
+ return ranges::min({difference_type(std::get<_Is>(__x._M_current)
+ - std::get<_Is>(__y._M_current))...},
+ ranges::less{},
+ [](difference_type __i) -> make_unsigned_t<difference_type> {
+ return __i < 0 ? -__i : __i;
+ });
+ }(make_index_sequence<sizeof...(_Vs)>{});
+ }
+
+ friend constexpr auto
+ iter_move(const _Iterator& __i)
+ { return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
+
+ friend constexpr void
+ iter_swap(const _Iterator& __l, const _Iterator& __r)
+ requires (indirectly_swappable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
+ {
+ [&]<size_t... _Is>(index_sequence<_Is...>) {
+ (ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
+ }(make_index_sequence<sizeof...(_Vs)>{});
+ }
+
+ friend class zip_view;
+ };
+
+ template<input_range... _Vs>
+ requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0)
+ template<bool _Const>
+ class zip_view<_Vs...>::_Sentinel
+ {
+ __detail::__tuple_or_pair_t<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_end;
+
+ constexpr explicit
+ _Sentinel(decltype(_M_end) __end)
+ : _M_end(__end)
+ { }
+
+ friend class zip_view;
+
+ public:
+ _Sentinel() = default;
+
+ constexpr
+ _Sentinel(_Sentinel<!_Const> __i)
+ requires _Const
+ && (convertible_to<sentinel_t<_Vs>,
+ sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
+ : _M_end(std::move(__i._M_end))
+ { }
+
+ template<bool _OtherConst>
+ requires (sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
+ iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
+ friend constexpr bool
+ operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
+ {
+ return [&]<size_t... _Is>(index_sequence<_Is...>) {
+ return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_end)) || ...);
+ }(make_index_sequence<sizeof...(_Vs)>{});
+ }
+
+ template<bool _OtherConst>
+ requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
+ iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
+ friend constexpr auto
+ operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
+ {
+ using _Ret
+ = common_type_t<range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vs>>...>;
+ return [&]<size_t... _Is>(index_sequence<_Is...>) {
+ return ranges::min({_Ret(std::get<_Is>(__x._M_current) - std::get<_Is>(__y._M_end))...},
+ ranges::less{},
+ [](_Ret __i) -> make_unsigned_t<_Ret> {
+ return __i < 0 ? -__i : __i;
+ });
+ }(make_index_sequence<sizeof...(_Vs)>{});
+ }
+
+ template<bool _OtherConst>
+ requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
+ iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
+ friend constexpr auto
+ operator-(const _Sentinel& __y, const _Iterator<_OtherConst>& __x)
+ { return -(__x - __y); }
+ };
+
+ namespace views
+ {
+ namespace __detail
+ {
+ template<typename... _Ts>
+ concept __can_zip_view
+ = requires { zip_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
+ }
+
+ struct _Zip
+ {
+ template<typename... _Ts>
+ requires (sizeof...(_Ts) == 0 || __detail::__can_zip_view<_Ts...>)
+ [[nodiscard]]
+ constexpr auto
+ operator()(_Ts&&... __ts) const
+ {
+ if constexpr (sizeof...(_Ts) == 0)
+ return views::empty<tuple<>>;
+ else
+ return zip_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
+ }
+ };
+
+ inline constexpr _Zip zip;
+ }
+#endif // C++23
} // namespace ranges
namespace views = ranges::views;