[libc++][ranges] implement `std::views::elements_view`
`subrange` is also a `tuple-like`. To avoid the add entire `subrange` dependencies to `tuple-like`, we need forward declaration of `subrange`. However, the class template constraints of `subrange` currently requires `__iterator/concepts.h`, which requires `<concepts>`. The problem is that currently `tuple-like` is used in several different places, including libc++ extension for pair constructors. we don't want to add `<concepts>` to pair and other stuff. So this change also created several small headers that `subrange`'s declaration needed inside `__iterator/concepts/`
Differential Revision: https://reviews.llvm.org/D136268
NOKEYCHECK=True
GitOrigin-RevId: 94461822c75d5080bf648f86552f7a59b76905c9
diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
index 06c5eb1..ea52f20 100644
--- a/include/CMakeLists.txt
+++ b/include/CMakeLists.txt
@@ -364,6 +364,7 @@
__fwd/span.h
__fwd/string.h
__fwd/string_view.h
+ __fwd/subrange.h
__fwd/tuple.h
__hash_table
__ios/fpos.h
@@ -503,6 +504,7 @@
__ranges/data.h
__ranges/drop_view.h
__ranges/drop_while_view.h
+ __ranges/elements_view.h
__ranges/empty.h
__ranges/empty_view.h
__ranges/enable_borrowed_range.h
@@ -554,10 +556,12 @@
__tree
__tuple_dir/apply_cv.h
__tuple_dir/make_tuple_types.h
+ __tuple_dir/pair_like.h
__tuple_dir/sfinae_helpers.h
__tuple_dir/tuple_element.h
__tuple_dir/tuple_indices.h
__tuple_dir/tuple_like.h
+ __tuple_dir/tuple_like_ext.h
__tuple_dir/tuple_size.h
__tuple_dir/tuple_types.h
__type_traits/add_const.h
diff --git a/include/__fwd/get.h b/include/__fwd/get.h
index 98758eb..ec1fab4 100644
--- a/include/__fwd/get.h
+++ b/include/__fwd/get.h
@@ -9,9 +9,11 @@
#ifndef _LIBCPP___FWD_GET_H
#define _LIBCPP___FWD_GET_H
+#include <__concepts/copyable.h>
#include <__config>
#include <__fwd/array.h>
#include <__fwd/pair.h>
+#include <__fwd/subrange.h>
#include <__fwd/tuple.h>
#include <__tuple_dir/tuple_element.h>
#include <cstddef>
@@ -90,6 +92,24 @@
get(const array<_Tp, _Size>&&) _NOEXCEPT;
#endif
+#if _LIBCPP_STD_VER >= 20
+
+namespace ranges {
+
+template <size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
+ requires((_Index == 0 && copyable<_Iter>) || _Index == 1)
+_LIBCPP_HIDE_FROM_ABI constexpr auto get(const subrange<_Iter, _Sent, _Kind>& __subrange);
+
+template <size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
+ requires(_Index < 2)
+_LIBCPP_HIDE_FROM_ABI constexpr auto get(subrange<_Iter, _Sent, _Kind>&& __subrange);
+
+} // namespace ranges
+
+using ranges::get;
+
+#endif // _LIBCPP_STD_VER >= 20
+
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FWD_GET_H
diff --git a/include/__fwd/subrange.h b/include/__fwd/subrange.h
new file mode 100644
index 0000000..8f72392
--- /dev/null
+++ b/include/__fwd/subrange.h
@@ -0,0 +1,38 @@
+//===---------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FWD_SUBRANGE_H
+#define _LIBCPP___FWD_SUBRANGE_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 20
+
+#include <__iterator/concepts.h>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+
+enum class _LIBCPP_ENUM_VIS subrange_kind : bool { unsized, sized };
+
+template <input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent, subrange_kind _Kind>
+ requires(_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _Iter>)
+class _LIBCPP_TEMPLATE_VIS subrange;
+
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 20
+
+#endif // _LIBCPP___FWD_SUBRANGE_H
diff --git a/include/__ranges/elements_view.h b/include/__ranges/elements_view.h
new file mode 100644
index 0000000..3afd6dd
--- /dev/null
+++ b/include/__ranges/elements_view.h
@@ -0,0 +1,423 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_ELEMENTS_VIEW_H
+#define _LIBCPP___RANGES_ELEMENTS_VIEW_H
+
+#include <__compare/three_way_comparable.h>
+#include <__concepts/constructible.h>
+#include <__concepts/convertible_to.h>
+#include <__concepts/derived_from.h>
+#include <__concepts/equality_comparable.h>
+#include <__config>
+#include <__fwd/get.h>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h>
+#include <__ranges/access.h>
+#include <__ranges/all.h>
+#include <__ranges/concepts.h>
+#include <__ranges/enable_borrowed_range.h>
+#include <__ranges/range_adaptor.h>
+#include <__ranges/size.h>
+#include <__ranges/view_interface.h>
+#include <__tuple_dir/tuple_element.h>
+#include <__tuple_dir/tuple_like.h>
+#include <__tuple_dir/tuple_size.h>
+#include <__type_traits/is_reference.h>
+#include <__type_traits/maybe_const.h>
+#include <__type_traits/remove_cv.h>
+#include <__type_traits/remove_cvref.h>
+#include <__type_traits/remove_reference.h>
+#include <__utility/declval.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+namespace ranges {
+
+template <class _View, size_t _Np, bool _Const>
+class __elements_view_iterator;
+
+template <class _View, size_t _Np, bool _Const>
+class __elements_view_sentinel;
+
+template <class _Tp, size_t _Np>
+concept __has_tuple_element = __tuple_like<_Tp> && _Np < tuple_size<_Tp>::value;
+
+template <class _Tp, size_t _Np>
+concept __returnable_element = is_reference_v<_Tp> || move_constructible<tuple_element_t<_Np, _Tp>>;
+
+template <input_range _View, size_t _Np>
+ requires view<_View> && __has_tuple_element<range_value_t<_View>, _Np> &&
+ __has_tuple_element<remove_reference_t<range_reference_t<_View>>, _Np> &&
+ __returnable_element<range_reference_t<_View>, _Np>
+class elements_view : public view_interface<elements_view<_View, _Np>> {
+public:
+ _LIBCPP_HIDE_FROM_ABI elements_view()
+ requires default_initializable<_View>
+ = default;
+
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit elements_view(_View __base) : __base_(std::move(__base)) {}
+
+ _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+ requires copy_constructible<_View>
+ {
+ return __base_;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr auto begin()
+ requires(!__simple_view<_View>)
+ {
+ return __iterator</*_Const=*/false>(ranges::begin(__base_));
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+ requires range<const _View>
+ {
+ return __iterator</*_Const=*/true>(ranges::begin(__base_));
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr auto end()
+ requires(!__simple_view<_View> && !common_range<_View>)
+ {
+ return __sentinel</*_Const=*/false>{ranges::end(__base_)};
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr auto end()
+ requires(!__simple_view<_View> && common_range<_View>)
+ {
+ return __iterator</*_Const=*/false>{ranges::end(__base_)};
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+ requires range<const _View>
+ {
+ return __sentinel</*_Const=*/true>{ranges::end(__base_)};
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+ requires common_range<const _View>
+ {
+ return __iterator</*_Const=*/true>{ranges::end(__base_)};
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+ requires sized_range<_View>
+ {
+ return ranges::size(__base_);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+ requires sized_range<const _View>
+ {
+ return ranges::size(__base_);
+ }
+
+private:
+ template <bool _Const>
+ using __iterator = __elements_view_iterator<_View, _Np, _Const>;
+
+ template <bool _Const>
+ using __sentinel = __elements_view_sentinel<_View, _Np, _Const>;
+
+ _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
+};
+
+template <class, size_t>
+struct __elements_view_iterator_category_base {};
+
+template <forward_range _Base, size_t _Np>
+struct __elements_view_iterator_category_base<_Base, _Np> {
+ static consteval auto __get_iterator_category() {
+ using _Result = decltype(std::get<_Np>(*std::declval<iterator_t<_Base>>()));
+ using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
+
+ if constexpr (!is_lvalue_reference_v<_Result>) {
+ return input_iterator_tag{};
+ } else if constexpr (derived_from<_Cat, random_access_iterator_tag>) {
+ return random_access_iterator_tag{};
+ } else {
+ return _Cat{};
+ }
+ }
+
+ using iterator_category = decltype(__get_iterator_category());
+};
+
+template <class _View, size_t _Np, bool _Const>
+class __elements_view_iterator : public __elements_view_iterator_category_base<__maybe_const<_Const, _View>, _Np> {
+ template <class, size_t, bool >
+ friend class __elements_view_iterator;
+
+ template <class, size_t, bool >
+ friend class __elements_view_sentinel;
+
+ using _Base = __maybe_const<_Const, _View>;
+
+ iterator_t<_Base> __current_ = iterator_t<_Base>();
+
+ _LIBCPP_HIDE_FROM_ABI static constexpr decltype(auto) __get_element(const iterator_t<_Base>& __i) {
+ if constexpr (is_reference_v<range_reference_t<_Base>>) {
+ return std::get<_Np>(*__i);
+ } else {
+ using _Element = remove_cv_t<tuple_element_t<_Np, range_reference_t<_Base>>>;
+ return static_cast<_Element>(std::get<_Np>(*__i));
+ }
+ }
+
+ static consteval auto __get_iterator_concept() {
+ if constexpr (random_access_range<_Base>) {
+ return random_access_iterator_tag{};
+ } else if constexpr (bidirectional_range<_Base>) {
+ return bidirectional_iterator_tag{};
+ } else if constexpr (forward_range<_Base>) {
+ return forward_iterator_tag{};
+ } else {
+ return input_iterator_tag{};
+ }
+ }
+
+public:
+ using iterator_concept = decltype(__get_iterator_concept());
+ using value_type = remove_cvref_t<tuple_element_t<_Np, range_value_t<_Base>>>;
+ using difference_type = range_difference_t<_Base>;
+
+ _LIBCPP_HIDE_FROM_ABI __elements_view_iterator()
+ requires default_initializable<iterator_t<_Base>>
+ = default;
+
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit __elements_view_iterator(iterator_t<_Base> __current)
+ : __current_(std::move(__current)) {}
+
+ _LIBCPP_HIDE_FROM_ABI constexpr __elements_view_iterator(__elements_view_iterator<_View, _Np, !_Const> __i)
+ requires _Const && convertible_to<iterator_t<_View>, iterator_t<_Base>>
+ : __current_(std::move(__i.__current_)) {}
+
+ _LIBCPP_HIDE_FROM_ABI constexpr const iterator_t<_Base>& base() const& noexcept { return __current_; }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Base> base() && { return std::move(__current_); }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() const { return __get_element(__current_); }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr __elements_view_iterator& operator++() {
+ ++__current_;
+ return *this;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++__current_; }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr __elements_view_iterator operator++(int)
+ requires forward_range<_Base>
+ {
+ auto temp = *this;
+ ++__current_;
+ return temp;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr __elements_view_iterator& operator--()
+ requires bidirectional_range<_Base>
+ {
+ --__current_;
+ return *this;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr __elements_view_iterator operator--(int)
+ requires bidirectional_range<_Base>
+ {
+ auto temp = *this;
+ --__current_;
+ return temp;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr __elements_view_iterator& operator+=(difference_type __n)
+ requires random_access_range<_Base>
+ {
+ __current_ += __n;
+ return *this;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr __elements_view_iterator& operator-=(difference_type __n)
+ requires random_access_range<_Base>
+ {
+ __current_ -= __n;
+ return *this;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](difference_type __n) const
+ requires random_access_range<_Base>
+ {
+ return __get_element(__current_ + __n);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+ operator==(const __elements_view_iterator& __x, const __elements_view_iterator& __y)
+ requires equality_comparable<iterator_t<_Base>>
+ {
+ return __x.__current_ == __y.__current_;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+ operator<(const __elements_view_iterator& __x, const __elements_view_iterator& __y)
+ requires random_access_range<_Base>
+ {
+ return __x.__current_ < __y.__current_;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+ operator>(const __elements_view_iterator& __x, const __elements_view_iterator& __y)
+ requires random_access_range<_Base>
+ {
+ return __y < __x;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+ operator<=(const __elements_view_iterator& __x, const __elements_view_iterator& __y)
+ requires random_access_range<_Base>
+ {
+ return !(__y < __x);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+ operator>=(const __elements_view_iterator& __x, const __elements_view_iterator& __y)
+ requires random_access_range<_Base>
+ {
+ return !(__x < __y);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend constexpr auto
+ operator<=>(const __elements_view_iterator& __x, const __elements_view_iterator& __y)
+ requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
+ {
+ return __x.__current_ <=> __y.__current_;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend constexpr __elements_view_iterator
+ operator+(const __elements_view_iterator& __x, difference_type __y)
+ requires random_access_range<_Base>
+ {
+ return __elements_view_iterator{__x} += __y;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend constexpr __elements_view_iterator
+ operator+(difference_type __x, const __elements_view_iterator& __y)
+ requires random_access_range<_Base>
+ {
+ return __y + __x;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend constexpr __elements_view_iterator
+ operator-(const __elements_view_iterator& __x, difference_type __y)
+ requires random_access_range<_Base>
+ {
+ return __elements_view_iterator{__x} -= __y;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type
+ operator-(const __elements_view_iterator& __x, const __elements_view_iterator& __y)
+ requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
+ {
+ return __x.__current_ - __y.__current_;
+ }
+};
+
+template <class _View, size_t _Np, bool _Const>
+class __elements_view_sentinel {
+private:
+ using _Base = __maybe_const<_Const, _View>;
+ _LIBCPP_NO_UNIQUE_ADDRESS sentinel_t<_Base> __end_ = sentinel_t<_Base>();
+
+ template <class, size_t, bool >
+ friend class __elements_view_sentinel;
+
+ template <bool _AnyConst>
+ _LIBCPP_HIDE_FROM_ABI static constexpr decltype(auto)
+ __get_current(const __elements_view_iterator<_View, _Np, _AnyConst>& __iter) {
+ return (__iter.__current_);
+ }
+
+public:
+ _LIBCPP_HIDE_FROM_ABI __elements_view_sentinel() = default;
+
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit __elements_view_sentinel(sentinel_t<_Base> __end)
+ : __end_(std::move(__end)) {}
+
+ _LIBCPP_HIDE_FROM_ABI constexpr __elements_view_sentinel(__elements_view_sentinel<_View, _Np, !_Const> __other)
+ requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
+ : __end_(std::move(__other.__end_)) {}
+
+ _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Base> base() const { return __end_; }
+
+ template <bool _OtherConst>
+ requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+ operator==(const __elements_view_iterator<_View, _Np, _OtherConst>& __x, const __elements_view_sentinel& __y) {
+ return __get_current(__x) == __y.__end_;
+ }
+
+ template <bool _OtherConst>
+ requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+ _LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
+ operator-(const __elements_view_iterator<_View, _Np, _OtherConst>& __x, const __elements_view_sentinel& __y) {
+ return __get_current(__x) - __y.__end_;
+ }
+
+ template <bool _OtherConst>
+ requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+ _LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
+ operator-(const __elements_view_sentinel& __x, const __elements_view_iterator<_View, _Np, _OtherConst>& __y) {
+ return __x.__end_ - __get_current(__y);
+ }
+};
+
+template <class _Tp, size_t _Np>
+inline constexpr bool enable_borrowed_range<elements_view<_Tp, _Np>> = enable_borrowed_range<_Tp>;
+
+template <class _Tp>
+using keys_view = elements_view<_Tp, 0>;
+template <class _Tp>
+using values_view = elements_view<_Tp, 1>;
+
+namespace views {
+namespace __elements {
+
+template <size_t _Np>
+struct __fn : __range_adaptor_closure<__fn<_Np>> {
+ template <class _Range>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
+ /**/ noexcept(noexcept(elements_view<all_t<_Range&&>, _Np>(std::forward<_Range>(__range))))
+ /*------*/ -> decltype(elements_view<all_t<_Range&&>, _Np>(std::forward<_Range>(__range))) {
+ /*-------------*/ return elements_view<all_t<_Range&&>, _Np>(std::forward<_Range>(__range));
+ }
+};
+} // namespace __elements
+
+inline namespace __cpo {
+template <size_t _Np>
+inline constexpr auto elements = __elements::__fn<_Np>{};
+inline constexpr auto keys = elements<0>;
+inline constexpr auto values = elements<1>;
+} // namespace __cpo
+} // namespace views
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_ELEMENTS_VIEW_H
diff --git a/include/__ranges/subrange.h b/include/__ranges/subrange.h
index f47db6b..2d9e4cc 100644
--- a/include/__ranges/subrange.h
+++ b/include/__ranges/subrange.h
@@ -18,6 +18,7 @@
#include <__concepts/different_from.h>
#include <__config>
#include <__fwd/get.h>
+#include <__fwd/subrange.h>
#include <__iterator/advance.h>
#include <__iterator/concepts.h>
#include <__iterator/incrementable_traits.h>
@@ -28,6 +29,7 @@
#include <__ranges/enable_borrowed_range.h>
#include <__ranges/size.h>
#include <__ranges/view_interface.h>
+#include <__tuple_dir/pair_like.h>
#include <__tuple_dir/tuple_element.h>
#include <__tuple_dir/tuple_size.h>
#include <__type_traits/conditional.h>
@@ -59,17 +61,6 @@
convertible_to<_From, _To> &&
!__uses_nonqualification_pointer_conversion<decay_t<_From>, decay_t<_To>>;
- template<class _Tp>
- concept __pair_like =
- !is_reference_v<_Tp> && requires(_Tp __t) {
- typename tuple_size<_Tp>::type; // Ensures `tuple_size<T>` is complete.
- requires derived_from<tuple_size<_Tp>, integral_constant<size_t, 2>>;
- typename tuple_element_t<0, remove_const_t<_Tp>>;
- typename tuple_element_t<1, remove_const_t<_Tp>>;
- { std::get<0>(__t) } -> convertible_to<const tuple_element_t<0, _Tp>&>;
- { std::get<1>(__t) } -> convertible_to<const tuple_element_t<1, _Tp>&>;
- };
-
template<class _Pair, class _Iter, class _Sent>
concept __pair_like_convertible_from =
!range<_Pair> && __pair_like<_Pair> &&
@@ -77,8 +68,6 @@
__convertible_to_non_slicing<_Iter, tuple_element_t<0, _Pair>> &&
convertible_to<_Sent, tuple_element_t<1, _Pair>>;
- enum class _LIBCPP_ENUM_VIS subrange_kind : bool { unsized, sized };
-
template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent = _Iter,
subrange_kind _Kind = sized_sentinel_for<_Sent, _Iter>
? subrange_kind::sized
diff --git a/include/__tuple_dir/pair_like.h b/include/__tuple_dir/pair_like.h
new file mode 100644
index 0000000..87407ad
--- /dev/null
+++ b/include/__tuple_dir/pair_like.h
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TUPLE_PAIR_LIKE_H
+#define _LIBCPP___TUPLE_PAIR_LIKE_H
+
+#include <__config>
+#include <__tuple_dir/tuple_like.h>
+#include <__tuple_dir/tuple_size.h>
+#include <__type_traits/remove_cvref.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+template <class _Tp>
+concept __pair_like = __tuple_like<_Tp> && tuple_size<remove_cvref_t<_Tp>>::value == 2;
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___TUPLE_PAIR_LIKE_H
diff --git a/include/__tuple_dir/sfinae_helpers.h b/include/__tuple_dir/sfinae_helpers.h
index fde5341..fcd65a0 100644
--- a/include/__tuple_dir/sfinae_helpers.h
+++ b/include/__tuple_dir/sfinae_helpers.h
@@ -13,7 +13,7 @@
#include <__fwd/tuple.h>
#include <__tuple_dir/make_tuple_types.h>
#include <__tuple_dir/tuple_element.h>
-#include <__tuple_dir/tuple_like.h>
+#include <__tuple_dir/tuple_like_ext.h>
#include <__tuple_dir/tuple_size.h>
#include <__tuple_dir/tuple_types.h>
#include <__type_traits/enable_if.h>
@@ -58,8 +58,8 @@
// __tuple_convertible
-template <class _Tp, class _Up, bool = __tuple_like<__libcpp_remove_reference_t<_Tp> >::value,
- bool = __tuple_like<_Up>::value>
+template <class _Tp, class _Up, bool = __tuple_like_ext<__libcpp_remove_reference_t<_Tp> >::value,
+ bool = __tuple_like_ext<_Up>::value>
struct __tuple_convertible
: public false_type {};
@@ -73,8 +73,8 @@
// __tuple_constructible
-template <class _Tp, class _Up, bool = __tuple_like<__libcpp_remove_reference_t<_Tp> >::value,
- bool = __tuple_like<_Up>::value>
+template <class _Tp, class _Up, bool = __tuple_like_ext<__libcpp_remove_reference_t<_Tp> >::value,
+ bool = __tuple_like_ext<_Up>::value>
struct __tuple_constructible
: public false_type {};
@@ -88,8 +88,8 @@
// __tuple_assignable
-template <class _Tp, class _Up, bool = __tuple_like<__libcpp_remove_reference_t<_Tp> >::value,
- bool = __tuple_like<_Up>::value>
+template <class _Tp, class _Up, bool = __tuple_like_ext<__libcpp_remove_reference_t<_Tp> >::value,
+ bool = __tuple_like_ext<_Up>::value>
struct __tuple_assignable
: public false_type {};
@@ -117,7 +117,7 @@
template <class _Tuple, size_t _ExpectedSize, class _RawTuple = __libcpp_remove_reference_t<_Tuple> >
using __tuple_like_with_size _LIBCPP_NODEBUG = __tuple_like_with_size_imp<
- __tuple_like<_RawTuple>::value,
+ __tuple_like_ext<_RawTuple>::value,
tuple_size<_RawTuple>, _ExpectedSize
>;
diff --git a/include/__tuple_dir/tuple_like.h b/include/__tuple_dir/tuple_like.h
index 3272877..dab395b 100644
--- a/include/__tuple_dir/tuple_like.h
+++ b/include/__tuple_dir/tuple_like.h
@@ -12,9 +12,10 @@
#include <__config>
#include <__fwd/array.h>
#include <__fwd/pair.h>
+#include <__fwd/subrange.h>
#include <__fwd/tuple.h>
-#include <__tuple_dir/tuple_types.h>
#include <__type_traits/integral_constant.h>
+#include <__type_traits/remove_cvref.h>
#include <cstddef>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -23,21 +24,27 @@
_LIBCPP_BEGIN_NAMESPACE_STD
-template <class _Tp> struct __tuple_like : false_type {};
+#if _LIBCPP_STD_VER >= 20
-template <class _Tp> struct __tuple_like<const _Tp> : public __tuple_like<_Tp> {};
-template <class _Tp> struct __tuple_like<volatile _Tp> : public __tuple_like<_Tp> {};
-template <class _Tp> struct __tuple_like<const volatile _Tp> : public __tuple_like<_Tp> {};
+template <class _Tp>
+struct __tuple_like_impl : false_type {};
-#ifndef _LIBCPP_CXX03_LANG
-template <class... _Tp> struct __tuple_like<tuple<_Tp...> > : true_type {};
-#endif
+template <class... _Tp>
+struct __tuple_like_impl<tuple<_Tp...> > : true_type {};
-template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {};
+template <class _T1, class _T2>
+struct __tuple_like_impl<pair<_T1, _T2> > : true_type {};
-template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {};
+template <class _Tp, size_t _Size>
+struct __tuple_like_impl<array<_Tp, _Size> > : true_type {};
-template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...> > : true_type {};
+template <class _Ip, class _Sp, ranges::subrange_kind _Kp>
+struct __tuple_like_impl<ranges::subrange<_Ip, _Sp, _Kp> > : true_type {};
+
+template <class _Tp>
+concept __tuple_like = __tuple_like_impl<remove_cvref_t<_Tp>>::value;
+
+#endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD
diff --git a/include/__tuple_dir/tuple_like_ext.h b/include/__tuple_dir/tuple_like_ext.h
new file mode 100644
index 0000000..bf98696
--- /dev/null
+++ b/include/__tuple_dir/tuple_like_ext.h
@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TUPLE_TUPLE_LIKE_EXT_H
+#define _LIBCPP___TUPLE_TUPLE_LIKE_EXT_H
+
+#include <__config>
+#include <__fwd/array.h>
+#include <__fwd/pair.h>
+#include <__fwd/tuple.h>
+#include <__tuple_dir/tuple_types.h>
+#include <__type_traits/integral_constant.h>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp> struct __tuple_like_ext : false_type {};
+
+template <class _Tp> struct __tuple_like_ext<const _Tp> : public __tuple_like_ext<_Tp> {};
+template <class _Tp> struct __tuple_like_ext<volatile _Tp> : public __tuple_like_ext<_Tp> {};
+template <class _Tp> struct __tuple_like_ext<const volatile _Tp> : public __tuple_like_ext<_Tp> {};
+
+#ifndef _LIBCPP_CXX03_LANG
+template <class... _Tp> struct __tuple_like_ext<tuple<_Tp...> > : true_type {};
+#endif
+
+template <class _T1, class _T2> struct __tuple_like_ext<pair<_T1, _T2> > : true_type {};
+
+template <class _Tp, size_t _Size> struct __tuple_like_ext<array<_Tp, _Size> > : true_type {};
+
+template <class... _Tp> struct __tuple_like_ext<__tuple_types<_Tp...> > : true_type {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___TUPLE_TUPLE_LIKE_EXT_H
diff --git a/include/module.modulemap.in b/include/module.modulemap.in
index d0cb522..5d4cf53 100644
--- a/include/module.modulemap.in
+++ b/include/module.modulemap.in
@@ -1229,6 +1229,7 @@
module data { private header "__ranges/data.h" }
module drop_view { private header "__ranges/drop_view.h" }
module drop_while_view { private header "__ranges/drop_while_view.h" }
+ module elements_view { private header "__ranges/elements_view.h" }
module empty { private header "__ranges/empty.h" }
module empty_view { private header "__ranges/empty_view.h" }
module enable_borrowed_range { private header "__ranges/enable_borrowed_range.h" }
@@ -1250,7 +1251,11 @@
module reverse_view { private header "__ranges/reverse_view.h" }
module single_view { private header "__ranges/single_view.h" }
module size { private header "__ranges/size.h" }
- module subrange { private header "__ranges/subrange.h" }
+ module subrange {
+ private header "__ranges/subrange.h"
+
+ module subrange_fwd { private header "__fwd/subrange.h" }
+ }
module take_view { private header "__ranges/take_view.h" }
module take_while_view { private header "__ranges/take_while_view.h" }
module transform_view {
@@ -1365,11 +1370,13 @@
module apply_cv { private header "__tuple_dir/apply_cv.h" }
module get_fwd { private header "__fwd/get.h" }
module make_tuple_types { private header "__tuple_dir/make_tuple_types.h" }
+ module pair_like { private header "__tuple_dir/pair_like.h" }
module sfinae_helpers { private header "__tuple_dir/sfinae_helpers.h" }
module tuple_element { private header "__tuple_dir/tuple_element.h" }
module tuple_fwd { private header "__fwd/tuple.h" }
module tuple_indices { private header "__tuple_dir/tuple_indices.h" }
module tuple_like { private header "__tuple_dir/tuple_like.h" }
+ module tuple_like_ext { private header "__tuple_dir/tuple_like_ext.h" }
module tuple_size { private header "__tuple_dir/tuple_size.h" }
module tuple_types { private header "__tuple_dir/tuple_types.h" }
}
diff --git a/include/ranges b/include/ranges
index 5928efa..db601d4 100644
--- a/include/ranges
+++ b/include/ranges
@@ -115,6 +115,27 @@
template<range R>
using borrowed_subrange_t = see below;
+ // [range.elements], elements view
+ template<input_range V, size_t N>
+ requires see below
+ class elements_view;
+
+ template<class T, size_t N>
+ inline constexpr bool enable_borrowed_range<elements_view<T, N>> =
+ enable_borrowed_range<T>;
+
+ template<class R>
+ using keys_view = elements_view<R, 0>;
+ template<class R>
+ using values_view = elements_view<R, 1>;
+
+ namespace views {
+ template<size_t N>
+ inline constexpr unspecified elements = unspecified;
+ inline constexpr auto keys = elements<0>;
+ inline constexpr auto values = elements<1>;
+ }
+
// [range.empty], empty view
template<class T>
requires is_object_v<T>
@@ -316,6 +337,7 @@
#include <__ranges/data.h>
#include <__ranges/drop_view.h>
#include <__ranges/drop_while_view.h>
+#include <__ranges/elements_view.h>
#include <__ranges/empty.h>
#include <__ranges/empty_view.h>
#include <__ranges/enable_borrowed_range.h>
diff --git a/include/tuple b/include/tuple
index b75d00c..b0616bd 100644
--- a/include/tuple
+++ b/include/tuple
@@ -1677,7 +1677,7 @@
tuple<_Types...>,
typename __make_tuple_types<__remove_cvref_t<_Tuple0> >::type
>::type,
- __tuple_like<__libcpp_remove_reference_t<_Tuple1> >::value,
+ __tuple_like_ext<__libcpp_remove_reference_t<_Tuple1> >::value,
_Tuple1, _Tuples...>
{
};
@@ -1687,7 +1687,7 @@
template <class _Tuple0, class ..._Tuples>
struct __tuple_cat_return<_Tuple0, _Tuples...>
: public __tuple_cat_return_1<tuple<>,
- __tuple_like<__libcpp_remove_reference_t<_Tuple0> >::value, _Tuple0,
+ __tuple_like_ext<__libcpp_remove_reference_t<_Tuple0> >::value, _Tuple0,
_Tuples...>
{
};