[libcxx-commits] [libcxx] [libc++] Add `ranges::fold_left_first` and ranges::`fold_left_first_with_iter` (PR #121558)

[via libcxx-commits]

github-actions[bot] wrote:

<!--LLVM CODE FORMAT COMMENT: {clang-format}-->


:warning: C/C++ code formatter, clang-format found issues in your code. :warning:

<details>
<summary>
You can test this locally with the following command:
</summary>

``````````bash
git-clang-format --diff 1135d36f869541f14934471e255c6e2631d6eebe a5515dba2f6d5fef5455d136d1dbccf20c340a4b --extensions h,,cpp,inc -- libcxx/include/__algorithm/ranges_fold.h libcxx/include/algorithm libcxx/modules/std/algorithm.inc libcxx/test/libcxx/diagnostics/algorithm.nodiscard.verify.cpp libcxx/test/std/algorithms/alg.nonmodifying/alg.fold/left_folds.pass.cpp
``````````

</details>

<details>
<summary>
View the diff from clang-format here.
</summary>

``````````diff
diff --git a/libcxx/include/__algorithm/ranges_fold.h b/libcxx/include/__algorithm/ranges_fold.h
index 91873e6bd3..b31ff7ca27 100644
--- a/libcxx/include/__algorithm/ranges_fold.h
+++ b/libcxx/include/__algorithm/ranges_fold.h
@@ -124,7 +124,7 @@ inline constexpr auto fold_left = __fold_left();
 
 struct __fold_left_first_with_iter {
   template <input_iterator _Ip, sentinel_for<_Ip> _Sp, __indirectly_binary_left_foldable<iter_value_t<_Ip>, _Ip> _Fp>
-  requires constructible_from<iter_value_t<_Ip>, iter_reference_t<_Ip>>
+    requires constructible_from<iter_value_t<_Ip>, iter_reference_t<_Ip>>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Ip __first, _Sp __last, _Fp __f) {
     using _Up = decltype(fold_left(std::move(__first), __last, iter_value_t<_Ip>(*__first), __f));
 
@@ -142,12 +142,13 @@ struct __fold_left_first_with_iter {
   }
 
   template <input_range _Rp, __indirectly_binary_left_foldable<range_value_t<_Rp>, iterator_t<_Rp>> _Fp>
-  requires constructible_from<range_value_t<_Rp>, range_reference_t<_Rp>>
+    requires constructible_from<range_value_t<_Rp>, range_reference_t<_Rp>>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Rp&& __r, _Fp __f) {
     auto __result = operator()(ranges::begin(__r), ranges::end(__r), std::ref(__f));
 
     using _Up = decltype(fold_left(ranges::begin(__r), ranges::end(__r), range_value_t<_Rp>(*ranges::begin(__r)), __f));
-    return fold_left_first_with_iter_result<borrowed_iterator_t<_Rp>, optional<_Up>>{std::move(__result.in), optional(std::move(__result.value))};
+    return fold_left_first_with_iter_result<borrowed_iterator_t<_Rp>, optional<_Up>>{
+        std::move(__result.in), optional(std::move(__result.value))};
   }
 };
 
@@ -155,13 +156,13 @@ inline constexpr auto fold_left_first_with_iter = __fold_left_first_with_iter();
 
 struct __fold_left_first {
   template <input_iterator _Ip, sentinel_for<_Ip> _Sp, __indirectly_binary_left_foldable<iter_value_t<_Ip>, _Ip> _Fp>
-  requires constructible_from<iter_value_t<_Ip>, iter_reference_t<_Ip>>
+    requires constructible_from<iter_value_t<_Ip>, iter_reference_t<_Ip>>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Ip __first, _Sp __last, _Fp __f) {
     return fold_left_first_with_iter(std::move(__first), std::move(__last), std::ref(__f)).value;
   }
 
   template <input_range _Rp, __indirectly_binary_left_foldable<range_value_t<_Rp>, iterator_t<_Rp>> _Fp>
-  requires constructible_from<range_value_t<_Rp>, range_reference_t<_Rp>>
+    requires constructible_from<range_value_t<_Rp>, range_reference_t<_Rp>>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Rp&& __r, _Fp __f) {
     return fold_left_first_with_iter(ranges::begin(__r), ranges::end(__r), std::ref(__f)).value;
   }
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.fold/left_folds.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.fold/left_folds.pass.cpp
index 22c5e1b862..c5b75a2e4c 100644
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.fold/left_folds.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.fold/left_folds.pass.cpp
@@ -52,8 +52,8 @@
 
 using std::ranges::fold_left;
 using std::ranges::fold_left_first;
-using std::ranges::fold_left_with_iter;
 using std::ranges::fold_left_first_with_iter;
+using std::ranges::fold_left_with_iter;
 
 template <class Result, class Range, class T>
 concept is_in_value_result =
@@ -112,21 +112,23 @@ 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);
+    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);
+    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 (result.value.has_value()) {
-        assert(telemetry.invocations == std::ranges::distance(r) - 1);
-        assert(telemetry.moves == 0);
-        assert(telemetry.copies == 1);
+      assert(telemetry.invocations == std::ranges::distance(r) - 1);
+      assert(telemetry.moves == 0);
+      assert(telemetry.copies == 1);
     }
   }
 
@@ -136,19 +138,18 @@ constexpr void check_iterator(R& r, F f, std::optional<Expected> const& expected
   }
 
   {
-    auto telemetry                               = invocable_telemetry();
-    auto f2                                      = invocable_with_telemetry(f, telemetry);
+    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 (result.has_value()) {
-        assert(telemetry.invocations == std::ranges::distance(r) - 1);
-        assert(telemetry.moves == 0);
-        assert(telemetry.copies == 1);
+      assert(telemetry.invocations == std::ranges::distance(r) - 1);
+      assert(telemetry.moves == 0);
+      assert(telemetry.copies == 1);
     }
   }
 }
 
-
 template <std::ranges::input_range R, class T, class F, std::equality_comparable Expected>
   requires std::copyable<R>
 constexpr void check_lvalue_range(R& r, T const& init, F f, Expected const& expected) {

``````````

</details>


https://github.com/llvm/llvm-project/pull/121558