[libc++] [ranges] Implement views::take, views::drop, ranges::equal. [WIP, needs tests]

[ldionne]

Summary

This is just something I whipped up in order to get some example Ranges code compiling with Clang/libc++.
If someone wants to commandeer it to get the tests written faster, that's cool with me.
There are a total of 6 commits here: refactor, [alg.req], ranges::distance, view::take, view::drop, ranges::equal. https://github.com/Quuxplusone/llvm-project/compare/09208a38def076224e14b3202a1fd07cbebbbe8e...ranges-take

[ldionne]

I already have views::take, views::drop and views::join locally, with partial tests. I'll take a look at what you did and incorporate it in mine.

My bad for not publicizing that, I've been unable to resume work on those due to other stuff coming up.

[philnik]

libcxx/include/__algorithm/ranges_equal.h

88–90

What is the rationale behind this namespace? Is there some requirement?

libcxx/include/__ranges/counted.h

83

Nit: remove line

[• Quuxplusone]

libcxx/include/__algorithm/ranges_equal.h

88–90

See https://reviews.llvm.org/D105456#2945862
and https://reviews.llvm.org/D107098#inline-1019805
and (as of today) https://quuxplusone.github.io/blog/2021/12/07/namespace-cpo/ :)

[ldionne]

See D116950 for std::ranges::drop.

[ldionne]

Abandoning since this has been superseded by a couple of newer reviews, like D125156.

libcxx/include/CMakeLists.txt

