[libcxx-commits] [libcxx] 7df5533 - [libc++] Implement `ranges::fold_left_first` and `ranges::fold_left_first_with_iter` (#180214)
via libcxx-commits
libcxx-commits at lists.llvm.org
Thu Apr 23 08:34:45 PDT 2026
Author: Connector Switch
Date: 2026-04-23T23:34:41+08:00
New Revision: 7df553349756468098289160f6c77aa21f1c2961
URL: https://github.com/llvm/llvm-project/commit/7df553349756468098289160f6c77aa21f1c2961
DIFF: https://github.com/llvm/llvm-project/commit/7df553349756468098289160f6c77aa21f1c2961.diff
LOG: [libc++] Implement `ranges::fold_left_first` and `ranges::fold_left_first_with_iter` (#180214)
- Part of #105208.
- Closes #174059.
- Closes #121558.
---------
Co-authored-by: JCGoran <jcgoran at protonmail.com>
Co-authored-by: A. Jiang <de34 at live.cn>
Added:
libcxx/test/std/algorithms/alg.nonmodifying/alg.fold/ranges.fold_left.pass.cpp
libcxx/test/std/algorithms/alg.nonmodifying/alg.fold/ranges.fold_left_first.pass.cpp
Modified:
libcxx/docs/ReleaseNotes/23.rst
libcxx/docs/Status/Cxx23Papers.csv
libcxx/include/__algorithm/ranges_fold.h
libcxx/include/algorithm
libcxx/modules/std/algorithm.inc
libcxx/test/benchmarks/algorithms/nonmodifying/fold.bench.cpp
libcxx/test/libcxx/algorithms/nodiscard.verify.cpp
libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp
Removed:
libcxx/test/std/algorithms/alg.nonmodifying/alg.fold/left_folds.pass.cpp
################################################################################
diff --git a/libcxx/docs/ReleaseNotes/23.rst b/libcxx/docs/ReleaseNotes/23.rst
index 574deec92d4fb..0160ea2179ccc 100644
--- a/libcxx/docs/ReleaseNotes/23.rst
+++ b/libcxx/docs/ReleaseNotes/23.rst
@@ -45,6 +45,8 @@ Implemented Papers
- P2781R9: ``std::constant_wrapper`` (`Github <https://llvm.org/PR148179>`__)
- P3978R3: ``constant_wrapper`` should unwrap on call and subscript (`Github <https://llvm.org/PR189605>`__)
- P2164R9: ``views::enumerate`` (`Github <https://llvm.org/PR105251>`__)
+- P2322R6 (partial): ``ranges::fold_left_first`` and ``ranges::fold_left_first_with_iter`` are supported
+ (`Github <https://llvm.org/PR105208>`__)
Improvements and New Features
-----------------------------
diff --git a/libcxx/docs/Status/Cxx23Papers.csv b/libcxx/docs/Status/Cxx23Papers.csv
index 1bef89cff117a..80ed7dba3ead7 100644
--- a/libcxx/docs/Status/Cxx23Papers.csv
+++ b/libcxx/docs/Status/Cxx23Papers.csv
@@ -65,7 +65,7 @@
"`P2286R8 <https://wg21.link/P2286R8>`__","Formatting Ranges","2022-07 (Virtual)","|Complete|","16","`#105202 <https://github.com/llvm/llvm-project/issues/105202>`__",""
"`P2291R3 <https://wg21.link/P2291R3>`__","Add Constexpr Modifiers to Functions ``to_chars`` and ``from_chars`` for Integral Types in ``<charconv>`` Header","2022-07 (Virtual)","|Complete|","16","`#105204 <https://github.com/llvm/llvm-project/issues/105204>`__",""
"`P2302R4 <https://wg21.link/P2302R4>`__","``std::ranges::contains``","2022-07 (Virtual)","|Complete|","19","`#105206 <https://github.com/llvm/llvm-project/issues/105206>`__",""
-"`P2322R6 <https://wg21.link/P2322R6>`__","``ranges::fold``","2022-07 (Virtual)","","","`#105208 <https://github.com/llvm/llvm-project/issues/105208>`__",""
+"`P2322R6 <https://wg21.link/P2322R6>`__","``ranges::fold``","2022-07 (Virtual)","|Partial|","","Only ``fold_left_with_iter``, ``fold_left``, ``fold_left_first_with_iter``, and ``fold_left_first`` are implemented."
"`P2374R4 <https://wg21.link/P2374R4>`__","``views::cartesian_product``","2022-07 (Virtual)","","","`#105209 <https://github.com/llvm/llvm-project/issues/105209>`__",""
"`P2404R3 <https://wg21.link/P2404R3>`__","Move-only types for ``equality_comparable_with``, ``totally_ordered_with``, and ``three_way_comparable_with``","2022-07 (Virtual)","|Complete|","22","`#105210 <https://github.com/llvm/llvm-project/issues/105210>`__","Implemented as a DR in C++20."
"`P2408R5 <https://wg21.link/P2408R5>`__","Ranges iterators as inputs to non-Ranges algorithms","2022-07 (Virtual)","","","`#105211 <https://github.com/llvm/llvm-project/issues/105211>`__",""
diff --git a/libcxx/include/__algorithm/ranges_fold.h b/libcxx/include/__algorithm/ranges_fold.h
index c2d150a16d328..50776a2f1b808 100644
--- a/libcxx/include/__algorithm/ranges_fold.h
+++ b/libcxx/include/__algorithm/ranges_fold.h
@@ -30,6 +30,7 @@
#include <__type_traits/invoke.h>
#include <__utility/forward.h>
#include <__utility/move.h>
+#include <optional>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
@@ -64,6 +65,9 @@ struct in_value_result {
template <class _Ip, class _Tp>
using fold_left_with_iter_result = in_value_result<_Ip, _Tp>;
+template <class _Ip, class _Tp>
+using fold_left_first_with_iter_result = in_value_result<_Ip, _Tp>;
+
template <class _Fp, class _Tp, class _Ip, class _Rp, class _Up = decay_t<_Rp>>
concept __indirectly_binary_left_foldable_impl =
convertible_to<_Rp, _Up> && //
@@ -126,6 +130,63 @@ struct __fold_left {
};
inline constexpr auto fold_left = __fold_left();
+
+struct __fold_left_first_with_iter {
+ template <input_iterator _Iter,
+ sentinel_for<_Iter> _Sent,
+ __indirectly_binary_left_foldable<iter_value_t<_Iter>, _Iter> _Func>
+ requires constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Iter __first, _Sent __last, _Func __func) {
+ using _Up = decltype(fold_left(std::move(__first), __last, iter_value_t<_Iter>(*__first), __func));
+
+ if (__first == __last)
+ return fold_left_first_with_iter_result<_Iter, optional<_Up>>{std::move(__first), optional<_Up>()};
+
+ _Up __result(*__first);
+ ++__first;
+ __identity __proj;
+ auto __end = std::__for_each(
+ std::move(__first),
+ std::move(__last),
+ [&](auto&& __element) {
+ __result = std::invoke(__func, std::move(__result), std::forward<decltype(__element)>(__element));
+ },
+ __proj);
+
+ return fold_left_first_with_iter_result<_Iter, optional<_Up>>{std::move(__end), optional<_Up>(std::move(__result))};
+ }
+
+ template <input_range _Range, __indirectly_binary_left_foldable<range_value_t<_Range>, iterator_t<_Range>> _Func>
+ requires constructible_from<range_value_t<_Range>, range_reference_t<_Range>>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Range&& __range, _Func __func) {
+ auto __result = operator()(ranges::begin(__range), ranges::end(__range), std::ref(__func));
+
+ using _Up = decltype(fold_left(
+ ranges::begin(__range), ranges::end(__range), range_value_t<_Range>(*ranges::begin(__range)), __func));
+ return fold_left_first_with_iter_result<borrowed_iterator_t<_Range>, optional<_Up>>{
+ std::move(__result.in), std::move(__result.value)};
+ }
+};
+
+inline constexpr auto fold_left_first_with_iter = __fold_left_first_with_iter();
+
+struct __fold_left_first {
+ template <input_iterator _Iter,
+ sentinel_for<_Iter> _Sent,
+ __indirectly_binary_left_foldable<iter_value_t<_Iter>, _Iter> _Func>
+ requires constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Iter __first, _Sent __last, _Func __func) {
+ return fold_left_first_with_iter(std::move(__first), std::move(__last), std::ref(__func)).value;
+ }
+
+ template <input_range _Range, __indirectly_binary_left_foldable<range_value_t<_Range>, iterator_t<_Range>> _Func>
+ requires constructible_from<range_value_t<_Range>, range_reference_t<_Range>>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Range&& __range, _Func __func) {
+ return fold_left_first_with_iter(ranges::begin(__range), ranges::end(__range), std::ref(__func)).value;
+ }
+};
+
+inline constexpr auto fold_left_first = __fold_left_first();
} // namespace ranges
#endif // _LIBCPP_STD_VER >= 23
diff --git a/libcxx/include/algorithm b/libcxx/include/algorithm
index 2200ce6219eb4..2418d03d69f11 100644
--- a/libcxx/include/algorithm
+++ b/libcxx/include/algorithm
@@ -951,6 +951,15 @@ namespace ranges {
template<input_range R, class T, indirectly-binary-left-foldable<T, iterator_t<R>> F>
constexpr auto fold_left(R&& r, T init, F f); // since C++23
+ template<input_iterator I, sentinel_for<I> S,
+ indirectly-binary-left-foldable<iter_value_t<I>, I> F>
+ requires constructible_from<iter_value_t<I>, iter_reference_t<I>>
+ constexpr auto ranges::fold_left_first(I first, S last, F f); // since C++23
+
+ template<input_range R, indirectly-binary-left-foldable<range_value_t<R>, iterator_t<R>> F>
+ requires constructible_from<range_value_t<R>, range_reference_t<R>>
+ constexpr auto ranges::fold_left_first(R&& r, F f); // since C++23
+
template<class I, class T>
using fold_left_with_iter_result = in_value_result<I, T>; // since C++23
@@ -961,6 +970,18 @@ namespace ranges {
template<input_range R, class T, indirectly-binary-left-foldable<T, iterator_t<R>> F>
constexpr see below fold_left_with_iter(R&& r, T init, F f); // since C++23
+ template<class I, class T>
+ using fold_left_first_with_iter_result = in_value_result<I, T>; // since C++23
+
+ template<input_iterator I, sentinel_for<I> S,
+ indirectly-binary-left-foldable<iter_value_t<I>, I> F>
+ requires constructible_from<iter_value_t<I>, iter_reference_t<I>>
+ constexpr see below ranges::fold_left_first_with_iter(I first, S last, F f); // since C++23
+
+ template<input_range R, indirectly-binary-left-foldable<range_value_t<R>, iterator_t<R>> F>
+ requires constructible_from<range_value_t<R>, range_reference_t<R>>
+ constexpr see below ranges::fold_left_first_with_iter(R&& r, F f); // since C++23
+
template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
diff --git a/libcxx/modules/std/algorithm.inc b/libcxx/modules/std/algorithm.inc
index 5cca7636da1df..512145a3435c7 100644
--- a/libcxx/modules/std/algorithm.inc
+++ b/libcxx/modules/std/algorithm.inc
@@ -164,15 +164,14 @@ export namespace std {
// [alg.fold], fold
using std::ranges::fold_left;
+ using std::ranges::fold_left_first;
+ using std::ranges::fold_left_first_with_iter;
+ using std::ranges::fold_left_first_with_iter_result;
using std::ranges::fold_left_with_iter;
using std::ranges::fold_left_with_iter_result;
# if 0
- using std::ranges::fold_left_first;
using std::ranges::fold_right;
using std::ranges::fold_right_last;
- using std::ranges::fold_left_with_iter;
- using std::ranges::fold_left_first_with_iter;
- using std::ranges::fold_left_first_with_iter;
# endif
#endif // _LIBCPP_STD_VER >= 23
} // namespace ranges
diff --git a/libcxx/test/benchmarks/algorithms/nonmodifying/fold.bench.cpp b/libcxx/test/benchmarks/algorithms/nonmodifying/fold.bench.cpp
index a795b5df7f7f4..f6d89ea14e949 100644
--- a/libcxx/test/benchmarks/algorithms/nonmodifying/fold.bench.cpp
+++ b/libcxx/test/benchmarks/algorithms/nonmodifying/fold.bench.cpp
@@ -13,6 +13,7 @@
#include <deque>
#include <iterator>
#include <list>
+#include <optional>
#include <string>
#include <type_traits>
#include <vector>
@@ -21,7 +22,13 @@
#include "../../GenerateInput.h"
int main(int argc, char** argv) {
- // ranges::{fold_left,fold_right}
+ auto std_ranges_fold_left = [](auto first, auto last, auto init, auto func) {
+ return std::ranges::fold_left(first, last, init, func);
+ };
+ auto std_ranges_fold_left_first = [](auto first, auto last, auto, auto func) {
+ return std::ranges::fold_left_first(first, last, func);
+ };
+ // ranges::{fold_left,fold_left_first,fold_right,fold_right_last}
{
auto bm = []<class Container>(std::string name, auto fold) {
benchmark::RegisterBenchmark(
@@ -56,9 +63,13 @@ int main(int argc, char** argv) {
->Arg(8192)
->Arg(1 << 20);
};
- bm.operator()<std::vector<unsigned int>>("rng::fold_left(vector<int>)", std::ranges::fold_left);
- bm.operator()<std::deque<unsigned int>>("rng::fold_left(deque<int>)", std::ranges::fold_left);
- bm.operator()<std::list<unsigned int>>("rng::fold_left(list<int>)", std::ranges::fold_left);
+ bm.operator()<std::vector<unsigned int>>("rng::fold_left(vector<int>)", std_ranges_fold_left);
+ bm.operator()<std::deque<unsigned int>>("rng::fold_left(deque<int>)", std_ranges_fold_left);
+ bm.operator()<std::list<unsigned int>>("rng::fold_left(list<int>)", std_ranges_fold_left);
+
+ bm.operator()<std::vector<unsigned int>>("rng::fold_left_first(vector<int>)", std_ranges_fold_left_first);
+ bm.operator()<std::deque<unsigned int>>("rng::fold_left_first(deque<int>)", std_ranges_fold_left_first);
+ bm.operator()<std::list<unsigned int>>("rng::fold_left_first(list<int>)", std_ranges_fold_left_first);
// TODO: fold_right not implemented yet
// bm.operator()<std::vector<unsigned int>>("rng::fold_right(vector<int>)", std::ranges::fold_right);
diff --git a/libcxx/test/libcxx/algorithms/nodiscard.verify.cpp b/libcxx/test/libcxx/algorithms/nodiscard.verify.cpp
index d4743f4c404c9..ccedadfba7e6a 100644
--- a/libcxx/test/libcxx/algorithms/nodiscard.verify.cpp
+++ b/libcxx/test/libcxx/algorithms/nodiscard.verify.cpp
@@ -396,5 +396,13 @@ void test() {
// expected-warning at -1{{ignoring return value of function declared with 'nodiscard' attribute}}
std::ranges::fold_left_with_iter(iter, iter, 0, std::plus());
// expected-warning at -1{{ignoring return value of function declared with 'nodiscard' attribute}}
+ std::ranges::fold_left_first(range, std::plus());
+ // expected-warning at -1{{ignoring return value of function declared with 'nodiscard' attribute}}
+ std::ranges::fold_left_first(iter, iter, std::plus());
+ // expected-warning at -1{{ignoring return value of function declared with 'nodiscard' attribute}}
+ std::ranges::fold_left_first_with_iter(range, std::plus());
+ // expected-warning at -1{{ignoring return value of function declared with 'nodiscard' attribute}}
+ std::ranges::fold_left_first_with_iter(iter, iter, std::plus());
+ // expected-warning at -1{{ignoring return value of function declared with 'nodiscard' attribute}}
#endif
}
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.fold/left_folds.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.fold/ranges.fold_left.pass.cpp
similarity index 100%
rename from libcxx/test/std/algorithms/alg.nonmodifying/alg.fold/left_folds.pass.cpp
rename to libcxx/test/std/algorithms/alg.nonmodifying/alg.fold/ranges.fold_left.pass.cpp
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.fold/ranges.fold_left_first.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.fold/ranges.fold_left_first.pass.cpp
new file mode 100644
index 0000000000000..73002dbfb0589
--- /dev/null
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.fold/ranges.fold_left_first.pass.cpp
@@ -0,0 +1,339 @@
+//===----------------------------------------------------------------------===//
+//
+// 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>
+
+// REQUIRES: std-at-least-c++23
+
+// template<input_iterator I, sentinel_for<I> S,
+// indirectly-binary-left-foldable<iter_value_t<I>, I> F>
+// requires constructible_from<iter_value_t<I>, iter_reference_t<I>>
+// constexpr see below ranges::fold_left_first_with_iter(I first, S last, F f);
+
+// template<input_range R, indirectly-binary-left-foldable<range_value_t<R>, iterator_t<R>> F>
+// requires constructible_from<range_value_t<R>, range_reference_t<R>>
+// constexpr see below ranges::fold_left_first_with_iter(R&& r, F f);
+
+// template<input_iterator I, sentinel_for<I> S,
+// indirectly-binary-left-foldable<iter_value_t<I>, I> F>
+// requires constructible_from<iter_value_t<I>, iter_reference_t<I>>
+// constexpr auto ranges::fold_left_first(I first, S last, F f);
+
+// template<input_range R, indirectly-binary-left-foldable<range_value_t<R>, iterator_t<R>> F>
+// requires constructible_from<range_value_t<R>, range_reference_t<R>>
+// constexpr auto ranges::fold_left_first(R&& r, F f);
+
+#include <algorithm>
+#include <cassert>
+#include <concepts>
+#include <deque>
+#include <forward_list>
+#include <functional>
+#include <iterator>
+#include <list>
+#include <optional>
+#include <ranges>
+#include <set>
+#include <string_view>
+#include <string>
+#include <vector>
+
+#include "test_macros.h"
+#include "test_range.h"
+#include "invocable_with_telemetry.h"
+#include "maths.h"
+
+#if !defined(TEST_HAS_NO_LOCALIZATION)
+# include <sstream>
+#endif
+
+using std::ranges::fold_left_first;
+using std::ranges::fold_left_first_with_iter;
+
+template <class Result, class Range, class T>
+concept is_in_value_result =
+ std::same_as<Result, std::ranges::fold_left_first_with_iter_result<std::ranges::iterator_t<Range>, T>>;
+
+template <class Result, class T>
+concept is_dangling_with =
+ std::same_as<Result, std::ranges::fold_left_first_with_iter_result<std::ranges::dangling, T>>;
+
+template <std::ranges::input_range R, class F, std::equality_comparable Expected>
+ requires std::copyable<R>
+constexpr void check_iterator(R& r, F f, std::optional<Expected> const& expected) {
+ {
+ is_in_value_result<R, std::optional<Expected>> decltype(auto) result =
+ fold_left_first_with_iter(r.begin(), r.end(), f);
+ assert(result.in == r.end());
+ assert(result.value == expected);
+ }
+
+ {
+ auto telemetry = invocable_telemetry();
+ auto f2 = invocable_with_telemetry(f, telemetry);
+ is_in_value_result<R, std::optional<Expected>> decltype(auto) result =
+ fold_left_first_with_iter(r.begin(), r.end(), f2);
+ assert(result.in == r.end());
+ assert(result.value == expected);
+ if (expected.has_value()) {
+ assert(telemetry.invocations == std::ranges::distance(r) - 1);
+ assert(telemetry.moves == 0);
+ assert(telemetry.copies == 1);
+ }
+ }
+
+ {
+ std::same_as<std::optional<Expected>> decltype(auto) result = fold_left_first(r.begin(), r.end(), f);
+ assert(result == expected);
+ }
+
+ {
+ auto telemetry = invocable_telemetry();
+ auto f2 = invocable_with_telemetry(f, telemetry);
+ std::same_as<std::optional<Expected>> decltype(auto) result = fold_left_first(r.begin(), r.end(), f2);
+ assert(result == expected);
+ if (expected.has_value()) {
+ assert(telemetry.invocations == std::ranges::distance(r) - 1);
+ assert(telemetry.moves == 0);
+ assert(telemetry.copies == 1);
+ }
+ }
+}
+
+template <std::ranges::input_range R, class F, std::equality_comparable Expected>
+ requires std::copyable<R>
+constexpr void check_lvalue_range(R& r, F f, std::optional<Expected> const& expected) {
+ {
+ is_in_value_result<R, std::optional<Expected>> decltype(auto) result = fold_left_first_with_iter(r, f);
+ assert(result.in == r.end());
+ assert(result.value == expected);
+ }
+
+ {
+ auto telemetry = invocable_telemetry();
+ auto f2 = invocable_with_telemetry(f, telemetry);
+ is_in_value_result<R, std::optional<Expected>> decltype(auto) result = fold_left_first_with_iter(r, f2);
+ assert(result.value == expected);
+ if (expected.has_value()) {
+ assert(telemetry.invocations == std::ranges::distance(r) - 1);
+ assert(telemetry.moves == 0);
+ assert(telemetry.copies == 1);
+ }
+ }
+
+ {
+ std::same_as<std::optional<Expected>> decltype(auto) result = fold_left_first(r, f);
+ assert(result == expected);
+ }
+
+ {
+ auto telemetry = invocable_telemetry();
+ auto f2 = invocable_with_telemetry(f, telemetry);
+ std::same_as<std::optional<Expected>> decltype(auto) result = fold_left_first(r, f2);
+ assert(result == expected);
+ if (expected.has_value()) {
+ assert(telemetry.invocations == std::ranges::distance(r) - 1);
+ assert(telemetry.moves == 0);
+ assert(telemetry.copies == 1);
+ }
+ }
+}
+
+template <std::ranges::input_range R, class F, std::equality_comparable Expected>
+ requires std::copyable<R>
+constexpr void check_rvalue_range(R& r, F f, std::optional<Expected> const& expected) {
+ {
+ auto r2 = r;
+ is_dangling_with<std::optional<Expected>> decltype(auto) result = fold_left_first_with_iter(std::move(r2), f);
+ assert(result.value == expected);
+ }
+
+ {
+ auto telemetry = invocable_telemetry();
+ auto f2 = invocable_with_telemetry(f, telemetry);
+ auto r2 = r;
+ is_dangling_with<std::optional<Expected>> decltype(auto) result = fold_left_first_with_iter(std::move(r2), f2);
+ assert(result.value == expected);
+ if (expected.has_value()) {
+ assert(telemetry.invocations == std::ranges::distance(r) - 1);
+ assert(telemetry.moves == 0);
+ assert(telemetry.copies == 1);
+ }
+ }
+
+ {
+ auto r2 = r;
+ std::same_as<std::optional<Expected>> decltype(auto) result = fold_left_first(std::move(r2), f);
+ assert(result == expected);
+ }
+
+ {
+ auto telemetry = invocable_telemetry();
+ auto f2 = invocable_with_telemetry(f, telemetry);
+ auto r2 = r;
+ std::same_as<std::optional<Expected>> decltype(auto) result = fold_left_first(std::move(r2), f2);
+ assert(result == expected);
+ if (expected.has_value()) {
+ assert(telemetry.invocations == std::ranges::distance(r) - 1);
+ assert(telemetry.moves == 0);
+ assert(telemetry.copies == 1);
+ }
+ }
+}
+
+template <std::ranges::input_range R, class F, std::equality_comparable Expected>
+ requires std::copyable<R>
+constexpr void check(R r, F f, std::optional<Expected> const& expected) {
+ check_iterator(r, f, expected);
+ check_lvalue_range(r, f, expected);
+ check_rvalue_range(r, f, expected);
+}
+
+constexpr void empty_range_test_case() {
+ auto const data = std::vector<int>{};
+ check(data, std::plus(), std::optional<int>());
+ check(data | std::views::take_while([](auto) { return false; }), std::plus(), std::optional<int>());
+}
+
+constexpr void common_range_test_case() {
+ auto const data = std::vector<int>{1, 2, 3, 4};
+ check(data, std::plus(), std::optional(triangular_sum(data)));
+ check(data, std::multiplies(), std::optional(factorial(data.back())));
+
+ auto multiply_with_prev = [n = 1](auto const x, auto const y) mutable {
+ auto const result = x * y * n;
+ n = y;
+ return static_cast<std::size_t>(result);
+ };
+ check(data, multiply_with_prev, std::optional(factorial(data.size()) * factorial(data.size() - 1)));
+
+ auto fib = [n = 0](auto x, auto) mutable {
+ auto old_x = x;
+ x += n;
+ n = old_x;
+ return x;
+ };
+ check(data, fib, std::optional(fibonacci(data.back())));
+}
+
+constexpr void non_common_range_test_case() {
+ auto parse = [](std::string_view const s) {
+ return s == "zero" ? 0.0
+ : s == "one" ? 1.0
+ : s == "two" ? 2.0
+ : s == "three" ? 3.0
+ : s == "four" ? 4.0
+ : s == "five" ? 5.0
+ : s == "six" ? 6.0
+ : s == "seven" ? 7.0
+ : s == "eight" ? 8.0
+ : s == "nine" ? 9.0
+ : (assert(false), 10.0); // the number here is arbitrary
+ };
+
+ {
+ auto data = std::vector<std::string>{"five", "three", "two", "six", "one", "four"};
+ auto range = data | std::views::transform(parse);
+ check(range, std::plus(), std::optional(triangular_sum(range)));
+ }
+
+ {
+ auto data = std::string("five three two six one four");
+ auto to_string_view = [](auto&& r) {
+ auto const n = std::ranges::distance(r);
+ return std::string_view(&*r.begin(), n);
+ };
+ auto range =
+ std::views::lazy_split(data, ' ') | std::views::transform(to_string_view) | std::views::transform(parse);
+ check(range, std::plus(), std::optional(triangular_sum(range)));
+ }
+}
+
+constexpr bool test_case() {
+ empty_range_test_case();
+ common_range_test_case();
+ non_common_range_test_case();
+ return true;
+}
+
+// Most containers aren't constexpr
+void runtime_only_test_case() {
+#if !defined(TEST_HAS_NO_LOCALIZATION)
+ { // istream_view is a genuine input range and needs specific handling.
+ constexpr auto raw_data = "Shells Orange Syrup Baratie Cocoyashi Loguetown";
+ constexpr auto expected = "ShellsOrangeSyrupBaratieCocoyashiLoguetown";
+
+ {
+ auto input = std::istringstream(raw_data);
+ auto data = std::views::istream<std::string>(input);
+ is_in_value_result<std::ranges::basic_istream_view<std::string, char>, std::optional<std::string>> decltype(auto)
+ result = fold_left_first_with_iter(data.begin(), data.end(), std::plus());
+
+ assert(result.in == data.end());
+ assert(result.value == expected);
+ }
+
+ {
+ auto input = std::istringstream(raw_data);
+ auto data = std::views::istream<std::string>(input);
+ is_in_value_result<std::ranges::basic_istream_view<std::string, char>, std::optional<std::string>> decltype(auto)
+ result = fold_left_first_with_iter(data, std::plus());
+ assert(result.in == data.end());
+ assert(result.value == expected);
+ }
+
+ {
+ auto input = std::istringstream(raw_data);
+ auto data = std::views::istream<std::string>(input);
+ assert(fold_left_first(data.begin(), data.end(), std::plus()) == expected);
+ }
+
+ {
+ auto input = std::istringstream(raw_data);
+ auto data = std::views::istream<std::string>(input);
+ assert(fold_left_first(data, std::plus()) == expected);
+ }
+ }
+#endif
+ {
+ auto const data = std::forward_list<int>{1, 3, 5, 7, 9};
+ auto const n = std::ranges::distance(data);
+ auto const expected = n * n; // sum of n consecutive odd numbers = n^2
+ check(data, std::plus(), std::optional(static_cast<int>(expected)));
+ }
+
+ {
+ auto const data = std::list<int>{2, 4, 6, 8, 10, 12};
+ auto const expected = triangular_sum(data);
+ check(data, std::plus<long>(), std::optional(static_cast<long>(expected)));
+ }
+
+ {
+ auto const data = std::deque<double>{-1.1, -2.2, -3.3, -4.4, -5.5, -6.6};
+ auto plus = [](double const x, double const y) { return static_cast<int>(x) + y; };
+ auto const expected = -21.6; // int(- 1.1) + -2.2 = - 1 + -2.2 = -3.2
+ // int(- 3.2) + -3.3 = - 3 + -3.3 = -6.3
+ // int(- 6.3) + -4.4 = - 6 + -4.4 = -10.4
+ // int(-10.4) + -5.5 = -10 + -5.5 = -15.5
+ // int(-15.5) + -6.6 = -15 + -6.6 = -21.6.
+ check(data, plus, std::optional(expected));
+ }
+
+ {
+ auto const data = std::set<int>{2, 4, 6, 8, 10, 12};
+ auto const expected = triangular_sum(data);
+ check(data, std::plus<long>(), std::optional(static_cast<long>(expected)));
+ }
+}
+
+int main(int, char**) {
+ test_case();
+ static_assert(test_case());
+ runtime_only_test_case();
+ return 0;
+}
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 d78d513e92d3f..ad26aefb93159 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
@@ -99,6 +99,8 @@ 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()));
+static_assert(test(std::ranges::fold_left_first, a, std::plus()));
+static_assert(test(std::ranges::fold_left_first_with_iter, a, std::plus()));
#endif
static_assert(test(std::ranges::for_each, a, odd));
static_assert(test(std::ranges::for_each_n, a, 10, odd));
More information about the libcxx-commits
mailing list