[libc++][ranges] Implement P2443R1: `views::chunk_by`

[JMazurkiewicz]

Summary

This patch implements https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2443r1.html (views::chunk_by).

[JMazurkiewicz]

Try to fix CI.

[JMazurkiewicz]

Fix CI (add missing includes), and update release notes.

[JMazurkiewicz]

Improve test coverage.
I haven't fixed the problem with transitive includes yet - does anyone know what might be the reason of this failure? (I've marked problematic includes with FIXME transitive include comment)

[JMazurkiewicz]

Fix formatting.

[fsb4000]

I think you should add ranges new beetween these two lines: https://github.com/llvm/llvm-project/blob/fac4c476b97b9f2a9dace059f084696d856c033b/libcxx/test/libcxx/transitive_includes/cxx03.csv#L647-L648 and https://github.com/llvm/llvm-project/blob/main/libcxx/test/libcxx/transitive_includes/cxx11.csv#L648-L649

In theory these files should be updated when you run ninja -C build libcxx-generate-files but that command doesn't work on Windows...

https://github.com/llvm/llvm-project/issues/57458

[JMazurkiewicz]

Update transitive includes manually.

[JMazurkiewicz]

Fix CI

[fsb4000]

Ok, I think current CI failures are not your fault.

Look at the Scheduled build: https://buildkite.com/llvm-project/libcxx-ci/builds/20489

It also failed.

[fsb4000]

I think I fixed the CI when I revert the commit: https://github.com/llvm/llvm-project/commit/24416d22bb284cf24335ee7aa63131e5de56a1bb

And I restarted CI, so I hope it should pass now.

[fsb4000]

The tests passed and I added more reviewers to this patch.

[JMazurkiewicz]

Thank you, @fsb4000!

[JMazurkiewicz]

Rebase

[JMazurkiewicz]

Fix CI.

[Mordante]

Thanks for working on this!
I haven't reviewed the tests yet, but I wanted to give you some feedback.

libcxx/include/__ranges/chunk_by_view.h

31

Can you explain what issue you have with these transitive includes?

78

please search for similar in the asserts and fix them too. Note users of libc++ tend not to read the Standard, so it's better to use the name used in libc++ than the name in the Standard.

81

Now the object can be moved on line 85.

86

Is there a reason why this is written in a different fashion as in the Standard? This makes it harder to verify its correctness.

110

Without const this can be moved. Note that the libc++ code uses const very sparingly.

132

Is there a reason to make the exposition only type public?

157

Since you used _LIBCPP_ASSERT for most preconditions, it would be great to do the same here.

libcxx/include/ranges

315

Please align all since comments

libcxx/test/libcxx/ranges/range.adaptors/range.chunk.by/assert.begin.pass.cpp

14–18

Typically we stat the file with this part and then the header under test.

44

Can you also test the other asserts you added?

libcxx/test/libcxx/transitive_includes/cxx11.csv

677

Did you remove headers or not?

libcxx/test/std/ranges/range.adaptors/range.chunk.by/adaptor.pass.cpp

11

Please add the header name here too.

[JMazurkiewicz]

• Address some of @Mordante's comments
• Rename iterator directory to range.chunk.by.iter

TODO: transitive includes, verify more assertions

[JMazurkiewicz]

Fix CI

[JMazurkiewicz]

libcxx/include/__ranges/chunk_by_view.h

86

Is there a reason why this is written in a different fashion as in the Standard?

