More formatting

Author: JCGoran

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,26 +142,27 @@ 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))};
   }
 };
 
 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;
   }

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) {