[libcxx-commits] [libcxx] P1223R5: `find_last` (PR #99312)
nicole mazzuca via libcxx-commits
libcxx-commits at lists.llvm.org
Wed Jul 17 05:12:18 PDT 2024
https://github.com/strega-nil created https://github.com/llvm/llvm-project/pull/99312
Implements [P1223R5][] completely.
Includes an implementation of `find_last`, `find_last_if`, and
`find_last_if_not`.
Note, this is my first contribution to libc++ in a very long time, so please keep that in mind when reviewing!
[P1223R5]: https://wg21.link/p1223r5
>From 1140286c1e65418f45558739553ae46fed6aa7d5 Mon Sep 17 00:00:00 2001
From: Nicole Mazzuca <nicole at strega-nil.co>
Date: Wed, 17 Jul 2024 00:43:09 +0200
Subject: [PATCH] P1223R5: find_last
Implements [P1223R5][] completely.
Includes an implementation of `find_last`, `find_last_if`, and
`find_last_if_not`.
[P1223R5]: https://wg21.link/p1223r5
---
libcxx/docs/FeatureTestMacroTable.rst | 2 +
libcxx/docs/Status/Cxx23Papers.csv | 2 +-
libcxx/include/CMakeLists.txt | 3 +
libcxx/include/__algorithm/ranges_find_if.h | 2 +
libcxx/include/__algorithm/ranges_find_last.h | 103 +++++++
.../include/__algorithm/ranges_find_last_if.h | 106 +++++++
.../__algorithm/ranges_find_last_if_not.h | 70 +++++
libcxx/include/algorithm | 23 ++
libcxx/include/module.modulemap | 3 +
libcxx/include/version | 2 +
libcxx/modules/std/algorithm.inc | 3 +-
...obust_against_copying_comparators.pass.cpp | 6 +
...obust_against_copying_projections.pass.cpp | 8 +
.../algorithm.nodiscard.verify.cpp | 12 +
.../alg.find.last/ranges.find_last.pass.cpp | 284 ++++++++++++++++++
.../ranges.find_last_if.pass.cpp | 233 ++++++++++++++
.../ranges.find_last_if_not.pass.cpp | 235 +++++++++++++++
.../ranges_robust_against_dangling.pass.cpp | 5 +
...es_robust_against_nonbool.compile.pass.cpp | 4 +
...es_robust_against_proxy_iterators.pass.cpp | 5 +
.../algorithm.version.compile.pass.cpp | 31 ++
.../version.version.compile.pass.cpp | 31 ++
.../niebloid.compile.pass.cpp | 3 +
.../generate_feature_test_macro_components.py | 5 +
24 files changed, 1178 insertions(+), 3 deletions(-)
create mode 100644 libcxx/include/__algorithm/ranges_find_last.h
create mode 100644 libcxx/include/__algorithm/ranges_find_last_if.h
create mode 100644 libcxx/include/__algorithm/ranges_find_last_if_not.h
create mode 100644 libcxx/test/std/algorithms/alg.nonmodifying/alg.find.last/ranges.find_last.pass.cpp
create mode 100644 libcxx/test/std/algorithms/alg.nonmodifying/alg.find.last/ranges.find_last_if.pass.cpp
create mode 100644 libcxx/test/std/algorithms/alg.nonmodifying/alg.find.last/ranges.find_last_if_not.pass.cpp
diff --git a/libcxx/docs/FeatureTestMacroTable.rst b/libcxx/docs/FeatureTestMacroTable.rst
index 1e347d043ef69..fcffa8d619ab9 100644
--- a/libcxx/docs/FeatureTestMacroTable.rst
+++ b/libcxx/docs/FeatureTestMacroTable.rst
@@ -360,6 +360,8 @@ Status
---------------------------------------------------------- -----------------
``__cpp_lib_ranges_contains`` ``202207L``
---------------------------------------------------------- -----------------
+ ``__cpp_lib_ranges_find_last`` ``202207L``
+ ---------------------------------------------------------- -----------------
``__cpp_lib_ranges_iota`` *unimplemented*
---------------------------------------------------------- -----------------
``__cpp_lib_ranges_join_with`` *unimplemented*
diff --git a/libcxx/docs/Status/Cxx23Papers.csv b/libcxx/docs/Status/Cxx23Papers.csv
index 4f589cd938d7c..ed50498238fd8 100644
--- a/libcxx/docs/Status/Cxx23Papers.csv
+++ b/libcxx/docs/Status/Cxx23Papers.csv
@@ -55,7 +55,7 @@
"`P0429R9 <https://wg21.link/P0429R9>`__","LWG","A Standard ``flat_map``","July 2022","",""
"`P1169R4 <https://wg21.link/P1169R4>`__","LWG","``static operator()``","July 2022","|Complete|","16.0"
"`P1222R4 <https://wg21.link/P1222R4>`__","LWG","A Standard ``flat_set``","July 2022","",""
-"`P1223R5 <https://wg21.link/P1223R5>`__","LWG","``ranges::find_last()``, ``ranges::find_last_if()``, and ``ranges::find_last_if_not()``","July 2022","","","|ranges|"
+"`P1223R5 <https://wg21.link/P1223R5>`__","LWG","``ranges::find_last()``, ``ranges::find_last_if()``, and ``ranges::find_last_if_not()``","July 2022","|Complete|","19.0","|ranges|"
"`P1467R9 <https://wg21.link/P1467R9>`__","LWG","Extended ``floating-point`` types and standard names","July 2022","",""
"`P1642R11 <https://wg21.link/P1642R11>`__","LWG","Freestanding ``[utilities]``, ``[ranges]``, and ``[iterators]``","July 2022","",""
"`P1899R3 <https://wg21.link/P1899R3>`__","LWG","``stride_view``","July 2022","","","|ranges|"
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index cd64fe91449c2..824806d562d23 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -97,6 +97,9 @@ set(files
__algorithm/ranges_find_first_of.h
__algorithm/ranges_find_if.h
__algorithm/ranges_find_if_not.h
+ __algorithm/ranges_find_last.h
+ __algorithm/ranges_find_last_if.h
+ __algorithm/ranges_find_last_if_not.h
__algorithm/ranges_for_each.h
__algorithm/ranges_for_each_n.h
__algorithm/ranges_generate.h
diff --git a/libcxx/include/__algorithm/ranges_find_if.h b/libcxx/include/__algorithm/ranges_find_if.h
index 888f9ec3cb2d5..fd2c090af2d6d 100644
--- a/libcxx/include/__algorithm/ranges_find_if.h
+++ b/libcxx/include/__algorithm/ranges_find_if.h
@@ -14,6 +14,8 @@
#include <__functional/invoke.h>
#include <__functional/ranges_operations.h>
#include <__iterator/concepts.h>
+#include <__iterator/next.h>
+#include <__iterator/prev.h>
#include <__iterator/projected.h>
#include <__ranges/access.h>
#include <__ranges/concepts.h>
diff --git a/libcxx/include/__algorithm/ranges_find_last.h b/libcxx/include/__algorithm/ranges_find_last.h
new file mode 100644
index 0000000000000..3aba8210660dc
--- /dev/null
+++ b/libcxx/include/__algorithm/ranges_find_last.h
@@ -0,0 +1,103 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ALGORITHM_RANGES_FIND_LAST_H
+#define _LIBCPP___ALGORITHM_RANGES_FIND_LAST_H
+
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.h>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/next.h>
+#include <__iterator/prev.h>
+#include <__iterator/projected.h>
+#include <__iterator/indirectly_comparable.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/subrange.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+namespace __find_last {
+struct __fn {
+ template <class _Iter, class _Sent, class _Type, class _Proj>
+ _LIBCPP_HIDE_FROM_ABI constexpr static subrange<_Iter>
+ __find_last_impl(_Iter __first, _Sent __last, const _Type& __value, _Proj& __proj) {
+ if (__first == __last) {
+ return subrange<_Iter>(__first, __first);
+ }
+
+ if constexpr (bidirectional_iterator<_Iter>) {
+ auto __last_it = ranges::next(__first, __last);
+ for (auto __it = ranges::prev(__last_it); __it != __first; --__it) {
+ if (std::invoke(__proj, *__it) == __value) {
+ return subrange<_Iter>(std::move(__it), std::move(__last_it));
+ }
+ }
+ if (std::invoke(__proj, *__first) == __value) {
+ return subrange<_Iter>(std::move(__first), std::move(__last_it));
+ }
+ return subrange<_Iter>(__last_it, __last_it);
+ } else {
+ bool __found = false;
+ _Iter __found_it;
+ for (; __first != __last; ++__first) {
+ if (std::invoke(__proj, *__first) == __value) {
+ __found = true;
+ __found_it = __first;
+ }
+ }
+
+ if (__found) {
+ return subrange<_Iter>(std::move(__found_it), std::move(__first));
+ } else {
+ return subrange<_Iter>(__first, __first);
+ }
+ }
+ }
+
+ template <forward_iterator _Iter, sentinel_for<_Iter> _Sent, class _Type, class _Proj = identity>
+ requires indirect_binary_predicate<ranges::equal_to, projected<_Iter, _Proj>, const _Type*>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange<_Iter>
+ operator()(_Iter __first, _Sent __last, const _Type& __value, _Proj __proj = {}) const {
+ return __find_last_impl(std::move(__first), std::move(__last), __value, __proj);
+ }
+
+ template <forward_range _Range, class _Type, class _Proj = identity>
+ requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Range>, _Proj>, const _Type*>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_subrange_t<_Range>
+ operator()(_Range&& __range, const _Type& __value, _Proj __proj = {}) const {
+ return __find_last_impl(ranges::begin(__range), ranges::end(__range), __value, __proj);
+ }
+};
+} // namespace __find_last
+
+inline namespace __cpo {
+inline constexpr auto find_last = __find_last::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___ALGORITHM_RANGES_FIND_LAST_H
diff --git a/libcxx/include/__algorithm/ranges_find_last_if.h b/libcxx/include/__algorithm/ranges_find_last_if.h
new file mode 100644
index 0000000000000..2435672a83b63
--- /dev/null
+++ b/libcxx/include/__algorithm/ranges_find_last_if.h
@@ -0,0 +1,106 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ALGORITHM_RANGES_FIND_LAST_IF_H
+#define _LIBCPP___ALGORITHM_RANGES_FIND_LAST_IF_H
+
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.h>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/next.h>
+#include <__iterator/prev.h>
+#include <__iterator/projected.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/subrange.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+
+template <class _Iter, class _Sent, class _Pred, class _Proj>
+_LIBCPP_HIDE_FROM_ABI constexpr static subrange<_Iter>
+__find_last_if_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
+ if (__first == __last) {
+ return subrange<_Iter>(__first, __first);
+ }
+
+ if constexpr (bidirectional_iterator<_Iter>) {
+ auto __last_it = ranges::next(__first, __last);
+ for (auto __it = ranges::prev(__last_it); __it != __first; --__it) {
+ if (std::invoke(__pred, std::invoke(__proj, *__it))) {
+ return subrange<_Iter>(std::move(__it), std::move(__last_it));
+ }
+ }
+ if (std::invoke(__pred, std::invoke(__proj, *__first))) {
+ return subrange<_Iter>(std::move(__first), std::move(__last_it));
+ }
+ return subrange<_Iter>(__last_it, __last_it);
+ } else {
+ bool __found = false;
+ _Iter __found_it;
+ for (; __first != __last; ++__first) {
+ if (std::invoke(__pred, std::invoke(__proj, *__first))) {
+ __found = true;
+ __found_it = __first;
+ }
+ }
+
+ if (__found) {
+ return subrange<_Iter>(std::move(__found_it), std::move(__first));
+ } else {
+ return subrange<_Iter>(__first, __first);
+ }
+ }
+}
+
+namespace __find_last_if {
+struct __fn {
+ template <forward_iterator _Iter,
+ sentinel_for<_Iter> _Sent,
+ class _Proj = identity,
+ indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange<_Iter>
+ operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const {
+ return __find_last_if_impl(std::move(__first), std::move(__last), __pred, __proj);
+ }
+
+ template <forward_range _Range,
+ class _Proj = identity,
+ indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_subrange_t<_Range>
+ operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
+ return __find_last_if_impl(ranges::begin(__range), ranges::end(__range), __pred, __proj);
+ }
+};
+} // namespace __find_last_if
+
+inline namespace __cpo {
+inline constexpr auto find_last_if = __find_last_if::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___ALGORITHM_RANGES_FIND_LAST_IF_H
diff --git a/libcxx/include/__algorithm/ranges_find_last_if_not.h b/libcxx/include/__algorithm/ranges_find_last_if_not.h
new file mode 100644
index 0000000000000..4b246c96695c2
--- /dev/null
+++ b/libcxx/include/__algorithm/ranges_find_last_if_not.h
@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ALGORITHM_RANGES_FIND_LAST_IF_NOT_H
+#define _LIBCPP___ALGORITHM_RANGES_FIND_LAST_IF_NOT_H
+
+#include <__algorithm/ranges_find_last_if.h>
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.h>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/projected.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/subrange.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+namespace __find_last_if_not {
+struct __fn {
+ template <forward_iterator _Iter,
+ sentinel_for<_Iter> _Sent,
+ class _Proj = identity,
+ indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange<_Iter>
+ operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const {
+ auto __pred2 = [&__pred](auto&& __e) -> bool { return !std::invoke(__pred, std::forward<decltype(__e)>(__e)); };
+ return ranges::__find_last_if_impl(std::move(__first), std::move(__last), __pred2, __proj);
+ }
+
+ template <forward_range _Range,
+ class _Proj = identity,
+ indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_subrange_t<_Range>
+ operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
+ auto __pred2 = [&__pred](auto&& __e) -> bool { return !std::invoke(__pred, std::forward<decltype(__e)>(__e)); };
+ return ranges::__find_last_if_impl(ranges::begin(__range), ranges::end(__range), __pred2, __proj);
+ }
+};
+} // namespace __find_last_if_not
+
+inline namespace __cpo {
+inline constexpr auto find_last_if_not = __find_last_if_not::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___ALGORITHM_RANGES_FIND_LAST_IF_NOT_H
diff --git a/libcxx/include/algorithm b/libcxx/include/algorithm
index a522a60f1b551..f36e396246a1d 100644
--- a/libcxx/include/algorithm
+++ b/libcxx/include/algorithm
@@ -101,6 +101,26 @@ namespace ranges {
indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
constexpr borrowed_iterator_t<R>
find_if_not(R&& r, Pred pred, Proj proj = {}); // since C++20
+ //
+ template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity>
+ requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+ constexpr subrange<I> find_last(I first, S last, const T& value, Proj proj = {});
+ template<forward_range R, class T, class Proj = identity>
+ requires
+ indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+ constexpr borrowed_subrange_t<R> find_last(R&& r, const T& value, Proj proj = {});
+ template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+ indirect_unary_predicate<projected<I, Proj>> Pred>
+ constexpr subrange<I> find_last_if(I first, S last, Pred pred, Proj proj = {});
+ template<forward_range R, class Proj = identity,
+ indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+ constexpr borrowed_subrange_t<R> find_last_if(R&& r, Pred pred, Proj proj = {});
+ template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+ indirect_unary_predicate<projected<I, Proj>> Pred>
+ constexpr subrange<I> find_last_if_not(I first, S last, Pred pred, Proj proj = {});
+ template<forward_range R, class Proj = identity,
+ indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+ constexpr borrowed_subrange_t<R> find_last_if_not(R&& r, Pred pred, Proj proj = {});
template<class T, class Proj = identity,
indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
@@ -1989,6 +2009,9 @@ template <class BidirectionalIterator, class Compare>
# include <__algorithm/fold.h>
# include <__algorithm/ranges_contains_subrange.h>
# include <__algorithm/ranges_ends_with.h>
+# include <__algorithm/ranges_find_last.h>
+# include <__algorithm/ranges_find_last_if.h>
+# include <__algorithm/ranges_find_last_if_not.h>
# include <__algorithm/ranges_starts_with.h>
#endif // _LIBCPP_STD_VER >= 23
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
index f4aaa14c1c2ee..cbe7d03ebc0a2 100644
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -764,6 +764,9 @@ module std_private_algorithm_ranges_find_end [system
module std_private_algorithm_ranges_find_first_of [system] { header "__algorithm/ranges_find_first_of.h" }
module std_private_algorithm_ranges_find_if [system] { header "__algorithm/ranges_find_if.h" }
module std_private_algorithm_ranges_find_if_not [system] { header "__algorithm/ranges_find_if_not.h" }
+module std_private_algorithm_ranges_find_last [system] { header "__algorithm/ranges_find_last.h" }
+module std_private_algorithm_ranges_find_last_if [system] { header "__algorithm/ranges_find_last_if.h" }
+module std_private_algorithm_ranges_find_last_if_not [system] { header "__algorithm/ranges_find_last_if_not.h" }
module std_private_algorithm_ranges_for_each [system] {
header "__algorithm/ranges_for_each.h"
export std_private_algorithm_in_fun_result
diff --git a/libcxx/include/version b/libcxx/include/version
index c971336bcb85c..6b3c46f8f7715 100644
--- a/libcxx/include/version
+++ b/libcxx/include/version
@@ -190,6 +190,7 @@ __cpp_lib_ranges_chunk 202202L <ranges>
__cpp_lib_ranges_chunk_by 202202L <ranges>
__cpp_lib_ranges_concat 202403L <ranges>
__cpp_lib_ranges_contains 202207L <algorithm>
+__cpp_lib_ranges_find_last 202207L <algorithm>
__cpp_lib_ranges_iota 202202L <numeric>
__cpp_lib_ranges_join_with 202202L <ranges>
__cpp_lib_ranges_repeat 202207L <ranges>
@@ -483,6 +484,7 @@ __cpp_lib_void_t 201411L <type_traits>
// # define __cpp_lib_ranges_chunk 202202L
# define __cpp_lib_ranges_chunk_by 202202L
# define __cpp_lib_ranges_contains 202207L
+# define __cpp_lib_ranges_find_last 202207L
// # define __cpp_lib_ranges_iota 202202L
// # define __cpp_lib_ranges_join_with 202202L
# define __cpp_lib_ranges_repeat 202207L
diff --git a/libcxx/modules/std/algorithm.inc b/libcxx/modules/std/algorithm.inc
index e7796bfa26af8..6c7a30330008a 100644
--- a/libcxx/modules/std/algorithm.inc
+++ b/libcxx/modules/std/algorithm.inc
@@ -77,12 +77,11 @@ export namespace std {
using std::ranges::find_if_not;
} // namespace ranges
+ // [alg.find.last], find last
namespace ranges {
-#if 0
using std::ranges::find_last;
using std::ranges::find_last_if;
using std::ranges::find_last_if_not;
-#endif
} // namespace ranges
// [alg.find.end], find end
diff --git a/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.pass.cpp b/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.pass.cpp
index 1a6c0d11460c5..3c1cd606c6bff 100644
--- a/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.pass.cpp
+++ b/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.pass.cpp
@@ -119,6 +119,12 @@ constexpr bool all_the_algorithms()
(void)std::ranges::find_if(a, UnaryTrue(&copies)); assert(copies == 0);
(void)std::ranges::find_if_not(first, last, UnaryTrue(&copies)); assert(copies == 0);
(void)std::ranges::find_if_not(a, UnaryTrue(&copies)); assert(copies == 0);
+#if TEST_STD_VER >= 23
+ (void)std::ranges::find_last_if(first, last, UnaryTrue(&copies)); assert(copies == 0);
+ (void)std::ranges::find_last_if(a, UnaryTrue(&copies)); assert(copies == 0);
+ (void)std::ranges::find_last_if_not(first, last, UnaryTrue(&copies)); assert(copies == 0);
+ (void)std::ranges::find_last_if_not(a, UnaryTrue(&copies)); assert(copies == 0);
+#endif
(void)std::ranges::for_each(first, last, UnaryVoid(&copies)); assert(copies == 1); copies = 0;
(void)std::ranges::for_each(a, UnaryVoid(&copies)); assert(copies == 1); copies = 0;
(void)std::ranges::for_each_n(first, count, UnaryVoid(&copies)); assert(copies == 1); copies = 0;
diff --git a/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.pass.cpp b/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.pass.cpp
index 71823d9afc1a4..95f0893b1440b 100644
--- a/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.pass.cpp
+++ b/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.pass.cpp
@@ -115,6 +115,14 @@ constexpr bool all_the_algorithms()
(void)std::ranges::find_if(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
(void)std::ranges::find_if_not(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
(void)std::ranges::find_if_not(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
+#if TEST_STD_VER >= 23
+ (void)std::ranges::find_last(first, last, value, Proj(&copies)); assert(copies == 0);
+ (void)std::ranges::find_last(a, value, Proj(&copies)); assert(copies == 0);
+ (void)std::ranges::find_last_if(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
+ (void)std::ranges::find_last_if(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
+ (void)std::ranges::find_last_if_not(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
+ (void)std::ranges::find_last_if_not(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
+#endif
(void)std::ranges::for_each(first, last, UnaryVoid(), Proj(&copies)); assert(copies == 0);
(void)std::ranges::for_each(a, UnaryVoid(), Proj(&copies)); assert(copies == 0);
(void)std::ranges::for_each_n(first, count, UnaryVoid(), Proj(&copies)); assert(copies == 0);
diff --git a/libcxx/test/libcxx/diagnostics/algorithm.nodiscard.verify.cpp b/libcxx/test/libcxx/diagnostics/algorithm.nodiscard.verify.cpp
index b36a426082ccb..14febc12a8a2d 100644
--- a/libcxx/test/libcxx/diagnostics/algorithm.nodiscard.verify.cpp
+++ b/libcxx/test/libcxx/diagnostics/algorithm.nodiscard.verify.cpp
@@ -372,6 +372,18 @@ void test() {
// expected-warning at -1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::ranges::contains_subrange(iter, iter, iter, iter);
// expected-warning at -1 {{ignoring return value of function declared with 'nodiscard' attribute}}
+ std::ranges::find_last_if_not(iter, iter, pred);
+ // expected-warning at -1 {{ignoring return value of function declared with 'nodiscard' attribute}}
+ std::ranges::find_last_if_not(range, pred);
+ // expected-warning at -1 {{ignoring return value of function declared with 'nodiscard' attribute}}
+ std::ranges::find_last_if(iter, iter, pred);
+ // expected-warning at -1 {{ignoring return value of function declared with 'nodiscard' attribute}}
+ std::ranges::find_last_if(range, pred);
+ // expected-warning at -1 {{ignoring return value of function declared with 'nodiscard' attribute}}
+ std::ranges::find_last(iter, iter, 1);
+ // expected-warning at -1 {{ignoring return value of function declared with 'nodiscard' attribute}}
+ std::ranges::find_last(range, 1);
+ // expected-warning at -1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::ranges::fold_left(range, 0, std::plus());
// expected-warning at -1{{ignoring return value of function declared with 'nodiscard' attribute}}
std::ranges::fold_left(iter, iter, 0, std::plus());
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.last/ranges.find_last.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.last/ranges.find_last.pass.cpp
new file mode 100644
index 0000000000000..967e7d6495285
--- /dev/null
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.last/ranges.find_last.pass.cpp
@@ -0,0 +1,284 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// ADDITIONAL_COMPILE_FLAGS(gcc-style-warnings): -Wno-sign-compare
+// MSVC warning C4242: 'argument': conversion from 'const _Ty' to 'ElementT', possible loss of data
+// MSVC warning C4244: 'argument': conversion from 'const _Ty' to 'ElementT', possible loss of data
+// ADDITIONAL_COMPILE_FLAGS(cl-style-warnings): /wd4242 /wd4244
+
+// template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity>
+// requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+// constexpr subrange<I> ranges::find_last(I first, S last, const T& value, Proj proj = {});
+// template<forward_range R, class T, class Proj = identity>
+// requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+// constexpr borrowed_subrange_t<R> ranges::find_last(R&& r, const T& value, Proj proj = {});
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <deque>
+#include <ranges>
+#include <vector>
+
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+struct NotEqualityComparable {};
+
+template <class It, class Sent = It>
+concept HasFindLastIt = requires(It it, Sent sent) { std::ranges::find_last(it, sent, *it); };
+static_assert(HasFindLastIt<int*>);
+static_assert(HasFindLastIt<forward_iterator<int*>>);
+static_assert(!HasFindLastIt<cpp20_input_iterator<int*>>);
+static_assert(!HasFindLastIt<NotEqualityComparable*>);
+static_assert(!HasFindLastIt<ForwardIteratorNotDerivedFrom>);
+static_assert(!HasFindLastIt<ForwardIteratorNotIncrementable>);
+static_assert(!HasFindLastIt<forward_iterator<int*>, SentinelForNotSemiregular>);
+static_assert(!HasFindLastIt<forward_iterator<int*>, InputRangeNotSentinelEqualityComparableWith>);
+
+static_assert(!HasFindLastIt<int*, int>);
+static_assert(!HasFindLastIt<int, int*>);
+
+template <class Range, class ValT>
+concept HasFindLastR = requires(Range r) { std::ranges::find_last(r, ValT{}); };
+static_assert(HasFindLastR<std::array<int, 1>, int>);
+static_assert(!HasFindLastR<int, int>);
+static_assert(!HasFindLastR<std::array<NotEqualityComparable, 1>, NotEqualityComparable>);
+static_assert(!HasFindLastR<ForwardRangeNotDerivedFrom, int>);
+static_assert(!HasFindLastR<ForwardRangeNotIncrementable, int>);
+static_assert(!HasFindLastR<ForwardRangeNotSentinelSemiregular, int>);
+static_assert(!HasFindLastR<ForwardRangeNotSentinelEqualityComparableWith, int>);
+
+static std::vector<int> comparable_data;
+
+template <class It, class Sent = It>
+constexpr void test_iterators() {
+ using ValueT = std::iter_value_t<It>;
+ { // simple test
+ {
+ ValueT a[] = {1, 2, 3, 4};
+ std::same_as<std::ranges::subrange<It>> auto ret = std::ranges::find_last(It(a), Sent(It(a + 4)), 2);
+ assert(base(ret.begin()) == a + 1);
+ assert(*ret.begin() == 2);
+ }
+ {
+ ValueT a[] = {1, 2, 3, 4};
+ auto range = std::ranges::subrange(It(a), Sent(It(a + 4)));
+ std::same_as<std::ranges::subrange<It>> auto ret = std::ranges::find_last(range, 2);
+ assert(base(ret.begin()) == a + 1);
+ assert(*ret.begin() == 2);
+ }
+ }
+
+ { // check that an empty range works
+ {
+ std::array<ValueT, 0> a = {};
+ auto ret = std::ranges::find_last(It(a.data()), Sent(It(a.data())), 1).begin();
+ assert(base(ret) == a.data());
+ }
+ {
+ std::array<ValueT, 0> a = {};
+ auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data())));
+ auto ret = std::ranges::find_last(range, 1).begin();
+ assert(base(ret) == a.data());
+ }
+ }
+
+ { // check that last is returned with no match
+ {
+ ValueT a[] = {1, 1, 1};
+ auto ret = std::ranges::find_last(a, a + 3, 0).begin();
+ assert(ret == a + 3);
+ }
+ {
+ ValueT a[] = {1, 1, 1};
+ auto ret = std::ranges::find_last(a, 0).begin();
+ assert(ret == a + 3);
+ }
+ }
+
+ if (!std::is_constant_evaluated())
+ comparable_data.clear();
+}
+
+template <class ElementT>
+class TriviallyComparable {
+ ElementT el_;
+
+public:
+ TEST_CONSTEXPR TriviallyComparable(ElementT el) : el_(el) {}
+ bool operator==(const TriviallyComparable&) const = default;
+};
+
+constexpr bool test() {
+ types::for_each(types::type_list<char, wchar_t, int, long, TriviallyComparable<char>, TriviallyComparable<wchar_t>>{},
+ []<class T> {
+ types::for_each(types::forward_iterator_list<T*>{}, []<class Iter> {
+ if constexpr (std::forward_iterator<Iter>)
+ test_iterators<Iter>();
+ test_iterators<Iter, sentinel_wrapper<Iter>>();
+ test_iterators<Iter, sized_sentinel<Iter>>();
+ });
+ });
+
+ {
+ std::vector<std::vector<int>> vec = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+ auto view = vec | std::views::join;
+ assert(std::ranges::find_last(view.begin(), view.end(), 4).begin() == std::next(view.begin(), 3));
+ assert(std::ranges::find_last(view, 4).begin() == std::next(view.begin(), 3));
+ }
+
+ { // check that the last element is returned
+ {
+ struct S {
+ int comp;
+ int other;
+ };
+ S a[] = { {0, 0}, {0, 2}, {0, 1} };
+ auto ret = std::ranges::find_last(a, 0, &S::comp).begin();
+ assert(ret == a + 2);
+ assert(ret->comp == 0);
+ assert(ret->other == 1);
+ }
+ {
+ struct S {
+ int comp;
+ int other;
+ };
+ S a[] = { {0, 0}, {0, 2}, {0, 1} };
+ auto ret = std::ranges::find_last(a, a + 3, 0, &S::comp).begin();
+ assert(ret == a + 2);
+ assert(ret->comp == 0);
+ assert(ret->other == 1);
+ }
+ }
+
+ {
+ // check that an iterator is returned with a borrowing range
+ int a[] = {1, 2, 3, 4};
+ std::same_as<std::ranges::subrange<int*>> auto ret = std::ranges::find_last(std::views::all(a), 1);
+ assert(ret.begin() == a);
+ assert(*ret.begin() == 1);
+ }
+
+ {
+ // count invocations of the projection
+ {
+ int a[] = {1, 2, 3, 4};
+ int projection_count = 0;
+ auto ret = std::ranges::find_last(a, a + 4, 2, [&](int i) { ++projection_count; return i; }).begin();
+ assert(ret == a + 1);
+ assert(*ret == 2);
+ assert(projection_count == 3);
+ }
+ {
+ int a[] = {1, 2, 3, 4};
+ int projection_count = 0;
+ auto ret = std::ranges::find_last(a, 2, [&](int i) { ++projection_count; return i; }).begin();
+ assert(ret == a + 1);
+ assert(*ret == 2);
+ assert(projection_count == 3);
+ }
+ }
+
+ return true;
+}
+
+template <class IndexT>
+class Comparable {
+ IndexT index_;
+
+public:
+ Comparable(IndexT i)
+ : index_([&]() {
+ IndexT size = static_cast<IndexT>(comparable_data.size());
+ comparable_data.push_back(i);
+ return size;
+ }()) {}
+
+ bool operator==(const Comparable& other) const {
+ return comparable_data[other.index_] == comparable_data[index_];
+ }
+
+ friend bool operator==(const Comparable& lhs, long long rhs) { return comparable_data[lhs.index_] == rhs; }
+};
+
+void test_deque() {
+ { // empty deque
+ std::deque<int> data;
+ assert(std::ranges::find_last(data, 4).begin() == data.end());
+ assert(std::ranges::find_last(data.begin(), data.end(), 4).begin() == data.end());
+ }
+
+ { // single element - match
+ std::deque<int> data = {4};
+ assert(std::ranges::find_last(data, 4).begin() == data.begin());
+ assert(std::ranges::find_last(data.begin(), data.end(), 4).begin() == data.begin());
+ }
+
+ { // single element - no match
+ std::deque<int> data = {3};
+ assert(std::ranges::find_last(data, 4).begin() == data.end());
+ assert(std::ranges::find_last(data.begin(), data.end(), 4).begin() == data.end());
+ }
+
+ // many elements
+ for (auto size : {2, 3, 1023, 1024, 1025, 2047, 2048, 2049}) {
+ { // last element match
+ std::deque<int> data;
+ data.resize(size);
+ std::fill(data.begin(), data.end(), 3);
+ data[size - 1] = 4;
+ assert(std::ranges::find_last(data, 4).begin() == data.end() - 1);
+ assert(std::ranges::find_last(data.begin(), data.end(), 4).begin() == data.end() - 1);
+ }
+
+ { // second-last element match
+ std::deque<int> data;
+ data.resize(size);
+ std::fill(data.begin(), data.end(), 3);
+ data[size - 2] = 4;
+ assert(std::ranges::find_last(data, 4).begin() == data.end() - 2);
+ assert(std::ranges::find_last(data.begin(), data.end(), 4).begin() == data.end() - 2);
+ }
+
+ { // no match
+ std::deque<int> data;
+ data.resize(size);
+ std::fill(data.begin(), data.end(), 3);
+ assert(std::ranges::find_last(data, 4).begin() == data.end());
+ assert(std::ranges::find_last(data.begin(), data.end(), 4).begin() == data.end());
+ }
+ }
+}
+
+int main(int, char**) {
+ test_deque();
+ test();
+ static_assert(test());
+
+ types::for_each(types::forward_iterator_list<Comparable<char>*>{}, []<class Iter> {
+ if constexpr (std::forward_iterator<Iter>)
+ test_iterators<Iter>();
+ test_iterators<Iter, sentinel_wrapper<Iter>>();
+ test_iterators<Iter, sized_sentinel<Iter>>();
+ });
+
+ types::for_each(types::forward_iterator_list<Comparable<wchar_t>*>{}, []<class Iter> {
+ if constexpr (std::forward_iterator<Iter>)
+ test_iterators<Iter>();
+ test_iterators<Iter, sentinel_wrapper<Iter>>();
+ test_iterators<Iter, sized_sentinel<Iter>>();
+ });
+
+ return 0;
+}
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.last/ranges.find_last_if.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.last/ranges.find_last_if.pass.cpp
new file mode 100644
index 0000000000000..e2fc64fd8160f
--- /dev/null
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.last/ranges.find_last_if.pass.cpp
@@ -0,0 +1,233 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+// indirect_unary_predicate<projected<I, Proj>> Pred>
+// constexpr subrange<I> ranges::find_last_if(I first, S last, Pred pred, Proj proj = {});
+// template<forward_range R, class Proj = identity,
+// indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+// constexpr borrowed_subrange_t<R> ranges::find_last_if(R&& r, Pred pred, Proj proj = {});
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+struct Predicate {
+ bool operator()(int);
+};
+
+template <class It, class Sent = It>
+concept HasFindLastIfIt = requires(It it, Sent sent) { std::ranges::find_last_if(it, sent, Predicate{}); };
+static_assert(HasFindLastIfIt<int*>);
+static_assert(HasFindLastIfIt<forward_iterator<int*>>);
+static_assert(!HasFindLastIfIt<cpp20_input_iterator<int*>>);
+static_assert(!HasFindLastIfIt<ForwardIteratorNotDerivedFrom>);
+static_assert(!HasFindLastIfIt<ForwardIteratorNotIncrementable>);
+static_assert(!HasFindLastIfIt<forward_iterator<int*>, SentinelForNotSemiregular>);
+static_assert(!HasFindLastIfIt<forward_iterator<int*>, InputRangeNotSentinelEqualityComparableWith>);
+
+static_assert(!HasFindLastIfIt<int*, int>);
+static_assert(!HasFindLastIfIt<int, int*>);
+
+template <class Pred>
+concept HasFindLastIfPred = requires(int* it, Pred pred) {std::ranges::find_last_if(it, it, pred); };
+
+static_assert(!HasFindLastIfPred<IndirectUnaryPredicateNotCopyConstructible>);
+static_assert(!HasFindLastIfPred<IndirectUnaryPredicateNotPredicate>);
+
+template <class R>
+concept HasFindLastIfR = requires(R r) { std::ranges::find_last_if(r, Predicate{}); };
+static_assert(HasFindLastIfR<std::array<int, 0>>);
+static_assert(!HasFindLastIfR<int>);
+static_assert(!HasFindLastIfR<ForwardRangeNotDerivedFrom>);
+static_assert(!HasFindLastIfR<ForwardRangeNotIncrementable>);
+static_assert(!HasFindLastIfR<ForwardRangeNotSentinelSemiregular>);
+static_assert(!HasFindLastIfR<ForwardRangeNotSentinelEqualityComparableWith>);
+
+template <class It, class Sent = It>
+constexpr void test_iterators() {
+ {
+ int a[] = {1, 2, 3, 4};
+ std::same_as<std::ranges::subrange<It>> auto ret = std::ranges::find_last_if(It(a), Sent(It(a + 4)), [](int x) { return x == 4; });
+ assert(base(ret.begin()) == a + 3);
+ assert(*ret.begin() == 4);
+ }
+ {
+ int a[] = {1, 2, 3, 4};
+ auto range = std::ranges::subrange(It(a), Sent(It(a + 4)));
+ std::same_as<std::ranges::subrange<It>> auto ret = std::ranges::find_last_if(range, [](int x) { return x == 4; });
+ assert(base(ret.begin()) == a + 3);
+ assert(*ret.begin() == 4);
+ }
+}
+
+struct NonConstComparable {
+ friend constexpr bool operator==(const NonConstComparable&, const NonConstComparable&) { return false; }
+ friend constexpr bool operator==(NonConstComparable&, NonConstComparable&) { return false; }
+ friend constexpr bool operator==(const NonConstComparable&, NonConstComparable&) { return false; }
+ friend constexpr bool operator==(NonConstComparable&, const NonConstComparable&) { return true; }
+};
+
+constexpr bool test() {
+ test_iterators<int*>();
+ test_iterators<const int*>();
+ test_iterators<forward_iterator<int*>, sentinel_wrapper<forward_iterator<int*>>>();
+ test_iterators<bidirectional_iterator<int*>>();
+ test_iterators<forward_iterator<int*>>();
+ test_iterators<random_access_iterator<int*>>();
+ test_iterators<contiguous_iterator<int*>>();
+
+ {
+ // check that projections are used properly and that they are called with the iterator directly
+ {
+ int a[] = {1, 2, 3, 4};
+ auto ret = std::ranges::find_last_if(a, a + 4, [&](int* i) { return i == a + 3; }, [](int& i) { return &i; }).begin();
+ assert(ret == a + 3);
+ }
+ {
+ int a[] = {1, 2, 3, 4};
+ auto ret = std::ranges::find_last_if(a, [&](int* i) { return i == a + 3; }, [](int& i) { return &i; }).begin();
+ assert(ret == a + 3);
+ }
+ }
+
+ {
+ // check that the last element is returned
+ {
+ struct S {
+ int comp;
+ int other;
+ };
+ S a[] = { {0, 0}, {0, 2}, {0, 1} };
+ auto ret = std::ranges::find_last_if(a, [](int i){ return i == 0; }, &S::comp).begin();
+ assert(ret == a + 2);
+ assert(ret->comp == 0);
+ assert(ret->other == 1);
+ }
+ {
+ struct S {
+ int comp;
+ int other;
+ };
+ S a[] = { {0, 0}, {0, 2}, {0, 1} };
+ auto ret = std::ranges::find_last_if(a, a + 3, [](int i) { return i == 0; }, &S::comp).begin();
+ assert(ret == a + 2);
+ assert(ret->comp == 0);
+ assert(ret->other == 1);
+ }
+ }
+
+ {
+ // check that end iterator is returned with no match
+ {
+ int a[] = {1, 1, 1};
+ auto ret = std::ranges::find_last_if(a, a + 3, [](int) { return false; }).begin();
+ assert(ret == a + 3);
+ }
+ {
+ int a[] = {1, 1, 1};
+ auto ret = std::ranges::find_last_if(a, [](int){ return false; }).begin();
+ assert(ret == a + 3);
+ }
+ }
+
+ {
+ // check that ranges::dangling is returned
+ [[maybe_unused]] std::same_as<std::ranges::dangling> auto ret =
+ std::ranges::find_last_if(std::array{1, 2}, [](int){ return false; });
+ }
+
+ {
+ // check that an iterator is returned with a borrowing range
+ int a[] = {1, 2, 3, 4};
+ std::same_as<std::ranges::subrange<int*>> auto ret = std::ranges::find_last_if(std::views::all(a), [](int){ return true; });
+ assert(ret.begin() == a + 3);
+ assert(*ret.begin() == 4);
+ }
+
+ {
+ // check that std::invoke is used
+ struct S { int i; };
+ S a[] = { S{1}, S{3}, S{2} };
+ std::same_as<S*> auto ret = std::ranges::find_last_if(a, [](int) { return false; }, &S::i).begin();
+ assert(ret == a + 3);
+ }
+
+ {
+ // count projection and predicate invocation count
+ {
+ int a[] = {1, 2, 3, 4};
+ int predicate_count = 0;
+ int projection_count = 0;
+ auto ret = std::ranges::find_last_if(a, a + 4,
+ [&](int i) { ++predicate_count; return i == 2; },
+ [&](int i) { ++projection_count; return i; }).begin();
+ assert(ret == a + 1);
+ assert(*ret == 2);
+ assert(predicate_count == 3);
+ assert(projection_count == 3);
+ }
+ {
+ int a[] = {1, 2, 3, 4};
+ int predicate_count = 0;
+ int projection_count = 0;
+ auto ret = std::ranges::find_last_if(a,
+ [&](int i) { ++predicate_count; return i == 2; },
+ [&](int i) { ++projection_count; return i; }).begin();
+ assert(ret == a + 1);
+ assert(*ret == 2);
+ assert(predicate_count == 3);
+ assert(projection_count == 3);
+ }
+ }
+
+ {
+ // check that the return type of `iter::operator*` doesn't change
+ {
+ NonConstComparable a[] = { NonConstComparable{} };
+ auto ret = std::ranges::find_last_if(a, a + 1, [](auto&& e) { return e == NonConstComparable{}; }).begin();
+ assert(ret == a);
+ }
+ {
+ NonConstComparable a[] = { NonConstComparable{} };
+ auto ret = std::ranges::find_last_if(a, [](auto&& e) { return e == NonConstComparable{}; }).begin();
+ assert(ret == a);
+ }
+ }
+
+ {
+ // check that an empty range works
+ {
+ std::array<int ,0> a = {};
+ auto ret = std::ranges::find_last_if(a.begin(), a.end(), [](int) { return true; }).begin();
+ assert(ret == a.begin());
+ }
+ {
+ std::array<int, 0> a = {};
+ auto ret = std::ranges::find_last_if(a, [](int) { return true; }).begin();
+ assert(ret == a.begin());
+ }
+ }
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.last/ranges.find_last_if_not.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.last/ranges.find_last_if_not.pass.cpp
new file mode 100644
index 0000000000000..0a1e0d29f65b1
--- /dev/null
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.last/ranges.find_last_if_not.pass.cpp
@@ -0,0 +1,235 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+// indirect_unary_predicate<projected<I, Proj>> Pred>
+// constexpr subrange<I> ranges::find_last_if_not(I first, S last, Pred pred, Proj proj = {});
+// template<forward_range R, class Proj = identity,
+// indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+// constexpr borrowed_subrange_t<R> ranges::find_last_if_not(R&& r, Pred pred, Proj proj = {});
+
+#include <stdio.h>
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+struct Predicate {
+ bool operator()(int);
+};
+
+template <class It, class Sent = It>
+concept HasFindLastIfNotIt = requires(It it, Sent sent) { std::ranges::find_last_if_not(it, sent, Predicate{}); };
+static_assert(HasFindLastIfNotIt<int*>);
+static_assert(HasFindLastIfNotIt<forward_iterator<int*>>);
+static_assert(!HasFindLastIfNotIt<cpp20_input_iterator<int*>>);
+static_assert(!HasFindLastIfNotIt<ForwardIteratorNotDerivedFrom>);
+static_assert(!HasFindLastIfNotIt<ForwardIteratorNotIncrementable>);
+static_assert(!HasFindLastIfNotIt<forward_iterator<int*>, SentinelForNotSemiregular>);
+static_assert(!HasFindLastIfNotIt<forward_iterator<int*>, InputRangeNotSentinelEqualityComparableWith>);
+
+static_assert(!HasFindLastIfNotIt<int*, int>);
+static_assert(!HasFindLastIfNotIt<int, int*>);
+
+template <class Pred>
+concept HasFindLastIfNotPred = requires(int* it, Pred pred) {std::ranges::find_last_if_not(it, it, pred); };
+
+static_assert(!HasFindLastIfNotPred<IndirectUnaryPredicateNotCopyConstructible>);
+static_assert(!HasFindLastIfNotPred<IndirectUnaryPredicateNotPredicate>);
+
+template <class R>
+concept HasFindLastIfNotR = requires(R r) { std::ranges::find_last_if_not(r, Predicate{}); };
+static_assert(HasFindLastIfNotR<std::array<int, 0>>);
+static_assert(!HasFindLastIfNotR<int>);
+static_assert(!HasFindLastIfNotR<ForwardRangeNotDerivedFrom>);
+static_assert(!HasFindLastIfNotR<ForwardRangeNotIncrementable>);
+static_assert(!HasFindLastIfNotR<ForwardRangeNotSentinelSemiregular>);
+static_assert(!HasFindLastIfNotR<ForwardRangeNotSentinelEqualityComparableWith>);
+
+template <class It, class Sent = It>
+constexpr void test_iterators() {
+ {
+ int a[] = {1, 2, 3, 4};
+ std::same_as<std::ranges::subrange<It>> auto ret = std::ranges::find_last_if_not(It(a), Sent(It(a + 4)), [](int x) { return x != 4; });
+ assert(base(ret.begin()) == a + 3);
+ assert(*ret.begin() == 4);
+ }
+ {
+ int a[] = {1, 2, 3, 4};
+ auto range = std::ranges::subrange(It(a), Sent(It(a + 4)));
+ std::same_as<std::ranges::subrange<It>> auto ret = std::ranges::find_last_if_not(range, [](int x) { return x != 4; });
+ assert(base(ret.begin()) == a + 3);
+ assert(*ret.begin() == 4);
+ }
+}
+
+struct NonConstComparableLValue {
+ friend constexpr bool operator==(const NonConstComparableLValue&, const NonConstComparableLValue&) { return false; }
+ friend constexpr bool operator==(NonConstComparableLValue&, NonConstComparableLValue&) { return false; }
+ friend constexpr bool operator==(const NonConstComparableLValue&, NonConstComparableLValue&) { return false; }
+ friend constexpr bool operator==(NonConstComparableLValue&, const NonConstComparableLValue&) { return true; }
+};
+
+constexpr bool test() {
+ test_iterators<int*>();
+ test_iterators<const int*>();
+ test_iterators<forward_iterator<int*>, sentinel_wrapper<forward_iterator<int*>>>();
+ test_iterators<bidirectional_iterator<int*>>();
+ test_iterators<forward_iterator<int*>>();
+ test_iterators<random_access_iterator<int*>>();
+ test_iterators<contiguous_iterator<int*>>();
+
+ {
+ // check that projections are used properly and that they are called with the iterator directly
+ {
+ int a[] = {1, 2, 3, 4};
+ auto ret = std::ranges::find_last_if_not(a, a + 4, [&](int* i) { return i != a + 3; }, [](int& i) { return &i; }).begin();
+ assert(ret == a + 3);
+ }
+ {
+ int a[] = {1, 2, 3, 4};
+ auto ret = std::ranges::find_last_if_not(a, [&](int* i) { return i != a + 3; }, [](int& i) { return &i; }).begin();
+ assert(ret == a + 3);
+ }
+ }
+
+ {
+ // check that the last element is returned
+ {
+ struct S {
+ int comp;
+ int other;
+ };
+ S a[] = { {0, 0}, {0, 2}, {0, 1} };
+ auto ret = std::ranges::find_last_if_not(a, [](int i){ return i != 0; }, &S::comp).begin();
+ assert(ret == a + 2);
+ assert(ret->comp == 0);
+ assert(ret->other == 1);
+ }
+ {
+ struct S {
+ int comp;
+ int other;
+ };
+ S a[] = { {0, 0}, {0, 2}, {0, 1} };
+ auto ret = std::ranges::find_last_if_not(a, a + 3, [](int i) { return i != 0; }, &S::comp).begin();
+ assert(ret == a + 2);
+ assert(ret->comp == 0);
+ assert(ret->other == 1);
+ }
+ }
+
+ {
+ // check that end iterator is returned with no match
+ {
+ int a[] = {1, 1, 1};
+ auto ret = std::ranges::find_last_if_not(a, a + 3, [](int) { return true; }).begin();
+ assert(ret == a + 3);
+ }
+ {
+ int a[] = {1, 1, 1};
+ auto ret = std::ranges::find_last_if_not(a, [](int){ return true; }).begin();
+ assert(ret == a + 3);
+ }
+ }
+
+ {
+ // check that ranges::dangling is returned
+ [[maybe_unused]] std::same_as<std::ranges::dangling> auto ret =
+ std::ranges::find_last_if_not(std::array{1, 2}, [](int){ return true; });
+ }
+
+ {
+ // check that an iterator is returned with a borrowing range
+ int a[] = {1, 2, 3, 4};
+ std::same_as<std::ranges::subrange<int*>> auto ret = std::ranges::find_last_if_not(std::views::all(a), [](int){ return false; });
+ assert(ret.begin() == a + 3);
+ assert(*ret.begin() == 4);
+ }
+
+ {
+ // check that std::invoke is used
+ struct S { int i; };
+ S a[] = { S{1}, S{3}, S{2} };
+ std::same_as<S*> auto ret = std::ranges::find_last_if_not(a, [](int) { return true; }, &S::i).begin();
+ assert(ret == a + 3);
+ }
+
+ {
+ // count projection and predicate invocation count
+ {
+ int a[] = {1, 2, 3, 4};
+ int predicate_count = 0;
+ int projection_count = 0;
+ auto ret = std::ranges::find_last_if_not(a, a + 4,
+ [&](int i) { ++predicate_count; return i != 2; },
+ [&](int i) { ++projection_count; return i; }).begin();
+ assert(ret == a + 1);
+ assert(*ret == 2);
+ assert(predicate_count == 3);
+ assert(projection_count == 3);
+ }
+ {
+ int a[] = {1, 2, 3, 4};
+ int predicate_count = 0;
+ int projection_count = 0;
+ auto ret = std::ranges::find_last_if_not(a,
+ [&](int i) { ++predicate_count; return i != 2; },
+ [&](int i) { ++projection_count; return i; }).begin();
+ assert(ret == a + 1);
+ assert(*ret == 2);
+ assert(predicate_count == 3);
+ assert(projection_count == 3);
+ }
+ }
+
+ {
+ // check that the return type of `iter::operator*` doesn't change
+ {
+ NonConstComparableLValue a[] = { NonConstComparableLValue{} };
+ auto ret = std::ranges::find_last_if_not(a, a + 1, [](auto&& e) { return e != NonConstComparableLValue{}; }).begin();
+ assert(ret == a);
+ }
+ {
+ NonConstComparableLValue a[] = { NonConstComparableLValue{} };
+ auto ret = std::ranges::find_last_if_not(a, [](auto&& e) { return e != NonConstComparableLValue{}; }).begin();
+ assert(ret == a);
+ }
+ }
+
+ {
+ // check that an empty range works
+ {
+ std::array<int ,0> a = {};
+ auto ret = std::ranges::find_last_if_not(a.begin(), a.end(), [](int) { return true; }).begin();
+ assert(ret == a.begin());
+ }
+ {
+ std::array<int, 0> a = {};
+ auto ret = std::ranges::find_last_if_not(a, [](int) { return true; }).begin();
+ assert(ret == a.begin());
+ }
+ }
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/algorithms/ranges_robust_against_dangling.pass.cpp b/libcxx/test/std/algorithms/ranges_robust_against_dangling.pass.cpp
index e01a86d9f746f..0624a6c2d49c7 100644
--- a/libcxx/test/std/algorithms/ranges_robust_against_dangling.pass.cpp
+++ b/libcxx/test/std/algorithms/ranges_robust_against_dangling.pass.cpp
@@ -116,6 +116,11 @@ constexpr bool test_all() {
dangling_1st(std::ranges::find, in, x);
dangling_1st(std::ranges::find_if, in, unary_pred);
dangling_1st(std::ranges::find_if_not, in, unary_pred);
+#if TEST_STD_VER >= 23
+ dangling_1st(std::ranges::find_last, in, x);
+ dangling_1st(std::ranges::find_last_if, in, unary_pred);
+ dangling_1st(std::ranges::find_last_if_not, in, unary_pred);
+#endif
dangling_1st(std::ranges::find_first_of, in, in2);
dangling_1st(std::ranges::adjacent_find, in);
dangling_1st<mismatch_result<dangling, InIter>>(std::ranges::mismatch, in, in2);
diff --git a/libcxx/test/std/algorithms/ranges_robust_against_nonbool.compile.pass.cpp b/libcxx/test/std/algorithms/ranges_robust_against_nonbool.compile.pass.cpp
index a5668f20ccfd2..5203ee18d7bb0 100644
--- a/libcxx/test/std/algorithms/ranges_robust_against_nonbool.compile.pass.cpp
+++ b/libcxx/test/std/algorithms/ranges_robust_against_nonbool.compile.pass.cpp
@@ -53,6 +53,10 @@ void f(Iterator it, Range in, Iterator out, std::size_t n, Value const& val, std
in_pred(std::ranges::none_of, pred1);
in_pred(std::ranges::find_if, pred1);
in_pred(std::ranges::find_if_not, pred1);
+#if TEST_STD_VER >= 23
+ in_pred(std::ranges::find_last_if, pred1);
+ in_pred(std::ranges::find_last_if_not, pred1);
+#endif
in_in_pred(std::ranges::find_first_of, pred2);
in_pred(std::ranges::adjacent_find, pred2);
in_in_pred(std::ranges::mismatch, pred2);
diff --git a/libcxx/test/std/algorithms/ranges_robust_against_proxy_iterators.pass.cpp b/libcxx/test/std/algorithms/ranges_robust_against_proxy_iterators.pass.cpp
index 139f1999bc9dc..ca1433b778751 100644
--- a/libcxx/test/std/algorithms/ranges_robust_against_proxy_iterators.pass.cpp
+++ b/libcxx/test/std/algorithms/ranges_robust_against_proxy_iterators.pass.cpp
@@ -82,6 +82,11 @@ constexpr void run_tests() {
test(std::ranges::find, in, x);
test(std::ranges::find_if, in, unary_pred);
test(std::ranges::find_if_not, in, unary_pred);
+#if TEST_STD_VER >= 23
+ test(std::ranges::find_last, in, x);
+ test(std::ranges::find_last_if, in, unary_pred);
+ test(std::ranges::find_last_if_not, in, unary_pred);
+#endif
test(std::ranges::find_first_of, in, in2);
test(std::ranges::adjacent_find, in);
test(std::ranges::mismatch, in, in2);
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/algorithm.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/algorithm.version.compile.pass.cpp
index 8ccd252115ac8..ded8006063241 100644
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/algorithm.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/algorithm.version.compile.pass.cpp
@@ -23,6 +23,7 @@
__cpp_lib_parallel_algorithm 201603L [C++17]
__cpp_lib_ranges 202207L [C++20]
__cpp_lib_ranges_contains 202207L [C++23]
+ __cpp_lib_ranges_find_last 202207L [C++23]
__cpp_lib_ranges_starts_ends_with 202106L [C++23]
__cpp_lib_robust_nonmodifying_seq_ops 201304L [C++14]
__cpp_lib_sample 201603L [C++17]
@@ -62,6 +63,10 @@
# error "__cpp_lib_ranges_contains should not be defined before c++23"
# endif
+# ifdef __cpp_lib_ranges_find_last
+# error "__cpp_lib_ranges_find_last should not be defined before c++23"
+# endif
+
# ifdef __cpp_lib_ranges_starts_ends_with
# error "__cpp_lib_ranges_starts_ends_with should not be defined before c++23"
# endif
@@ -108,6 +113,10 @@
# error "__cpp_lib_ranges_contains should not be defined before c++23"
# endif
+# ifdef __cpp_lib_ranges_find_last
+# error "__cpp_lib_ranges_find_last should not be defined before c++23"
+# endif
+
# ifdef __cpp_lib_ranges_starts_ends_with
# error "__cpp_lib_ranges_starts_ends_with should not be defined before c++23"
# endif
@@ -169,6 +178,10 @@
# error "__cpp_lib_ranges_contains should not be defined before c++23"
# endif
+# ifdef __cpp_lib_ranges_find_last
+# error "__cpp_lib_ranges_find_last should not be defined before c++23"
+# endif
+
# ifdef __cpp_lib_ranges_starts_ends_with
# error "__cpp_lib_ranges_starts_ends_with should not be defined before c++23"
# endif
@@ -239,6 +252,10 @@
# error "__cpp_lib_ranges_contains should not be defined before c++23"
# endif
+# ifdef __cpp_lib_ranges_find_last
+# error "__cpp_lib_ranges_find_last should not be defined before c++23"
+# endif
+
# ifdef __cpp_lib_ranges_starts_ends_with
# error "__cpp_lib_ranges_starts_ends_with should not be defined before c++23"
# endif
@@ -315,6 +332,13 @@
# error "__cpp_lib_ranges_contains should have the value 202207L in c++23"
# endif
+# ifndef __cpp_lib_ranges_find_last
+# error "__cpp_lib_ranges_find_last should be defined in c++23"
+# endif
+# if __cpp_lib_ranges_find_last != 202207L
+# error "__cpp_lib_ranges_find_last should have the value 202207L in c++23"
+# endif
+
# ifndef __cpp_lib_ranges_starts_ends_with
# error "__cpp_lib_ranges_starts_ends_with should be defined in c++23"
# endif
@@ -412,6 +436,13 @@
# error "__cpp_lib_ranges_contains should have the value 202207L in c++26"
# endif
+# ifndef __cpp_lib_ranges_find_last
+# error "__cpp_lib_ranges_find_last should be defined in c++26"
+# endif
+# if __cpp_lib_ranges_find_last != 202207L
+# error "__cpp_lib_ranges_find_last should have the value 202207L in c++26"
+# endif
+
# ifndef __cpp_lib_ranges_starts_ends_with
# error "__cpp_lib_ranges_starts_ends_with should be defined in c++26"
# endif
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
index a01ee702a5172..fb62e57eaf424 100644
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
@@ -173,6 +173,7 @@
__cpp_lib_ranges_chunk_by 202202L [C++23]
__cpp_lib_ranges_concat 202403L [C++26]
__cpp_lib_ranges_contains 202207L [C++23]
+ __cpp_lib_ranges_find_last 202207L [C++23]
__cpp_lib_ranges_iota 202202L [C++23]
__cpp_lib_ranges_join_with 202202L [C++23]
__cpp_lib_ranges_repeat 202207L [C++23]
@@ -848,6 +849,10 @@
# error "__cpp_lib_ranges_contains should not be defined before c++23"
# endif
+# ifdef __cpp_lib_ranges_find_last
+# error "__cpp_lib_ranges_find_last should not be defined before c++23"
+# endif
+
# ifdef __cpp_lib_ranges_iota
# error "__cpp_lib_ranges_iota should not be defined before c++23"
# endif
@@ -1744,6 +1749,10 @@
# error "__cpp_lib_ranges_contains should not be defined before c++23"
# endif
+# ifdef __cpp_lib_ranges_find_last
+# error "__cpp_lib_ranges_find_last should not be defined before c++23"
+# endif
+
# ifdef __cpp_lib_ranges_iota
# error "__cpp_lib_ranges_iota should not be defined before c++23"
# endif
@@ -2811,6 +2820,10 @@
# error "__cpp_lib_ranges_contains should not be defined before c++23"
# endif
+# ifdef __cpp_lib_ranges_find_last
+# error "__cpp_lib_ranges_find_last should not be defined before c++23"
+# endif
+
# ifdef __cpp_lib_ranges_iota
# error "__cpp_lib_ranges_iota should not be defined before c++23"
# endif
@@ -4145,6 +4158,10 @@
# error "__cpp_lib_ranges_contains should not be defined before c++23"
# endif
+# ifdef __cpp_lib_ranges_find_last
+# error "__cpp_lib_ranges_find_last should not be defined before c++23"
+# endif
+
# ifdef __cpp_lib_ranges_iota
# error "__cpp_lib_ranges_iota should not be defined before c++23"
# endif
@@ -5662,6 +5679,13 @@
# error "__cpp_lib_ranges_contains should have the value 202207L in c++23"
# endif
+# ifndef __cpp_lib_ranges_find_last
+# error "__cpp_lib_ranges_find_last should be defined in c++23"
+# endif
+# if __cpp_lib_ranges_find_last != 202207L
+# error "__cpp_lib_ranges_find_last should have the value 202207L in c++23"
+# endif
+
# if !defined(_LIBCPP_VERSION)
# ifndef __cpp_lib_ranges_iota
# error "__cpp_lib_ranges_iota should be defined in c++23"
@@ -7521,6 +7545,13 @@
# error "__cpp_lib_ranges_contains should have the value 202207L in c++26"
# endif
+# ifndef __cpp_lib_ranges_find_last
+# error "__cpp_lib_ranges_find_last should be defined in c++26"
+# endif
+# if __cpp_lib_ranges_find_last != 202207L
+# error "__cpp_lib_ranges_find_last should have the value 202207L in c++26"
+# endif
+
# if !defined(_LIBCPP_VERSION)
# ifndef __cpp_lib_ranges_iota
# error "__cpp_lib_ranges_iota should be defined in c++26"
diff --git a/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp b/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp
index 9506ca1c768bd..b26b397056343 100644
--- a/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp
+++ b/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp
@@ -88,6 +88,9 @@ static_assert(test(std::ranges::find_first_of, a, a));
static_assert(test(std::ranges::find_if, a, odd));
static_assert(test(std::ranges::find_if_not, a, odd));
#if TEST_STD_VER >= 23
+static_assert(test(std::ranges::find_last, a, 42));
+static_assert(test(std::ranges::find_last_if, a, odd));
+static_assert(test(std::ranges::find_last_if_not, a, odd));
static_assert(test(std::ranges::fold_left, a, 0, std::plus()));
static_assert(test(std::ranges::fold_left_with_iter, a, 0, std::plus()));
#endif
diff --git a/libcxx/utils/generate_feature_test_macro_components.py b/libcxx/utils/generate_feature_test_macro_components.py
index 773b1523cde4e..e2eef4e884488 100755
--- a/libcxx/utils/generate_feature_test_macro_components.py
+++ b/libcxx/utils/generate_feature_test_macro_components.py
@@ -1033,6 +1033,11 @@ def add_version_header(tc):
"values": {"c++23": 202207},
"headers": ["algorithm"],
},
+ {
+ "name": "__cpp_lib_ranges_find_last",
+ "values": {"c++23": 202207},
+ "headers": ["algorithm"],
+ },
{
"name": "__cpp_lib_ranges_iota",
"values": {"c++23": 202202},
More information about the libcxx-commits
mailing list