set(files
   __algorithm/partial_sort_copy.h
   __algorithm/partial_sort.h
   __algorithm/partition_copy.h
   __algorithm/partition_point.h
   __algorithm/partition.h
   __algorithm/pop_heap.h
   __algorithm/prev_permutation.h
   __algorithm/push_heap.h
+  __algorithm/ranges_equal.h
   __algorithm/remove_copy_if.h
   __algorithm/remove_copy.h
   __algorithm/remove_if.h
   __algorithm/remove.h
   __algorithm/replace_copy_if.h
   __algorithm/replace_copy.h
   __algorithm/replace_if.h
   __algorithm/replace.h
set(files
   __functional/reference_wrapper.h
   __functional/unary_function.h
   __functional/unary_negate.h
   __functional/unwrap_ref.h
   __functional/weak_result_type.h
   __hash_table
   __iterator/access.h
   __iterator/advance.h
+  __iterator/algorithm_concepts.h
   __iterator/back_insert_iterator.h
   __iterator/common_iterator.h
   __iterator/concepts.h
   __iterator/counted_iterator.h
   __iterator/data.h
   __iterator/default_sentinel.h
   __iterator/distance.h
   __iterator/empty.h
   __iterator/erase_if_container.h
   __iterator/front_insert_iterator.h
   __iterator/incrementable_traits.h
+  __iterator/indirectly_copyable.h
+  __iterator/indirectly_movable.h
+  __iterator/indirectly_swappable.h
   __iterator/insert_iterator.h
   __iterator/istream_iterator.h
   __iterator/istreambuf_iterator.h
   __iterator/iter_move.h
   __iterator/iter_swap.h
   __iterator/iterator_traits.h
   __iterator/iterator.h
   __iterator/move_iterator.h
   __iterator/next.h
   __iterator/ostream_iterator.h
   __iterator/ostreambuf_iterator.h
   __iterator/prev.h
   __iterator/projected.h
+  __iterator/ranges_distance.h
   __iterator/readable_traits.h
   __iterator/reverse_access.h
   __iterator/reverse_iterator.h
   __iterator/size.h
   __iterator/unreachable_sentinel.h
   __iterator/wrap_iter.h
   __libcpp_version
   __locale
set(files
   __ranges/access.h
   __ranges/all.h
   __ranges/common_view.h
   __ranges/concepts.h
   __ranges/copyable_box.h
   __ranges/counted.h
   __ranges/dangling.h
   __ranges/data.h
+  __ranges/drop.h
   __ranges/drop_view.h
   __ranges/empty_view.h
   __ranges/empty.h
   __ranges/enable_borrowed_range.h
   __ranges/enable_view.h
   __ranges/iota_view.h
   __ranges/join_view.h
   __ranges/non_propagating_cache.h
   __ranges/range_adaptor.h
   __ranges/ref_view.h
   __ranges/reverse_view.h
   __ranges/single_view.h
   __ranges/size.h
   __ranges/subrange.h
+  __ranges/take.h
   __ranges/take_view.h
   __ranges/transform_view.h
   __ranges/view_interface.h
   __split_buffer
   __std_stream
   __string
   __support/android/locale_bionic.h
   __support/fuchsia/xlocale.h

libcxx/include/__algorithm/ranges_equal.h

+// -*- 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___ALGORITHM_RANGES_EQUAL_H
+#define _LIBCPP___ALGORITHM_RANGES_EQUAL_H
+
+#include <__config>
+#include <__iterator/algorithm_concepts.h>
+#include <__iterator/concepts.h>
+#include <__iterator/ranges_distance.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+// [alg.equal]
+
+namespace ranges {
+
+namespace __equal {
+
+  struct __fn {
+    template<input_or_output_iterator _It1, sentinel_for<_It1> _Sent1,
+             input_or_output_iterator _It2, sentinel_for<_It2> _Sent2,
+             class _Pred = ranges::equal_to,
+             class _Proj1 = identity, class _Proj2 = identity>
+      requires indirectly_comparable<_It1, _It2, _Pred, _Proj1, _Proj2>
+    constexpr bool operator()(_It1 __first1, _Sent1 __last1,
+                              _It2 __first2, _Sent2 __last2,
+                              _Pred __pred = {},
+                              _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
+      if constexpr (sized_sentinel_for<_Sent1, _It1> && sized_sentinel_for<_Sent2, _It2>) {
+        if (ranges::distance(__first1, __last1) != ranges::distance(__first2, __last2))
+          return false;
+      }
+      while (__first1 != __last1) {
+        if (__first2 == __last2)
+          return false;
+        if (!bool(_VSTD::invoke(__pred, _VSTD::invoke(__proj1, *__first1), _VSTD::invoke(__proj2, *__first2))))
+          return false;
+        ++__first1;
+        ++__first2;
+      }
+      return (__first2 == __last2);
+    }
+
+    template<input_range _Rp1, input_range _Rp2,
+             class _Pred = ranges::equal_to,
+             class _Proj1 = identity, class _Proj2 = identity>
+      requires indirectly_comparable<iterator_t<_Rp1>, iterator_t<_Rp2>, _Pred, _Proj1, _Proj2>
+    constexpr bool operator()(_Rp1&& __r1, _Rp2&& __r2,
+                              _Pred __pred = {},
+                              _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
+      if constexpr (sized_range<_Rp1> && sized_range<_Rp2>) {
+        if (ranges::distance(__r1) != ranges::distance(__r2))
+          return false;
+      }
+      auto __first1 = ranges::begin(__r1);
+      auto __last1 = ranges::end(__r1);
+      auto __first2 = ranges::begin(__r2);
+      auto __last2 = ranges::end(__r2);
+      while (__first1 != __last1) {
+        if (__first2 == __last2)
+          return false;
+        if (!bool(_VSTD::invoke(__pred, _VSTD::invoke(__proj1, *__first1), _VSTD::invoke(__proj2, *__first2))))
+          return false;
+        ++__first1;
+        ++__first2;
+      }
+      return (__first2 == __last2);
+    }
+  };
+
+} // namespace __equal
+
+inline namespace __cpo {
+  inline constexpr auto equal = __equal::__fn{};
+} // namespace __cpo
+
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ALGORITHM_RANGES_EQUAL_H

libcxx/include/__iterator/algorithm_concepts.h

+// -*- 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___ITERATOR_ALGORITHM_CONCEPTS_H
+#define _LIBCPP___ITERATOR_ALGORITHM_CONCEPTS_H
+
+#include <__config>
+#include <__concepts/copyable.h>
+#include <__concepts/movable.h>
+#include <__functional/identity.h>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/indirectly_copyable.h>
+#include <__iterator/indirectly_movable.h>
+#include <__iterator/indirectly_swappable.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/projected.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+// [alg.req.ind.cmp]
+
+template<class _It1, class _It2, class _Pred, class _Proj1 = identity, class _Proj2 = identity>
+concept indirectly_comparable =
+  indirect_binary_predicate<_Pred, projected<_It1, _Proj1>, projected<_It2, _Proj2>>;
+
+// [alg.req.permutable]
+
+template<class _In>
+concept permutable =
+  forward_iterator<_In> &&
+  indirectly_movable_storable<_In, _In> &&
+  indirectly_swappable<_In, _In>;
+
+// [alg.req.mergeable]
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+template<class _In1, class _In2, class _Out, class _Pred = ranges::less,
+         class _Proj1 = identity, class _Proj2 = identity>
+concept mergeable =
+  input_iterator<_In1> &&
+  input_iterator<_In2> &&
+  weakly_incrementable<_Out> &&
+  indirectly_copyable<_In1, _Out> &&
+  indirectly_copyable<_In2, _Out> &&
+  indirect_strict_weak_order<_Pred, projected<_In1, _Proj1>, projected<_In2, _Proj2>>;
+
+// [alg.req.sortable]
+
+template<class _It, class _Pred = ranges::less, class _Proj = identity>
+concept sortable =
+  permutable<_It> &&
+  indirect_strict_weak_order<_Pred, projected<_It, _Proj>>;
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ITERATOR_ALGORITHM_CONCEPTS_H

libcxx/include/__iterator/common_iterator.h

 // -*- 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___ITERATOR_COMMON_ITERATOR_H
 #define _LIBCPP___ITERATOR_COMMON_ITERATOR_H
 
 #include <__config>
 #include <__debug>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
+#include <__iterator/indirectly_swappable.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/readable_traits.h>
 #include <concepts>
 #include <variant>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/__iterator/concepts.h

concept indirect_strict_weak_order =
   strict_weak_order<_Fp&, iter_reference_t<_It1>, iter_value_t<_It2>&> &&
   strict_weak_order<_Fp&, iter_reference_t<_It1>, iter_reference_t<_It2>> &&
   strict_weak_order<_Fp&, iter_common_reference_t<_It1>, iter_common_reference_t<_It2>>;
 
 template<class _Fp, class... _Its>
   requires (indirectly_readable<_Its> && ...) && invocable<_Fp, iter_reference_t<_Its>...>
 using indirect_result_t = invoke_result_t<_Fp, iter_reference_t<_Its>...>;
 
-template<class _In, class _Out>
-concept indirectly_movable =
-  indirectly_readable<_In> &&
-  indirectly_writable<_Out, iter_rvalue_reference_t<_In>>;
-
-template<class _In, class _Out>
-concept indirectly_movable_storable =
-  indirectly_movable<_In, _Out> &&
-  indirectly_writable<_Out, iter_value_t<_In>> &&
-  movable<iter_value_t<_In>> &&
-  constructible_from<iter_value_t<_In>, iter_rvalue_reference_t<_In>> &&
-  assignable_from<iter_value_t<_In>&, iter_rvalue_reference_t<_In>>;
-
-// Note: indirectly_swappable is located in iter_swap.h to prevent a dependency cycle
-// (both iter_swap and indirectly_swappable require indirectly_readable).
-
 // clang-format on
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_CONCEPTS_H

libcxx/include/__iterator/counted_iterator.h

 // -*- 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___ITERATOR_COUNTED_ITERATOR_H
 #define _LIBCPP___ITERATOR_COUNTED_ITERATOR_H
 
 #include <__config>
 #include <__debug>
 #include <__iterator/concepts.h>
 #include <__iterator/default_sentinel.h>
+#include <__iterator/incrementable_traits.h>
+#include <__iterator/indirectly_swappable.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
-#include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/readable_traits.h>
 #include <__memory/pointer_traits.h>
 #include <__utility/move.h>
 #include <compare>
 #include <concepts>
 #include <type_traits>
 

libcxx/include/__iterator/indirectly_copyable.h

+// -*- 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___ITERATOR_INDIRECTLY_COPYABLE_H
+#define _LIBCPP___ITERATOR_INDIRECTLY_COPYABLE_H
+
+#include <__config>
+#include <__concepts/assignable.h>
+#include <__concepts/constructible.h>
+#include <__concepts/copyable.h>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/readable_traits.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+// [alg.req.ind.copy]
+
+template<class _In, class _Out>
+concept indirectly_copyable =
+  indirectly_readable<_In> &&
+  indirectly_writable<_Out, iter_reference_t<_In>>;
+
+template<class _In, class _Out>
+concept indirectly_copyable_storable =
+  indirectly_copyable<_In, _Out> &&
+  indirectly_writable<_Out, iter_value_t<_In>&> &&
+  indirectly_writable<_Out, const iter_value_t<_In>&> &&
+  indirectly_writable<_Out, iter_value_t<_In>&&> &&
+  indirectly_writable<_Out, const iter_value_t<_In>&&> &&
+  copyable<iter_value_t<_In>> &&
+  constructible_from<iter_value_t<_In>, iter_reference_t<_In>> &&
+  assignable_from<iter_value_t<_In>&, iter_reference_t<_In>>;
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ITERATOR_INDIRECTLY_COPYABLE_H

libcxx/include/__iterator/indirectly_movable.h

+// -*- 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___ITERATOR_INDIRECTLY_MOVABLE_H
+#define _LIBCPP___ITERATOR_INDIRECTLY_MOVABLE_H
+
+#include <__config>
+#include <__concepts/assignable.h>
+#include <__concepts/constructible.h>
+#include <__concepts/movable.h>
+#include <__iterator/concepts.h>
+#include <__iterator/iter_move.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/readable_traits.h>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+// [alg.req.ind.move]
+
+template<class _In, class _Out>
+concept indirectly_movable =
+  indirectly_readable<_In> &&
+  indirectly_writable<_Out, iter_rvalue_reference_t<_In>>;
+
+template<class _In, class _Out>
+concept indirectly_movable_storable =
+  indirectly_movable<_In, _Out> &&
+  indirectly_writable<_Out, iter_value_t<_In>> &&
+  movable<iter_value_t<_In>> &&
+  constructible_from<iter_value_t<_In>, iter_rvalue_reference_t<_In>> &&
+  assignable_from<iter_value_t<_In>&, iter_rvalue_reference_t<_In>>;
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ITERATOR_INDIRECTLY_MOVABLE_H

libcxx/include/__iterator/indirectly_swappable.h

+// -*- 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___ITERATOR_INDIRECTLY_SWAPPABLE_H
+#define _LIBCPP___ITERATOR_INDIRECTLY_SWAPPABLE_H
+
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/iter_swap.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) && !defined(_LIBCPP_HAS_NO_RANGES)
+
+// [alg.req.ind.swap]
+
+template<class _It1, class _It2 = _It1>
+concept indirectly_swappable =
+  indirectly_readable<_It1> && indirectly_readable<_It2> &&
+  requires (const _It1 __it1, const _It2 __it2) {
+    ranges::iter_swap(__it1, __it1);
+    ranges::iter_swap(__it2, __it2);
+    ranges::iter_swap(__it1, __it2);
+    ranges::iter_swap(__it2, __it1);
+  };
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) && !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ITERATOR_INDIRECTLY_SWAPPABLE_H

libcxx/include/__iterator/iter_swap.h

 // -*- 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___ITERATOR_ITER_SWAP_H
 #define _LIBCPP___ITERATOR_ITER_SWAP_H
 
 #include <__config>
+#include <__concepts/swappable.h>
 #include <__iterator/concepts.h>
+#include <__iterator/indirectly_movable.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/readable_traits.h>
 #include <__ranges/access.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
-#include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

 } // end namespace __iter_swap
 
 inline namespace __cpo {
   inline constexpr auto iter_swap = __iter_swap::__fn{};
 } // namespace __cpo
 
 } // namespace ranges
 