This is based on reference implementation from P2443R1 (https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2443r1.html#pnum_16); I've only replaced not_fn(bind(ref(*pred_), _2, _1)) with lambda expression.

132

No, I think that I wanted to test something here.

[JMazurkiewicz]

• Test all added assertions,
• Rebase,
• Fix CI?

TODO: transitive includes

[JMazurkiewicz]

Rebase; try to fix CI.

[JMazurkiewicz]

Rebase; fix CI.

[var-const]

Thank you for working on this! Sorry I'm slow with the review.

libcxx/include/__ranges/chunk_by_view.h

58

Question: can __base_ actually have be empty?

59

Can you please add a TODO to update this to __movable_box once D151629 lands?

63

Is it necessary to explicitly call the default constructor of __non_propagating_cache here?

69

Please add a blank line after this line.

78

Nit: I'd s/with begin iterator/on a begin iterator/.

80

Please add a blank line after this line.

109

Nit: can you add a blank line after this line to separate error checking from the main flow of the function?

151

Nit: s/past end/a past-the-end/.

[var-const]

libcxx/include/__ranges/chunk_by_view.h

78

Hmm, I don't feel too strongly, but I actually wrote a comment asking to do the opposite before I read this thread. I think that ideally we'd assert in public functions (so that the name difference doesn't apply), but if the Standard wants us to assert in private functions, I'd go with the standard name (which is the name of the function we're implementing) rather than our internal name (for the same reason that I would use non-uglified template argument names, etc.). Do we have any precedent for this?

109

Hmm, it's interesting that the standard allows creating an unusable chunk_by_view -- just curious, do you know if there's a use case for that?

109

I know it's in the standard, but it seems like this check is redundant with the one in find-next, or am I missing something?

204

Would any tests fail if we removed decay_t here?

libcxx/test/libcxx/ranges/range.adaptors/range.chunk.by/assert.find-next.pass.cpp

26 ↗

(On Diff #520676)

Question: is this the only (or easiest) way to get an invalid predicate? Would a default-constructed view work here, perhaps?

libcxx/test/libcxx/transitive_includes/cxx11.csv

673

Question: why is this include added?

libcxx/test/std/ranges/range.adaptors/range.chunk.by/adaptor.pass.cpp

60

Question: is it possible to simply compare for equality, or do we necessarily have to use mismatch?

61

Nit: we normally don't use "shallow" const much, and in this small scope in particular it seems unnecessary.

91

Ultranit: unclosed backtick.

187

Nit: please add newlines (here and in other similar places):

{
  [[maybe_unused]] auto partial = std::views::chunk_by(3.14159);
}

libcxx/test/std/ranges/range.adaptors/range.chunk.by/begin.pass.cpp

91

Ultranit: s/a/an/. Consider rephrasing the comment to something like over a longer range, though (the exact number isn't really important here, unlike in the previous two cases).

106

Optional: I don't think we need to assert this since we're testing begin, not the constructor.

147

Can you add a brief comment to explain why the number is 4?

152

I would inline these functions. Normally we use named functions in tests when they are reused.

libcxx/test/std/ranges/range.adaptors/range.chunk.by/constraints.compile.pass.cpp

32

Ultranit: s/an/a/.

35

It looks like types from almost_satisfies_types.h would be helpful here.

59

Nit: can these be more descriptive names?

91

Nit: can you add blank lines after opening and before closing a namespace?

libcxx/test/std/ranges/range.adaptors/range.chunk.by/ctor.default.pass.cpp

76

Optional: I think it would be a little easier to compare the sizes of the inputs, it can simplify the loop as well if you could rely on them being the same size.

81

Please add brief comments to each test case.

libcxx/test/std/ranges/range.adaptors/range.chunk.by/pred.pass.cpp

34

Question: can a default-constructed chunk_by_view contain a valid predicate?

libcxx/test/std/ranges/range.adaptors/range.chunk.by/range.chunk.by.iter/compare.pass.cpp

93

If I'm reading this correctly, the comments should be reversed -- test<Iterator> tests with a sentinel, and test<Iterator, Iterator> tests with a pair of iterators.

101

You can use types::for_each to reduce boilerplate here.

libcxx/test/std/ranges/range.adaptors/range.chunk.by/range.chunk.by.iter/ctor.default.pass.cpp

26

Note: honestly, I think it's a little overkill (to be clear, I'm not requesting to change it), the scope of the test is very small and I think a simple boolean with a comment would have sufficed (it would also avoid having to call to_underlying).

libcxx/test/std/ranges/range.adaptors/range.chunk.by/range.chunk.by.iter/decrement.pass.cpp

73

Nit: s/a two chunks/two chunks/.

140

Ultranit: s/predicate/a predicate/.

libcxx/test/std/ranges/range.adaptors/range.chunk.by/range.chunk.by.iter/deref.pass.cpp

38

Nit: if the intention is to check the return type, perhaps use std::same_as for the iterator?

40

Can we check the exact contents of each chunk instead?

45

This actually uses a sentinel, right? (and vice versa below)

libcxx/test/std/ranges/range.adaptors/range.chunk.by/range.chunk.by.iter/increment.pass.cpp

48

Ultranit: s/an/the/.

110

Question: can you elaborate?

113

Nit: this formatting looks weird, is it produced by clang-format?

libcxx/test/std/ranges/range.adaptors/range.chunk.by/range.chunk.by.iter/types.compile.pass.cpp

44

Using types::for_each would help reduce the boilerplate in this file (here and with the static assertions below too probably).

libcxx/test/std/ranges/range.adaptors/range.chunk.by/types.h

46

Question: why is this necessary? (Wouldn't the generated deduction guide do the same thing?)

[JMazurkiewicz]

• Rebase,
• Address almost all comments from @var-const (thank you for the review!),
• Enable std::ranges::chunk_by_view and std::views::chunk_by in std.cppm.

[JMazurkiewicz]

+comments

libcxx/include/__ranges/chunk_by_view.h

58

Yes, when it is for example ranges::empty_view.

63

It's not, I've removed it.

109

I know it's in the standard, but it seems like this check is redundant with the one in find-next, or am I missing something?

109

I know it's in the standard, but it seems like this check is redundant with the one in find-next, or am I missing something?

109

Hmm, it's interesting that the standard allows creating an unusable chunk_by_view -- just curious, do you know if there's a use case for that?

I have no idea.

I know it's in the standard, but it seems like this check is redundant with the one in find-next, or am I missing something?

This check is not redundant. I've explained why in comment in assert.find-next.pass.cpp file.

204

No... until now. I've added extra test coverage in adaptor.pass.cpp (marked with Test that one can call std::views::chunk_by with arbitrary stuff (...) comment).

libcxx/test/libcxx/ranges/range.adaptors/range.chunk.by/assert.find-next.pass.cpp

26 ↗

(On Diff #520676)

This is the easiest way (I think) to get __find_next to fail. If we used default constructed view here, then begin() would fail instead of __find_next.

libcxx/test/std/ranges/range.adaptors/range.chunk.by/adaptor.pass.cpp

60

Yes, replaced with std::ranges::equal.

libcxx/test/std/ranges/range.adaptors/range.chunk.by/pred.pass.cpp

34

I don't think it is possible - default-constructed __copyable_box (or __movable_box) never contains a value.

libcxx/test/std/ranges/range.adaptors/range.chunk.by/range.chunk.by.iter/deref.pass.cpp

45

Yes, I've swapped comments again.

libcxx/test/std/ranges/range.adaptors/range.chunk.by/range.chunk.by.iter/increment.pass.cpp

110

All callables can be called like regular function f(), but not all invocables can (we need to use std::invoke for them). This tests checks if we use std::invoke properly or we just use pred() syntax.

I've added comment explaining this here and in decrement.pass.cpp.

113

Yes, it is produced by clang-format. I'm going to fix it manually.

libcxx/test/std/ranges/range.adaptors/range.chunk.by/range.chunk.by.iter/types.compile.pass.cpp

44

Done for testValueTypeAndDifferenceType, but I don't think it is possible for static_assertions.

libcxx/test/std/ranges/range.adaptors/range.chunk.by/types.h

46

Yes, it is necessary. Without this deduction guide I get error: 'View' may not intend to support class template argument deduction warning, but since tests use -Werror this ends up as a hard error.

[JMazurkiewicz]

Fix CI.

[JMazurkiewicz]

• Rebase,
• Fix CI: use __movable_box.

[JMazurkiewicz]

Rebase

[var-const]

Thanks for working on this! LGTM (with just one comment), and feel free to ping me if you run into any problems when rebasing.

libcxx/test/libcxx/ranges/range.adaptors/range.chunk.by/assert.begin.pass.cpp

14

Quick tip: when you rebase, you can replace D_LIBCPP_ENABLE_ASSERTIONS=1 with // UNSUPPORTED: !libcpp-has-hardened-mode && !libcpp-has-debug-mode.

libcxx/test/libcxx/ranges/range.adaptors/range.chunk.by/assert.find-next.pass.cpp

26 ↗

(On Diff #520676)

Thanks for explaining. I think it deserves a comment in the test file.

[Mordante]

@JMazurkiewicz friendly ping.

[JMazurkiewicz]

• Rebase,
• Target LLVM 18,
• Address more @var-const's comments.

[JMazurkiewicz]

Fix CI

[JMazurkiewicz]

Rebase and fix CI

[JMazurkiewicz]

Rebase, fix CI.

[var-const]

libcxx/include/__ranges/chunk_by_view.h

49

Quick question -- why do we need this?

[var-const]

libcxx/include/__ranges/chunk_by_view.h

49

Never mind -- it looks like it's to protect against macros like move.

[var-const]

@JMazurkiewicz Please let me know if you need any help to merge this patch.

Regarding the CI failure with reserved names -- I presume this is related to https://reviews.llvm.org/D147356, you might need to add the "push macros / pop macros" dance to ranges_adjacent_find.h and movable_box.h.

[JMazurkiewicz]

• Rebase
• Defend against move macro
• Replace _LIBCPP_ASSERT with _LIBCPP_ASSERT_UNCATEGORIZED
• Add _LIBCPP_PUSH_MACROS; #include <__undef_macros> ... _LIBCPP_POP_MACROS in ranges_adjacent_find.h and movable_box.h
• Try to fix CI and make this patch ready for the commit :)

[JMazurkiewicz]

Is this patch OK now? @var-const

If so, can you merge it for me? "Jakub Mazurkiewicz <[e-mail]>"

[var-const]

In D144767#4636804, @JMazurkiewicz wrote:

Is this patch OK now? @var-const

If so, can you merge it for me? "Jakub Mazurkiewicz <[e-mail]>"

Thank you for the patch! Merged now.

[ldionne]

This seems to break the C++20 CI: https://buildkite.com/llvm-project/libcxx-ci/builds/29475#018a6a62-4d93-4db9-bb60-0d011a40552e

Did you folks ensure a green build before merging? I'll try to take a look at what's wrong and fix it.

[JMazurkiewicz]

Did you folks ensure a green build before merging?

Yes, it was green.

Looks like views::chunk_by and ranges::chunk_by_view should be guarded with #if _LIBCPP_STD_VER >= 23 in modules/std/ranges.inc file. Do you want me to publish pull request with fix on Github? @ldionne

[ldionne]

Should be fixed by 98d28e947cc332f5bb9878e967ea5d7e414cf785! I reproduced and verified the fix locally.

I think what happened is a race condition with the enablement of C++23 modules in C++20. Basically the CI didn't run this test in C++20 mode when you triggered the CI. No big deal, it should work now.

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_optional``                            ``202110L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_out_ptr``                             *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_as_rvalue``                    ``202207L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_chunk``                        *unimplemented*
     ------------------------------------------------- -----------------
-    ``__cpp_lib_ranges_chunk_by``                     *unimplemented*
+    ``__cpp_lib_ranges_chunk_by``                     ``202202L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_iota``                         *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_join_with``                    *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_slide``                        *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_starts_ends_with``             *unimplemented*

libcxx/docs/ReleaseNotes.rst

 What's New in Libc++ 17.0.0?
 ============================
 
 Implemented Papers
 ------------------
 - P2520R0 - ``move_iterator<T*>`` should be a random access iterator
 - P1328R1 - ``constexpr type_info::operator==()``
 - P1413R3 - Formatting ``thread::id`` (the ``stacktrace`` is not done yet)
+- P2443R1 - ``views::chunk_by``
 
 Improvements and New Features
 -----------------------------
 - ``std::equal`` and ``std::ranges::equal`` are now forwarding to ``std::memcmp`` for integral types and pointers,
   which can lead up to 40x performance improvements.
 
 - ``std::string_view`` now provides iterators that check for out-of-bounds accesses when the safe
   libc++ mode is enabled.

libcxx/docs/Status/Cxx2bPapers.csv

 "`P1206R7 <https://wg21.link/P1206R7>`__","LWG","``ranges::to``: A function to convert any range to a container","February 2022","","","|ranges|"
 "`P1413R3 <https://wg21.link/P1413R3>`__","LWG","Deprecate ``std::aligned_storage`` and ``std::aligned_union``","February 2022","|Complete| [#note-P1413R3]_",""
 "`P2255R2 <https://wg21.link/P2255R2>`__","LWG","A type trait to detect reference binding to temporary","February 2022","",""
 "`P2273R3 <https://wg21.link/P2273R3>`__","LWG","Making ``std::unique_ptr`` constexpr","February 2022","|Complete|","16.0"
 "`P2387R3 <https://wg21.link/P2387R3>`__","LWG","Pipe support for user-defined range adaptors","February 2022","","","|ranges|"
 "`P2440R1 <https://wg21.link/P2440R1>`__","LWG","``ranges::iota``, ``ranges::shift_left`` and ``ranges::shift_right``","February 2022","","","|ranges|"
 "`P2441R2 <https://wg21.link/P2441R2>`__","LWG","``views::join_with``","February 2022","","","|ranges|"
 "`P2442R1 <https://wg21.link/P2442R1>`__","LWG","Windowing range adaptors: ``views::chunk`` and ``views::slide``","February 2022","","","|ranges|"
-"`P2443R1 <https://wg21.link/P2443R1>`__","LWG","``views::chunk_by``","February 2022","","","|ranges|"
+"`P2443R1 <https://wg21.link/P2443R1>`__","LWG","``views::chunk_by``","February 2022","|Complete|","17.0","|ranges|"
 "","","","","","",""
 "`P0009R18 <https://wg21.link/P0009R18>`__","LWG","mdspan: A Non-Owning Multidimensional Array Reference","July 2022","",""
 "`P0429R9 <https://wg21.link/P0429R9>`__","LWG","A Standard ``flat_map``","July 2022","",""
 "`P1169R4 <https://wg21.link/P1169R4>`__","LWG","``static operator()``","July 2022","|Complete|","16.0"
 "`P1222R4 <https://wg21.link/P1222R4>`__","LWG","A Standard ``flat_set``","July 2022","",""
 "`P1223R5 <https://wg21.link/P1223R5>`__","LWG","``ranges::find_last()``, ``ranges::find_last_if()``, and ``ranges::find_last_if_not()``","July 2022","","","|ranges|"
 "`P1467R9 <https://wg21.link/P1467R9>`__","LWG","Extended ``floating-point`` types and standard names","July 2022","",""
 "`P1642R11 <https://wg21.link/P1642R11>`__","LWG","Freestanding ``[utilities]``, ``[ranges]``, and ``[iterators]``","July 2022","",""

libcxx/docs/Status/RangesViews.csv

 C++23,`cartesian_product <https://wg21.link/P2374R4>`_,Unassigned,No patch yet,Not started
 C++23,`zip <https://wg21.link/P2321R2>`_,Hui Xie,`D122806 <https://llvm.org/D122806>`_,✅
 C++23,`zip_transform <https://wg21.link/P2321R2>`_,Hui Xie,No patch yet,Not started
 C++23,`adjacent <https://wg21.link/P2321R2>`_,Hui Xie,No patch yet,Not started
 C++23,`adjacent_transform <https://wg21.link/P2321R2>`_,Hui Xie,No patch yet,Not started
 C++23,`join_with <https://wg21.link/P2441R2>`_,Unassigned,No patch yet,Not started
 C++23,`slide <https://wg21.link/P2442R1>`_,Unassigned,No patch yet,Not started
 C++23,`chunk <https://wg21.link/P2442R1>`_,Unassigned,No patch yet,Not started
-C++23,`chunk_by <https://wg21.link/P2443R1>`_,Unassigned,No patch yet,Not started
+C++23,`chunk_by <https://wg21.link/P2443R1>`_,Jakub Mazurkiewicz,`D144767 <https://llvm.org/D144767>`,✅
 C++23,`as_const <https://wg21.link/P2278R4>`_,Unassigned,No patch yet,Not started
 C++23,`as_rvalue <https://wg21.link/P2446R2>`_,Nikolas Klauser,`D137637 <https://llvm.org/D137637>`_,✅
 C++23,`stride <https://wg21.link/P1899R3>`_,Unassigned,No patch yet,Not started

libcxx/include/CMakeLists.txt

set(files
   __random/subtract_with_carry_engine.h
   __random/uniform_int_distribution.h
   __random/uniform_random_bit_generator.h
   __random/uniform_real_distribution.h
   __random/weibull_distribution.h
   __ranges/access.h
   __ranges/all.h
   __ranges/as_rvalue_view.h
+  __ranges/chunk_by_view.h
   __ranges/common_view.h
   __ranges/concepts.h
   __ranges/copyable_box.h
   __ranges/counted.h
   __ranges/dangling.h
   __ranges/data.h
   __ranges/drop_view.h
   __ranges/drop_while_view.h

libcxx/include/__ranges/chunk_by_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_CHUNK_BY_VIEW_H
+#define _LIBCPP___RANGES_CHUNK_BY_VIEW_H
+
+#include <__algorithm/ranges_adjacent_find.h>
+#include <__concepts/constructible.h>
+#include <__config>
+#include <__debug>
+#include <__functional/bind_back.h>
+#include <__functional/invoke.h>
+#include <__functional/not_fn.h>
+#include <__functional/reference_wrapper.h>
+#include <__iterator/concepts.h>
+#include <__iterator/default_sentinel.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/next.h>
+#include <__iterator/prev.h>
+#include <__memory/addressof.h>
+#include <__ranges/access.h>
+#include <__ranges/all.h>
+#include <__ranges/concepts.h>
+#include <__ranges/copyable_box.h>
+#include <__ranges/non_propagating_cache.h>
+#include <__ranges/range_adaptor.h>
+#include <__ranges/reverse_view.h>
+#include <__ranges/subrange.h>
+#include <__ranges/view_interface.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/is_object.h>
+#include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+namespace ranges {
+
+template <forward_range _View, indirect_binary_predicate<iterator_t<_View>, iterator_t<_View>> _Pred>
+  requires view<_View> && is_object_v<_Pred>
+class chunk_by_view : public view_interface<chunk_by_view<_View, _Pred>> {
+  _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
+  _LIBCPP_NO_UNIQUE_ADDRESS __copyable_box<_Pred> __pred_;
+
+  // We cache the result of begin() to allow providing an amortized O(1).
+  using _Cache           = __non_propagating_cache<iterator_t<_View>>;
+  _Cache __cached_begin_ = _Cache();
+
+  class __iterator;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_View> __find_next(iterator_t<_View> __current) {
+    _LIBCPP_ASSERT(
+        __pred_.__has_value(), "Trying to call __find_next() on a chunk_by_view that does not have a valid predicate.");
+    return ranges::next(ranges::adjacent_find(__current, ranges::end(__base_), std::not_fn(std::ref(*__pred_))),
+                        1,
+                        ranges::end(__base_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_View> __find_prev(iterator_t<_View> __current)
+    requires bidirectional_range<_View>
+  {
+    _LIBCPP_ASSERT(__current != ranges::begin(__base_), "Trying to call __find_prev() with begin iterator.");
+    _LIBCPP_ASSERT(
+        __pred_.__has_value(), "Trying to call __find_prev() on a chunk_by_view that does not have a valid predicate.");
+    auto __first = ranges::begin(__base_);
+    reverse_view __reversed{subrange{__first, __current}};
+    auto __reversed_pred = [this]<class _Tp, class _Up>(_Tp&& __x, _Up&& __y) {
+      return !std::invoke(*__pred_, std::forward<_Up>(__y), std::forward<_Tp>(__x));
+    };
+    return ranges::prev(ranges::adjacent_find(__reversed, __reversed_pred).base(), 1, std::move(__first));
+  }
+
+public:
+  _LIBCPP_HIDE_FROM_ABI chunk_by_view()
+    requires default_initializable<_View> && default_initializable<_Pred>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit chunk_by_view(_View __base, _Pred __pred)
+      : __base_(std::move(__base)), __pred_(in_place, std::move(__pred)) {}
+
+  _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 const _Pred& pred() const { return *__pred_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator begin() {
+    _LIBCPP_ASSERT(
+        __pred_.__has_value(), "Trying to call begin() on a chunk_by_view that does not have a valid predicate.");
+    auto __first = ranges::begin(__base_);
+    if (!__cached_begin_.__has_value()) {
+      __cached_begin_.__emplace(__find_next(__first));
+    }
+    return {*this, std::move(__first), *__cached_begin_};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() {
+    if constexpr (common_range<_View>) {
+      return __iterator{*this, ranges::end(__base_), ranges::end(__base_)};
+    } else {
+      return default_sentinel;
+    }
+  }
+};
+
+template <class _Range, class _Pred>
+chunk_by_view(_Range&&, _Pred) -> chunk_by_view<views::all_t<_Range>, _Pred>;
+
+template <forward_range _View, indirect_binary_predicate<iterator_t<_View>, iterator_t<_View>> _Pred>
+  requires view<_View> && is_object_v<_Pred>
+class chunk_by_view<_View, _Pred>::__iterator {
+  friend chunk_by_view;
+
+  chunk_by_view* __parent_                               = nullptr;
+  _LIBCPP_NO_UNIQUE_ADDRESS iterator_t<_View> __current_ = iterator_t<_View>();
+  _LIBCPP_NO_UNIQUE_ADDRESS iterator_t<_View> __next_    = iterator_t<_View>();
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(
+      chunk_by_view& __parent, iterator_t<_View> __current, iterator_t<_View> __next)
+      : __parent_(std::addressof(__parent)), __current_(__current), __next_(__next) {}
+
+public:
+  using value_type        = subrange<iterator_t<_View>>;
+  using difference_type   = range_difference_t<_View>;
+  using iterator_category = input_iterator_tag;
+  using iterator_concept  = conditional_t<bidirectional_range<_View>, bidirectional_iterator_tag, forward_iterator_tag>;
+
+  _LIBCPP_HIDE_FROM_ABI __iterator() = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type operator*() const {
+    _LIBCPP_ASSERT(__current_ != __next_, "Trying to dereference past end chunk_by_view iterator.");
+    return {__current_, __next_};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
+    _LIBCPP_ASSERT(__current_ != __next_, "Trying to increment past end chunk_by_view iterator.");
+    __current_ = __next_;
+    __next_    = __parent_->__find_next(__current_);
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int) {
+    auto __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()
+    requires bidirectional_range<_View>
+  {
+    __next_    = __current_;
+    __current_ = __parent_->__find_prev(__next_);
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)
+    requires bidirectional_range<_View>
+  {
+    auto __tmp = *this;
+    --*this;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y) {
+    return __x.__current_ == __y.__current_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, default_sentinel_t) {
+    return __x.__current_ == __x.__next_;
+  }
+};
+
+namespace views {
+namespace __chunk_by {
+struct __fn {
+  template <class _Range, class _Pred>
+  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Pred&& __pred) const
+      noexcept(noexcept(/**/ chunk_by_view(std::forward<_Range>(__range), std::forward<_Pred>(__pred))))
+          -> decltype(/*--*/ chunk_by_view(std::forward<_Range>(__range), std::forward<_Pred>(__pred))) {
+    return /*-------------*/ chunk_by_view(std::forward<_Range>(__range), std::forward<_Pred>(__pred));
+  }
+
+  template <class _Pred>
+    requires constructible_from<decay_t<_Pred>, _Pred>
+  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Pred&& __pred) const
+      noexcept(is_nothrow_constructible_v<decay_t<_Pred>, _Pred>) {
+    return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Pred>(__pred)));
+  }
+};
+} // namespace __chunk_by
+
+inline namespace __cpo {
+inline constexpr auto chunk_by = __chunk_by::__fn{};
+} // namespace __cpo
+} // namespace views
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_CHUNK_BY_VIEW_H

libcxx/include/module.modulemap.in

module ranges {
     module __ranges {
       module access                 { private header "__ranges/access.h" }
       module all                    {
         private header "__ranges/all.h"
         export functional.__functional.compose
         export functional.__functional.perfect_forward
       }
       module as_rvalue_view         { private header "__ranges/as_rvalue_view.h" }
+      module chunk_by_view          { private header "__ranges/chunk_by_view.h" }
       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"
         export span
       }
       module dangling               { private header "__ranges/dangling.h" }

libcxx/include/ranges

// [range.reverse], reverse view
   template<class Val>
     using wistream_view = basic_istream_view<Val, wchar_t>;
 
   namespace views { template<class T> inline constexpr unspecified istream = unspecified; }
 
   // [range.zip], zip view
   template<input_range... Views>
     requires (view<Views> && ...) && (sizeof...(Views) > 0)
-  class zip_view;        // C++2b
+  class zip_view;                                                           // since C++23
 
   template<class... Views>
-    inline constexpr bool enable_borrowed_range<zip_view<Views...>> =    // C++2b
+    inline constexpr bool enable_borrowed_range<zip_view<Views...>> =       // since C++23
       (enable_borrowed_range<Views> && ...);
 
-  namespace views { inline constexpr unspecified zip = unspecified; }    // C++2b
+  namespace views { inline constexpr unspecified zip = unspecified; }       // since C++23
 
   // [range.as.rvalue]
   template <view V>
     requires input_range<V>
-  class as_rvalue_view; // since C++23
+  class as_rvalue_view;                                                     // since C++23
 
   namespace views { inline constexpr unspecified as_rvalue ) unspecified; } // since C++23
+
+  [range.chunk.by]
+  template<forward_range V, indirect_binary_predicate<iterator_t<V>, iterator_t<V>> Pred>
+    requires view<V> && is_object_v<Pred>
+  class chunk_by_view;                                                      // since C++23
+
+  namespace views { inline constexpr unspecified chunk_by = unspecified; }  // since C++23
 }
 
 namespace std {
   namespace views = ranges::views;
 
   template<class T> struct tuple_size;
   template<size_t I, class T> struct tuple_element;
 

 }
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/as_rvalue_view.h>
+#include <__ranges/chunk_by_view.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_view.h>
 #include <__ranges/drop_while_view.h>
 #include <__ranges/elements_view.h>

libcxx/include/version

 # define __cpp_lib_invoke_r                             202106L
 # define __cpp_lib_is_scoped_enum                       202011L
 // # define __cpp_lib_move_only_function                   202110L
 # undef  __cpp_lib_optional
 # define __cpp_lib_optional                             202110L
 // # define __cpp_lib_out_ptr                              202106L
 # define __cpp_lib_ranges_as_rvalue                     202207L
 // # define __cpp_lib_ranges_chunk                         202202L
-// # define __cpp_lib_ranges_chunk_by                      202202L
+# define __cpp_lib_ranges_chunk_by                      202202L
 // # define __cpp_lib_ranges_iota                          202202L
 // # define __cpp_lib_ranges_join_with                     202202L
 // # define __cpp_lib_ranges_slide                         202202L
 // # define __cpp_lib_ranges_starts_ends_with              202106L
 // # define __cpp_lib_ranges_to_container                  202202L
 // # define __cpp_lib_ranges_zip                           202110L
 // # define __cpp_lib_reference_from_temporary             202202L
 // # define __cpp_lib_spanstream                           202106L

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__random/subtract_with_carry_engine.h> // expected-error@*:* {{use of private header from outside its module: '__random/subtract_with_carry_engine.h'}}
 #include <__random/uniform_int_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/uniform_int_distribution.h'}}
 #include <__random/uniform_random_bit_generator.h> // expected-error@*:* {{use of private header from outside its module: '__random/uniform_random_bit_generator.h'}}
 #include <__random/uniform_real_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/uniform_real_distribution.h'}}
 #include <__random/weibull_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/weibull_distribution.h'}}
 #include <__ranges/access.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/access.h'}}
 #include <__ranges/all.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/all.h'}}
 #include <__ranges/as_rvalue_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/as_rvalue_view.h'}}
+#include <__ranges/chunk_by_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/chunk_by_view.h'}}
 #include <__ranges/common_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/common_view.h'}}
 #include <__ranges/concepts.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/concepts.h'}}
 #include <__ranges/copyable_box.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/copyable_box.h'}}
 #include <__ranges/counted.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/counted.h'}}
 #include <__ranges/dangling.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/dangling.h'}}
 #include <__ranges/data.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/data.h'}}
 #include <__ranges/drop_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/drop_view.h'}}
 #include <__ranges/drop_while_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/drop_while_view.h'}}

libcxx/test/libcxx/ranges/range.adaptors/range.chunk.by/adaptor.nodiscard.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <ranges>
+
+// Test the libc++ extension that std::views::chunk_by is marked as [[nodiscard]].
+
+#include <functional>
+#include <ranges>
+
+void test() {
+  int range[] = {1, 2, 3, 0, 1, 2};
+  std::ranges::less_equal pred;
+
+  std::views::chunk_by(pred); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  std::views::chunk_by(range, pred); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  range | std::views::chunk_by(pred); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  std::views::all | std::views::chunk_by(pred); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+}

libcxx/test/libcxx/ranges/range.adaptors/range.chunk.by/assert.begin.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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: has-unix-headers
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: no-exceptions
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
+
+// <ranges>
+
+// Call begin() on chunk_by_view with empty predicate
+
+#include <ranges>
+
+#include "check_assertion.h"
+
+struct ThrowOnCopyPred {
+  ThrowOnCopyPred() = default;
+  ThrowOnCopyPred(const ThrowOnCopyPred&) { throw 0; }
+  ThrowOnCopyPred& operator=(const ThrowOnCopyPred&) = delete;
+
+  ThrowOnCopyPred(ThrowOnCopyPred&&)            = default;
+  ThrowOnCopyPred& operator=(ThrowOnCopyPred&&) = default;
+
+  bool operator()(int, int) const { return 0; }
+};
+
+int main(int, char**) {
+  int input[] = {1, 2, 3};
+  auto view1  = std::views::chunk_by(input, ThrowOnCopyPred{});
+  auto view2  = std::views::chunk_by(input, ThrowOnCopyPred{});
+  try {
+    view1 = view2;
+  } catch (...) {
+  }
+  TEST_LIBCPP_ASSERT_FAILURE(
+      view1.begin(), "Trying to call begin() on a chunk_by_view that does not have a valid predicate.");
+  return 0;
+}

libcxx/test/libcxx/ranges/range.adaptors/range.chunk.by/range.chunk.by.iter/assert.deref.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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: has-unix-headers
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: no-exceptions
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
+
+// <ranges>
+
+// Dereference past end chunk_by_view iterator
+
+#include <ranges>
+
+#include "check_assertion.h"
+
+int main(int, char**) {
+  int input[] = {1, 2, 3};
+  auto view   = std::views::chunk_by(input, std::less{});
+  auto it     = view.begin();
+  ++it;
+  TEST_LIBCPP_ASSERT_FAILURE(*it, "Trying to dereference past end chunk_by_view iterator.");
+  return 0;
+}

libcxx/test/libcxx/ranges/range.adaptors/range.chunk.by/range.chunk.by.iter/assert.increment.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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: has-unix-headers
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: no-exceptions
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
+
+// <ranges>
+
+// Increment past end chunk_by_view iterator
+
+#include <ranges>
+
+#include "check_assertion.h"
+
+int main(int, char**) {
+  int input[] = {1, 2, 3};
+  auto view   = std::views::chunk_by(input, std::less{});
+  auto it     = view.begin();
+  ++it;
+  TEST_LIBCPP_ASSERT_FAILURE(++it, "Trying to increment past end chunk_by_view iterator.");
+  return 0;
+}

libcxx/test/libcxx/transitive_includes/cxx03.csv

 random version
 ranges compare
 ranges cstddef
 ranges cstdlib
 ranges initializer_list
 ranges iosfwd
 ranges iterator
 ranges limits
+ranges new
 ranges optional
 ranges span
 ranges tuple
 ranges type_traits
-ranges variant
 ranges version
 ratio climits
 ratio cstdint
 ratio type_traits
 ratio version
 regex atomic
 regex cctype
 regex compare

libcxx/test/libcxx/transitive_includes/cxx11.csv

 random version
 ranges compare
 ranges cstddef
 ranges cstdlib
 ranges initializer_list
 ranges iosfwd
 ranges iterator
 ranges limits
+ranges new
 ranges optional
 ranges span
 ranges tuple
 ranges type_traits
-ranges variant
 ranges version
 ratio climits
 ratio cstdint
 ratio type_traits
 ratio version
 regex atomic
 regex cctype
 regex compare

libcxx/test/libcxx/transitive_includes/cxx14.csv

 random version
 ranges compare
 ranges cstddef
 ranges cstdlib
 ranges initializer_list
 ranges iosfwd
 ranges iterator
 ranges limits
+ranges new
 ranges optional
 ranges span
 ranges tuple
 ranges type_traits
-ranges variant
 ranges version
 ratio climits
 ratio cstdint
 ratio type_traits
 ratio version
 regex atomic
 regex cctype
 regex compare

libcxx/test/libcxx/transitive_includes/cxx17.csv

 random version
 ranges compare
 ranges cstddef
 ranges cstdlib
 ranges initializer_list
 ranges iosfwd
 ranges iterator
 ranges limits
+ranges new
 ranges optional
 ranges span
 ranges tuple
 ranges type_traits
-ranges variant
 ranges version
 ratio climits
 ratio cstdint
 ratio type_traits
 ratio version
 regex atomic
 regex cctype
 regex compare

libcxx/test/libcxx/transitive_includes/cxx20.csv

 random version
 ranges compare
 ranges cstddef
 ranges cstdlib
 ranges initializer_list
 ranges iosfwd
 ranges iterator
 ranges limits
+ranges new
 ranges optional
 ranges span
 ranges tuple
 ranges type_traits
-ranges variant
 ranges version
 ratio climits
 ratio cstdint
 ratio type_traits
 ratio version
 regex atomic
 regex cctype
 regex compare

libcxx/test/std/language.support/support.limits/support.limits.general/ranges.version.compile.pass.cpp

 #     error "__cpp_lib_ranges_chunk should have the value 202202L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_ranges_chunk
 #     error "__cpp_lib_ranges_chunk should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_ranges_chunk_by
-#     error "__cpp_lib_ranges_chunk_by should be defined in c++2b"
-#   endif
-#   if __cpp_lib_ranges_chunk_by != 202202L
-#     error "__cpp_lib_ranges_chunk_by should have the value 202202L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_ranges_chunk_by
-#     error "__cpp_lib_ranges_chunk_by should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_ranges_chunk_by
+#   error "__cpp_lib_ranges_chunk_by should be defined in c++2b"
+# endif
+# if __cpp_lib_ranges_chunk_by != 202202L
+#   error "__cpp_lib_ranges_chunk_by should have the value 202202L in c++2b"
+# endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_join_with
 #     error "__cpp_lib_ranges_join_with should be defined in c++2b"
 #   endif
 #   if __cpp_lib_ranges_join_with != 202202L
 #     error "__cpp_lib_ranges_join_with should have the value 202202L in c++2b"
 #   endif

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp

 #     error "__cpp_lib_ranges_chunk should have the value 202202L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_ranges_chunk
 #     error "__cpp_lib_ranges_chunk should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_ranges_chunk_by
-#     error "__cpp_lib_ranges_chunk_by should be defined in c++2b"
-#   endif
-#   if __cpp_lib_ranges_chunk_by != 202202L
-#     error "__cpp_lib_ranges_chunk_by should have the value 202202L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_ranges_chunk_by
-#     error "__cpp_lib_ranges_chunk_by should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_ranges_chunk_by
+#   error "__cpp_lib_ranges_chunk_by should be defined in c++2b"
+# endif
+# if __cpp_lib_ranges_chunk_by != 202202L
+#   error "__cpp_lib_ranges_chunk_by should have the value 202202L in c++2b"
+# endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_iota
 #     error "__cpp_lib_ranges_iota should be defined in c++2b"
 #   endif
 #   if __cpp_lib_ranges_iota != 202202L
 #     error "__cpp_lib_ranges_iota should have the value 202202L in c++2b"
 #   endif

libcxx/test/std/ranges/range.adaptors/range.chunk.by/adaptor.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, c++20
+
+// <ranges>
+
+// std::views::chunk_by
+
+#include <ranges>
+
+#include <algorithm>
+#include <cassert>
+#include <concepts>
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
+
+#include "test_iterators.h"
+
+template <class View, class T>
+concept CanBePiped =
+    requires(View&& view, T&& t) {
+      { std::forward<View>(view) | std::forward<T>(t) };
+    };
+
+struct Pred {
+  constexpr bool operator()(int x, int y) const { return x != -y; }
+};
+
+struct NonCopyablePredicate : Pred {
+  NonCopyablePredicate(NonCopyablePredicate const&) = delete;
+};
+
+struct Range : std::ranges::view_base {
+  using Iterator = forward_iterator<int*>;
+  using Sentinel = sentinel_wrapper<Iterator>;
+  constexpr explicit Range(int* b, int* e) : begin_(b), end_(e) {}
+  constexpr Iterator begin() const { return Iterator(begin_); }
+  constexpr Sentinel end() const { return Sentinel(Iterator(end_)); }
+
+private:
+  int* begin_;
+  int* end_;
+};
+
+template <typename View>
+constexpr void compareViews(View v, std::initializer_list<std::initializer_list<int>> list) {
+  auto b1 = v.begin();
+  auto e1 = v.end();
+  auto b2 = list.begin();
+  auto e2 = list.end();
+  for (; b1 != e1 && b2 != e2; ++b1, ++b2) {
+    auto [chunk_e1, chunk_e2] = std::ranges::mismatch(*b1, *b2, [](int x, int y) {
+      const bool result = x == y;
+      assert(result);
+      return result;
+    });
+    assert(chunk_e1 == (*b1).end());
+    assert(chunk_e2 == (*b2).end());
+  }
+  assert(b1 == e1);
+  assert(b2 == e2);
+}
+
+constexpr int absoluteValue(int x) { return x < 0 ? -x : x; }
+
+template <class T>
+constexpr const T&& asConstRvalue(T&& t) {
+  return static_cast<T const&&>(t);
+}
+
+constexpr bool test() {
+  int buff[] = {-4, -3, -2, -1, 1, 2, 3, 4};
+
+  // Test range adaptor object
+  {
+    using RangeAdaptorObject = decltype(std::views::chunk_by);
+    static_assert(std::is_const_v<RangeAdaptorObject>);
+
+    // The type of a customization point object, ignoring cv-qualifiers, shall model semiregular
+    static_assert(std::semiregular<std::remove_const<RangeAdaptorObject>>);
+  }
+
+  // Test `views::chunk_by(pred)(v)
+  {
+    using Result = std::ranges::chunk_by_view<Range, Pred>;
+    Range const range(buff, buff + 8);
+    Pred pred;
+
+    {
+      // 'views::chunk_by(pred)' - &&
+      std::same_as<Result> decltype(auto) result = std::views::chunk_by(pred)(range);
+      compareViews(result, {{-4, -3, -2, -1}, {1, 2, 3, 4}});
+    }
+    {
+      // 'views::chunk_by(pred)' - const&&
+      std::same_as<Result> decltype(auto) result = asConstRvalue(std::views::chunk_by(pred))(range);
+      compareViews(result, {{-4, -3, -2, -1}, {1, 2, 3, 4}});
+    }
+    {
+      // 'views::chunk_by(pred)' - &
+      auto partial                               = std::views::chunk_by(pred);
+      std::same_as<Result> decltype(auto) result = partial(range);
+      compareViews(result, {{-4, -3, -2, -1}, {1, 2, 3, 4}});
+    }
+    {
+      // 'views::chunk_by(pred)' - const&
+      auto const partial                         = std::views::chunk_by(pred);
+      std::same_as<Result> decltype(auto) result = partial(range);
+      compareViews(result, {{-4, -3, -2, -1}, {1, 2, 3, 4}});
+    }
+  }
+
+  // Test `v | views::chunk_by(pred)`
+  {
+    using Result = std::ranges::chunk_by_view<Range, Pred>;
+    Range const range(buff, buff + 8);
+    Pred pred;
+
+    {
+      // 'views::chunk_by(pred)' - &&
+      std::same_as<Result> decltype(auto) result = range | std::views::chunk_by(pred);
+      compareViews(result, {{-4, -3, -2, -1}, {1, 2, 3, 4}});
+    }
+    {
+      // 'views::chunk_by(pred)' - const&&
+      std::same_as<Result> decltype(auto) result = range | asConstRvalue(std::views::chunk_by(pred));
+      compareViews(result, {{-4, -3, -2, -1}, {1, 2, 3, 4}});
+    }
+    {
+      // 'views::chunk_by(pred)' - &
+      auto partial                               = std::views::chunk_by(pred);
+      std::same_as<Result> decltype(auto) result = range | partial;
+      compareViews(result, {{-4, -3, -2, -1}, {1, 2, 3, 4}});
+    }
+    {
+      // 'views::chunk_by(pred)' - const&
+      auto const partial                         = std::views::chunk_by(pred);
+      std::same_as<Result> decltype(auto) result = range | partial;
+      compareViews(result, {{-4, -3, -2, -1}, {1, 2, 3, 4}});
+    }
+  }
+
+  // Test `views::chunk_by(v, pred)` range adaptor object
+  {
+    using Result = std::ranges::chunk_by_view<Range, Pred>;
+    Range const range(buff, buff + 8);
+    Pred pred;
+
+    {
+      // 'views::chunk_by' - &&
+      auto range_adaptor                         = std::views::chunk_by;
+      std::same_as<Result> decltype(auto) result = std::move(range_adaptor)(range, pred);
+      compareViews(result, {{-4, -3, -2, -1}, {1, 2, 3, 4}});
+    }
+    {
+      // 'views::chunk_by' - const&&
+      auto const range_adaptor                   = std::views::chunk_by;
+      std::same_as<Result> decltype(auto) result = std::move(range_adaptor)(range, pred);
+      compareViews(result, {{-4, -3, -2, -1}, {1, 2, 3, 4}});
+    }
+    {
+      // 'views::chunk_by' - &
+      auto range_adaptor                         = std::views::chunk_by;
+      std::same_as<Result> decltype(auto) result = range_adaptor(range, pred);
+      compareViews(result, {{-4, -3, -2, -1}, {1, 2, 3, 4}});
+    }
+    {
+      // 'views::chunk_by' - const&
+      auto const range_adaptor                   = std::views::chunk_by;
+      std::same_as<Result> decltype(auto) result = range_adaptor(range, pred);
+      compareViews(result, {{-4, -3, -2, -1}, {1, 2, 3, 4}});
+    }
+  }
+
+  // Test that one can call std::views::chunk_by with arbitrary stuff, as long as we
+  // don't try to actually complete the call by passing it a range.
+  //
+  // That makes no sense and we can't do anything with the result, but it's valid.
+  { [[maybe_unused]] auto partial = std::views::chunk_by(3.14159); }
+
+  // Test `adaptor | views::chunk_by(pred)`
+  {
+    Range const range(buff, buff + 8);
+
+    {
+      auto pred1 = [](int i) { return absoluteValue(i) < 3; };
+      Pred pred2;
+      using Result = std::ranges::chunk_by_view<std::ranges::filter_view<Range, decltype(pred1)>, Pred>;
+      std::same_as<Result> decltype(auto) result = range | std::views::filter(pred1) | std::views::chunk_by(pred2);
+      compareViews(result, {{-2, -1}, {1, 2}});
+    }
+    {
+      auto pred1 = [](int i) { return absoluteValue(i) < 3; };
+      Pred pred2;
+      using Result       = std::ranges::chunk_by_view<std::ranges::filter_view<Range, decltype(pred1)>, Pred>;
+      auto const partial = std::views::filter(pred1) | std::views::chunk_by(pred2);
+      std::same_as<Result> decltype(auto) result = range | partial;
+      compareViews(result, {{-2, -1}, {1, 2}});
+    }
+  }
+
+  // Test SFINAE friendliness
+  {
+    struct NotAView {};
+    struct NotInvocable {};
+
+    static_assert(!CanBePiped<Range, decltype(std::views::chunk_by)>);
+    static_assert(CanBePiped<Range, decltype(std::views::chunk_by(Pred{}))>);
+    static_assert(!CanBePiped<NotAView, decltype(std::views::chunk_by(Pred{}))>);
+    static_assert(!CanBePiped<std::initializer_list<int>, decltype(std::views::chunk_by(Pred{}))>);
+    static_assert(!CanBePiped<Range, decltype(std::views::chunk_by(NotInvocable{}))>);
+
+    static_assert(!std::is_invocable_v<decltype(std::views::chunk_by)>);
+    static_assert(!std::is_invocable_v<decltype(std::views::chunk_by), Pred, Range>);
+    static_assert(std::is_invocable_v<decltype(std::views::chunk_by), Range, Pred>);
+    static_assert(!std::is_invocable_v<decltype(std::views::chunk_by), Range, Pred, Pred>);
+    static_assert(!std::is_invocable_v<decltype(std::views::chunk_by), NonCopyablePredicate>);
+  }
+
+  { static_assert(std::is_same_v<decltype(std::ranges::views::chunk_by), decltype(std::views::chunk_by)>); }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.chunk.by/base.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, c++20
+
+// <ranges>
+
+// constexpr View base() const& requires copy_constructible<View>;
+// constexpr View base() &&;
+
+#include <ranges>
+
+#include <cassert>
+#include <concepts>
+#include <utility>
+
+struct Range : std::ranges::view_base {
+  constexpr explicit Range(int* b, int* e) : begin_(b), end_(e) {}
+  constexpr Range(Range const& other) : begin_(other.begin_), end_(other.end_), wasCopyInitialized(true) {}
+  constexpr Range(Range&& other) : begin_(other.begin_), end_(other.end_), wasMoveInitialized(true) {}
+  Range& operator=(Range const&) = default;
+  Range& operator=(Range&&)      = default;
+  constexpr int* begin() const { return begin_; }
+  constexpr int* end() const { return end_; }
+
+  int* begin_;
+  int* end_;
+  bool wasCopyInitialized = false;
+  bool wasMoveInitialized = false;
+};
+
+static_assert(std::ranges::view<Range>);
+static_assert(std::ranges::forward_range<Range>);
+
+struct Pred {
+  bool operator()(int, int) const;
+};
+
+struct NonCopyableRange : std::ranges::view_base {
+  explicit NonCopyableRange(int*, int*);
+  NonCopyableRange(NonCopyableRange const&)            = delete;
+  NonCopyableRange(NonCopyableRange&&)                 = default;
+  NonCopyableRange& operator=(NonCopyableRange const&) = default;
+  NonCopyableRange& operator=(NonCopyableRange&&)      = default;
+  int* begin() const;
+  int* end() const;
+};
+
+static_assert(!std::copy_constructible<NonCopyableRange>);
+
+template <typename T>
+concept CanCallBaseOn = requires(T t) { std::forward<T>(t).base(); };
+
+constexpr bool test() {
+  int buff[] = {1, 2, 3, 4};
+
+  // Check the const& overload
+  {
+    Range range(buff, buff + 4);
+    std::ranges::chunk_by_view<Range, Pred> const view(range, Pred{});
+    std::same_as<Range> decltype(auto) result = view.base();
+    assert(result.wasCopyInitialized);
+    assert(result.begin() == buff);
+    assert(result.end() == buff + 4);
+  }
+
+  // Check the && overload
+  {
+    Range range(buff, buff + 4);
+    std::ranges::chunk_by_view<Range, Pred> view(range, Pred{});
+    std::same_as<Range> decltype(auto) result = std::move(view).base();
+    assert(result.wasMoveInitialized);
+    assert(result.begin() == buff);
+    assert(result.end() == buff + 4);
+  }
+
+  // Ensure the const& overload is not considered when the base is not copy-constructible
+  {
+    static_assert(!CanCallBaseOn<std::ranges::chunk_by_view<NonCopyableRange, Pred> const&>);
+    static_assert(!CanCallBaseOn<std::ranges::chunk_by_view<NonCopyableRange, Pred>&>);
+    static_assert(!CanCallBaseOn<std::ranges::chunk_by_view<NonCopyableRange, Pred> const&&>);
+    static_assert(CanCallBaseOn<std::ranges::chunk_by_view<NonCopyableRange, Pred>&&>);
+    static_assert(CanCallBaseOn<std::ranges::chunk_by_view<NonCopyableRange, Pred>>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.chunk.by/begin.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, c++20
+
+// <ranges>
+
+// constexpr iterator begin();
+
+#include <ranges>
+
+#include <cassert>
+#include <utility>
+
+#include "test_iterators.h"
+#include "types.h"
+
+struct Range : std::ranges::view_base {
+  using Iterator = forward_iterator<int*>;
+  using Sentinel = sentinel_wrapper<Iterator>;
+  constexpr explicit Range(int* b, int* e) : begin_(b), end_(e) {}
+  constexpr Iterator begin() const { return Iterator(begin_); }
+  constexpr Sentinel end() const { return Sentinel(Iterator(end_)); }
+
+private:
+  int* begin_;
+  int* end_;
+};
+
+struct TrackingPred : TrackInitialization {
+  using TrackInitialization::TrackInitialization;
+  constexpr bool operator()(int x, int y) { return x != -y; }
+};
+
+template <class T>
+concept HasBegin = requires(T t) { t.begin(); };
+
+static_assert(HasBegin<std::ranges::chunk_by_view<Range, TrackingPred>>);
+static_assert(!HasBegin<const std::ranges::chunk_by_view<Range, TrackingPred>>);
+
+constexpr void general_tests() {
+  int buff[] = {-4, -3, -2, -1, 1, 2, 3, 4};
+
+  // Check the return type of `begin()`
+  {
+    Range range(buff, buff + 1);
+    auto pred = [](int, int) { return true; };
+    std::ranges::chunk_by_view view(range, pred);
+    using ChunkByIterator = std::ranges::iterator_t<decltype(view)>;
+    ASSERT_SAME_TYPE(ChunkByIterator, decltype(view.begin()));
+  }
+
+  // begin() over an empty range
+  {
+    Range range(buff, buff);
+    auto pred = [](int, int) { return true; };
+    std::ranges::chunk_by_view view(range, pred);
+    auto it = view.begin();
+    assert(it == view.begin());
+    assert(it == view.end());
+  }
+
+  // begin() over a 1-element range
+  {
+    Range range(buff, buff + 1);
+    auto pred = [](int x, int y) { return x == y; };
+    std::ranges::chunk_by_view view(range, pred);
+    auto it = view.begin();
+    assert(base((*it).begin()) == buff);
+    assert(base((*it).end()) == buff + 1);
+  }
+
+  // begin() over a 2-element range
+  {
+    Range range(buff, buff + 2);
+    auto pred = [](int x, int y) { return x == y; };
+    std::ranges::chunk_by_view view(range, pred);
+    auto it = view.begin();
+    assert(base((*it).begin()) == buff);
+    assert(base((*it).end()) == buff + 1);
+    assert(base((*++it).begin()) == buff + 1);
+    assert(base((*it).end()) == buff + 2);
+  }
+
+  // begin() over a 8-element range
+  {
+    Range range(buff, buff + 8);
+    auto pred = [](int x, int y) { return x != -y; };
+    std::ranges::chunk_by_view view(range, pred);
+    auto it = view.begin();
+    assert(base((*it).end()) == buff + 4);
+  }
+
+  // Make sure we do not make a copy of the predicate when we call begin()
+  // (we should be passing it to ranges::adjacent_find using std::ref)
+  {
+    bool moved = false, copied = false;
+    Range range(buff, buff + 2);
+    std::ranges::chunk_by_view view(range, TrackingPred(&moved, &copied));
+    assert(std::exchange(moved, false));
+    [[maybe_unused]] auto it = view.begin();
+    assert(!moved);
+    assert(!copied);
+  }
+
+  // Test with a non-const predicate
+  {
+    Range range(buff, buff + 8);
+    auto pred = [](int x, int y) mutable { return x != -y; };
+    std::ranges::chunk_by_view view(range, pred);
+    auto it = view.begin();
+    assert(base((*it).end()) == buff + 4);
+  }
+
+  // Test with a predicate that takes by non-const reference
+  {
+    Range range(buff, buff + 8);
+    auto pred = [](int& x, int& y) { return x != -y; };
+    std::ranges::chunk_by_view view(range, pred);
+    auto it = view.begin();
+    assert(base((*it).end()) == buff + 4);
+  }
+}
+
+constexpr void cache_tests() {
+  int buff[] = {-4, -3, -2, -1, 1, 2, 3, 4};
+
+  // Make sure that we cache the result of begin() on subsequent calls
+  Range range(buff, buff + 8);
+  int called = 0;
+  auto pred  = [&](int x, int y) {
+    ++called;
+    return x != -y;
+  };
+
+  std::ranges::chunk_by_view view(range, pred);
+  assert(called == 0);
+  for (int k = 0; k != 3; ++k) {
+    auto it = view.begin();
+    assert(base((*it).end()) == buff + 4);
+    assert(called == 4);
+  }
+}
+
+constexpr bool test() {
+  general_tests();
+  cache_tests();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.chunk.by/constraints.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, c++20
+
+// <ranges>
+
+// Check constraints on the type itself.
+//
+// template <forward_range View, indirect_binary_predicate<iterator_t<View>, iterator_t<View>> Pred>
+//   requires view<View> && is_object_v<Pred>
+// class chunk_by_view;
+
+#include <ranges>
+
+#include <concepts>
+#include <cstddef>
+#include <iterator>
+#include <type_traits>
+
+#include "test_iterators.h"
+
+template <class View, class Pred>
+concept CanFormChunkByView = requires { typename std::ranges::chunk_by_view<View, Pred>; };
+
+// chunk_by_view is not valid when the view is not an forward_range
+namespace test1 {
+struct View : std::ranges::view_base {
+  struct NotForwardIterator {
+    using value_type = int;
+    NotForwardIterator& operator++();
+    void operator++(int);
+    int operator*() const;
+
+    using difference_type = std::ptrdiff_t;
+    friend bool operator==(NotForwardIterator const&, NotForwardIterator const&);
+  };
+  NotForwardIterator begin() const;
+  NotForwardIterator end() const;
+};
+struct Pred {
+  bool operator()(int, int) const;
+};
+
+static_assert(!std::ranges::forward_range<View>);
+static_assert(std::indirect_binary_predicate<Pred, int*, int*>);
+static_assert(std::ranges::view<View>);
+static_assert(std::is_object_v<Pred>);
+static_assert(!CanFormChunkByView<View, Pred>);
+} // namespace test1
+
+// chunk_by_view is not valid when the predicate is not indirect_binary_predicate
+namespace test2 {
+struct View : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+};
+struct Pred {};
+
+static_assert(std::ranges::forward_range<View>);
+static_assert(!std::indirect_binary_predicate<Pred, int*, int*>);
+static_assert(std::ranges::view<View>);
+static_assert(std::is_object_v<Pred>);
+static_assert(!CanFormChunkByView<View, Pred>);
+} // namespace test2
+
+// chunk_by_view is not valid when the view is not a view
+namespace test3 {
+struct View {
+  int* begin() const;
+  int* end() const;
+};
+struct Pred {
+  bool operator()(int, int) const;
+};
+
+static_assert(std::ranges::input_range<View>);
+static_assert(std::indirect_binary_predicate<Pred, int*, int*>);
+static_assert(!std::ranges::view<View>);
+static_assert(std::is_object_v<Pred>);
+static_assert(!CanFormChunkByView<View, Pred>);
+} // namespace test3
+
+// chunk_by_view is not valid when the predicate is not an object type
+namespace test4 {
+struct View : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+};
+using Pred = bool (&)(int, int);
+
+static_assert(std::ranges::input_range<View>);
+static_assert(std::indirect_binary_predicate<Pred, int*, int*>);
+static_assert(std::ranges::view<View>);
+static_assert(!std::is_object_v<Pred>);
+static_assert(!CanFormChunkByView<View, Pred>);
+} // namespace test4
+
+// chunk_by_view is valid when all the constraints are satisfied (test the test)
+namespace test5 {
+struct View : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+};
+struct Pred {
+  bool operator()(int, int) const;
+};
+
+static_assert(std::ranges::input_range<View>);
+static_assert(std::indirect_binary_predicate<Pred, int*, int*>);
+static_assert(std::ranges::view<View>);
+static_assert(std::is_object_v<Pred>);
+static_assert(CanFormChunkByView<View, Pred>);
+} // namespace test5

libcxx/test/std/ranges/range.adaptors/range.chunk.by/ctad.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, c++20
+
+// <ranges>
+
+// template <class Range, class Pred>
+// chunk_by_view(Range&&, Pred) -> chunk_by_view<views::all_t<Range>, Pred>;
+
+#include <ranges>
+
+#include <cassert>
+#include <type_traits>
+
+#include "test_iterators.h"
+
+struct View : std::ranges::view_base {
+  View() = default;
+  forward_iterator<int*> begin() const;
+  sentinel_wrapper<forward_iterator<int*>> end() const;
+};
+static_assert(std::ranges::view<View>);
+
+// A range that is not a view
+struct Range {
+  Range() = default;
+  forward_iterator<int*> begin() const;
+  sentinel_wrapper<forward_iterator<int*>> end() const;
+};
+static_assert(std::ranges::range<Range>);
+static_assert(!std::ranges::view<Range>);
+
+struct Pred {
+  constexpr bool operator()(int x, int y) const { return x <= y; }
+};
+
+constexpr bool test() {
+  {
+    View v;
+    Pred pred;
+    std::ranges::chunk_by_view view(v, pred);
+    static_assert(std::is_same_v<decltype(view), std::ranges::chunk_by_view<View, Pred>>);
+  }
+  {
+    Range r;
+    Pred pred;
+    std::ranges::chunk_by_view view(r, pred);
+    static_assert(std::is_same_v<decltype(view), std::ranges::chunk_by_view<std::ranges::ref_view<Range>, Pred>>);
+  }
+  {
+    Pred pred;
+    std::ranges::chunk_by_view view(Range{}, pred);
+    static_assert(std::is_same_v<decltype(view), std::ranges::chunk_by_view<std::ranges::owning_view<Range>, Pred>>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.chunk.by/ctor.default.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, c++20
+
+// <ranges>
+
+// chunk_by_view() requires std::default_initializable<View> &&
+//                          std::default_initializable<Pred> = default;
+
+#include <ranges>
+
+#include <cassert>
+#include <type_traits>
+
+constexpr int buff[] = {-2, 1, -1, 2};
+
+struct DefaultConstructibleView : std::ranges::view_base {
+  DefaultConstructibleView() = default;
+  constexpr int const* begin() const { return buff; }
+  constexpr int const* end() const { return buff + 4; }
+};
+
+struct DefaultConstructiblePredicate {
+  DefaultConstructiblePredicate() = default;
+  constexpr bool operator()(int x, int y) const { return x != -y; }
+};
+
+struct NoDefaultView : std::ranges::view_base {
+  NoDefaultView() = delete;
+  int* begin() const;
+  int* end() const;
+};
+
+struct NoDefaultPredicate {
+  NoDefaultPredicate() = delete;
+  constexpr bool operator()(int, int) const;
+};
+
+struct NoexceptView : std::ranges::view_base {
+  NoexceptView() noexcept;
+  int const* begin() const;
+  int const* end() const;
+};
+
+struct NoexceptPredicate {
+  NoexceptPredicate() noexcept;
+  bool operator()(int, int) const;
+};
+
+struct MayThrowView : std::ranges::view_base {
+  MayThrowView() noexcept(false);
+  int const* begin() const;
+  int const* end() const;
+};
+
+struct MayThrowPredicate {
+  MayThrowPredicate() noexcept(false);
+  bool operator()(int, int) const;
+};
+
+constexpr void compareRanges(std::ranges::subrange<const int*> v, std::initializer_list<int> list) {
+  auto b1 = v.begin();
+  auto e1 = v.end();
+  auto b2 = list.begin();
+  auto e2 = list.end();
+  for (; b1 != e1 && b2 != e2; ++b1, ++b2) {
+    assert(*b1 == *b2);
+  }
+  assert(b1 == e1);
+  assert(b2 == e2);
+}
+
+constexpr bool test() {
+  {
+    using View = std::ranges::chunk_by_view<DefaultConstructibleView, DefaultConstructiblePredicate>;
+    View view;
+    auto it = view.begin(), end = view.end();
+    compareRanges(*it++, {-2, 1});
+    compareRanges(*it++, {-1, 2});
+    assert(it == end);
+  }
+  {
+    using View = std::ranges::chunk_by_view<DefaultConstructibleView, DefaultConstructiblePredicate>;
+    View view  = {};
+    auto it = view.begin(), end = view.end();
+    compareRanges(*it++, {-2, 1});
+    compareRanges(*it++, {-1, 2});
+    assert(it == end);
+  }
+
+  // Check cases where the default constructor isn't provided
+  {
+    static_assert(
+        !std::is_default_constructible_v<std::ranges::chunk_by_view<NoDefaultView, DefaultConstructiblePredicate>>);
+    static_assert(
+        !std::is_default_constructible_v<std::ranges::chunk_by_view<DefaultConstructibleView, NoDefaultPredicate>>);
+    static_assert(!std::is_default_constructible_v<std::ranges::chunk_by_view<NoDefaultView, NoDefaultPredicate>>);
+  }
+
+  // Check noexcept-ness
+  {
+    {
+      using View = std::ranges::chunk_by_view<MayThrowView, MayThrowPredicate>;
+      static_assert(!noexcept(View()));
+    }
+    {
+      using View = std::ranges::chunk_by_view<MayThrowView, NoexceptPredicate>;
+      static_assert(!noexcept(View()));
+    }
+    {
+      using View = std::ranges::chunk_by_view<NoexceptView, MayThrowPredicate>;
+      static_assert(!noexcept(View()));
+    }
+    {
+      using View = std::ranges::chunk_by_view<NoexceptView, NoexceptPredicate>;
+      static_assert(noexcept(View()));
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.chunk.by/ctor.view_pred.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, c++20
+
+// <ranges>
+
+// constexpr chunk_by_view(View, Pred);
+
+#include <ranges>
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <utility>
+
+#include "types.h"
+
+struct Range : std::ranges::view_base {
+  constexpr explicit Range(int* b, int* e) : begin_(b), end_(e) {}
+  constexpr int* begin() const { return begin_; }
+  constexpr int* end() const { return end_; }
+
+private:
+  int* begin_;
+  int* end_;
+};
+
+static_assert(std::ranges::view<Range>);
+static_assert(std::ranges::forward_range<Range>);
+
+struct Pred {
+  constexpr bool operator()(int x, int y) const { return x <= y; }
+};
+
+struct TrackingPred : TrackInitialization {
+  using TrackInitialization::TrackInitialization;
+  constexpr bool operator()(int&, int&) const;
+};
+
+struct TrackingRange : TrackInitialization, std::ranges::view_base {
+  using TrackInitialization::TrackInitialization;
+  int* begin() const;
+  int* end() const;
+};
+
+template <class T>
+void implicitConstructionTest(T);
+
+template <class T, class... Args>
+concept ImplicitConstructibleFrom =
+    requires(Args&&... args) { implicitConstructionTest({std::forward<Args>(args)...}); };
+
+constexpr bool test() {
+  int buff[] = {1, 2, 3, 0, 1, 2, -1, -1, 0};
+
+  // Test explicit syntax
+  {
+    Range range(buff, buff + 9);
+    Pred pred;
+    std::ranges::chunk_by_view<Range, Pred> view(range, pred);
+    auto it = view.begin(), end = view.end();
+    assert(std::ranges::equal(*it++, std::array{1, 2, 3}));
+    assert(std::ranges::equal(*it++, std::array{0, 1, 2}));
+    assert(std::ranges::equal(*it++, std::array{-1, -1, 0}));
+    assert(it == end);
+  }
+
+  // Test implicit syntax
+
+  {
+    using ChunkByView = std::ranges::chunk_by_view<Range, Pred>;
+    static_assert(!ImplicitConstructibleFrom<ChunkByView, Range, Pred>);
+    static_assert(!ImplicitConstructibleFrom<ChunkByView, const Range&, const Pred&>);
+  }
+
+  // Make sure we move the view
+  {
+    bool moved = false, copied = false;
+    TrackingRange range(&moved, &copied);
+    Pred pred;
+    [[maybe_unused]] std::ranges::chunk_by_view<TrackingRange, Pred> view(std::move(range), pred);
+    assert(moved);
+    assert(!copied);
+  }
+
+  // Make sure we move the predicate
+  {
+    bool moved = false, copied = false;
+    Range range(buff, buff + 9);
+    TrackingPred pred(&moved, &copied);
+    [[maybe_unused]] std::ranges::chunk_by_view<Range, TrackingPred> view(range, std::move(pred));
+    assert(moved);
+    assert(!copied);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.chunk.by/end.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, c++20
+
+// <ranges>
+
+// constexpr auto end();
+
+#include <ranges>
+
+#include <cassert>
+#include <concepts>
+#include <functional>
+
+#include "test_iterators.h"
+
+struct NonCommonRange : std::ranges::view_base {
+  using Iterator = forward_iterator<int*>;
+  using Sentinel = sentinel_wrapper<Iterator>;
+  constexpr explicit NonCommonRange(int* b, int* e) : begin_(b), end_(e) {}
+  constexpr Iterator begin() const { return Iterator(begin_); }
+  constexpr Sentinel end() const { return Sentinel(Iterator(end_)); }
+
+private:
+  int* begin_;
+  int* end_;
+};
+
+static_assert(std::ranges::forward_range<NonCommonRange>);
+static_assert(!std::ranges::common_range<NonCommonRange>);
+
+struct CommonRange : std::ranges::view_base {
+  using Iterator = bidirectional_iterator<int*>;
+  constexpr explicit CommonRange(int* b, int* e) : begin_(b), end_(e) {}
+  constexpr Iterator begin() const { return Iterator(begin_); }
+  constexpr Iterator end() const { return Iterator(end_); }
+
+private:
+  int* begin_;
+  int* end_;
+};
+
+static_assert(std::ranges::bidirectional_range<CommonRange>);
+static_assert(std::ranges::common_range<CommonRange>);
+
+constexpr bool test() {
+  int buff[] = {1, 0, 3, 1, 2, 3, 4, 5};
+
+  // Check the return type of `end()`
+  {
+    CommonRange range(buff, buff + 1);
+    auto pred = [](int, int) { return true; };
+    std::ranges::chunk_by_view view(range, pred);
+    using ChunkByView = decltype(view);
+    static_assert(std::ranges::common_range<ChunkByView>);
+    ASSERT_SAME_TYPE(std::ranges::sentinel_t<ChunkByView>, decltype(view.end()));
+  }
+
+  // end() on an empty range
+  {
+    CommonRange range(buff, buff);
+    auto pred = [](int x, int y) { return x <= y; };
+    std::ranges::chunk_by_view view(range, pred);
+    auto end = view.end();
+    assert(end == std::default_sentinel);
+  }
+
+  // end() on a 1-element range
+  {
+    CommonRange range(buff, buff + 1);
+    auto pred = [](int& x, int& y) { return x <= y; };
+    std::ranges::chunk_by_view view(range, pred);
+    auto end = view.end();
+    assert(base((*--end).begin()) == buff);
+    assert(base((*end).end()) == buff + 1);
+  }
+
+  // end() on a 2-element range
+  {
+    CommonRange range(buff, buff + 2);
+    auto pred = [](int const& x, int const& y) { return x <= y; };
+    std::ranges::chunk_by_view view(range, pred);
+    auto end = view.end();
+    assert(base((*--end).begin()) == buff + 1);
+    assert(base((*--end).end()) == buff + 1);
+  }
+
+  // end() on a 8-element range
+  {
+    CommonRange range(buff, buff + 8);
+    auto pred = [](const int x, const int y) { return x < y; };
+    std::ranges::chunk_by_view view(range, pred);
+    auto end = view.end();
+    assert(base((*--end).end()) == buff + 8);
+    assert(base((*--end).end()) == buff + 3);
+  }
+
+  // end() on a non-common range
+  {
+    NonCommonRange range(buff, buff + 1);
+    std::ranges::chunk_by_view view(range, std::ranges::less_equal{});
+    auto end = view.end();
+    ASSERT_SAME_TYPE(std::default_sentinel_t, std::ranges::sentinel_t<decltype(view)>);
+    ASSERT_SAME_TYPE(std::default_sentinel_t, decltype(end));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.chunk.by/pred.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, c++20
+
+// <ranges>
+
+// constexpr Pred const& pred() const;
+
+#include <ranges>
+
+#include <cassert>
+#include <concepts>
+
+struct Range : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+};
+
+struct Pred {
+  bool operator()(int, int) const;
+  int value;
+};
+
+constexpr bool test() {
+  {
+    Pred pred{42};
+    std::ranges::chunk_by_view<Range, Pred> const view(Range{}, pred);
+    std::same_as<Pred const&> decltype(auto) result = view.pred();
+    assert(result.value == 42);
+
+    // Make sure we're really holding a reference to something inside the view
+    assert(&result == &view.pred());
+  }
+
+  // Same, but calling on a non-const view
+  {
+    Pred pred{42};
+    std::ranges::chunk_by_view<Range, Pred> view(Range{}, pred);
+    std::same_as<Pred const&> decltype(auto) result = view.pred();
+    assert(result.value == 42);
+
+    // Make sure we're really holding a reference to something inside the view
+    assert(&result == &view.pred());
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.chunk.by/range.chunk.by.iter/compare.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, c++20
+
+// <ranges>
+
+// friend constexpr bool operator==(const iterator& x, const iterator& y);
+// friend constexpr bool operator==(const iterator& x, default_sentinel_t);
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <functional>
+#include <utility>
+
+#include "../types.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+
+template <class Iterator, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using Underlying      = View<Iterator, Sentinel>;
+  using ChunkByView     = std::ranges::chunk_by_view<Underlying, std::ranges::less_equal>;
+  using ChunkByIterator = std::ranges::iterator_t<ChunkByView>;
+
+  auto make_chunk_by_view = [](auto begin, auto end) {
+    View view{Iterator(begin), Sentinel(Iterator(end))};
+    return ChunkByView(std::move(view), std::ranges::less_equal{});
+  };
+
+  // Test operator==
+  {
+    std::array array{0, 1, 2};
+    ChunkByView view  = make_chunk_by_view(array.begin(), array.end());
+    ChunkByIterator i = view.begin();
+    ChunkByIterator j = view.begin();
+
+    std::same_as<bool> decltype(auto) result = (i == j);
+    assert(result);
+    ++i;
+    assert(!(i == j));
+  }
+
+  // Test synthesized operator!=
+  {
+    std::array array{0, 1, 2};
+    ChunkByView view  = make_chunk_by_view(array.begin(), array.end());
+    ChunkByIterator i = view.begin();
+    ChunkByIterator j = view.begin();
+
+    std::same_as<bool> decltype(auto) result = (i != j);
+    assert(!result);
+    ++i;
+    assert(i != j);
+  }
+
+  // Test operator== with std::default_sentinel_t
+  {
+    std::array array{0, 1, 2};
+    ChunkByView view  = make_chunk_by_view(array.begin(), array.end());
+    ChunkByIterator i = view.begin();
+
+    std::same_as<bool> decltype(auto) result = (i == std::default_sentinel);
+    assert(!result);
+    ++i;
+    assert(i == std::default_sentinel);
+  }
+
+  // Test synthesized operator!= with std::default_sentinel_t
+  {
+    std::array array{0, 1, 2};
+    ChunkByView view  = make_chunk_by_view(array.begin(), array.end());
+    ChunkByIterator i = view.begin();
+
+    std::same_as<bool> decltype(auto) result = (i != std::default_sentinel);
+    assert(result);
+    ++i;
+    assert(!(i != std::default_sentinel));
+  }
+}
+
+template <class Iterator>
+constexpr void test_with_pair() {
+  // Test with pair of iterators
+  test<Iterator>();
+
+  // Test with iterator-sentinel pair
+  test<Iterator, Iterator>();
+}
+
+constexpr bool tests() {
+  test<forward_iterator<int*>>();
+  test<bidirectional_iterator<int*>>();
+  test<random_access_iterator<int*>>();
+  test<contiguous_iterator<int*>>();
+  test<int*>();
+
+  test<forward_iterator<int const*>>();
+  test<bidirectional_iterator<int const*>>();
+  test<random_access_iterator<int const*>>();
+  test<contiguous_iterator<int const*>>();
+  test<int const*>();
+
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.chunk.by/range.chunk.by.iter/ctor.default.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, c++20
+
+// <ranges>
+
+// std::ranges::chunk_by_view<V>::<iterator>() = default;
+
+#include <ranges>
+
+#include <cassert>
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+#include "../types.h"
+#include "test_iterators.h"
+
+enum class IsNoexcept : bool { no, yes };
+
+template <class Iterator, IsNoexcept WithoutException>
+constexpr void testDefaultConstructible() {
+  // Make sure the iterator is default constructible.
+  using ChunkByView     = std::ranges::chunk_by_view<View<Iterator>, std::ranges::less_equal>;
+  using ChunkByIterator = std::ranges::iterator_t<ChunkByView>;
+  ChunkByIterator i{};
+  ChunkByIterator j;
+  assert(i == j);
+  static_assert(noexcept(ChunkByIterator{}) == std::to_underlying(WithoutException));
+}
+
+constexpr bool tests() {
+  testDefaultConstructible<forward_iterator<int*>, IsNoexcept::no>();
+  testDefaultConstructible<bidirectional_iterator<int*>, IsNoexcept::no>();
+  testDefaultConstructible<random_access_iterator<int*>, IsNoexcept::no>();
+  testDefaultConstructible<contiguous_iterator<int*>, IsNoexcept::no>();
+  testDefaultConstructible<int*, IsNoexcept::yes>();
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.chunk.by/range.chunk.by.iter/decrement.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, c++20
+
+// <ranges>
+
+// constexpr iterator& operator--();
+// constexpr iterator operator--(int);
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <functional>
+#include <span>
+#include <type_traits>
+#include <utility>
+
+#include "../types.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+
+template <class T>
+concept HasPreDecrement =
+    requires(T t) {
+      { --t };
+    };
+
+template <class T>
+concept HasPostDecrement =
+    requires(T t) {
+      { t-- };
+    };
+
+struct TrackingPred : TrackInitialization {
+  using TrackInitialization::TrackInitialization;
+  constexpr bool operator()(int x, int y) const { return x <= y; }
+};
+
+template <class Iterator, IsConst Constant, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using Underlying      = View<Iterator, Sentinel>;
+  using ChunkByView     = std::ranges::chunk_by_view<Underlying, std::ranges::less_equal>;
+  using ChunkByIterator = std::ranges::iterator_t<ChunkByView>;
+
+  static_assert(HasPostDecrement<ChunkByIterator>);
+  static_assert(HasPreDecrement<ChunkByIterator>);
+
+  auto make_chunk_by_view = [](auto begin, auto end) {
+    View view{Iterator{begin}, Sentinel{Iterator{end}}};
+    return ChunkByView{std::move(view), std::ranges::less_equal{}};
+  };
+
+  // Test with a single chunk
+  {
+    std::array array{0, 1, 2, 3, 4};
+    ChunkByView view   = make_chunk_by_view(array.begin(), array.end());
+    ChunkByIterator it = std::ranges::next(view.begin(), view.end());
+
+    std::same_as<ChunkByIterator&> decltype(auto) result = --it;
+    assert(&result == &it);
+    assert(base((*result).begin()) == array.begin());
+  }
+
+  // Test with a two chunks
+  {
+    std::array array{0, 1, 2, 0, 1, 2};
+    ChunkByView view   = make_chunk_by_view(array.begin(), array.end());
+    ChunkByIterator it = std::ranges::next(view.begin(), view.end());
+
+    std::same_as<ChunkByIterator&> decltype(auto) result = --it;
+    assert(&result == &it);
+    assert(base((*result).begin()) == array.begin() + 3);
+
+    --it;
+    assert(base((*result).begin()) == array.begin());
+  }
+
+  // Test going forward and then backward on the same iterator
+  {
+    std::array array{7, 8, 9, 4, 5, 6, 1, 2, 3, 0};
+    ChunkByView view   = make_chunk_by_view(array.begin(), array.end());
+    ChunkByIterator it = view.begin();
+
+    ++it;
+    --it;
+    assert(base((*it).begin()) == array.begin());
+    assert(base((*it).end()) == array.begin() + 3);
+
+    ++it;
+    ++it;
+    --it;
+    assert(base((*it).begin()) == array.begin() + 3);
+    assert(base((*it).end()) == array.begin() + 6);
+
+    ++it;
+    ++it;
+    --it;
+    assert(base((*it).begin()) == array.begin() + 6);
+    assert(base((*it).end()) == array.begin() + 9);
+
+    ++it;
+    ++it;
+    --it;
+    assert(base((*it).begin()) == array.begin() + 9);
+  }
+
+  // Decrement an iterator multiple times
+  if constexpr (std::ranges::common_range<Underlying>) {
+    std::array array{1, 2, 1, 2, 1};
+    ChunkByView view = make_chunk_by_view(array.begin(), array.end());
+
+    ChunkByIterator it = view.end();
+    --it;
+    --it;
+    --it;
+    assert(base((*it).begin()) == array.begin());
+  }
+
+  // Test with a predicate that takes by non-const reference
+  if constexpr (!std::to_underlying(Constant)) {
+    std::array array{1, 2, 3, -3, -2, -1};
+    View v{Iterator{array.begin()}, Sentinel{Iterator{array.end()}}};
+    auto view = std::views::chunk_by(std::move(v), [](int& x, int& y) { return x <= y; });
+
+    auto it = std::ranges::next(view.begin());
+    assert(base((*it).begin()) == array.begin() + 3);
+    --it;
+    assert(base((*it).begin()) == array.begin());
+  }
+
+  // Test with predicate that is invocable but not callable
+  {
+    std::array array = {1, 2, 3, -3, -2, -1};
+    auto v           = View{Iterator{array.begin()}, Sentinel{Iterator{array.end()}}} |
+             std::views::transform([](int x) { return IntWrapper{x}; });
+    auto view = std::views::chunk_by(std::move(v), &IntWrapper::lessEqual);
+
+    auto it = std::ranges::next(view.begin());
+    assert(base((*it).begin().base()) == array.begin() + 3);
+    --it;
+    assert(base((*it).begin().base()) == array.begin());
+  }
+
+  // Make sure we do not make a copy of the predicate when we decrement
+  if constexpr (std::ranges::common_range<Underlying>) {
+    bool moved = false, copied = false;
+    std::array array{1, 2, 1, 3};
+    View v{Iterator(array.begin()), Sentinel(Iterator(array.end()))};
+    auto view = std::views::chunk_by(std::move(v), TrackingPred(&moved, &copied));
+    assert(std::exchange(moved, false));
+    auto it = view.end();
+    --it;
+    it--;
+    assert(!moved);
+    assert(!copied);
+  }
+
+  // Check post-decrement
+  {
+    std::array array{0, 1, 2, -3, -2, -1, -6, -5, -4};
+    ChunkByView view   = make_chunk_by_view(array.begin(), array.end());
+    ChunkByIterator it = std::ranges::next(view.begin(), view.end());
+
+    std::same_as<ChunkByIterator> decltype(auto) result = it--;
+    assert(result != it);
+    assert(result == std::default_sentinel);
+    assert(base((*it).begin()) == array.begin() + 6);
+
+    result = it--;
+    assert(base((*it).begin()) == array.begin() + 3);
+    assert(base((*result).begin()) == array.begin() + 6);
+
+    result = it--;
+    assert(base((*it).begin()) == array.begin());
+    assert(base((*result).begin()) == array.begin() + 3);
+  }
+}
+
+template <class Iterator, IsConst Constant>
+constexpr void test_with_pair() {
+  // Test with pair of iterators
+  test<Iterator, Constant>();
+
+  // Test with iterator-sentinel pair
+  test<Iterator, Constant, Iterator>();
+}
+
+constexpr bool tests() {
+  test_with_pair<bidirectional_iterator<int*>, IsConst::no>();
+  test_with_pair<random_access_iterator<int*>, IsConst::no>();
+  test_with_pair<contiguous_iterator<int*>, IsConst::no>();
+  test_with_pair<int*, IsConst::no>();
+
+  test_with_pair<bidirectional_iterator<int const*>, IsConst::yes>();
+  test_with_pair<random_access_iterator<int const*>, IsConst::yes>();
+  test_with_pair<contiguous_iterator<int const*>, IsConst::yes>();
+  test_with_pair<int const*, IsConst::yes>();
+
+  // Make sure `operator--` isn't provided for non bidirectional ranges
+  {
+    using ForwardView = View<forward_iterator<int*>, sentinel_wrapper<forward_iterator<int*>>>;
+    using ChunkByView = std::ranges::chunk_by_view<ForwardView, std::ranges::less_equal>;
+    static_assert(!HasPreDecrement<std::ranges::iterator_t<ChunkByView>>);
+    static_assert(!HasPostDecrement<std::ranges::iterator_t<ChunkByView>>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.chunk.by/range.chunk.by.iter/deref.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, c++20
+
+// <ranges>
+
+// constexpr value_type operator*() const;
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <functional>
+#include <utility>
+
+#include "../types.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+
+template <class Iter, class Sent = sentinel_wrapper<Iter>>
+constexpr void test() {
+  using Underlying      = View<Iter, Sent>;
+  using ChunkByView     = std::ranges::chunk_by_view<Underlying, std::ranges::less_equal>;
+  using ChunkByIterator = std::ranges::iterator_t<ChunkByView>;
+
+  std::array array{0, 1, 2, 3, -1, 0, 1, 2, -2, 3, 4, 5};
+  Underlying underlying{Iter{array.begin()}, Sent{Iter{array.end()}}};
+  ChunkByView view{underlying, std::ranges::less_equal{}};
+
+  for (ChunkByIterator iter = view.begin(); iter != view.end(); ++iter) {
+    std::same_as<typename ChunkByIterator::value_type> auto chunk = *iter;
+    assert(std::ranges::distance(chunk) == 4);
+  }
+}
+
+constexpr bool tests() {
+  // Check iterator pair
+  test<forward_iterator<int*>>();
+  test<bidirectional_iterator<int*>>();
+  test<random_access_iterator<int*>>();
+  test<contiguous_iterator<int*>>();
+  test<int*>();
+
+  // Check iterator-sentinel pair
+  test<forward_iterator<int*>, forward_iterator<int*>>();
+  test<bidirectional_iterator<int*>, bidirectional_iterator<int*>>();
+  test<random_access_iterator<int*>, random_access_iterator<int*>>();
+  test<contiguous_iterator<int*>, contiguous_iterator<int*>>();
+  test<int*, int*>();
+
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.chunk.by/range.chunk.by.iter/increment.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, c++20
+
+// <ranges>
+
+// constexpr iterator& operator++();
+// constexpr iterator operator++(int);
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <functional>
+#include <span>
+#include <type_traits>
+#include <utility>
+
+#include "../types.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+
+struct TrackingPred : TrackInitialization {
+  using TrackInitialization::TrackInitialization;
+  constexpr bool operator()(int x, int y) const { return x <= y; }
+};
+
+template <class Iterator, IsConst Constant>
+constexpr void test() {
+  using Sentinel        = sentinel_wrapper<Iterator>;
+  using Underlying      = View<Iterator, Sentinel>;
+  using ChunkByView     = std::ranges::chunk_by_view<Underlying, std::ranges::less_equal>;
+  using ChunkByIterator = std::ranges::iterator_t<ChunkByView>;
+
+  auto make_chunk_by_view = [](auto begin, auto end) {
+    View view{Iterator{begin}, Sentinel{Iterator{end}}};
+    return ChunkByView{std::move(view), std::ranges::less_equal{}};
+  };
+
+  // Increment an iterator when it won't find another satisfied value after begin()
+  {
+    std::array array{0, 1, 2, 3, 4};
+    ChunkByView view   = make_chunk_by_view(array.begin(), array.end());
+    ChunkByIterator it = view.begin();
+
+    std::same_as<ChunkByIterator&> decltype(auto) result = ++it;
+    assert(&result == &it);
+    assert(result == view.end());
+    assert(result == std::default_sentinel);
+  }
+
+  // Increment the iterator and it finds another value after begin()
+  {
+    std::array array{1, 2, 3, -1, -2, -3};
+    int const* second_chunk = array.begin() + 3;
+    ChunkByView view        = make_chunk_by_view(array.begin(), array.end());
+
+    ChunkByIterator it = view.begin();
+    ++it;
+    assert(base((*it).begin()) == second_chunk);
+  }
+
+  // Increment advances all the way to the end of the range
+  {
+    std::array array{1, 2, 3, 4, 1};
+    ChunkByView view = make_chunk_by_view(array.begin(), array.end());
+
+    ChunkByIterator it = view.begin();
+    ++it;
+    assert(base((*it).begin()) == array.begin() + 4);
+  }
+
+  // Increment an iterator multiple times
+  {
+    std::array array{0, 1, 0, 2, 0, 3, 0, 4};
+    ChunkByView view = make_chunk_by_view(array.begin(), array.end());
+
+    ChunkByIterator it = view.begin();
+    assert(base((*it).begin()) == array.begin());
+    ++it;
+    assert(base((*it).begin()) == array.begin() + 2);
+    ++it;
+    assert(base((*it).begin()) == array.begin() + 4);
+    ++it;
+    assert(base((*it).begin()) == array.begin() + 6);
+    ++it;
+    assert(it == std::default_sentinel);
+  }
+
+  // Test with a predicate that takes by non-const reference
+  if constexpr (!std::to_underlying(Constant)) {
+    std::array array{1, 2, 3, -3, -2, -1};
+    View v{Iterator{array.begin()}, Sentinel{Iterator{array.end()}}};
+    auto view = std::views::chunk_by(std::move(v), [](int& x, int& y) { return x <= y; });
+
+    auto it = view.begin();
+    assert(base((*it).begin()) == array.begin());
+    ++it;
+    assert(base((*it).begin()) == array.begin() + 3);
+  }
+
+  // Test with predicate that is invocable but not callable
+  {
+    std::array array = {1, 2, 3, -3, -2, -1};
+    auto v           = View{Iterator{array.begin()}, Sentinel{Iterator{array.end()}}} |
+             std::views::transform([](int x) { return IntWrapper{x}; });
+    auto view = std::views::chunk_by(std::move(v), &IntWrapper::lessEqual);
+
+    auto it = view.begin();
+    assert(base((*it).begin().base()) == array.begin());
+    ++it;
+    assert(base((*it).begin().base()) == array.begin() + 3);
+  }
+
+  // Make sure we do not make a copy of the predicate when we increment
+  // (we should be passing it to ranges::adjacent_find using std::ref)
+  {
+    bool moved = false, copied = false;
+    std::array array{1, 2, 1, 3};
+    View v{Iterator(array.begin()), Sentinel(Iterator(array.end()))};
+    auto view = std::views::chunk_by(std::move(v), TrackingPred(&moved, &copied));
+    assert(std::exchange(moved, false));
+    auto it = view.begin();
+    ++it;
+    it++;
+    assert(!moved);
+    assert(!copied);
+  }
+
+  // Check post-increment
+  {
+    std::array array{0, 1, 2, -3, -2, -1, -6, -5, -4};
+    ChunkByView view   = make_chunk_by_view(array.begin(), array.end());
+    ChunkByIterator it = view.begin();
+
+    std::same_as<ChunkByIterator> decltype(auto) result = it++;
+    assert(result != it);
+    assert(base((*result).begin()) == array.begin());
+    assert(base((*it).begin()) == array.begin() + 3);
+
+    result = it++;
+    assert(base((*result).begin()) == array.begin() + 3);
+    assert(base((*it).begin()) == array.begin() + 6);
+
+    result = it++;
+    assert(base((*result).begin()) == array.begin() + 6);
+    assert(it == std::default_sentinel);
+  }
+}
+
+constexpr bool tests() {
+  test<forward_iterator<int*>, IsConst::no>();
+  test<bidirectional_iterator<int*>, IsConst::no>();
+  test<random_access_iterator<int*>, IsConst::no>();
+  test<contiguous_iterator<int*>, IsConst::no>();
+  test<int*, IsConst::no>();
+
+  test<forward_iterator<int const*>, IsConst::yes>();
+  test<bidirectional_iterator<int const*>, IsConst::yes>();
+  test<random_access_iterator<int const*>, IsConst::yes>();
+  test<contiguous_iterator<int const*>, IsConst::yes>();
+  test<int const*, IsConst::yes>();
+
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.chunk.by/range.chunk.by.iter/types.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, c++20
+
+// <ranges>
+
+// std::ranges::chunk_by_view::<iterator>::value_type
+// std::ranges::chunk_by_view::<iterator>::difference_type
+// std::ranges::chunk_by_view::<iterator>::iterator_category
+// std::ranges::chunk_by_view::<iterator>::iterator_concept
+
+#include <ranges>
+
+#include <functional>
+#include <type_traits>
+
+#include "../types.h"
+#include "test_iterators.h"
+
+template <class Iter>
+constexpr void testValueTypeAndDifferenceType() {
+  using Underlying      = View<Iter>;
+  using ChunkByView     = std::ranges::chunk_by_view<Underlying, std::ranges::less_equal>;
+  using ChunkByIterator = std::ranges::iterator_t<ChunkByView>;
+  static_assert(std::same_as<typename ChunkByIterator::value_type, std::ranges::range_value_t<ChunkByView>>);
+  static_assert(std::same_as<typename ChunkByIterator::value_type, std::ranges::subrange<Iter>>);
+  static_assert(std::same_as<typename ChunkByIterator::difference_type, std::ranges::range_difference_t<ChunkByView>>);
+  static_assert(std::same_as<typename ChunkByIterator::difference_type, std::ranges::range_difference_t<Underlying>>);
+}
+
+template <class Iter>
+using ChunkByIteratorFor = std::ranges::iterator_t<std::ranges::chunk_by_view<View<Iter>, std::ranges::less_equal>>;
+
+constexpr void test() {
+  // Check that value_type is range_value_t and difference_type is range_difference_t
+  {
+    testValueTypeAndDifferenceType<forward_iterator<int*>>();
+    testValueTypeAndDifferenceType<bidirectional_iterator<int*>>();
+    testValueTypeAndDifferenceType<random_access_iterator<int*>>();
+    testValueTypeAndDifferenceType<contiguous_iterator<int*>>();
+    testValueTypeAndDifferenceType<int*>();
+  }
+
+  // Check iterator_concept for various categories of ranges
+  {
+    static_assert(
+        std::same_as<ChunkByIteratorFor<forward_iterator<int*>>::iterator_concept, std::forward_iterator_tag>);
+    static_assert(std::same_as<ChunkByIteratorFor<bidirectional_iterator<int*>>::iterator_concept,
+                               std::bidirectional_iterator_tag>);
+    static_assert(std::same_as<ChunkByIteratorFor<random_access_iterator<int*>>::iterator_concept,
+                               std::bidirectional_iterator_tag>);
+    static_assert(
+        std::same_as<ChunkByIteratorFor<contiguous_iterator<int*>>::iterator_concept, std::bidirectional_iterator_tag>);
+    static_assert(std::same_as<ChunkByIteratorFor<int*>::iterator_concept, std::bidirectional_iterator_tag>);
+  }
+
+  // Check iterator_category for various categories of ranges
+  {
+    static_assert(std::same_as<ChunkByIteratorFor<forward_iterator<int*>>::iterator_category, std::input_iterator_tag>);
+    static_assert(
+        std::same_as<ChunkByIteratorFor<bidirectional_iterator<int*>>::iterator_category, std::input_iterator_tag>);
+    static_assert(
+        std::same_as<ChunkByIteratorFor<random_access_iterator<int*>>::iterator_category, std::input_iterator_tag>);
+    static_assert(
+        std::same_as<ChunkByIteratorFor<contiguous_iterator<int*>>::iterator_category, std::input_iterator_tag>);
+    static_assert(std::same_as<ChunkByIteratorFor<int*>::iterator_category, std::input_iterator_tag>);
+  }
+}

libcxx/test/std/ranges/range.adaptors/range.chunk.by/types.h

+//===----------------------------------------------------------------------===//
+//
+// 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 TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_CHUNK_BY_TYPES_H
+#define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_CHUNK_BY_TYPES_H
+
+#include <ranges>
+#include <utility>
+
+#include "test_iterators.h"
+
+struct TrackInitialization {
+  constexpr explicit TrackInitialization(bool* moved, bool* copied) : moved_(moved), copied_(copied) {}
+  constexpr TrackInitialization(TrackInitialization const& other) : moved_(other.moved_), copied_(other.copied_) {
+    *copied_ = true;
+  }
+  constexpr TrackInitialization(TrackInitialization&& other) : moved_(other.moved_), copied_(other.copied_) {
+    *moved_ = true;
+  }
+  TrackInitialization& operator=(TrackInitialization const&) = default;
+  TrackInitialization& operator=(TrackInitialization&&)      = default;
+  bool* moved_;
+  bool* copied_;
+};
+
+enum class IsConst : bool { no, yes };
+
+template <std::forward_iterator Iter, std::sentinel_for<Iter> Sent = sentinel_wrapper<Iter>>
+struct View : std::ranges::view_base {
+  constexpr explicit View(Iter b, Sent e) : begin_(b), end_(e) {}
+  constexpr Iter begin() { return begin_; }
+  constexpr Sent end() { return end_; }
+
+private:
+  Iter begin_;
+  Sent end_;
+};
+
+template <class I, class S>
+View(I b, S e) -> View<I, S>;
+
+struct IntWrapper {
+  constexpr IntWrapper(int v) : value_(v) {}
+
+  int value_;
+  constexpr bool lessEqual(IntWrapper other) const { return value_ <= other.value_; }
+};
+
+#endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_CHUNK_BY_TYPES_H

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "name": "__cpp_lib_ranges_chunk",
     "values": { "c++2b": 202202 },
     "headers": ["ranges"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_ranges_chunk_by",
     "values": { "c++2b": 202202 },
     "headers": ["ranges"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_ranges_iota",
     "values": { "c++2b": 202202 },
     "headers": ["numeric"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_ranges_join_with",
     "values": { "c++2b": 202202 },