* [PATCH 1/2] libstdc++: Implement ranges::adjacent_view from P2321R2 @ 2022-08-30 17:13 Patrick Palka 2022-08-30 17:13 ` [PATCH 2/2] libstdc++: Implement ranges::adjacent_transform_view " Patrick Palka 2022-08-31 10:26 ` [PATCH 1/2] libstdc++: Implement ranges::adjacent_view " Jonathan Wakely 0 siblings, 2 replies; 6+ messages in thread From: Patrick Palka @ 2022-08-30 17:13 UTC (permalink / raw) To: gcc-patches; +Cc: libstdc++, Patrick Palka Tested on x86_64-pc-linux-gnu, does this look OK for trunk? libstdc++-v3/ChangeLog: * include/std/ranges (adjacent_view): Define. (enable_borrowed_range<adjacent_view>): Define. (__detail::__repeated_tuple): Define. (adjacent_view::_Iterator): Define. (adjacent_view::_Sentinel): Define. (views::__detail::__can_adjacent_view): Define. (views::_Adjacent): Define. (views::adjacent): Define. (views::pairwise): Define. * testsuite/std/ranges/adaptors/adjacent/1.cc: New test. --- libstdc++-v3/include/std/ranges | 359 ++++++++++++++++++ .../std/ranges/adaptors/adjacent/1.cc | 110 ++++++ 2 files changed, 469 insertions(+) create mode 100644 libstdc++-v3/testsuite/std/ranges/adaptors/adjacent/1.cc diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges index 6e2e561ed12..4fb879a088c 100644 --- a/libstdc++-v3/include/std/ranges +++ b/libstdc++-v3/include/std/ranges @@ -5081,6 +5081,365 @@ namespace views::__adaptor inline constexpr _ZipTransform zip_transform; } + + template<forward_range _Vp, size_t _Nm> + requires view<_Vp> && (_Nm > 0) + class adjacent_view : public view_interface<adjacent_view<_Vp, _Nm>> + { + _Vp _M_base = _Vp(); + + template<bool> class _Iterator; + template<bool> class _Sentinel; + + struct __as_sentinel + { }; + + public: + adjacent_view() requires default_initializable<_Vp> = default; + + constexpr explicit + adjacent_view(_Vp __base) + : _M_base(std::move(__base)) + { } + + constexpr auto + begin() requires (!__detail::__simple_view<_Vp>) + { return _Iterator<false>(ranges::begin(_M_base), ranges::end(_M_base)); } + + constexpr auto + begin() const requires range<const _Vp> + { return _Iterator<true>(ranges::begin(_M_base), ranges::end(_M_base)); } + + constexpr auto + end() requires (!__detail::__simple_view<_Vp>) + { + if constexpr (common_range<_Vp>) + return _Iterator<false>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base)); + else + return _Sentinel<false>(ranges::end(_M_base)); + } + + constexpr auto + end() const requires range<const _Vp> + { + if constexpr (common_range<const _Vp>) + return _Iterator<true>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base)); + else + return _Sentinel<true>(ranges::end(_M_base)); + } + + constexpr auto + size() requires sized_range<_Vp> + { + using _ST = decltype(ranges::size(_M_base)); + using _CT = common_type_t<_ST, size_t>; + auto __sz = static_cast<_CT>(ranges::size(_M_base)); + __sz -= std::min<_CT>(__sz, _Nm - 1); + return static_cast<_ST>(__sz); + } + + constexpr auto + size() const requires sized_range<const _Vp> + { + using _ST = decltype(ranges::size(_M_base)); + using _CT = common_type_t<_ST, size_t>; + auto __sz = static_cast<_CT>(ranges::size(_M_base)); + __sz -= std::min<_CT>(__sz, _Nm - 1); + return static_cast<_ST>(__sz); + } + }; + + template<typename _Vp, size_t _Nm> + inline constexpr bool enable_borrowed_range<adjacent_view<_Vp, _Nm>> + = enable_borrowed_range<_Vp>; + + namespace __detail + { + // Yields tuple<_Tp, ..., _Tp> with _Nm elements. + template<typename _Tp, size_t _Nm> + using __repeated_tuple = decltype(std::tuple_cat(std::declval<array<_Tp, _Nm>>())); + } + + template<forward_range _Vp, size_t _Nm> + requires view<_Vp> && (_Nm > 0) + template<bool _Const> + class adjacent_view<_Vp, _Nm>::_Iterator + { + using _Base = __detail::__maybe_const_t<_Const, _Vp>; + array<iterator_t<_Base>, _Nm> _M_current = array<iterator_t<_Base>, _Nm>(); + + constexpr + _Iterator(iterator_t<_Base> __first, sentinel_t<_Base> __last) + { + for (auto& __i : _M_current) + { + __i = __first; + ranges::advance(__first, 1, __last); + } + } + + constexpr + _Iterator(__as_sentinel, iterator_t<_Base> __first, iterator_t<_Base> __last) + { + if constexpr (!bidirectional_range<_Base>) + for (auto& __it : _M_current) + __it = __last; + else + for (ssize_t __i = _Nm-1; __i >= 0; --__i) + { + _M_current[__i] = __last; + ranges::advance(__last, -1, __first); + } + } + + static auto + _S_iter_concept() + { + if constexpr (random_access_range<_Base>) + return random_access_iterator_tag{}; + else if constexpr (bidirectional_range<_Base>) + return bidirectional_iterator_tag{}; + else + return forward_iterator_tag{}; + } + + friend class adjacent_view; + + public: + using iterator_category = input_iterator_tag; + using iterator_concept = decltype(_S_iter_concept()); + using value_type = conditional_t<_Nm == 2, + pair<range_value_t<_Base>, range_value_t<_Base>>, + __detail::__repeated_tuple<range_value_t<_Base>, _Nm>>; + using difference_type = range_difference_t<_Base>; + + _Iterator() = default; + + constexpr + _Iterator(_Iterator<!_Const> __i) + requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>> + { + for (size_t __j = 0; __j < _Nm; ++__j) + _M_current[__j] = std::move(__i[__j]); + } + + constexpr auto + operator*() const + { + auto __f = [](auto& __i) -> decltype(auto) { return *__i; }; + return __detail::__tuple_transform(__f, _M_current); + } + + constexpr _Iterator& + operator++() + { + for (auto& __i : _M_current) + ++__i; + return *this; + } + + constexpr _Iterator + operator++(int) + { + auto __tmp = *this; + ++*this; + return __tmp; + } + + constexpr _Iterator& + operator--() requires bidirectional_range<_Base> + { + for (auto& __i : _M_current) + --__i; + return *this; + } + + constexpr _Iterator + operator--(int) requires bidirectional_range<_Base> + { + auto __tmp = *this; + --*this; + return __tmp; + } + + constexpr _Iterator& + operator+=(difference_type __x) + requires random_access_range<_Base> + { + for (auto& __i : _M_current) + __i += __x; + return *this; + } + + constexpr _Iterator& + operator-=(difference_type __x) + requires random_access_range<_Base> + { + for (auto& __i : _M_current) + __i -= __x; + return *this; + } + + constexpr auto + operator[](difference_type __n) const + requires random_access_range<_Base> + { + auto __f = [&](auto& __i) -> decltype(auto) { return __i[__n]; }; + return __detail::__tuple_transform(__f, _M_current); + } + + friend constexpr bool + operator==(const _Iterator& __x, const _Iterator& __y) + { return __x._M_current.back() == __y._M_current.back(); } + + friend constexpr bool + operator<(const _Iterator& __x, const _Iterator& __y) + requires random_access_range<_Base> + { return __x._M_current.back() < __y._M_current.back(); } + + friend constexpr bool + operator>(const _Iterator& __x, const _Iterator& __y) + requires random_access_range<_Base> + { return __y < __x; } + + friend constexpr bool + operator<=(const _Iterator& __x, const _Iterator& __y) + requires random_access_range<_Base> + { return !(__y < __x); } + + friend constexpr bool + operator>=(const _Iterator& __x, const _Iterator& __y) + requires random_access_range<_Base> + { return !(__x < __y); } + + friend constexpr auto + operator<=>(const _Iterator& __x, const _Iterator& __y) + requires random_access_range<_Base> + && three_way_comparable<iterator_t<_Base>> + { return __x._M_current.back() <=> __y._M_current.back(); } + + friend constexpr _Iterator + operator+(const _Iterator& __i, difference_type __n) + requires random_access_range<_Base> + { + auto __r = __i; + __r += __n; + return __r; + } + + friend constexpr _Iterator + operator+(difference_type __n, const _Iterator& __i) + requires random_access_range<_Base> + { + auto __r = __i; + __r += __n; + return __r; + } + + friend constexpr _Iterator + operator-(const _Iterator& __i, difference_type __n) + requires random_access_range<_Base> + { + auto __r = __i; + __r -= __n; + return __r; + } + + friend constexpr difference_type + operator-(const _Iterator& __x, const _Iterator& __y) + requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>> + { return __x._M_current.back() - __y._M_current.back(); } + + 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<_Base>> + { + for (size_t __i = 0; __i < _Nm; __i++) + ranges::iter_swap(__l._M_current[__i], __r._M_current[__i]); + } + }; + + template<forward_range _Vp, size_t _Nm> + requires view<_Vp> && (_Nm > 0) + template<bool _Const> + class adjacent_view<_Vp, _Nm>::_Sentinel + { + using _Base = __detail::__maybe_const_t<_Const, _Vp>; + + sentinel_t<_Base> _M_end = sentinel_t<_Base>(); + + constexpr explicit + _Sentinel(sentinel_t<_Base> __end) + : _M_end(__end) + { } + + friend class adjacent_view; + + public: + _Sentinel() = default; + + constexpr + _Sentinel(_Sentinel<!_Const> __i) + requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>> + : _M_end(std::move(__i._M_end)) + { } + + template<bool _OtherConst> + requires sentinel_for<sentinel_t<_Base>, + iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>> + friend constexpr bool + operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y) + { return __x._M_current.back() == __y._M_end; } + + template<bool _OtherConst> + requires sized_sentinel_for<sentinel_t<_Base>, + iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>> + friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>> + operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y) + { return __x._M_current.back() - __y._M_end; } + + template<bool _OtherConst> + requires sized_sentinel_for<sentinel_t<_Base>, + iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>> + friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>> + operator-(const _Sentinel& __y, const _Iterator<_OtherConst>& __x) + { return __y._M_end - __x._M_current.back(); } + }; + + namespace views + { + namespace __detail + { + template<size_t _Nm, typename _Range> + concept __can_adjacent_view + = requires { adjacent_view<all_t<_Range>, _Nm>(std::declval<_Range>()); }; + } + + template<size_t _Nm> + struct _Adjacent : __adaptor::_RangeAdaptorClosure + { + template<viewable_range _Range> + requires (_Nm == 0) || __detail::__can_adjacent_view<_Nm, _Range> + [[nodiscard]] + constexpr auto + operator()(_Range&& __r) const + { + if constexpr (_Nm == 0) + return views::empty<tuple<>>; + else + return adjacent_view<all_t<_Range>, _Nm>(std::forward<_Range>(__r)); + } + }; + + template<size_t _Nm> + inline constexpr _Adjacent<_Nm> adjacent; + + inline constexpr auto pairwise = adjacent<2>; + } #endif // C++23 } // namespace ranges diff --git a/libstdc++-v3/testsuite/std/ranges/adaptors/adjacent/1.cc b/libstdc++-v3/testsuite/std/ranges/adaptors/adjacent/1.cc new file mode 100644 index 00000000000..9829f79364f --- /dev/null +++ b/libstdc++-v3/testsuite/std/ranges/adaptors/adjacent/1.cc @@ -0,0 +1,110 @@ +// { dg-options "-std=gnu++23" } +// { dg-do run { target c++23 } } + +#include <ranges> +#include <algorithm> +#include <utility> +#include <testsuite_hooks.h> +#include <testsuite_iterators.h> + +namespace ranges = std::ranges; +namespace views = std::views; + +constexpr bool +test01() +{ + static_assert(ranges::empty(std::array{1, 2, 3} | views::adjacent<0>)); + + auto v1 = std::array{1, 2} | views::adjacent<1>; + const auto i0 = v1.begin(), i1 = v1.begin() + 1; + VERIFY( i0 + 1 - 1 == i0 ); + VERIFY( i0 < i1 ); + VERIFY( i1 < v1.end() ); + VERIFY( i1 - i0 == 1 ); + VERIFY( i0 - i1 == -1 ); + VERIFY( v1.end() - i1 == 1 ); + VERIFY( i1 - v1.end() == -1 ); + ranges::iter_swap(i0, i1); + VERIFY( ranges::equal(std::move(v1) | views::keys, (int[]){2, 1}) ); + + int x[] = {1, 2, 3, 4}; + auto v2 = x | views::pairwise; + auto i2 = v2.begin(); + i2 += 2; + i2 -= -1; + VERIFY( i2 == v2.end() ); + VERIFY( ranges::size(v2) == 3 ); + VERIFY( ranges::size(std::as_const(v2)) == 3 ); + VERIFY( ranges::equal(v2 | views::keys, (int[]){1, 2, 3}) ); + VERIFY( ranges::equal(v2 | views::values, (int[]){2, 3, 4}) ); + + int y[] = {1, 2, 3, 4, 5}; + const auto v3 = y | views::adjacent<3>; + VERIFY( ranges::size(v3) == 3 ); + for (unsigned i = 0; i < ranges::size(x); i++) + { + VERIFY( &std::get<0>(v3[i]) == &y[i] + 0 ); + VERIFY( &std::get<1>(v3[i]) == &y[i] + 1 ); + VERIFY( &std::get<2>(v3[i]) == &y[i] + 2 ); + } + + const auto v5 = y | views::adjacent<5>; + VERIFY( ranges::equal(v5, views::single(std::make_tuple(1, 2, 3, 4, 5))) ); + + const auto v6 = y | views::adjacent<6>; + VERIFY( ranges::empty(v6) ); + + const auto v0 = y | views::adjacent<0>; + VERIFY( ranges::empty(v0) ); + + return true; +} + +constexpr bool +test02() +{ + using __gnu_test::test_input_range; + using __gnu_test::test_forward_range; + using __gnu_test::test_random_access_range; + + using ty1 = ranges::adjacent_view<views::all_t<test_forward_range<int>>, 2>; + static_assert(ranges::forward_range<ty1>); + static_assert(!ranges::bidirectional_range<ty1>); + static_assert(!ranges::sized_range<ty1>); + + using ty2 = ranges::adjacent_view<views::all_t<test_random_access_range<int>>, 3>; + static_assert(ranges::random_access_range<ty2>); + static_assert(ranges::sized_range<ty2>); + + return true; +} + +constexpr bool +test03() +{ + auto v = views::iota(0, 4) | views::filter([](auto) { return true; }) | views::pairwise; + using ty = decltype(v); + static_assert(ranges::forward_range<ty>); + static_assert(ranges::common_range<ty>); + static_assert(!ranges::sized_range<ty>); + VERIFY( v.begin() == v.begin() ); + VERIFY( v.begin() != v.end() ); + VERIFY( ranges::next(v.begin(), 3) == v.end() ); + auto it = v.begin(); + ++it; + it++; + VERIFY( ranges::next(it) == v.end() ); + it--; + --it; + VERIFY( it == v.begin() ); + + return true; +} + +int +main() +{ + static_assert(test01()); + static_assert(test02()); + static_assert(test03()); +} -- 2.37.2.490.g6c8e4ee870 ^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH 2/2] libstdc++: Implement ranges::adjacent_transform_view from P2321R2 2022-08-30 17:13 [PATCH 1/2] libstdc++: Implement ranges::adjacent_view from P2321R2 Patrick Palka @ 2022-08-30 17:13 ` Patrick Palka 2022-09-01 11:14 ` Jonathan Wakely 2022-08-31 10:26 ` [PATCH 1/2] libstdc++: Implement ranges::adjacent_view " Jonathan Wakely 1 sibling, 1 reply; 6+ messages in thread From: Patrick Palka @ 2022-08-30 17:13 UTC (permalink / raw) To: gcc-patches; +Cc: libstdc++, Patrick Palka Tested on x86_64-pc-linux-gnu, does this look OK for trunk? libstdc++-v3/ChangeLog: * include/std/ranges (__detail::__unarize): Define. (adjacent_view::_Iterator): Befriend adjacent_transform_view. (adjacent_transform_view): Define. (adjacent_transform_view::_Iterator): Define. (adjacent_transform_view::_Sentinel): Define. (views::__detail::__can_adjacent_transform_view): Define. (views::_AdjacentTransform): Define. (views::adjacent_transform): Define. (views::pairwise): Define. * testsuite/std/ranges/adaptors/adjacent_transform/1.cc: New test. --- libstdc++-v3/include/std/ranges | 342 ++++++++++++++++++ .../ranges/adaptors/adjacent_transform/1.cc | 106 ++++++ 2 files changed, 448 insertions(+) create mode 100644 libstdc++-v3/testsuite/std/ranges/adaptors/adjacent_transform/1.cc diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges index 4fb879a088c..3a7f0545030 100644 --- a/libstdc++-v3/include/std/ranges +++ b/libstdc++-v3/include/std/ranges @@ -5158,6 +5158,20 @@ namespace views::__adaptor // Yields tuple<_Tp, ..., _Tp> with _Nm elements. template<typename _Tp, size_t _Nm> using __repeated_tuple = decltype(std::tuple_cat(std::declval<array<_Tp, _Nm>>())); + + // For a functor F that takes N arguments, the expression declval<__unarize<F, N>>(x) + // is equivalent to declval<F>(x, ..., x). + template<typename _Fp, size_t _Nm> + struct __unarize + { + template<typename... _Ts> + static invoke_result_t<_Fp, _Ts...> + __tuple_apply(const tuple<_Ts...>&); // not defined + + template<typename _Tp> + decltype(__tuple_apply(std::declval<__repeated_tuple<_Tp, _Nm>>())) + operator()(_Tp&&); // not defined + }; } template<forward_range _Vp, size_t _Nm> @@ -5205,6 +5219,13 @@ namespace views::__adaptor friend class adjacent_view; + template<forward_range _Wp, copy_constructible _Fp, size_t _Mm> + requires view<_Wp> && (_Mm > 0) && is_object_v<_Fp> + && regular_invocable<__detail::__unarize<_Fp&, _Mm>, range_reference_t<_Wp>> + && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Mm>, + range_reference_t<_Wp>>> + friend class adjacent_transform_view; + public: using iterator_category = input_iterator_tag; using iterator_concept = decltype(_S_iter_concept()); @@ -5440,6 +5461,327 @@ namespace views::__adaptor inline constexpr auto pairwise = adjacent<2>; } + + template<forward_range _Vp, copy_constructible _Fp, size_t _Nm> + requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp> + && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>> + && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>, + range_reference_t<_Vp>>> + class adjacent_transform_view : public view_interface<adjacent_transform_view<_Vp, _Fp, _Nm>> + { + [[no_unique_address]] __detail::__box<_Fp> _M_fun; + adjacent_view<_Vp, _Nm> _M_inner; + + using _InnerView = adjacent_view<_Vp, _Nm>; + + template<bool _Const> + using _InnerIter = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>; + + template<bool _Const> + using _InnerSent = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>; + + template<bool> class _Iterator; + template<bool> class _Sentinel; + + public: + adjacent_transform_view() = default; + + constexpr explicit + adjacent_transform_view(_Vp __base, _Fp __fun) + : _M_fun(std::move(__fun)), _M_inner(std::move(__base)) + { } + + constexpr auto + begin() + { return _Iterator<false>(*this, _M_inner.begin()); } + + constexpr auto + begin() const + requires range<const _InnerView> + && regular_invocable<__detail::__unarize<const _Fp&, _Nm>, + range_reference_t<const _Vp>> + { return _Iterator<true>(*this, _M_inner.begin()); } + + constexpr auto + end() + { + if constexpr (common_range<_InnerView>) + return _Iterator<false>(*this, _M_inner.end()); + else + return _Sentinel<false>(_M_inner.end()); + } + + constexpr auto + end() const + requires range<const _InnerView> + && regular_invocable<__detail::__unarize<const _Fp&, _Nm>, + range_reference_t<const _Vp>> + { + if constexpr (common_range<const _InnerView>) + return _Iterator<true>(*this, _M_inner.end()); + else + return _Sentinel<true>(_M_inner.end()); + } + + constexpr auto + size() requires sized_range<_InnerView> + { return _M_inner.size(); } + + constexpr auto + size() const requires sized_range<const _InnerView> + { return _M_inner.size(); } + }; + + template<forward_range _Vp, copy_constructible _Fp, size_t _Nm> + requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp> + && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>> + && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>, + range_reference_t<_Vp>>> + template<bool _Const> + class adjacent_transform_view<_Vp, _Fp, _Nm>::_Iterator + { + using _Parent = __detail::__maybe_const_t<_Const, adjacent_transform_view>; + using _Base = __detail::__maybe_const_t<_Const, _Vp>; + + _Parent* _M_parent = nullptr; + _InnerIter<_Const> _M_inner; + + constexpr + _Iterator(_Parent& __parent, _InnerIter<_Const> __inner) + : _M_parent(std::__addressof(__parent)), _M_inner(std::move(__inner)) + { } + + static auto + _S_iter_cat() + { + using __detail::__maybe_const_t; + using __detail::__unarize; + using _Res = invoke_result_t<__unarize<__maybe_const_t<_Const, _Fp>&, _Nm>, + range_reference_t<_Base>>; + using _Cat = iterator_traits<iterator_t<_Base>>::iterator_category; + if constexpr (!is_lvalue_reference_v<_Res>) + return input_iterator_tag{}; + else if constexpr (derived_from<_Cat, random_access_iterator_tag>) + return random_access_iterator_tag{}; + else if constexpr (derived_from<_Cat, bidirectional_iterator_tag>) + return bidirectional_iterator_tag{}; + else if constexpr (derived_from<_Cat, forward_iterator_tag>) + return forward_iterator_tag{}; + else + return input_iterator_tag{}; + } + + friend class adjacent_transform_view; + + public: + using iterator_category = decltype(_S_iter_cat()); + using iterator_concept = typename _InnerIter<_Const>::iterator_concept; + using value_type + = remove_cvref_t<invoke_result_t + <__detail::__unarize<__detail::__maybe_const_t<_Const, _Fp>&, _Nm>, + range_reference_t<_Base>>>; + using difference_type = range_difference_t<_Base>; + + _Iterator() = default; + + constexpr + _Iterator(_Iterator<!_Const> __i) + requires _Const && convertible_to<_InnerIter<false>, _InnerIter<_Const>> + : _M_parent(__i._M_parent), _M_inner(std::move(__i._M_inner)) + { } + + constexpr decltype(auto) + operator*() const + { + return std::apply([&](const auto&... __iters) -> decltype(auto) { + return std::__invoke(*_M_parent->_M_fun, *__iters...); + }, _M_inner._M_current); + } + + constexpr _Iterator& + operator++() + { + ++_M_inner; + return *this; + } + + constexpr _Iterator + operator++(int) + { + auto __tmp = *this; + ++*this; + return __tmp; + } + + constexpr _Iterator& + operator--() requires bidirectional_range<_Base> + { + --_M_inner; + return *this; + } + + constexpr _Iterator + operator--(int) requires bidirectional_range<_Base> + { + auto __tmp = *this; + --*this; + return __tmp; + } + + constexpr _Iterator& + operator+=(difference_type __x) requires random_access_range<_Base> + { + _M_inner += __x; + return *this; + } + + constexpr _Iterator& + operator-=(difference_type __x) requires random_access_range<_Base> + { + _M_inner -= __x; + return *this; + } + + constexpr decltype(auto) + operator[](difference_type __n) const requires random_access_range<_Base> + { + return std::apply([&](const auto&... __iters) -> decltype(auto) { + return std::__invoke(*_M_parent->_M_fun, __iters[__n]...); + }, _M_inner._M_current); + } + + friend constexpr bool + operator==(const _Iterator& __x, const _Iterator& __y) + { return __x._M_inner == __y._M_inner; } + + friend constexpr bool + operator<(const _Iterator& __x, const _Iterator& __y) + requires random_access_range<_Base> + { return __x._M_inner < __y._M_inner; } + + friend constexpr bool + operator>(const _Iterator& __x, const _Iterator& __y) + requires random_access_range<_Base> + { return __x._M_inner > __y._M_inner; } + + friend constexpr bool + operator<=(const _Iterator& __x, const _Iterator& __y) + requires random_access_range<_Base> + { return __x._M_inner <= __y._M_inner; } + + friend constexpr bool + operator>=(const _Iterator& __x, const _Iterator& __y) + requires random_access_range<_Base> + { return __x._M_inner >= __y._M_inner; } + + friend constexpr auto + operator<=>(const _Iterator& __x, const _Iterator& __y) + requires random_access_range<_Base> && + three_way_comparable<_InnerIter<_Const>> + { return __x._M_inner <=> __y._M_inner; } + + friend constexpr _Iterator + operator+(const _Iterator& __i, difference_type __n) + requires random_access_range<_Base> + { return _Iterator(*__i._M_parent, __i._M_inner + __n); } + + friend constexpr _Iterator + operator+(difference_type __n, const _Iterator& __i) + requires random_access_range<_Base> + { return _Iterator(*__i._M_parent, __i._M_inner + __n); } + + friend constexpr _Iterator + operator-(const _Iterator& __i, difference_type __n) + requires random_access_range<_Base> + { return _Iterator(*__i._M_parent, __i._M_inner - __n); } + + friend constexpr difference_type + operator-(const _Iterator& __x, const _Iterator& __y) + requires sized_sentinel_for<_InnerIter<_Const>, _InnerIter<_Const>> + { return __x._M_inner - __y._M_inner; } + }; + + template<forward_range _Vp, copy_constructible _Fp, size_t _Nm> + requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp> + && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>> + && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>, + range_reference_t<_Vp>>> + template<bool _Const> + class adjacent_transform_view<_Vp, _Fp, _Nm>::_Sentinel + { + _InnerSent<_Const> _M_inner; + + constexpr explicit + _Sentinel(_InnerSent<_Const> __inner) + : _M_inner(__inner) + { } + + friend class adjacent_transform_view; + + public: + _Sentinel() = default; + + constexpr + _Sentinel(_Sentinel<!_Const> __i) + requires _Const && convertible_to<_InnerSent<false>, _InnerSent<_Const>> + : _M_inner(std::move(__i._M_inner)) + { } + + template<bool _OtherConst> + requires sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>> + friend constexpr bool + operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y) + { return __x._M_inner == __y._M_inner; } + + template<bool _OtherConst> + requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>> + friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>> + operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y) + { return __x._M_inner - __y._M_inner; } + + template<bool _OtherConst> + requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>> + friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>> + operator-(const _Sentinel& __x, const _Iterator<_OtherConst>& __y) + { return __x._M_inner - __y._M_inner; } + }; + + namespace views + { + namespace __detail + { + template<size_t _Nm, typename _Range, typename _Fp> + concept __can_adjacent_transform_view + = requires { adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm> + (std::declval<_Range>(), std::declval<_Fp>()); }; + } + + template<size_t _Nm> + struct _AdjacentTransform : __adaptor::_RangeAdaptor<_AdjacentTransform<_Nm>> + { + template<viewable_range _Range, typename _Fp> + requires (_Nm == 0) || __detail::__can_adjacent_transform_view<_Nm, _Range, _Fp> + [[nodiscard]] + constexpr auto + operator()(_Range&& __r, _Fp&& __f) const + { + if constexpr (_Nm == 0) + return views::empty<tuple<>>; + else + return adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm> + (std::forward<_Range>(__r), std::forward<_Fp>(__f)); + } + + using __adaptor::_RangeAdaptor<_AdjacentTransform>::operator(); + static constexpr int _S_arity = 2; + static constexpr bool _S_has_simple_extra_args = true; + }; + + template<size_t _Nm> + inline constexpr _AdjacentTransform<_Nm> adjacent_transform; + + inline constexpr auto pairwise_transform = adjacent_transform<2>; + } #endif // C++23 } // namespace ranges diff --git a/libstdc++-v3/testsuite/std/ranges/adaptors/adjacent_transform/1.cc b/libstdc++-v3/testsuite/std/ranges/adaptors/adjacent_transform/1.cc new file mode 100644 index 00000000000..07f20b702dd --- /dev/null +++ b/libstdc++-v3/testsuite/std/ranges/adaptors/adjacent_transform/1.cc @@ -0,0 +1,106 @@ +// { dg-options "-std=gnu++23" } +// { dg-do run { target c++23 } } + +#include <ranges> +#include <algorithm> +#include <utility> +#include <testsuite_hooks.h> +#include <testsuite_iterators.h> + +namespace ranges = std::ranges; +namespace views = std::views; + +constexpr bool +test01() +{ + auto v1 = std::array{1, 2, 3} | views::adjacent_transform<1>(std::identity{}); + VERIFY( ranges::equal(v1, (int[]){1, 2, 3}) ); + const auto i0 = v1.begin(), i1 = v1.begin() + 1; + VERIFY( i0 + 1 - 1 == i0 ); + VERIFY( i0 < i1 ); + VERIFY( i1 < v1.end() ); + VERIFY( i1 - i0 == 1 ); + VERIFY( i0 - i1 == -1 ); + VERIFY( v1.end() - i1 == 2 ); + VERIFY( i1 - v1.end() == -2 ); + ranges::iter_swap(i0, i1); + VERIFY( ranges::equal(std::move(v1), (int[]){2, 1, 3}) ); + + auto v2 = std::array{1, -1, 2, -2} | views::pairwise_transform(std::multiplies{}); + auto i2 = v2.begin(); + i2 += 1; + i2 -= -2; + VERIFY( i2 == v2.end() ); + VERIFY( ranges::size(v2) == 3 ); + VERIFY( ranges::size(std::as_const(v2)) == 3 ); + VERIFY( ranges::equal(v2, (int[]){-1, -2, -4}) ); + + int y[] = {1, 2, 3, 4, 5, 6}; + auto v3 = y | views::adjacent_transform<3>([](auto... xs) { return ranges::max({xs...}); }); + VERIFY( ranges::size(v3) == 4 ); + VERIFY( ranges::equal(v3, (int[]){3, 4, 5, 6}) ); + + const auto v6 = y | views::adjacent_transform<6>([](auto...) { return 0; }); + VERIFY( ranges::equal(v6, (int[]){0}) ); + + const auto v7 = y | views::adjacent_transform<7>([](auto...) { return 0; }); + VERIFY( ranges::empty(v7) ); + + const auto v0 = y | views::adjacent_transform<0>([] { return 0; }); + VERIFY( ranges::empty(v0) ); + + return true; +} + +constexpr bool +test02() +{ + using __gnu_test::test_input_range; + using __gnu_test::test_forward_range; + using __gnu_test::test_random_access_range; + + using ty1 = ranges::adjacent_transform_view<views::all_t<test_forward_range<int>>, + std::plus<>, 2>; + static_assert(ranges::forward_range<ty1>); + static_assert(!ranges::bidirectional_range<ty1>); + static_assert(!ranges::sized_range<ty1>); + + using ty2 = ranges::adjacent_transform_view<views::all_t<test_random_access_range<int>>, + decltype([](int, int, int) { return 0;}), 3>; + static_assert(ranges::random_access_range<ty2>); + static_assert(ranges::sized_range<ty2>); + + return true; +} + +constexpr bool +test03() +{ + auto v = views::iota(0, 4) + | views::filter([](auto) { return true; }) + | views::pairwise_transform(std::plus{}); + using ty = decltype(v); + static_assert(ranges::forward_range<ty>); + static_assert(ranges::common_range<ty>); + static_assert(!ranges::sized_range<ty>); + VERIFY( v.begin() == v.begin() ); + VERIFY( v.begin() != v.end() ); + VERIFY( ranges::next(v.begin(), 3) == v.end() ); + auto it = v.begin(); + ++it; + it++; + VERIFY( ranges::next(it) == v.end() ); + it--; + --it; + VERIFY( it == v.begin() ); + + return true; +} + +int +main() +{ + static_assert(test01()); + static_assert(test02()); + static_assert(test03()); +} -- 2.37.2.490.g6c8e4ee870 ^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 2/2] libstdc++: Implement ranges::adjacent_transform_view from P2321R2 2022-08-30 17:13 ` [PATCH 2/2] libstdc++: Implement ranges::adjacent_transform_view " Patrick Palka @ 2022-09-01 11:14 ` Jonathan Wakely 0 siblings, 0 replies; 6+ messages in thread From: Jonathan Wakely @ 2022-09-01 11:14 UTC (permalink / raw) To: Patrick Palka; +Cc: gcc-patches, libstdc++ On Tue, 30 Aug 2022 at 18:14, Patrick Palka via Libstdc++ <libstdc++@gcc.gnu.org> wrote: > > Tested on x86_64-pc-linux-gnu, does this look OK for trunk? OK > > libstdc++-v3/ChangeLog: > > * include/std/ranges (__detail::__unarize): Define. > (adjacent_view::_Iterator): Befriend adjacent_transform_view. > (adjacent_transform_view): Define. > (adjacent_transform_view::_Iterator): Define. > (adjacent_transform_view::_Sentinel): Define. > (views::__detail::__can_adjacent_transform_view): Define. > (views::_AdjacentTransform): Define. > (views::adjacent_transform): Define. > (views::pairwise): Define. > * testsuite/std/ranges/adaptors/adjacent_transform/1.cc: New test. > --- > libstdc++-v3/include/std/ranges | 342 ++++++++++++++++++ > .../ranges/adaptors/adjacent_transform/1.cc | 106 ++++++ > 2 files changed, 448 insertions(+) > create mode 100644 libstdc++-v3/testsuite/std/ranges/adaptors/adjacent_transform/1.cc > > diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges > index 4fb879a088c..3a7f0545030 100644 > --- a/libstdc++-v3/include/std/ranges > +++ b/libstdc++-v3/include/std/ranges > @@ -5158,6 +5158,20 @@ namespace views::__adaptor > // Yields tuple<_Tp, ..., _Tp> with _Nm elements. > template<typename _Tp, size_t _Nm> > using __repeated_tuple = decltype(std::tuple_cat(std::declval<array<_Tp, _Nm>>())); > + > + // For a functor F that takes N arguments, the expression declval<__unarize<F, N>>(x) > + // is equivalent to declval<F>(x, ..., x). > + template<typename _Fp, size_t _Nm> > + struct __unarize > + { > + template<typename... _Ts> > + static invoke_result_t<_Fp, _Ts...> > + __tuple_apply(const tuple<_Ts...>&); // not defined > + > + template<typename _Tp> > + decltype(__tuple_apply(std::declval<__repeated_tuple<_Tp, _Nm>>())) > + operator()(_Tp&&); // not defined > + }; > } > > template<forward_range _Vp, size_t _Nm> > @@ -5205,6 +5219,13 @@ namespace views::__adaptor > > friend class adjacent_view; > > + template<forward_range _Wp, copy_constructible _Fp, size_t _Mm> > + requires view<_Wp> && (_Mm > 0) && is_object_v<_Fp> > + && regular_invocable<__detail::__unarize<_Fp&, _Mm>, range_reference_t<_Wp>> > + && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Mm>, > + range_reference_t<_Wp>>> > + friend class adjacent_transform_view; > + > public: > using iterator_category = input_iterator_tag; > using iterator_concept = decltype(_S_iter_concept()); > @@ -5440,6 +5461,327 @@ namespace views::__adaptor > > inline constexpr auto pairwise = adjacent<2>; > } > + > + template<forward_range _Vp, copy_constructible _Fp, size_t _Nm> > + requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp> > + && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>> > + && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>, > + range_reference_t<_Vp>>> > + class adjacent_transform_view : public view_interface<adjacent_transform_view<_Vp, _Fp, _Nm>> > + { > + [[no_unique_address]] __detail::__box<_Fp> _M_fun; > + adjacent_view<_Vp, _Nm> _M_inner; > + > + using _InnerView = adjacent_view<_Vp, _Nm>; > + > + template<bool _Const> > + using _InnerIter = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>; > + > + template<bool _Const> > + using _InnerSent = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>; > + > + template<bool> class _Iterator; > + template<bool> class _Sentinel; > + > + public: > + adjacent_transform_view() = default; > + > + constexpr explicit > + adjacent_transform_view(_Vp __base, _Fp __fun) > + : _M_fun(std::move(__fun)), _M_inner(std::move(__base)) > + { } > + > + constexpr auto > + begin() > + { return _Iterator<false>(*this, _M_inner.begin()); } > + > + constexpr auto > + begin() const > + requires range<const _InnerView> > + && regular_invocable<__detail::__unarize<const _Fp&, _Nm>, > + range_reference_t<const _Vp>> > + { return _Iterator<true>(*this, _M_inner.begin()); } > + > + constexpr auto > + end() > + { > + if constexpr (common_range<_InnerView>) > + return _Iterator<false>(*this, _M_inner.end()); > + else > + return _Sentinel<false>(_M_inner.end()); > + } > + > + constexpr auto > + end() const > + requires range<const _InnerView> > + && regular_invocable<__detail::__unarize<const _Fp&, _Nm>, > + range_reference_t<const _Vp>> > + { > + if constexpr (common_range<const _InnerView>) > + return _Iterator<true>(*this, _M_inner.end()); > + else > + return _Sentinel<true>(_M_inner.end()); > + } > + > + constexpr auto > + size() requires sized_range<_InnerView> > + { return _M_inner.size(); } > + > + constexpr auto > + size() const requires sized_range<const _InnerView> > + { return _M_inner.size(); } > + }; > + > + template<forward_range _Vp, copy_constructible _Fp, size_t _Nm> > + requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp> > + && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>> > + && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>, > + range_reference_t<_Vp>>> > + template<bool _Const> > + class adjacent_transform_view<_Vp, _Fp, _Nm>::_Iterator > + { > + using _Parent = __detail::__maybe_const_t<_Const, adjacent_transform_view>; > + using _Base = __detail::__maybe_const_t<_Const, _Vp>; > + > + _Parent* _M_parent = nullptr; > + _InnerIter<_Const> _M_inner; > + > + constexpr > + _Iterator(_Parent& __parent, _InnerIter<_Const> __inner) > + : _M_parent(std::__addressof(__parent)), _M_inner(std::move(__inner)) > + { } > + > + static auto > + _S_iter_cat() > + { > + using __detail::__maybe_const_t; > + using __detail::__unarize; > + using _Res = invoke_result_t<__unarize<__maybe_const_t<_Const, _Fp>&, _Nm>, > + range_reference_t<_Base>>; > + using _Cat = iterator_traits<iterator_t<_Base>>::iterator_category; > + if constexpr (!is_lvalue_reference_v<_Res>) > + return input_iterator_tag{}; > + else if constexpr (derived_from<_Cat, random_access_iterator_tag>) > + return random_access_iterator_tag{}; > + else if constexpr (derived_from<_Cat, bidirectional_iterator_tag>) > + return bidirectional_iterator_tag{}; > + else if constexpr (derived_from<_Cat, forward_iterator_tag>) > + return forward_iterator_tag{}; > + else > + return input_iterator_tag{}; > + } > + > + friend class adjacent_transform_view; > + > + public: > + using iterator_category = decltype(_S_iter_cat()); > + using iterator_concept = typename _InnerIter<_Const>::iterator_concept; > + using value_type > + = remove_cvref_t<invoke_result_t > + <__detail::__unarize<__detail::__maybe_const_t<_Const, _Fp>&, _Nm>, > + range_reference_t<_Base>>>; > + using difference_type = range_difference_t<_Base>; > + > + _Iterator() = default; > + > + constexpr > + _Iterator(_Iterator<!_Const> __i) > + requires _Const && convertible_to<_InnerIter<false>, _InnerIter<_Const>> > + : _M_parent(__i._M_parent), _M_inner(std::move(__i._M_inner)) > + { } > + > + constexpr decltype(auto) > + operator*() const > + { > + return std::apply([&](const auto&... __iters) -> decltype(auto) { > + return std::__invoke(*_M_parent->_M_fun, *__iters...); > + }, _M_inner._M_current); > + } > + > + constexpr _Iterator& > + operator++() > + { > + ++_M_inner; > + return *this; > + } > + > + constexpr _Iterator > + operator++(int) > + { > + auto __tmp = *this; > + ++*this; > + return __tmp; > + } > + > + constexpr _Iterator& > + operator--() requires bidirectional_range<_Base> > + { > + --_M_inner; > + return *this; > + } > + > + constexpr _Iterator > + operator--(int) requires bidirectional_range<_Base> > + { > + auto __tmp = *this; > + --*this; > + return __tmp; > + } > + > + constexpr _Iterator& > + operator+=(difference_type __x) requires random_access_range<_Base> > + { > + _M_inner += __x; > + return *this; > + } > + > + constexpr _Iterator& > + operator-=(difference_type __x) requires random_access_range<_Base> > + { > + _M_inner -= __x; > + return *this; > + } > + > + constexpr decltype(auto) > + operator[](difference_type __n) const requires random_access_range<_Base> > + { > + return std::apply([&](const auto&... __iters) -> decltype(auto) { > + return std::__invoke(*_M_parent->_M_fun, __iters[__n]...); > + }, _M_inner._M_current); > + } > + > + friend constexpr bool > + operator==(const _Iterator& __x, const _Iterator& __y) > + { return __x._M_inner == __y._M_inner; } > + > + friend constexpr bool > + operator<(const _Iterator& __x, const _Iterator& __y) > + requires random_access_range<_Base> > + { return __x._M_inner < __y._M_inner; } > + > + friend constexpr bool > + operator>(const _Iterator& __x, const _Iterator& __y) > + requires random_access_range<_Base> > + { return __x._M_inner > __y._M_inner; } > + > + friend constexpr bool > + operator<=(const _Iterator& __x, const _Iterator& __y) > + requires random_access_range<_Base> > + { return __x._M_inner <= __y._M_inner; } > + > + friend constexpr bool > + operator>=(const _Iterator& __x, const _Iterator& __y) > + requires random_access_range<_Base> > + { return __x._M_inner >= __y._M_inner; } > + > + friend constexpr auto > + operator<=>(const _Iterator& __x, const _Iterator& __y) > + requires random_access_range<_Base> && > + three_way_comparable<_InnerIter<_Const>> > + { return __x._M_inner <=> __y._M_inner; } > + > + friend constexpr _Iterator > + operator+(const _Iterator& __i, difference_type __n) > + requires random_access_range<_Base> > + { return _Iterator(*__i._M_parent, __i._M_inner + __n); } > + > + friend constexpr _Iterator > + operator+(difference_type __n, const _Iterator& __i) > + requires random_access_range<_Base> > + { return _Iterator(*__i._M_parent, __i._M_inner + __n); } > + > + friend constexpr _Iterator > + operator-(const _Iterator& __i, difference_type __n) > + requires random_access_range<_Base> > + { return _Iterator(*__i._M_parent, __i._M_inner - __n); } > + > + friend constexpr difference_type > + operator-(const _Iterator& __x, const _Iterator& __y) > + requires sized_sentinel_for<_InnerIter<_Const>, _InnerIter<_Const>> > + { return __x._M_inner - __y._M_inner; } > + }; > + > + template<forward_range _Vp, copy_constructible _Fp, size_t _Nm> > + requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp> > + && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>> > + && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>, > + range_reference_t<_Vp>>> > + template<bool _Const> > + class adjacent_transform_view<_Vp, _Fp, _Nm>::_Sentinel > + { > + _InnerSent<_Const> _M_inner; > + > + constexpr explicit > + _Sentinel(_InnerSent<_Const> __inner) > + : _M_inner(__inner) > + { } > + > + friend class adjacent_transform_view; > + > + public: > + _Sentinel() = default; > + > + constexpr > + _Sentinel(_Sentinel<!_Const> __i) > + requires _Const && convertible_to<_InnerSent<false>, _InnerSent<_Const>> > + : _M_inner(std::move(__i._M_inner)) > + { } > + > + template<bool _OtherConst> > + requires sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>> > + friend constexpr bool > + operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y) > + { return __x._M_inner == __y._M_inner; } > + > + template<bool _OtherConst> > + requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>> > + friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>> > + operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y) > + { return __x._M_inner - __y._M_inner; } > + > + template<bool _OtherConst> > + requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>> > + friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>> > + operator-(const _Sentinel& __x, const _Iterator<_OtherConst>& __y) > + { return __x._M_inner - __y._M_inner; } > + }; > + > + namespace views > + { > + namespace __detail > + { > + template<size_t _Nm, typename _Range, typename _Fp> > + concept __can_adjacent_transform_view > + = requires { adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm> > + (std::declval<_Range>(), std::declval<_Fp>()); }; > + } > + > + template<size_t _Nm> > + struct _AdjacentTransform : __adaptor::_RangeAdaptor<_AdjacentTransform<_Nm>> > + { > + template<viewable_range _Range, typename _Fp> > + requires (_Nm == 0) || __detail::__can_adjacent_transform_view<_Nm, _Range, _Fp> > + [[nodiscard]] > + constexpr auto > + operator()(_Range&& __r, _Fp&& __f) const > + { > + if constexpr (_Nm == 0) > + return views::empty<tuple<>>; > + else > + return adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm> > + (std::forward<_Range>(__r), std::forward<_Fp>(__f)); > + } > + > + using __adaptor::_RangeAdaptor<_AdjacentTransform>::operator(); > + static constexpr int _S_arity = 2; > + static constexpr bool _S_has_simple_extra_args = true; > + }; > + > + template<size_t _Nm> > + inline constexpr _AdjacentTransform<_Nm> adjacent_transform; > + > + inline constexpr auto pairwise_transform = adjacent_transform<2>; > + } > #endif // C++23 > } // namespace ranges > > diff --git a/libstdc++-v3/testsuite/std/ranges/adaptors/adjacent_transform/1.cc b/libstdc++-v3/testsuite/std/ranges/adaptors/adjacent_transform/1.cc > new file mode 100644 > index 00000000000..07f20b702dd > --- /dev/null > +++ b/libstdc++-v3/testsuite/std/ranges/adaptors/adjacent_transform/1.cc > @@ -0,0 +1,106 @@ > +// { dg-options "-std=gnu++23" } > +// { dg-do run { target c++23 } } > + > +#include <ranges> > +#include <algorithm> > +#include <utility> > +#include <testsuite_hooks.h> > +#include <testsuite_iterators.h> > + > +namespace ranges = std::ranges; > +namespace views = std::views; > + > +constexpr bool > +test01() > +{ > + auto v1 = std::array{1, 2, 3} | views::adjacent_transform<1>(std::identity{}); > + VERIFY( ranges::equal(v1, (int[]){1, 2, 3}) ); > + const auto i0 = v1.begin(), i1 = v1.begin() + 1; > + VERIFY( i0 + 1 - 1 == i0 ); > + VERIFY( i0 < i1 ); > + VERIFY( i1 < v1.end() ); > + VERIFY( i1 - i0 == 1 ); > + VERIFY( i0 - i1 == -1 ); > + VERIFY( v1.end() - i1 == 2 ); > + VERIFY( i1 - v1.end() == -2 ); > + ranges::iter_swap(i0, i1); > + VERIFY( ranges::equal(std::move(v1), (int[]){2, 1, 3}) ); > + > + auto v2 = std::array{1, -1, 2, -2} | views::pairwise_transform(std::multiplies{}); > + auto i2 = v2.begin(); > + i2 += 1; > + i2 -= -2; > + VERIFY( i2 == v2.end() ); > + VERIFY( ranges::size(v2) == 3 ); > + VERIFY( ranges::size(std::as_const(v2)) == 3 ); > + VERIFY( ranges::equal(v2, (int[]){-1, -2, -4}) ); > + > + int y[] = {1, 2, 3, 4, 5, 6}; > + auto v3 = y | views::adjacent_transform<3>([](auto... xs) { return ranges::max({xs...}); }); > + VERIFY( ranges::size(v3) == 4 ); > + VERIFY( ranges::equal(v3, (int[]){3, 4, 5, 6}) ); > + > + const auto v6 = y | views::adjacent_transform<6>([](auto...) { return 0; }); > + VERIFY( ranges::equal(v6, (int[]){0}) ); > + > + const auto v7 = y | views::adjacent_transform<7>([](auto...) { return 0; }); > + VERIFY( ranges::empty(v7) ); > + > + const auto v0 = y | views::adjacent_transform<0>([] { return 0; }); > + VERIFY( ranges::empty(v0) ); > + > + return true; > +} > + > +constexpr bool > +test02() > +{ > + using __gnu_test::test_input_range; > + using __gnu_test::test_forward_range; > + using __gnu_test::test_random_access_range; > + > + using ty1 = ranges::adjacent_transform_view<views::all_t<test_forward_range<int>>, > + std::plus<>, 2>; > + static_assert(ranges::forward_range<ty1>); > + static_assert(!ranges::bidirectional_range<ty1>); > + static_assert(!ranges::sized_range<ty1>); > + > + using ty2 = ranges::adjacent_transform_view<views::all_t<test_random_access_range<int>>, > + decltype([](int, int, int) { return 0;}), 3>; > + static_assert(ranges::random_access_range<ty2>); > + static_assert(ranges::sized_range<ty2>); > + > + return true; > +} > + > +constexpr bool > +test03() > +{ > + auto v = views::iota(0, 4) > + | views::filter([](auto) { return true; }) > + | views::pairwise_transform(std::plus{}); > + using ty = decltype(v); > + static_assert(ranges::forward_range<ty>); > + static_assert(ranges::common_range<ty>); > + static_assert(!ranges::sized_range<ty>); > + VERIFY( v.begin() == v.begin() ); > + VERIFY( v.begin() != v.end() ); > + VERIFY( ranges::next(v.begin(), 3) == v.end() ); > + auto it = v.begin(); > + ++it; > + it++; > + VERIFY( ranges::next(it) == v.end() ); > + it--; > + --it; > + VERIFY( it == v.begin() ); > + > + return true; > +} > + > +int > +main() > +{ > + static_assert(test01()); > + static_assert(test02()); > + static_assert(test03()); > +} > -- > 2.37.2.490.g6c8e4ee870 > ^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 1/2] libstdc++: Implement ranges::adjacent_view from P2321R2 2022-08-30 17:13 [PATCH 1/2] libstdc++: Implement ranges::adjacent_view from P2321R2 Patrick Palka 2022-08-30 17:13 ` [PATCH 2/2] libstdc++: Implement ranges::adjacent_transform_view " Patrick Palka @ 2022-08-31 10:26 ` Jonathan Wakely 2022-08-31 13:30 ` Patrick Palka 1 sibling, 1 reply; 6+ messages in thread From: Jonathan Wakely @ 2022-08-31 10:26 UTC (permalink / raw) To: Patrick Palka; +Cc: gcc-patches, libstdc++ On Tue, 30 Aug 2022 at 18:14, Patrick Palka via Libstdc++ <libstdc++@gcc.gnu.org> wrote: > > Tested on x86_64-pc-linux-gnu, does this look OK for trunk? > + constexpr > + _Iterator(__as_sentinel, iterator_t<_Base> __first, iterator_t<_Base> __last) > + { > + if constexpr (!bidirectional_range<_Base>) > + for (auto& __it : _M_current) > + __it = __last; > + else > + for (ssize_t __i = _Nm-1; __i >= 0; --__i) ssize_t is defined by POSIX in <sys/types.h> but isn't in ISO C or C++. It looks like MinGW defines it to ... something ... sometimes, but I don't think we can rely on it for non-POSIX targets. > + template<size_t _Nm> > + struct _Adjacent : __adaptor::_RangeAdaptorClosure > + { > + template<viewable_range _Range> > + requires (_Nm == 0) || __detail::__can_adjacent_view<_Nm, _Range> > + [[nodiscard]] > + constexpr auto > + operator()(_Range&& __r) const Does this attribute actually work here? I thought we needed to use `operator() [[nodiscard]]` for functions with a requires-clause, because otherwise the attribute gives a parse error. Maybe I've misremembered the problem, and it just doesn't give a -Wunused-result warning. The decl above is setting off my spidey sense for some reason though. ^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 1/2] libstdc++: Implement ranges::adjacent_view from P2321R2 2022-08-31 10:26 ` [PATCH 1/2] libstdc++: Implement ranges::adjacent_view " Jonathan Wakely @ 2022-08-31 13:30 ` Patrick Palka 2022-08-31 13:31 ` Jonathan Wakely 0 siblings, 1 reply; 6+ messages in thread From: Patrick Palka @ 2022-08-31 13:30 UTC (permalink / raw) To: Jonathan Wakely; +Cc: Patrick Palka, gcc-patches, libstdc++ On Wed, 31 Aug 2022, Jonathan Wakely wrote: > On Tue, 30 Aug 2022 at 18:14, Patrick Palka via Libstdc++ > <libstdc++@gcc.gnu.org> wrote: > > > > Tested on x86_64-pc-linux-gnu, does this look OK for trunk? > > > > + constexpr > > + _Iterator(__as_sentinel, iterator_t<_Base> __first, iterator_t<_Base> __last) > > + { > > + if constexpr (!bidirectional_range<_Base>) > > + for (auto& __it : _M_current) > > + __it = __last; > > + else > > + for (ssize_t __i = _Nm-1; __i >= 0; --__i) > > ssize_t is defined by POSIX in <sys/types.h> but isn't in ISO C or > C++. It looks like MinGW defines it to ... something ... sometimes, > but I don't think we can rely on it for non-POSIX targets. I see. Using ssize_t makes the loop a little cleaner but it's hardly necessary, so consider it rewritten into: for (size_t __i = 0; __i < _Nm; ++__i) { _M_current[_Nm - 1 - __i] = __last; ranges::advance(__last, -1, __first); } > > > > + template<size_t _Nm> > > + struct _Adjacent : __adaptor::_RangeAdaptorClosure > > + { > > + template<viewable_range _Range> > > + requires (_Nm == 0) || __detail::__can_adjacent_view<_Nm, _Range> > > + [[nodiscard]] > > + constexpr auto > > + operator()(_Range&& __r) const > > Does this attribute actually work here? > > I thought we needed to use `operator() [[nodiscard]]` for functions > with a requires-clause, because otherwise the attribute gives a parse > error. Maybe I've misremembered the problem, and it just doesn't give > a -Wunused-result warning. The decl above is setting off my spidey > sense for some reason though. Oops yeah, it looks like this position of [[nodiscard]] works with standard concepts, but it's a parse error with -fconcepts-ts due to the different requires-clause grammar. Here's v2 which avoids using ssize_t, and puts the [[nodiscard]] after 'operator()' (_Zip and _ZipTransform have the same issue which I can fix separately): -- >8 -- libstdc++-v3/ChangeLog: * include/std/ranges (adjacent_view): Define. (enable_borrowed_range<adjacent_view>): Define. (__detail::__repeated_tuple): Define. (adjacent_view::_Iterator): Define. (adjacent_view::_Sentinel): Define. (views::__detail::__can_adjacent_view): Define. (views::_Adjacent): Define. (views::adjacent): Define. (views::pairwise): Define. * testsuite/std/ranges/adaptors/adjacent/1.cc: New test. --- libstdc++-v3/include/std/ranges | 358 ++++++++++++++++++ .../std/ranges/adaptors/adjacent/1.cc | 110 ++++++ 2 files changed, 468 insertions(+) create mode 100644 libstdc++-v3/testsuite/std/ranges/adaptors/adjacent/1.cc diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges index 6e2e561ed12..2352aad76fc 100644 --- a/libstdc++-v3/include/std/ranges +++ b/libstdc++-v3/include/std/ranges @@ -5081,6 +5081,364 @@ namespace views::__adaptor inline constexpr _ZipTransform zip_transform; } + + template<forward_range _Vp, size_t _Nm> + requires view<_Vp> && (_Nm > 0) + class adjacent_view : public view_interface<adjacent_view<_Vp, _Nm>> + { + _Vp _M_base = _Vp(); + + template<bool> class _Iterator; + template<bool> class _Sentinel; + + struct __as_sentinel + { }; + + public: + adjacent_view() requires default_initializable<_Vp> = default; + + constexpr explicit + adjacent_view(_Vp __base) + : _M_base(std::move(__base)) + { } + + constexpr auto + begin() requires (!__detail::__simple_view<_Vp>) + { return _Iterator<false>(ranges::begin(_M_base), ranges::end(_M_base)); } + + constexpr auto + begin() const requires range<const _Vp> + { return _Iterator<true>(ranges::begin(_M_base), ranges::end(_M_base)); } + + constexpr auto + end() requires (!__detail::__simple_view<_Vp>) + { + if constexpr (common_range<_Vp>) + return _Iterator<false>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base)); + else + return _Sentinel<false>(ranges::end(_M_base)); + } + + constexpr auto + end() const requires range<const _Vp> + { + if constexpr (common_range<const _Vp>) + return _Iterator<true>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base)); + else + return _Sentinel<true>(ranges::end(_M_base)); + } + + constexpr auto + size() requires sized_range<_Vp> + { + using _ST = decltype(ranges::size(_M_base)); + using _CT = common_type_t<_ST, size_t>; + auto __sz = static_cast<_CT>(ranges::size(_M_base)); + __sz -= std::min<_CT>(__sz, _Nm - 1); + return static_cast<_ST>(__sz); + } + + constexpr auto + size() const requires sized_range<const _Vp> + { + using _ST = decltype(ranges::size(_M_base)); + using _CT = common_type_t<_ST, size_t>; + auto __sz = static_cast<_CT>(ranges::size(_M_base)); + __sz -= std::min<_CT>(__sz, _Nm - 1); + return static_cast<_ST>(__sz); + } + }; + + template<typename _Vp, size_t _Nm> + inline constexpr bool enable_borrowed_range<adjacent_view<_Vp, _Nm>> + = enable_borrowed_range<_Vp>; + + namespace __detail + { + // Yields tuple<_Tp, ..., _Tp> with _Nm elements. + template<typename _Tp, size_t _Nm> + using __repeated_tuple = decltype(std::tuple_cat(std::declval<array<_Tp, _Nm>>())); + } + + template<forward_range _Vp, size_t _Nm> + requires view<_Vp> && (_Nm > 0) + template<bool _Const> + class adjacent_view<_Vp, _Nm>::_Iterator + { + using _Base = __detail::__maybe_const_t<_Const, _Vp>; + array<iterator_t<_Base>, _Nm> _M_current = array<iterator_t<_Base>, _Nm>(); + + constexpr + _Iterator(iterator_t<_Base> __first, sentinel_t<_Base> __last) + { + for (auto& __i : _M_current) + { + __i = __first; + ranges::advance(__first, 1, __last); + } + } + + constexpr + _Iterator(__as_sentinel, iterator_t<_Base> __first, iterator_t<_Base> __last) + { + if constexpr (!bidirectional_range<_Base>) + for (auto& __it : _M_current) + __it = __last; + else + for (size_t __i = 0; __i < _Nm; ++__i) + { + _M_current[_Nm - 1 - __i] = __last; + ranges::advance(__last, -1, __first); + } + } + + static auto + _S_iter_concept() + { + if constexpr (random_access_range<_Base>) + return random_access_iterator_tag{}; + else if constexpr (bidirectional_range<_Base>) + return bidirectional_iterator_tag{}; + else + return forward_iterator_tag{}; + } + + friend class adjacent_view; + + public: + using iterator_category = input_iterator_tag; + using iterator_concept = decltype(_S_iter_concept()); + using value_type = conditional_t<_Nm == 2, + pair<range_value_t<_Base>, range_value_t<_Base>>, + __detail::__repeated_tuple<range_value_t<_Base>, _Nm>>; + using difference_type = range_difference_t<_Base>; + + _Iterator() = default; + + constexpr + _Iterator(_Iterator<!_Const> __i) + requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>> + { + for (size_t __j = 0; __j < _Nm; ++__j) + _M_current[__j] = std::move(__i[__j]); + } + + constexpr auto + operator*() const + { + auto __f = [](auto& __i) -> decltype(auto) { return *__i; }; + return __detail::__tuple_transform(__f, _M_current); + } + + constexpr _Iterator& + operator++() + { + for (auto& __i : _M_current) + ++__i; + return *this; + } + + constexpr _Iterator + operator++(int) + { + auto __tmp = *this; + ++*this; + return __tmp; + } + + constexpr _Iterator& + operator--() requires bidirectional_range<_Base> + { + for (auto& __i : _M_current) + --__i; + return *this; + } + + constexpr _Iterator + operator--(int) requires bidirectional_range<_Base> + { + auto __tmp = *this; + --*this; + return __tmp; + } + + constexpr _Iterator& + operator+=(difference_type __x) + requires random_access_range<_Base> + { + for (auto& __i : _M_current) + __i += __x; + return *this; + } + + constexpr _Iterator& + operator-=(difference_type __x) + requires random_access_range<_Base> + { + for (auto& __i : _M_current) + __i -= __x; + return *this; + } + + constexpr auto + operator[](difference_type __n) const + requires random_access_range<_Base> + { + auto __f = [&](auto& __i) -> decltype(auto) { return __i[__n]; }; + return __detail::__tuple_transform(__f, _M_current); + } + + friend constexpr bool + operator==(const _Iterator& __x, const _Iterator& __y) + { return __x._M_current.back() == __y._M_current.back(); } + + friend constexpr bool + operator<(const _Iterator& __x, const _Iterator& __y) + requires random_access_range<_Base> + { return __x._M_current.back() < __y._M_current.back(); } + + friend constexpr bool + operator>(const _Iterator& __x, const _Iterator& __y) + requires random_access_range<_Base> + { return __y < __x; } + + friend constexpr bool + operator<=(const _Iterator& __x, const _Iterator& __y) + requires random_access_range<_Base> + { return !(__y < __x); } + + friend constexpr bool + operator>=(const _Iterator& __x, const _Iterator& __y) + requires random_access_range<_Base> + { return !(__x < __y); } + + friend constexpr auto + operator<=>(const _Iterator& __x, const _Iterator& __y) + requires random_access_range<_Base> + && three_way_comparable<iterator_t<_Base>> + { return __x._M_current.back() <=> __y._M_current.back(); } + + friend constexpr _Iterator + operator+(const _Iterator& __i, difference_type __n) + requires random_access_range<_Base> + { + auto __r = __i; + __r += __n; + return __r; + } + + friend constexpr _Iterator + operator+(difference_type __n, const _Iterator& __i) + requires random_access_range<_Base> + { + auto __r = __i; + __r += __n; + return __r; + } + + friend constexpr _Iterator + operator-(const _Iterator& __i, difference_type __n) + requires random_access_range<_Base> + { + auto __r = __i; + __r -= __n; + return __r; + } + + friend constexpr difference_type + operator-(const _Iterator& __x, const _Iterator& __y) + requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>> + { return __x._M_current.back() - __y._M_current.back(); } + + 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<_Base>> + { + for (size_t __i = 0; __i < _Nm; __i++) + ranges::iter_swap(__l._M_current[__i], __r._M_current[__i]); + } + }; + + template<forward_range _Vp, size_t _Nm> + requires view<_Vp> && (_Nm > 0) + template<bool _Const> + class adjacent_view<_Vp, _Nm>::_Sentinel + { + using _Base = __detail::__maybe_const_t<_Const, _Vp>; + + sentinel_t<_Base> _M_end = sentinel_t<_Base>(); + + constexpr explicit + _Sentinel(sentinel_t<_Base> __end) + : _M_end(__end) + { } + + friend class adjacent_view; + + public: + _Sentinel() = default; + + constexpr + _Sentinel(_Sentinel<!_Const> __i) + requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>> + : _M_end(std::move(__i._M_end)) + { } + + template<bool _OtherConst> + requires sentinel_for<sentinel_t<_Base>, + iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>> + friend constexpr bool + operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y) + { return __x._M_current.back() == __y._M_end; } + + template<bool _OtherConst> + requires sized_sentinel_for<sentinel_t<_Base>, + iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>> + friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>> + operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y) + { return __x._M_current.back() - __y._M_end; } + + template<bool _OtherConst> + requires sized_sentinel_for<sentinel_t<_Base>, + iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>> + friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>> + operator-(const _Sentinel& __y, const _Iterator<_OtherConst>& __x) + { return __y._M_end - __x._M_current.back(); } + }; + + namespace views + { + namespace __detail + { + template<size_t _Nm, typename _Range> + concept __can_adjacent_view + = requires { adjacent_view<all_t<_Range>, _Nm>(std::declval<_Range>()); }; + } + + template<size_t _Nm> + struct _Adjacent : __adaptor::_RangeAdaptorClosure + { + template<viewable_range _Range> + requires (_Nm == 0) || __detail::__can_adjacent_view<_Nm, _Range> + constexpr auto + operator() [[nodiscard]] (_Range&& __r) const + { + if constexpr (_Nm == 0) + return views::empty<tuple<>>; + else + return adjacent_view<all_t<_Range>, _Nm>(std::forward<_Range>(__r)); + } + }; + + template<size_t _Nm> + inline constexpr _Adjacent<_Nm> adjacent; + + inline constexpr auto pairwise = adjacent<2>; + } #endif // C++23 } // namespace ranges diff --git a/libstdc++-v3/testsuite/std/ranges/adaptors/adjacent/1.cc b/libstdc++-v3/testsuite/std/ranges/adaptors/adjacent/1.cc new file mode 100644 index 00000000000..9829f79364f --- /dev/null +++ b/libstdc++-v3/testsuite/std/ranges/adaptors/adjacent/1.cc @@ -0,0 +1,110 @@ +// { dg-options "-std=gnu++23" } +// { dg-do run { target c++23 } } + +#include <ranges> +#include <algorithm> +#include <utility> +#include <testsuite_hooks.h> +#include <testsuite_iterators.h> + +namespace ranges = std::ranges; +namespace views = std::views; + +constexpr bool +test01() +{ + static_assert(ranges::empty(std::array{1, 2, 3} | views::adjacent<0>)); + + auto v1 = std::array{1, 2} | views::adjacent<1>; + const auto i0 = v1.begin(), i1 = v1.begin() + 1; + VERIFY( i0 + 1 - 1 == i0 ); + VERIFY( i0 < i1 ); + VERIFY( i1 < v1.end() ); + VERIFY( i1 - i0 == 1 ); + VERIFY( i0 - i1 == -1 ); + VERIFY( v1.end() - i1 == 1 ); + VERIFY( i1 - v1.end() == -1 ); + ranges::iter_swap(i0, i1); + VERIFY( ranges::equal(std::move(v1) | views::keys, (int[]){2, 1}) ); + + int x[] = {1, 2, 3, 4}; + auto v2 = x | views::pairwise; + auto i2 = v2.begin(); + i2 += 2; + i2 -= -1; + VERIFY( i2 == v2.end() ); + VERIFY( ranges::size(v2) == 3 ); + VERIFY( ranges::size(std::as_const(v2)) == 3 ); + VERIFY( ranges::equal(v2 | views::keys, (int[]){1, 2, 3}) ); + VERIFY( ranges::equal(v2 | views::values, (int[]){2, 3, 4}) ); + + int y[] = {1, 2, 3, 4, 5}; + const auto v3 = y | views::adjacent<3>; + VERIFY( ranges::size(v3) == 3 ); + for (unsigned i = 0; i < ranges::size(x); i++) + { + VERIFY( &std::get<0>(v3[i]) == &y[i] + 0 ); + VERIFY( &std::get<1>(v3[i]) == &y[i] + 1 ); + VERIFY( &std::get<2>(v3[i]) == &y[i] + 2 ); + } + + const auto v5 = y | views::adjacent<5>; + VERIFY( ranges::equal(v5, views::single(std::make_tuple(1, 2, 3, 4, 5))) ); + + const auto v6 = y | views::adjacent<6>; + VERIFY( ranges::empty(v6) ); + + const auto v0 = y | views::adjacent<0>; + VERIFY( ranges::empty(v0) ); + + return true; +} + +constexpr bool +test02() +{ + using __gnu_test::test_input_range; + using __gnu_test::test_forward_range; + using __gnu_test::test_random_access_range; + + using ty1 = ranges::adjacent_view<views::all_t<test_forward_range<int>>, 2>; + static_assert(ranges::forward_range<ty1>); + static_assert(!ranges::bidirectional_range<ty1>); + static_assert(!ranges::sized_range<ty1>); + + using ty2 = ranges::adjacent_view<views::all_t<test_random_access_range<int>>, 3>; + static_assert(ranges::random_access_range<ty2>); + static_assert(ranges::sized_range<ty2>); + + return true; +} + +constexpr bool +test03() +{ + auto v = views::iota(0, 4) | views::filter([](auto) { return true; }) | views::pairwise; + using ty = decltype(v); + static_assert(ranges::forward_range<ty>); + static_assert(ranges::common_range<ty>); + static_assert(!ranges::sized_range<ty>); + VERIFY( v.begin() == v.begin() ); + VERIFY( v.begin() != v.end() ); + VERIFY( ranges::next(v.begin(), 3) == v.end() ); + auto it = v.begin(); + ++it; + it++; + VERIFY( ranges::next(it) == v.end() ); + it--; + --it; + VERIFY( it == v.begin() ); + + return true; +} + +int +main() +{ + static_assert(test01()); + static_assert(test02()); + static_assert(test03()); +} -- 2.37.2.490.g6c8e4ee870 ^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 1/2] libstdc++: Implement ranges::adjacent_view from P2321R2 2022-08-31 13:30 ` Patrick Palka @ 2022-08-31 13:31 ` Jonathan Wakely 0 siblings, 0 replies; 6+ messages in thread From: Jonathan Wakely @ 2022-08-31 13:31 UTC (permalink / raw) To: Patrick Palka; +Cc: gcc-patches, libstdc++ On Wed, 31 Aug 2022 at 14:30, Patrick Palka <ppalka@redhat.com> wrote: > > On Wed, 31 Aug 2022, Jonathan Wakely wrote: > > > On Tue, 30 Aug 2022 at 18:14, Patrick Palka via Libstdc++ > > <libstdc++@gcc.gnu.org> wrote: > > > > > > Tested on x86_64-pc-linux-gnu, does this look OK for trunk? > > > > > > > + constexpr > > > + _Iterator(__as_sentinel, iterator_t<_Base> __first, iterator_t<_Base> __last) > > > + { > > > + if constexpr (!bidirectional_range<_Base>) > > > + for (auto& __it : _M_current) > > > + __it = __last; > > > + else > > > + for (ssize_t __i = _Nm-1; __i >= 0; --__i) > > > > ssize_t is defined by POSIX in <sys/types.h> but isn't in ISO C or > > C++. It looks like MinGW defines it to ... something ... sometimes, > > but I don't think we can rely on it for non-POSIX targets. > > I see. Using ssize_t makes the loop a little cleaner but it's hardly > necessary, so consider it rewritten into: > > for (size_t __i = 0; __i < _Nm; ++__i) > { > _M_current[_Nm - 1 - __i] = __last; > ranges::advance(__last, -1, __first); > } > > > > > > > > + template<size_t _Nm> > > > + struct _Adjacent : __adaptor::_RangeAdaptorClosure > > > + { > > > + template<viewable_range _Range> > > > + requires (_Nm == 0) || __detail::__can_adjacent_view<_Nm, _Range> > > > + [[nodiscard]] > > > + constexpr auto > > > + operator()(_Range&& __r) const > > > > Does this attribute actually work here? > > > > I thought we needed to use `operator() [[nodiscard]]` for functions > > with a requires-clause, because otherwise the attribute gives a parse > > error. Maybe I've misremembered the problem, and it just doesn't give > > a -Wunused-result warning. The decl above is setting off my spidey > > sense for some reason though. > > Oops yeah, it looks like this position of [[nodiscard]] works with > standard concepts, but it's a parse error with -fconcepts-ts due to the > different requires-clause grammar. > > Here's v2 which avoids using ssize_t, and puts the [[nodiscard]] after > 'operator()' (_Zip and _ZipTransform have the same issue which I can > fix separately): OK for trunk with those changes, thanks. ^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2022-09-01 11:14 UTC | newest] Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2022-08-30 17:13 [PATCH 1/2] libstdc++: Implement ranges::adjacent_view from P2321R2 Patrick Palka 2022-08-30 17:13 ` [PATCH 2/2] libstdc++: Implement ranges::adjacent_transform_view " Patrick Palka 2022-09-01 11:14 ` Jonathan Wakely 2022-08-31 10:26 ` [PATCH 1/2] libstdc++: Implement ranges::adjacent_view " Jonathan Wakely 2022-08-31 13:30 ` Patrick Palka 2022-08-31 13:31 ` Jonathan Wakely
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).