-template<class _I1, class _I2 = _I1>
-concept indirectly_swappable =
-  indirectly_readable<_I1> && indirectly_readable<_I2> &&
-  requires(const _I1 __i1, const _I2 __i2) {
-    ranges::iter_swap(__i1, __i1);
-    ranges::iter_swap(__i2, __i2);
-    ranges::iter_swap(__i1, __i2);
-    ranges::iter_swap(__i2, __i1);
-  };
-
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_ITER_SWAP_H

libcxx/include/__iterator/iterator_traits.h

 // -*- 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___ITERATOR_ITERATOR_TRAITS_H
 #define _LIBCPP___ITERATOR_ITERATOR_TRAITS_H
 
+#include <__concepts/arithmetic.h>
+#include <__concepts/constructible.h>
+#include <__concepts/convertible_to.h>
+#include <__concepts/copyable.h>
+#include <__concepts/equality_comparable.h>
+#include <__concepts/same_as.h>
+#include <__concepts/totally_ordered.h>
 #include <__config>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/readable_traits.h>
-#include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__iterator/ranges_distance.h

+// -*- 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___ITERATOR_RANGES_DISTANCE_H
+#define _LIBCPP___ITERATOR_RANGES_DISTANCE_H
+
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/incrementable_traits.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/size.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+// [range.iter.op.distance]
+
+namespace ranges {
+
+namespace __distance {
+
+  struct __fn {
+    template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
+      requires (!sized_sentinel_for<_Sent, _It>)
+    constexpr iter_difference_t<_It> operator()(_It __first, _Sent __last) const {
+      iter_difference_t<_It> __count = 0;
+      while (__first != __last) {
+        ++__first;
+        ++__count;
+      }
+      return __count;
+    }
+
+    template<input_or_output_iterator _It, sized_sentinel_for<_It> _Sent>
+    constexpr iter_difference_t<_It> operator()(_It __first, _Sent __last) const {
+      return __last - __first;
+    }
+
+    template<range _Rp>
+    constexpr range_difference_t<_Rp> operator()(_Rp&& __r) const {
+      if constexpr (sized_range<_Rp>) {
+        return static_cast<range_difference_t<_Rp>>(ranges::size(__r));
+      } else {
+        return (*this)(ranges::begin(__r), ranges::end(__r));
+      }
+    }
+  };
+
+} // namespace __distance
+
+inline namespace __cpo {
+  inline constexpr auto distance = __distance::__fn{};
+} // namespace __cpo
+
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ITERATOR_RANGES_DISTANCE_H

libcxx/include/__ranges/counted.h

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
 namespace ranges::views {
 
 namespace __counted {
+
   template<class _From, class _To>
   concept __explicitly_convertible = requires {
     _To(_From{});
   };
 
   struct __fn {
     template<class _Iter, class _Diff>
       requires contiguous_iterator<decay_t<_Iter>> &&
struct __fn {
     constexpr auto operator()(_Iter&& __it, _Diff __c) const
       noexcept(noexcept(
         ranges::subrange(counted_iterator(_VSTD::forward<_Iter>(__it), __c), default_sentinel)
       ))
     {
       return ranges::subrange(counted_iterator(_VSTD::forward<_Iter>(__it), __c), default_sentinel);
     }
   };
-}
+
+} // namespace __counted
 
 inline namespace __cpo {
   inline constexpr auto counted = __counted::__fn{};
 } // namespace __cpo
 
 } // namespace ranges::views
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_COUNTED_H

libcxx/include/__ranges/drop.h

+// -*- 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_DROP_H
+#define _LIBCPP___RANGES_DROP_H
+
+#include <__algorithm/min.h>
+#include <__concepts/constructible.h>
+#include <__config>
+#include <__functional/bind_back.h>
+#include <__iterator/ranges_distance.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/drop_view.h>
+#include <__ranges/empty_view.h>
+#include <__ranges/iota_view.h>
+#include <__ranges/range_adaptor.h>
+#include <__ranges/size.h>
+#include <__ranges/subrange.h>
+#include <__utility/forward.h>
+#include <__utility/priority_tag.h>
+#include <concepts>
+#include <span>
+#include <string_view>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+namespace ranges::views {
+
+namespace __drop {
+
+  template<class> struct __is_iota_view : false_type {};
+  template<class _Start, class _Bound> struct __is_iota_view<iota_view<_Start, _Bound>> : true_type {};
+
+  template<class> struct __is_string_view : false_type {};
+  template<class _CharT, class _Traits> struct __is_string_view<basic_string_view<_CharT, _Traits>> : true_type {};
+
+  template<class> struct __is_subrange : false_type {};
+  template<class _Ip, class _Sp, ranges::subrange_kind _Kp> struct __is_subrange<subrange<_Ip, _Sp, _Kp>> : true_type {};
+
+  template<class> struct __is_subrange_without_storesize : false_type {};
+  template<class _Ip, class _Sp> struct __is_subrange<subrange<_Ip, _Sp, subrange_kind::unsized>> : bool_constant<!sized_sentinel_for<_Sp, _Ip>> {};
+
+  struct __fn : __range_adaptor_closure<__fn> {
+
+    template<class _Result, class _It, class _Dp, class _Sent>
+      requires __is_subrange_without_storesize<_Result>::value
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __make_result(_It __first, _Dp __n, type_identity_t<_Dp> __count, _Sent __last)
+        noexcept(noexcept(_Result(__first + _VSTD::min(__n, __count), __last, _VSTD::__to_unsigned_like(__n - std::min(__n, __count)))))
+        -> decltype(      _Result(__first + _VSTD::min(__n, __count), __last, _VSTD::__to_unsigned_like(__n - std::min(__n, __count))))
+        { return          _Result(__first + _VSTD::min(__n, __count), __last, _VSTD::__to_unsigned_like(__n - std::min(__n, __count))); }
+
+    template<class _Result, class _It, class _Dp, class _Sent>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __make_result(_It __first, _Dp __n, type_identity_t<_Dp> __count, _Sent __last)
+        noexcept(noexcept(_Result(__first + _VSTD::min(__n, __count), __last)))
+        -> decltype(      _Result(__first + _VSTD::min(__n, __count), __last))
+        { return          _Result(__first + _VSTD::min(__n, __count), __last); }
+
+    template<class _Rp, class _Count>
+      requires __is_empty_view<decay_t<_Rp>>::value
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr decay_t<_Rp> __go(_Rp&& __r, _Count&&) noexcept {
+      return _VSTD::forward<_Rp>(__r);
+    }
+
+    template<class _Rp, class _Count>
+      requires random_access_range<_Rp> && sized_range<_Rp> && __is_std_span<decay_t<_Rp>>::value
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Rp&& __r, _Count&& __count)
+      noexcept(noexcept(__make_result<span<typename decay_t<_Rp>::element_type>>(ranges::begin(__r), ranges::distance(__r), __count, ranges::end(__r))))
+      -> decltype(      __make_result<span<typename decay_t<_Rp>::element_type>>(ranges::begin(__r), ranges::distance(__r), __count, ranges::end(__r)))
+      { return          __make_result<span<typename decay_t<_Rp>::element_type>>(ranges::begin(__r), ranges::distance(__r), __count, ranges::end(__r)); }
+
+    template<class _Rp, class _Count>
+      requires random_access_range<_Rp> && sized_range<_Rp> && __is_string_view<decay_t<_Rp>>::value
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Rp&& __r, _Count&& __count)
+      noexcept(noexcept(__make_result<decay_t<_Rp>>(ranges::begin(__r), ranges::distance(__r), __count, ranges::end(__r))))
+      -> decltype(      __make_result<decay_t<_Rp>>(ranges::begin(__r), ranges::distance(__r), __count, ranges::end(__r)))
+      { return          __make_result<decay_t<_Rp>>(ranges::begin(__r), ranges::distance(__r), __count, ranges::end(__r)); }
+
+    template<class _Rp, class _Count>
+      requires random_access_range<_Rp> && sized_range<_Rp> && __is_iota_view<decay_t<_Rp>>::value
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Rp&& __r, _Count&& __count)
+      noexcept(noexcept(__make_result<decay_t<_Rp>>(ranges::begin(__r), ranges::distance(__r), __count, ranges::end(__r))))
+      -> decltype(      __make_result<decay_t<_Rp>>(ranges::begin(__r), ranges::distance(__r), __count, ranges::end(__r)))
+      { return          __make_result<decay_t<_Rp>>(ranges::begin(__r), ranges::distance(__r), __count, ranges::end(__r)); }
+
+    template<class _Rp, class _Count>
+      requires random_access_range<_Rp> && sized_range<_Rp> && __is_subrange<decay_t<_Rp>>::value
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Rp&& __r, _Count&& __count)
+      noexcept(noexcept(__make_result<decay_t<_Rp>>(ranges::begin(__r), ranges::distance(__r), __count, ranges::end(__r))))
+      -> decltype(      __make_result<decay_t<_Rp>>(ranges::begin(__r), ranges::distance(__r), __count, ranges::end(__r)))
+      { return          __make_result<decay_t<_Rp>>(ranges::begin(__r), ranges::distance(__r), __count, ranges::end(__r)); }
+
+    template<class _Rp, class _Count>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Rp&& __r, _Count&& __count)
+      noexcept(noexcept(ranges::drop_view(_VSTD::forward<_Rp>(__r), _VSTD::forward<_Count>(__count))))
+      -> decltype(      ranges::drop_view(_VSTD::forward<_Rp>(__r), _VSTD::forward<_Count>(__count)))
+      { return          ranges::drop_view(_VSTD::forward<_Rp>(__r), _VSTD::forward<_Count>(__count)); }
+
+    template<class _Rp, convertible_to<range_difference_t<_Rp&&>> _Count>
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Rp&& __r, _Count&& __count) const
+      noexcept(noexcept(__go(_VSTD::forward<_Rp>(__r), _VSTD::forward<_Count>(__count))))
+      -> decltype(      __go(_VSTD::forward<_Rp>(__r), _VSTD::forward<_Count>(__count)))
+      { return          __go(_VSTD::forward<_Rp>(__r), _VSTD::forward<_Count>(__count)); }
+
+    template<class _Count>
+      requires constructible_from<decay_t<_Count>, _Count>
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Count&& __count) const
+      noexcept(is_nothrow_constructible_v<decay_t<_Count>, _Count>)
+    { return __range_adaptor_closure_t(_VSTD::__bind_back(*this, _VSTD::forward<_Count>(__count))); }
+  };
+
+} // namespace __drop
+
+inline namespace __cpo {
+  inline constexpr auto drop = __drop::__fn{};
+} // namespace __cpo
+
+} // namespace ranges::views
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_DROP_H

