[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

30

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

670 ↗

(On Diff #507328)

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

681 ↗

(On Diff #520676)

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

92 ↗

(On Diff #520676)

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.

100 ↗

(On Diff #520676)

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

25 ↗

(On Diff #520676)

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

72 ↗

(On Diff #520676)

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

139 ↗

(On Diff #520676)

Ultranit: s/predicate/a predicate/.

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

37 ↗

(On Diff #520676)

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

39 ↗

(On Diff #520676)

Can we check the exact contents of each chunk instead?

44 ↗

(On Diff #520676)

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

47 ↗

(On Diff #520676)

Ultranit: s/an/the/.

109 ↗

(On Diff #520676)

Question: can you elaborate?

112 ↗

(On Diff #520676)

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

43 ↗

(On Diff #520676)

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

44 ↗

(On Diff #520676)

Yes, I've swapped comments again.

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

109 ↗

(On Diff #520676)

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.

112 ↗

(On Diff #520676)

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

43 ↗

(On Diff #520676)

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

     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_chunk``                        *unimplemented*
     ------------------------------------------------- -----------------
-    ``__cpp_lib_ranges_chunk_by``                     *unimplemented*
+    ``__cpp_lib_ranges_chunk_by``                     ``202202L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_iota``                         *unimplemented*
     ------------------------------------------------- -----------------

libcxx/docs/ReleaseNotes.rst

 ------------------
 - P2520R0 - ``move_iterator<T*>`` should be a random access iterator
 - P1328R1 - ``constexpr type_info::operator==()``
+- P2443R1 - ``views::chunk_by``
 
 Improvements and New Features
 -----------------------------

libcxx/docs/Status/Cxx2bPapers.csv

 "`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","",""

libcxx/docs/Status/RangesViews.csv

 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

   __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

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>          // FIXME transitive include
+#include <__ranges/non_propagating_cache.h> // FIXME transitive include
+#include <__ranges/range_adaptor.h>
+#include <__ranges/reverse_view.h>          // FIXME transitive include
+#include <__ranges/subrange.h>              // FIXME transitive include
+#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.");
+    const 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, __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.");
+    const auto __first = ranges::begin(__base_);
+    if (!__cached_begin_.__has_value()) {
+      __cached_begin_.__emplace(__find_next(__first));
+    }
+    return {*this, __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 {
+public:
+  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>;
+
+  __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++() {
+    __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

         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" }

libcxx/include/ranges

   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 {

 #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>

libcxx/include/version

 // # 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

libcxx/test/libcxx/private_headers.verify.cpp

 #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'}}

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
+
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <ranges>
+
+// Call begin() on chunk_by_view with empty predicate
+
+// 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
+
+#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/std/language.support/support.limits/support.limits.general/ranges.version.compile.pass.cpp

 #   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
+# 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)

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

 #   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
+# 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)

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
+
+// 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
+
+// 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
+
+// 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
+
+// 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
+
+// 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
+
+// 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
+
+// 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
+
+// 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/iterator/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
+
+// 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/iterator/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
+
+// 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/iterator/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
+
+// 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/iterator/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
+
+// 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/iterator/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
+
+// 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/iterator/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
+
+// 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/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
+
+// 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/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

     "name": "__cpp_lib_ranges_chunk_by",
     "values": { "c++2b": 202202 },
     "headers": ["ranges"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_ranges_iota",
     "values": { "c++2b": 202202 },