libcxx/include/__ranges/empty_view.h

namespace ranges {
   class empty_view : public view_interface<empty_view<_Tp>> {
   public:
     _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* begin() noexcept { return nullptr; }
     _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* end() noexcept { return nullptr; }
     _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* data() noexcept { return nullptr; }
     _LIBCPP_HIDE_FROM_ABI static constexpr size_t size() noexcept { return 0; }
     _LIBCPP_HIDE_FROM_ABI static constexpr bool empty() noexcept { return true; }
   };
+
+  template<class> struct __is_empty_view : false_type {};
+  template<class _Tp> struct __is_empty_view<empty_view<_Tp>> : true_type {};
+
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_EMPTY_VIEW_H

libcxx/include/__ranges/join_view.h

 // -*- 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_JOIN_VIEW_H
 #define _LIBCPP___RANGES_JOIN_VIEW_H
 
 #include <__config>
 #include <__iterator/concepts.h>
+#include <__iterator/indirectly_swappable.h>
 #include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
 #include <__ranges/non_propagating_cache.h>
 #include <__ranges/ref_view.h>
 #include <__ranges/subrange.h>
 #include <__ranges/view_interface.h>

libcxx/include/__ranges/take.h

+// -*- 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_TAKE_H
+#define _LIBCPP___RANGES_TAKE_H
+
+#include <__algorithm/min.h>
+#include <__concepts/constructible.h>
+#include <__config>
+#include <__functional/bind_back.h>
+#include <__iterator/ranges_distance.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/empty_view.h>
+#include <__ranges/iota_view.h>
+#include <__ranges/range_adaptor.h>
+#include <__ranges/size.h>
+#include <__ranges/subrange.h>
+#include <__ranges/take_view.h>
+#include <__utility/forward.h>
+#include <__utility/priority_tag.h>
+#include <concepts>
+#include <span>
+#include <string_view>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+namespace ranges::views {
+
+namespace __take {
+
+  template<class> struct __is_iota_view : false_type {};
+  template<class _Start, class _Bound> struct __is_iota_view<iota_view<_Start, _Bound>> : true_type {};
+
+  template<class> struct __is_string_view : false_type {};
+  template<class _CharT, class _Traits> struct __is_string_view<basic_string_view<_CharT, _Traits>> : true_type {};
+
+  template<class> struct __is_subrange : false_type {};
+  template<class _Ip, class _Sp, ranges::subrange_kind _Kp> struct __is_subrange<subrange<_Ip, _Sp, _Kp>> : true_type {};
+
+  struct __fn : __range_adaptor_closure<__fn> {
+
+    template<class _It, class _Dp>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __make_iota_view(_It __first, _Dp __n, type_identity_t<_Dp> __count)
+        noexcept(noexcept(ranges::iota_view(*__first, *(__first + _VSTD::min(__n, __count)))))
+        -> decltype(      ranges::iota_view(*__first, *(__first + _VSTD::min(__n, __count))))
+        { return          ranges::iota_view(*__first, *(__first + _VSTD::min(__n, __count))); }
+
+    template<class _Result, class _It, class _Dp>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __make_result(_It __first, _Dp __n, type_identity_t<_Dp> __count)
+        noexcept(noexcept(_Result(__first, __first + _VSTD::min(__n, __count))))
+        -> decltype(      _Result(__first, __first + _VSTD::min(__n, __count)))
+        { return          _Result(__first, __first + _VSTD::min(__n, __count)); }
+
+    template<class _Rp, class _Count>
+      requires __is_empty_view<decay_t<_Rp>>::value
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr decay_t<_Rp> __go(_Rp&& __r, _Count&&) noexcept {
+      return _VSTD::forward<_Rp>(__r);
+    }
+
+    template<class _Rp, class _Count>
+      requires random_access_range<_Rp> && sized_range<_Rp> && __is_std_span<decay_t<_Rp>>::value
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Rp&& __r, _Count&& __count)
+      noexcept(noexcept(__make_result<span<typename decay_t<_Rp>::element_type>>(ranges::begin(__r), ranges::distance(__r), __count)))
+      -> decltype(      __make_result<span<typename decay_t<_Rp>::element_type>>(ranges::begin(__r), ranges::distance(__r), __count))
+      { return          __make_result<span<typename decay_t<_Rp>::element_type>>(ranges::begin(__r), ranges::distance(__r), __count); }
+
+    template<class _Rp, class _Count>
+      requires random_access_range<_Rp> && sized_range<_Rp> && __is_string_view<decay_t<_Rp>>::value
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Rp&& __r, _Count&& __count)
+      noexcept(noexcept(__make_result<decay_t<_Rp>>(ranges::begin(__r), ranges::distance(__r), __count)))
+      -> decltype(      __make_result<decay_t<_Rp>>(ranges::begin(__r), ranges::distance(__r), __count))
+      { return          __make_result<decay_t<_Rp>>(ranges::begin(__r), ranges::distance(__r), __count); }
+
+    template<class _Rp, class _Count>
+      requires random_access_range<_Rp> && sized_range<_Rp> && __is_subrange<decay_t<_Rp>>::value
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Rp&& __r, _Count&& __count)
+      noexcept(noexcept(__make_result<subrange<iterator_t<decay_t<_Rp>>>>(ranges::begin(__r), ranges::distance(__r), __count)))
+      -> decltype(      __make_result<subrange<iterator_t<decay_t<_Rp>>>>(ranges::begin(__r), ranges::distance(__r), __count))
+      { return          __make_result<subrange<iterator_t<decay_t<_Rp>>>>(ranges::begin(__r), ranges::distance(__r), __count); }
+
+    template<class _Rp, class _Count>
+      requires random_access_range<_Rp> && sized_range<_Rp> && __is_iota_view<decay_t<_Rp>>::value
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Rp&& __r, _Count&& __count)
+      noexcept(noexcept(__make_iota_view(ranges::begin(__r), ranges::distance(__r), __count)))
+      -> decltype(      __make_iota_view(ranges::begin(__r), ranges::distance(__r), __count))
+      { return          __make_iota_view(ranges::begin(__r), ranges::distance(__r), __count); }
+
+    template<class _Rp, class _Count>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Rp&& __r, _Count&& __count)
+      noexcept(noexcept(ranges::take_view(_VSTD::forward<_Rp>(__r), _VSTD::forward<_Count>(__count))))
+      -> decltype(      ranges::take_view(_VSTD::forward<_Rp>(__r), _VSTD::forward<_Count>(__count)))
+      { return          ranges::take_view(_VSTD::forward<_Rp>(__r), _VSTD::forward<_Count>(__count)); }
+
+    template<class _Rp, convertible_to<range_difference_t<_Rp&&>> _Count>
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Rp&& __r, _Count&& __count) const
+      noexcept(noexcept(__go(_VSTD::forward<_Rp>(__r), _VSTD::forward<_Count>(__count))))
+      -> decltype(      __go(_VSTD::forward<_Rp>(__r), _VSTD::forward<_Count>(__count)))
+      { return          __go(_VSTD::forward<_Rp>(__r), _VSTD::forward<_Count>(__count)); }
+
+    template<class _Count>
+      requires constructible_from<decay_t<_Count>, _Count>
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Count&& __count) const
+      noexcept(is_nothrow_constructible_v<decay_t<_Count>, _Count>)
+    { return __range_adaptor_closure_t(_VSTD::__bind_back(*this, _VSTD::forward<_Count>(__count))); }
+  };
+
+} // namespace __take
+
+inline namespace __cpo {
+  inline constexpr auto take = __take::__fn{};
+} // namespace __cpo
+
+} // namespace ranges::views
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_TAKE_H

libcxx/include/algorithm

 #include <__algorithm/partial_sort.h>
 #include <__algorithm/partial_sort_copy.h>
 #include <__algorithm/partition.h>
 #include <__algorithm/partition_copy.h>
 #include <__algorithm/partition_point.h>
 #include <__algorithm/pop_heap.h>
 #include <__algorithm/prev_permutation.h>
 #include <__algorithm/push_heap.h>
+#include <__algorithm/ranges_equal.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_copy.h>
 #include <__algorithm/remove_copy_if.h>
 #include <__algorithm/remove_if.h>
 #include <__algorithm/replace.h>
 #include <__algorithm/replace_copy.h>
 #include <__algorithm/replace_copy_if.h>
 #include <__algorithm/replace_if.h>

libcxx/include/iterator

 
 */
 
 #include <__config>
 #include <__debug>
 #include <__functional_base>
 #include <__iterator/access.h>
 #include <__iterator/advance.h>
+#include <__iterator/algorithm_concepts.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/common_iterator.h>
 #include <__iterator/concepts.h>
 #include <__iterator/counted_iterator.h>
 #include <__iterator/data.h>
 #include <__iterator/default_sentinel.h>
 #include <__iterator/distance.h>
 #include <__iterator/empty.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/front_insert_iterator.h>
 #include <__iterator/incrementable_traits.h>
+#include <__iterator/indirectly_copyable.h>
+#include <__iterator/indirectly_movable.h>
+#include <__iterator/indirectly_swappable.h>
 #include <__iterator/insert_iterator.h>
 #include <__iterator/istreambuf_iterator.h>
 #include <__iterator/istream_iterator.h>
 #include <__iterator/iterator.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/move_iterator.h>
 #include <__iterator/next.h>
 #include <__iterator/ostreambuf_iterator.h>
 #include <__iterator/ostream_iterator.h>
 #include <__iterator/prev.h>
 #include <__iterator/projected.h>
+#include <__iterator/ranges_distance.h>
 #include <__iterator/readable_traits.h>
 #include <__iterator/reverse_access.h>
 #include <__iterator/reverse_iterator.h>
 #include <__iterator/size.h>
 #include <__iterator/unreachable_sentinel.h>
 #include <__iterator/wrap_iter.h>
 #include <__memory/addressof.h>
 #include <__memory/pointer_traits.h>

libcxx/include/module.modulemap

module __algorithm {
       module partial_sort             { private header "__algorithm/partial_sort.h" }
       module partial_sort_copy        { private header "__algorithm/partial_sort_copy.h" }
       module partition                { private header "__algorithm/partition.h" }
       module partition_copy           { private header "__algorithm/partition_copy.h" }
       module partition_point          { private header "__algorithm/partition_point.h" }
       module pop_heap                 { private header "__algorithm/pop_heap.h" }
       module prev_permutation         { private header "__algorithm/prev_permutation.h" }
       module push_heap                { private header "__algorithm/push_heap.h" }
+      module ranges_equal             { private header "__algorithm/ranges_equal.h" }
       module remove                   { private header "__algorithm/remove.h" }
       module remove_copy              { private header "__algorithm/remove_copy.h" }
       module remove_copy_if           { private header "__algorithm/remove_copy_if.h" }
       module remove_if                { private header "__algorithm/remove_if.h" }
       module replace                  { private header "__algorithm/replace.h" }
       module replace_copy             { private header "__algorithm/replace_copy.h" }
       module replace_copy_if          { private header "__algorithm/replace_copy_if.h" }
       module replace_if               { private header "__algorithm/replace_if.h" }
module iterator {
     export *
 
     module __iterator {
       module access                { private header "__iterator/access.h" }
       module advance               {
         private header "__iterator/advance.h"
         export __function_like
       }
+      module algorithm_concepts    { private header "__iterator/algorithm_concepts.h" }
       module back_insert_iterator  { private header "__iterator/back_insert_iterator.h" }
       module common_iterator       { private header "__iterator/common_iterator.h" }
       module concepts              { private header "__iterator/concepts.h" }
       module counted_iterator      { private header "__iterator/counted_iterator.h" }
       module data                  { private header "__iterator/data.h" }
       module default_sentinel      { private header "__iterator/default_sentinel.h" }
       module distance              { private header "__iterator/distance.h" }
       module empty                 { private header "__iterator/empty.h" }
       module erase_if_container    { private header "__iterator/erase_if_container.h" }
       module front_insert_iterator { private header "__iterator/front_insert_iterator.h" }
       module incrementable_traits  { private header "__iterator/incrementable_traits.h" }
+      module indirectly_copyable   { private header "__iterator/indirectly_copyable.h" }
+      module indirectly_movable    { private header "__iterator/indirectly_movable.h" }
+      module indirectly_swappable  { private header "__iterator/indirectly_swappable.h" }
       module insert_iterator       { private header "__iterator/insert_iterator.h" }
       module istream_iterator      { private header "__iterator/istream_iterator.h" }
       module istreambuf_iterator   { private header "__iterator/istreambuf_iterator.h" }
       module iter_move             { private header "__iterator/iter_move.h" }
       module iter_swap             { private header "__iterator/iter_swap.h" }
       module iterator              { private header "__iterator/iterator.h" }
       module iterator_traits       { private header "__iterator/iterator_traits.h" }
       module move_iterator         { private header "__iterator/move_iterator.h" }
       module next                  {
         private header "__iterator/next.h"
         export __function_like
       }
       module ostream_iterator      { private header "__iterator/ostream_iterator.h" }
       module ostreambuf_iterator   { private header "__iterator/ostreambuf_iterator.h" }
       module prev                  {
         private header "__iterator/prev.h"
         export __function_like
       }
       module projected             { private header "__iterator/projected.h" }
+      module ranges_distance       { private header "__iterator/ranges_distance.h" }
       module readable_traits       { private header "__iterator/readable_traits.h" }
       module reverse_access        { private header "__iterator/reverse_access.h" }
       module reverse_iterator      { private header "__iterator/reverse_iterator.h" }
       module size                  { private header "__iterator/size.h" }
       module unreachable_sentinel  { private header "__iterator/unreachable_sentinel.h" }
       module wrap_iter             { private header "__iterator/wrap_iter.h" }
     }
   }
module __ranges {
         export functional.__functional.perfect_forward
       }
       module common_view            { private header "__ranges/common_view.h"           }
       module concepts               { private header "__ranges/concepts.h"              }
       module copyable_box           { private header "__ranges/copyable_box.h"          }
       module counted                { private header "__ranges/counted.h"               }
       module dangling               { private header "__ranges/dangling.h"              }
       module data                   { private header "__ranges/data.h"                  }
+      module drop                   { private header "__ranges/drop.h"                  }
       module drop_view              { private header "__ranges/drop_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" }
       module enable_view            { private header "__ranges/enable_view.h"           }
       module iota_view              { private header "__ranges/iota_view.h"             }
       module join_view              { private header "__ranges/join_view.h"             }
       module non_propagating_cache  { private header "__ranges/non_propagating_cache.h" }
       module range_adaptor          { private header "__ranges/range_adaptor.h"         }
       module ref_view               { private header "__ranges/ref_view.h"              }
       module reverse_view           { private header "__ranges/reverse_view.h"          }
       module size                   { private header "__ranges/size.h"                  }
       module single_view            { private header "__ranges/single_view.h"           }
       module subrange               { private header "__ranges/subrange.h"              }
+      module take                   { private header "__ranges/take.h"                  }
       module take_view              { private header "__ranges/take_view.h"             }
       module transform_view         {
         private header "__ranges/transform_view.h"
         export functional.__functional.bind_back
         export functional.__functional.perfect_forward
       }
       module view_interface         { private header "__ranges/view_interface.h"        }
     }

libcxx/include/ranges

 #include <__config>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/common_view.h>
 #include <__ranges/concepts.h>
 #include <__ranges/counted.h>
 #include <__ranges/dangling.h>
 #include <__ranges/data.h>
+#include <__ranges/drop.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/empty.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/iota_view.h>
 #include <__ranges/join_view.h>
 #include <__ranges/ref_view.h>
 #include <__ranges/reverse_view.h>
 #include <__ranges/single_view.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
+#include <__ranges/take.h>
 #include <__ranges/take_view.h>
 #include <__ranges/transform_view.h>
 #include <__ranges/view_interface.h>
 #include <compare>          // Required by the standard.
 #include <initializer_list> // Required by the standard.
 #include <iterator>         // Required by the standard.
 #include <type_traits>
 

libcxx/test/libcxx/diagnostics/detail.headers/algorithm/ranges_equal.module.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_equal.h'}}
+#include <__algorithm/ranges_equal.h>

libcxx/test/libcxx/diagnostics/detail.headers/iterator/algorithm_concepts.module.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__iterator/algorithm_concepts.h'}}
+#include <__iterator/algorithm_concepts.h>

libcxx/test/libcxx/diagnostics/detail.headers/iterator/indirectly_copyable.module.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__iterator/indirectly_copyable.h'}}
+#include <__iterator/indirectly_copyable.h>

libcxx/test/libcxx/diagnostics/detail.headers/iterator/indirectly_movable.module.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__iterator/indirectly_movable.h'}}
+#include <__iterator/indirectly_movable.h>

libcxx/test/libcxx/diagnostics/detail.headers/iterator/indirectly_swappable.module.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__iterator/indirectly_swappable.h'}}
+#include <__iterator/indirectly_swappable.h>

libcxx/test/libcxx/diagnostics/detail.headers/iterator/ranges_distance.module.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__iterator/ranges_distance.h'}}
+#include <__iterator/ranges_distance.h>

libcxx/test/libcxx/diagnostics/detail.headers/ranges/drop.module.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__ranges/drop.h'}}
+#include <__ranges/drop.h>

libcxx/test/libcxx/diagnostics/detail.headers/ranges/take.module.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__ranges/take.h'}}
+#include <__ranges/take.h>

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.copy/indirectly_copyable.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class In, class Out>
+// concept indirectly_movable;
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "MoveOnly.h"
+
+struct IndirectlyMovableFromIntPtr {
+  struct AssignableFromIntRvalue {
+    AssignableFromIntRvalue& operator=(int&&);
+  };
+  AssignableFromIntRvalue& operator*() const;
+};
+
+struct IndirectlyCopyableFromLvaluesOnly {
+  struct AssignableFromIntLvalue {
+    AssignableFromIntLvalue& operator=(int&);
+  };
+  AssignableFromIntLvalue& operator*() const;
+};
+static_assert(!std::indirectly_movable<int*, IndirectlyCopyableFromLvaluesOnly>);
+
+struct IndirectlyCopyableFromIntPtr {
+  struct AssignableFromInt {
+    AssignableFromInt& operator=(int);
+  };
+  AssignableFromInt& operator*() const;
+};
+
+static_assert( std::indirectly_copyable<int*, int*>);
+static_assert( std::indirectly_copyable<const int*, int*>);
+static_assert(!std::indirectly_copyable<int*, const int*>);
+static_assert(!std::indirectly_copyable<const int*, const int*>);
+static_assert(!std::indirectly_copyable<MoveOnly*, MoveOnly*>);
+static_assert(!std::indirectly_copyable<const MoveOnly*, MoveOnly*>);
+static_assert(!std::indirectly_copyable<int*, IndirectlyMovableFromIntPtr>);
+static_assert( std::indirectly_copyable<int*, IndirectlyCopyableFromLvaluesOnly>);
+static_assert( std::indirectly_copyable<int*, IndirectlyCopyableFromIntPtr>);
+static_assert( std::indirectly_copyable<const int*, IndirectlyCopyableFromIntPtr>);
+static_assert(!std::indirectly_copyable<IndirectlyCopyableFromIntPtr, int*>);
+static_assert(!std::indirectly_copyable<IndirectlyCopyableFromIntPtr, const int*>);

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.copy/indirectly_copyable.subsumption.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class In, class Out>
+// concept indirectly_copyable;
+
+#include <iterator>
+
+template<std::indirectly_readable I, class O>
+constexpr bool indirectly_copyable_subsumption() {
+  return false;
+}
+
+template<class I, std::indirectly_writable<std::iter_reference_t<I>> O>
+constexpr bool indirectly_copyable_subsumption() {
+  return false;
+}
+
+template<class I, class O>
+  requires std::indirectly_copyable<I, O>
+constexpr bool indirectly_copyable_subsumption() {
+  return true;
+}
+
+static_assert(indirectly_copyable_subsumption<int*, int*>());

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable.compile.pass.cpp

 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class In, class Out>
 // concept indirectly_movable;
 
 #include <iterator>
 
 #include "test_macros.h"
+#include "MoveOnly.h"
 
-struct IndirectlyMovableWithInt {
-  int& operator*() const;
+struct IndirectlyMovableFromIntPtr {
+  struct AssignableFromIntRvalue {
+    AssignableFromIntRvalue& operator=(int&&);
   };
-
-struct Empty {};
-
-struct MoveOnly {
-  MoveOnly(MoveOnly&&) = default;
-  MoveOnly(MoveOnly const&) = delete;
-  MoveOnly& operator=(MoveOnly&&) = default;
-  MoveOnly& operator=(MoveOnly const&) = delete;
-  MoveOnly() = default;
-};
-
-template<class T>
-struct PointerTo {
-  using value_type = T;
-  T& operator*() const;
+  AssignableFromIntRvalue& operator*() const;
 };
 
 static_assert( std::indirectly_movable<int*, int*>);
-static_assert( std::indirectly_movable<const int*, int *>);
-static_assert(!std::indirectly_movable<int*, const int *>);
-static_assert(!std::indirectly_movable<const int*, const int *>);
-static_assert( std::indirectly_movable<int*, int[2]>);
-static_assert(!std::indirectly_movable<int[2], int*>);
-static_assert(!std::indirectly_movable<int[2], int[2]>);
-static_assert(!std::indirectly_movable<int(&)[2], int(&)[2]>);
-static_assert(!std::indirectly_movable<int, int*>);
-static_assert(!std::indirectly_movable<int, int>);
-static_assert( std::indirectly_movable<Empty*, Empty*>);
-static_assert( std::indirectly_movable<int*, IndirectlyMovableWithInt>);
-static_assert(!std::indirectly_movable<Empty*, IndirectlyMovableWithInt>);
-static_assert( std::indirectly_movable<int*, IndirectlyMovableWithInt>);
+static_assert( std::indirectly_movable<const int*, int*>);
+static_assert(!std::indirectly_movable<int*, const int*>);
+static_assert(!std::indirectly_movable<const int*, const int*>);
 static_assert( std::indirectly_movable<MoveOnly*, MoveOnly*>);
+static_assert(!std::indirectly_movable<const MoveOnly*, MoveOnly*>);
 static_assert(!std::indirectly_movable<MoveOnly*, const MoveOnly*>);
 static_assert(!std::indirectly_movable<const MoveOnly*, const MoveOnly*>);
-static_assert(!std::indirectly_movable<const MoveOnly*, MoveOnly*>);
-static_assert( std::indirectly_movable<PointerTo<MoveOnly>, PointerTo<MoveOnly>>);
-static_assert( std::indirectly_movable<MoveOnly*, PointerTo<MoveOnly>>);
+static_assert( std::indirectly_movable<int*, IndirectlyMovableFromIntPtr>);
+static_assert(!std::indirectly_movable<const int*, IndirectlyMovableFromIntPtr>);
+static_assert(!std::indirectly_movable<IndirectlyMovableFromIntPtr, int*>);
+static_assert(!std::indirectly_movable<IndirectlyMovableFromIntPtr, const int*>);