[libc++] Improves clang-format settings.

[Mordante]

Summary

Add a new test based .clang-format file which inherits from the generic
one. This moves some test specific formatting rules to the test
directory.

The main benefit is that headers are sorted, which makes it more likely
to catch these errors before creating a review instead of spotting the
error in the CI clang-tidy step.

[Mordante]

Update formatting.

[Mordante]

CI fixes.

[ldionne]

Nice improvement!

libcxx/.clang-format

 Language: Cpp
 Standard: c++20
 SpacesInAngles: Leave
 
 AlwaysBreakTemplateDeclarations: true
 PointerAlignment: Left
 
 
-# Disable formatting options which may break tests.
-SortIncludes: false
-ReflowComments: false
-
 # libc++'s preferred indentions of preprocessor statements.
 IndentPPDirectives: AfterHash
 
 # libc++ has some long names so we need more than the 80 column limit imposed by LLVM style, for sensible formatting
 ColumnLimit: 120

libcxx/include/__chrono/convert_to_tm.h

if constexpr (sizeof(std::chrono::hours::rep) > sizeof(__result.tm_hour))
         std::__throw_format_error("Formatting hh_mm_ss, encountered an hour overflow");
     __result.tm_hour = __value.hours().count();
   } else
     static_assert(sizeof(_ChronoT) == 0, "Add the missing type specialization");
 
   return __result;
 }
 
-#endif //if _LIBCPP_STD_VER >= 20
+#endif // if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___CHRONO_CONVERT_TO_TM_H

libcxx/include/__chrono/ostream.h

operator<<(basic_ostream<_CharT, _Traits>& __os, const duration<_Rep, _Period>& __d) {
   __s.precision(__os.precision());
   __s << __d.count() << chrono::__units_suffix<_CharT, _Period>();
   return __os << __s.str();
 }
 
 template <class _CharT, class _Traits>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, const day& __d) {
-  return __os
-      << (__d.ok()
-              ? std::format(_LIBCPP_STATICALLY_WIDEN(_CharT, "{:%d}"), __d)
+  return __os << (__d.ok() ? std::format(_LIBCPP_STATICALLY_WIDEN(_CharT, "{:%d}"), __d)
                            // Note this error differs from the wording of the Standard. The
                            // Standard wording doesn't work well on AIX or Windows. There
                            // the formatted day seems to be either modulo 100 or completely
                            // omitted. Judging by the wording this is valid.
                            // TODO FMT Write a paper of file an LWG issue.
-              : std::format(_LIBCPP_STATICALLY_WIDEN(_CharT, "{:02} is not a valid day"), static_cast<unsigned>(__d)));
+                           : std::format(_LIBCPP_STATICALLY_WIDEN(_CharT, "{:02} is not a valid day"),
+                                         static_cast<unsigned>(__d)));
 }
 
 template <class _CharT, class _Traits>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, const month& __m) {
   return __os << (__m.ok() ? std::format(__os.getloc(), _LIBCPP_STATICALLY_WIDEN(_CharT, "{:L%b}"), __m)
                            : std::format(__os.getloc(),
                                          _LIBCPP_STATICALLY_WIDEN(_CharT, "{} is not a valid month"),

 template <class _CharT, class _Traits, class _Duration>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, const hh_mm_ss<_Duration> __hms) {
   return __os << std::format(__os.getloc(), _LIBCPP_STATICALLY_WIDEN(_CharT, "{:L%T}"), __hms);
 }
 
 } // namespace chrono
 
-#endif //if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
+#endif // if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___CHRONO_OSTREAM_H

libcxx/include/algorithm

 
 namespace std
 {
 
 namespace ranges {
 
   // [algorithms.results], algorithm result types
   template <class I, class F>
-    struct in_fun_result;     // since C++20
+    struct in_fun_result;                // since C++20
 
   template <class I1, class I2>
-    struct in_in_result;      // since C++20
+    struct in_in_result;                 // since C++20
 
   template <class I, class O>
-    struct in_out_result;  // since C++20
+    struct in_out_result;                // since C++20
 
   template <class I1, class I2, class O>
-    struct in_in_out_result;  // since C++20
+    struct in_in_out_result;             // since C++20
 
   template <class I, class O1, class O2>
-    struct in_out_out_result; // since C++20
+    struct in_out_out_result;            // since C++20
 
   template <class I1, class I2>
-    struct min_max_result;    // since C++20
+    struct min_max_result;               // since C++20
 
   template <class I>
-    struct in_found_result;   // since C++20
+    struct in_found_result;              // since C++20
 
   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
-    indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>             // since C++20
+    indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>                                   // since C++20
   constexpr I min_element(I first, S last, Comp comp = {}, Proj proj = {});
 
   template<forward_range R, class Proj = identity,
-    indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> // since C++20
+    indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>                       // since C++20
   constexpr borrowed_iterator_t<R> min_element(R&& r, Comp comp = {}, Proj proj = {});
 
   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
     indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
-  constexpr I ranges::max_element(I first, S last, Comp comp = {}, Proj proj = {});                        // since C++20
+  constexpr I ranges::max_element(I first, S last, Comp comp = {}, Proj proj = {});                       // since C++20
 
   template<forward_range R, class Proj = identity,
     indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
-  constexpr borrowed_iterator_t<R> ranges::max_element(R&& r, Comp comp = {}, Proj proj = {});             // since C++20
+  constexpr borrowed_iterator_t<R> ranges::max_element(R&& r, Comp comp = {}, Proj proj = {});            // since C++20
 
   template<class I1, class I2>
     using mismatch_result = in_in_result<I1, I2>;
 
   template <input_iterator I1, sentinel_for<_I1> S1, input_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>
-  constexpr mismatch_result<_I1, _I2>
-  mismatch()(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) // since C++20
+  constexpr mismatch_result<_I1, _I2>                                                                     // since C++20
+  mismatch()(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {})
 
   template <input_range R1, input_range R2,
           class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
     requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
   constexpr mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
-  mismatch(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {})                           // since C++20
+  mismatch(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {})                          // since C++20
 
     requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
-    constexpr I find(I first, S last, const T& value, Proj proj = {});              // since C++20
+    constexpr I find(I first, S last, const T& value, Proj proj = {});                                    // since C++20
 
   template<input_range R, class T, class Proj = identity>
     requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
     constexpr borrowed_iterator_t<R>
-      find(R&& r, const T& value, Proj proj = {});                                  // since C++20
+      find(R&& r, const T& value, Proj proj = {});                                                        // since C++20
 
   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
            indirect_unary_predicate<projected<I, Proj>> Pred>
-    constexpr I find_if(I first, S last, Pred pred, Proj proj = {});                // since C++20
+    constexpr I find_if(I first, S last, Pred pred, Proj proj = {});                                      // since C++20
 
   template<input_range R, class Proj = identity,
            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
     constexpr borrowed_iterator_t<R>
-      find_if(R&& r, Pred pred, Proj proj = {});                                    // since C++20
+      find_if(R&& r, Pred pred, Proj proj = {});                                                          // since C++20
 
   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
            indirect_unary_predicate<projected<I, Proj>> Pred>
-    constexpr I find_if_not(I first, S last, Pred pred, Proj proj = {});            // since C++20
+    constexpr I find_if_not(I first, S last, Pred pred, Proj proj = {});                                  // since C++20
 
   template<input_range R, class Proj = identity,
            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
+      find_if_not(R&& r, Pred pred, Proj proj = {});                                                      // since C++20
 
   template<class T, class Proj = identity,
            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
-    constexpr const T& min(const T& a, const T& b, Comp comp = {}, Proj proj = {}); // since C++20
+    constexpr const T& min(const T& a, const T& b, Comp comp = {}, Proj proj = {});                       // since C++20
 
   template<copyable T, class Proj = identity,
            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
-    constexpr T min(initializer_list<T> r, Comp comp = {}, Proj proj = {});         // since C++20
+    constexpr T min(initializer_list<T> r, Comp comp = {}, Proj proj = {});                               // since C++20
 
  template<input_range R, class Proj = identity,
           indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
    requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
    constexpr range_value_t<R>
-     min(R&& r, Comp comp = {}, Proj proj = {});                                    // since C++20
+     min(R&& r, Comp comp = {}, Proj proj = {});                                                          // since C++20
 
   template<class T, class Proj = identity,
            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
-    constexpr const T& max(const T& a, const T& b, Comp comp = {}, Proj proj = {}); // since C++20
+    constexpr const T& max(const T& a, const T& b, Comp comp = {}, Proj proj = {});                       // since C++20
 
   template<copyable T, class Proj = identity,
            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
-    constexpr T max(initializer_list<T> r, Comp comp = {}, Proj proj = {});         // since C++20
+    constexpr T max(initializer_list<T> r, Comp comp = {}, Proj proj = {});                               // since C++20
 
   template<input_range R, class Proj = identity,
            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
     requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
     constexpr range_value_t<R>
-      max(R&& r, Comp comp = {}, Proj proj = {});                                   // since C++20
+      max(R&& r, Comp comp = {}, Proj proj = {});                                                         // since C++20
 
   template<class I, class O>
-    using unary_transform_result = in_out_result<I, O>;                             // since C++20
+    using unary_transform_result = in_out_result<I, O>;                                                   // since C++20
 
   template<class I1, class I2, class O>
-    using binary_transform_result = in_in_out_result<I1, I2, O>;                    // since C++20
+    using binary_transform_result = in_in_out_result<I1, I2, O>;                                          // since C++20
 
   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
            copy_constructible F, class Proj = identity>
     requires indirectly_writable<O, indirect_result_t<F&, projected<I, Proj>>>
     constexpr ranges::unary_transform_result<I, O>
-      transform(I first1, S last1, O result, F op, Proj proj = {});                 // since C++20
+      transform(I first1, S last1, O result, F op, Proj proj = {});                                       // since C++20
 
   template<input_range R, weakly_incrementable O, copy_constructible F,
            class Proj = identity>
     requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
     constexpr ranges::unary_transform_result<borrowed_iterator_t<R>, O>
-      transform(R&& r, O result, F op, Proj proj = {});                             // since C++20
+      transform(R&& r, O result, F op, Proj proj = {});                                                   // since C++20
 
   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
            weakly_incrementable O, copy_constructible F, class Proj1 = identity,
            class Proj2 = identity>
     requires indirectly_writable<O, indirect_result_t<F&, projected<I1, Proj1>,
                                            projected<I2, Proj2>>>
     constexpr ranges::binary_transform_result<I1, I2, O>
       transform(I1 first1, S1 last1, I2 first2, S2 last2, O result,
-                        F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});           // since C++20
+                        F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});                                 // since C++20
 
   template<input_range R1, input_range R2, weakly_incrementable O,
            copy_constructible F, class Proj1 = identity, class Proj2 = identity>
     requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
                                            projected<iterator_t<R2>, Proj2>>>
     constexpr ranges::binary_transform_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
       transform(R1&& r1, R2&& r2, O result,
-                        F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});           // since C++20
+                        F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});                                 // since C++20
 
   template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
     requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
     constexpr iter_difference_t<I>
-      count(I first, S last, const T& value, Proj proj = {});                       // since C++20
+      count(I first, S last, const T& value, Proj proj = {});                                             // since C++20
 
   template<input_range R, class T, class Proj = identity>
     requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
     constexpr range_difference_t<R>
-      count(R&& r, const T& value, Proj proj = {});                                 // since C++20
+      count(R&& r, const T& value, Proj proj = {});                                                       // since C++20
 
   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
            indirect_unary_predicate<projected<I, Proj>> Pred>
     constexpr iter_difference_t<I>
-      count_if(I first, S last, Pred pred, Proj proj = {});                         // since C++20
+      count_if(I first, S last, Pred pred, Proj proj = {});                                               // since C++20
 
   template<input_range R, class Proj = identity,
            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
     constexpr range_difference_t<R>
-      count_if(R&& r, Pred pred, Proj proj = {});                                   // since C++20
+      count_if(R&& r, Pred pred, Proj proj = {});                                                         // since C++20
 
   template<class T>
   using minmax_result = min_max_result<T>;
 
   template<class T, class Proj = identity,
            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
     constexpr ranges::minmax_result<const T&>
-      minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});                     // since C++20
+      minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});                                     // since C++20
 
   template<copyable T, class Proj = identity,
            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
     constexpr ranges::minmax_result<T>
-      minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});                      // since C++20
+      minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});                                      // since C++20
 
   template<input_range R, class Proj = identity,
            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
     requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
     constexpr ranges::minmax_result<range_value_t<R>>
-      minmax(R&& r, Comp comp = {}, Proj proj = {});                                      // since C++20
+      minmax(R&& r, Comp comp = {}, Proj proj = {});                                                      // since C++20
 
   template<class I>
   using minmax_element_result = min_max_result<I>;
 
   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
            indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
     constexpr ranges::minmax_element_result<I>
-      minmax_element(I first, S last, Comp comp = {}, Proj proj = {});                    // since C++20
+      minmax_element(I first, S last, Comp comp = {}, Proj proj = {});                                    // since C++20
 
   template<forward_range R, class Proj = identity,
            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
     constexpr ranges::minmax_element_result<borrowed_iterator_t<R>>
-      minmax_element(R&& r, Comp comp = {}, Proj proj = {});                              // since C++20
+      minmax_element(R&& r, Comp comp = {}, Proj proj = {});                                              // since C++20
 
   template<class I, class O>
-    using copy_result = in_out_result<I, O>;                                              // since C++20
+    using copy_result = in_out_result<I, O>;                                                // since C++20
 
   template<class I, class O>
-    using copy_n_result = in_out_result<I, O>;                                            // since C++20
+    using copy_n_result = in_out_result<I, O>;                                              // since C++20
 
   template<class I, class O>
     using copy_if_result = in_out_result<I, O>;                                             // since C++20
 
   template<class I1, class I2>
     using copy_backward_result = in_out_result<I1, I2>;                                     // since C++20
 
   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
template<input_range R, class Proj = identity,
 
   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
     requires sortable<iterator_t<R>, Comp, Proj>
     constexpr borrowed_iterator_t<R>
       ranges::sort_heap(R&& r, Comp comp = {}, Proj proj = {});                             // since C++20
 
   template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
             indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
-    constexpr bool is_heap(I first, S last, Comp comp = {}, Proj proj = {});                // Since C++20
+    constexpr bool is_heap(I first, S last, Comp comp = {}, Proj proj = {});                // since C++20
 
   template<random_access_range R, class Proj = identity,
             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
-    constexpr bool is_heap(R&& r, Comp comp = {}, Proj proj = {});                          // Since C++20
+    constexpr bool is_heap(R&& r, Comp comp = {}, Proj proj = {});                          // since C++20
 
   template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
            indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
-    constexpr I is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});             // Since C++20
+    constexpr I is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});             // since C++20
 
   template<random_access_range R, class Proj = identity,
            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
     constexpr borrowed_iterator_t<R>
-      is_heap_until(R&& r, Comp comp = {}, Proj proj = {});                                 // Since C++20
+      is_heap_until(R&& r, Comp comp = {}, Proj proj = {});                                 // since C++20
 
   template<bidirectional_iterator I, sentinel_for<I> S>
     requires permutable<I>
     constexpr I ranges::reverse(I first, S last);                                           // since C++20
 
   template<bidirectional_range R>
     requires permutable<iterator_t<R>>
     constexpr borrowed_iterator_t<R> ranges::reverse(R&& r);                                // since C++20
template<input_range R, class Proj = identity,
   template<class T, output_range<const T&> R>
     constexpr borrowed_iterator_t<R> ranges::fill(R&& r, const T& value);                   // since C++20
 
   template<class T, output_iterator<const T&> O>
     constexpr O ranges::fill_n(O first, iter_difference_t<O> n, const T& value);            // since C++20
 
   template<input_or_output_iterator O, sentinel_for<O> S, copy_constructible F>
     requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
-    constexpr O generate(O first, S last, F gen);                                           // Since C++20
+    constexpr O generate(O first, S last, F gen);                                           // since C++20
 
   template<class R, copy_constructible F>
     requires invocable<F&> && output_range<R, invoke_result_t<F&>>
-    constexpr borrowed_iterator_t<R> generate(R&& r, F gen);                                // Since C++20
+    constexpr borrowed_iterator_t<R> generate(R&& r, F gen);                                // since C++20
 
   template<input_or_output_iterator O, copy_constructible F>
     requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
-    constexpr O generate_n(O first, iter_difference_t<O> n, F gen);                         // Since C++20
+    constexpr O generate_n(O first, iter_difference_t<O> n, F gen);                         // since C++20
 
  template<input_iterator I1, sentinel_for<I1> S1, input_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>
    constexpr bool ranges::equal(I1 first1, S1 last1, I2 first2, S2 last2,
                                 Pred pred = {},
                                 Proj1 proj1 = {}, Proj2 proj2 = {});                        // since C++20
 
  template<input_range R1, input_range R2, class Pred = ranges::equal_to,
           class Proj1 = identity, class Proj2 = identity>
    requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
    constexpr bool ranges::equal(R1&& r1, R2&& r2, Pred pred = {},
                                 Proj1 proj1 = {}, Proj2 proj2 = {});                        // since C++20
 
   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
            indirect_unary_predicate<projected<I, Proj>> Pred>
-    constexpr bool ranges::all_of(I first, S last, Pred pred, Proj proj = {});      // since C++20
+    constexpr bool ranges::all_of(I first, S last, Pred pred, Proj proj = {});              // since C++20
 
   template<input_range R, class Proj = identity,
            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
-    constexpr bool ranges::all_of(R&& r, Pred pred, Proj proj = {});                // since C++20
+    constexpr bool ranges::all_of(R&& r, Pred pred, Proj proj = {});                        // since C++20
 
   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
            indirect_unary_predicate<projected<I, Proj>> Pred>
-    constexpr bool ranges::any_of(I first, S last, Pred pred, Proj proj = {});      // since C++20
+    constexpr bool ranges::any_of(I first, S last, Pred pred, Proj proj = {});              // since C++20
 
   template<input_range R, class Proj = identity,
            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
-    constexpr bool ranges::any_of(R&& r, Pred pred, Proj proj = {});                // since C++20
+    constexpr bool ranges::any_of(R&& r, Pred pred, Proj proj = {});                        // since C++20
 
   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
            indirect_unary_predicate<projected<I, Proj>> Pred>
-    constexpr bool ranges::none_of(I first, S last, Pred pred, Proj proj = {});     // since C++20
+    constexpr bool ranges::none_of(I first, S last, Pred pred, Proj proj = {});             // since C++20
 
   template<input_range R, class Proj = identity,
            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
-    constexpr bool ranges::none_of(R&& r, Pred pred, Proj proj = {});               // since C++20
+    constexpr bool ranges::none_of(R&& r, Pred pred, Proj proj = {});                       // since C++20
 
   template<input_iterator I1, sentinel_for<I1> S1,
           random_access_iterator I2, sentinel_for<I2> S2,
           class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
     requires indirectly_copyable<I1, I2> && sortable<I2, Comp, Proj2> &&
             indirect_strict_weak_order<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
     constexpr partial_sort_copy_result<I1, I2>
       partial_sort_copy(I1 first, S1 last, I2 result_first, S2 result_last,
-                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});        // Since C++20
+                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});                // since C++20
 
   template<input_range R1, random_access_range R2, class Comp = ranges::less,
           class Proj1 = identity, class Proj2 = identity>
     requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
             sortable<iterator_t<R2>, Comp, Proj2> &&
             indirect_strict_weak_order<Comp, projected<iterator_t<R1>, Proj1>,
                                         projected<iterator_t<R2>, Proj2>>
     constexpr partial_sort_copy_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
       partial_sort_copy(R1&& r, R2&& result_r, Comp comp = {},
-                        Proj1 proj1 = {}, Proj2 proj2 = {});                        // Since C++20
+                        Proj1 proj1 = {}, Proj2 proj2 = {});                                // since C++20
 
   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
            indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
     constexpr bool ranges::is_sorted(I first, S last, Comp comp = {}, Proj proj = {});      // since C++20
 
   template<forward_range R, class Proj = identity,
            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
     constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {});                // since C++20
 
   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
            indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
     constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});   // since C++20
 
   template<forward_range R, class Proj = identity,
            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
     constexpr borrowed_iterator_t<R>
       ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});                       // since C++20
 
   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
           class Proj = identity>
     requires sortable<I, Comp, Proj>
     constexpr I
-      ranges::nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});            // since C++20
+      ranges::nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});          // since C++20
 
   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
     requires sortable<iterator_t<R>, Comp, Proj>
     constexpr borrowed_iterator_t<R>
-      ranges::nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});          // since C++20
+      ranges::nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});        // since C++20
 
   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
-           indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
-    constexpr I upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {}); // since C++20
+           indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>    // since C++20
+    constexpr I upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
 
   template<forward_range R, class T, class Proj = identity,
            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
              ranges::less>
     constexpr borrowed_iterator_t<R>
-      upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});                     // since C++20
+      upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});                   // since C++20
 
   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
            indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
     constexpr I lower_bound(I first, S last, const T& value, Comp comp = {},
-                                    Proj proj = {});                                          // since C++20
+                                    Proj proj = {});                                        // since C++20
   template<forward_range R, class T, class Proj = identity,
            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
              ranges::less>
     constexpr borrowed_iterator_t<R>
-      lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});                     // since C++20
+      lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});                   // since C++20
 
   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
            indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
     constexpr bool binary_search(I first, S last, const T& value, Comp comp = {},
-                                         Proj proj = {});                                     // since C++20
+                                         Proj proj = {});                                   // since C++20
 
   template<forward_range R, class T, class Proj = identity,
            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
              ranges::less>
     constexpr bool binary_search(R&& r, const T& value, Comp comp = {},
-                                         Proj proj = {});                                     // since C++20
+                                         Proj proj = {});                                   // since C++20
 
   template<permutable I, sentinel_for<I> S, class Proj = identity,
            indirect_unary_predicate<projected<I, Proj>> Pred>
     constexpr subrange<I>
-      partition(I first, S last, Pred pred, Proj proj = {});                                  // Since C++20
+      partition(I first, S last, Pred pred, Proj proj = {});                                // since C++20
 
   template<forward_range R, class Proj = identity,
            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
     requires permutable<iterator_t<R>>
     constexpr borrowed_subrange_t<R>
-      partition(R&& r, Pred pred, Proj proj = {});                                            // Since C++20
+      partition(R&& r, Pred pred, Proj proj = {});                                          // since C++20
 
   template<bidirectional_iterator I, sentinel_for<I> S, class Proj = identity,
            indirect_unary_predicate<projected<I, Proj>> Pred>
     requires permutable<I>
-    subrange<I> stable_partition(I first, S last, Pred pred, Proj proj = {});                 // Since C++20
+    subrange<I> stable_partition(I first, S last, Pred pred, Proj proj = {});               // since C++20
 
   template<bidirectional_range R, class Proj = identity,
            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
     requires permutable<iterator_t<R>>
-    borrowed_subrange_t<R> stable_partition(R&& r, Pred pred, Proj proj = {});                // Since C++20
+    borrowed_subrange_t<R> stable_partition(R&& r, Pred pred, Proj proj = {});              // since C++20
 
   template<input_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>
     constexpr I1 ranges::find_first_of(I1 first1, S1 last1, I2 first2, S2 last2,
                                        Pred pred = {},
                                        Proj1 proj1 = {}, Proj2 proj2 = {});                 // since C++20
 
   template<input_range R1, forward_range R2,
            class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
     requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
     constexpr borrowed_iterator_t<R1>
       ranges::find_first_of(R1&& r1, R2&& r2,
                             Pred pred = {},
                             Proj1 proj1 = {}, Proj2 proj2 = {});                            // since C++20
 
   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
            indirect_binary_predicate<projected<I, Proj>,
                                      projected<I, Proj>> Pred = ranges::equal_to>
-    constexpr I ranges::adjacent_find(I first, S last, Pred pred = {}, Proj proj = {});     // since C+20
+    constexpr I ranges::adjacent_find(I first, S last, Pred pred = {}, Proj proj = {});     // since C++20
 
   template<forward_range R, class Proj = identity,
            indirect_binary_predicate<projected<iterator_t<R>, Proj>,
                                      projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
     constexpr borrowed_iterator_t<R> ranges::adjacent_find(R&& r, Pred pred = {}, Proj proj = {});  // since C++20
 
   template<input_iterator I, sentinel_for<I> S, class T1, class T2, class Proj = identity>
     requires indirectly_writable<I, const T2&> &&
constexpr const T&
       ranges::clamp(const T& v, const T& lo, const T& hi, Comp comp = {}, Proj proj = {});          // since C++20
 
   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
            class Proj1 = identity, class Proj2 = identity,
            indirect_strict_weak_order<projected<I1, Proj1>,
                                       projected<I2, Proj2>> Comp = ranges::less>
     constexpr bool
       ranges::lexicographical_compare(I1 first1, S1 last1, I2 first2, S2 last2,
-                                      Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});    // since C++20
+                                      Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});          // since C++20
 
   template<input_range R1, input_range R2, class Proj1 = identity,
            class Proj2 = identity,
            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
                                       projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
     constexpr bool
       ranges::lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
-                                      Proj1 proj1 = {}, Proj2 proj2 = {});                    // since C++20
+                                      Proj1 proj1 = {}, Proj2 proj2 = {});                          // since C++20
 
   template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
     requires indirectly_movable<I1, I2>
     constexpr ranges::move_backward_result<I1, I2>
       ranges::move_backward(I1 first, S1 last, I2 result);                                          // since C++20
 
   template<bidirectional_range R, bidirectional_iterator I>
     requires indirectly_movable<iterator_t<R>, I>
template<class I, class O1, class O2>
       using partition_copy_result = in_out_out_result<I, O1, O2>;                                   // since C++20
 
   template<input_iterator I, sentinel_for<I> S,
           weakly_incrementable O1, weakly_incrementable O2,
           class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
     requires indirectly_copyable<I, O1> && indirectly_copyable<I, O2>
     constexpr partition_copy_result<I, O1, O2>
       partition_copy(I first, S last, O1 out_true, O2 out_false, Pred pred,
-                    Proj proj = {});                                                                // Since C++20
+                    Proj proj = {});                                                                // since C++20
 
   template<input_range R, weakly_incrementable O1, weakly_incrementable O2,
           class Proj = identity,
           indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
     requires indirectly_copyable<iterator_t<R>, O1> &&
             indirectly_copyable<iterator_t<R>, O2>
     constexpr partition_copy_result<borrowed_iterator_t<R>, O1, O2>
-      partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});                  // Since C++20
+      partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});                  // since C++20
 
   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
            indirect_unary_predicate<projected<I, Proj>> Pred>
-    constexpr I partition_point(I first, S last, Pred pred, Proj proj = {});                        // Since C++20
+    constexpr I partition_point(I first, S last, Pred pred, Proj proj = {});                        // since C++20
 
   template<forward_range R, class Proj = identity,
            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
     constexpr borrowed_iterator_t<R>
-      partition_point(R&& r, Pred pred, Proj proj = {});                                            // Since C++20
+      partition_point(R&& r, Pred pred, Proj proj = {});                                            // since C++20
 
   template<class I1, class I2, class O>
     using merge_result = in_in_out_result<I1, I2, O>;                                               // since C++20
 
   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
            weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity,
            class Proj2 = identity>
     requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
template<bidirectional_range R, weakly_incrementable O>
     constexpr ranges::reverse_copy_result<borrowed_iterator_t<R>, O>
       ranges::reverse_copy(R&& r, O result);                                                        // since C++20
 
   template<permutable I, sentinel_for<I> S>
     constexpr subrange<I> rotate(I first, I middle, S last);                                        // since C++20
 
   template<forward_range R>
     requires permutable<iterator_t<R>>
-    constexpr borrowed_subrange_t<R> rotate(R&& r, iterator_t<R> middle);                           // Since C++20
+    constexpr borrowed_subrange_t<R> rotate(R&& r, iterator_t<R> middle);                           // since C++20
 
   template <class _InIter, class _OutIter>
   using rotate_copy_result = in_out_result<_InIter, _OutIter>;                                      // since C++20
 
   template<forward_iterator I, sentinel_for<I> S, weakly_incrementable O>
     requires indirectly_copyable<I, O>
     constexpr ranges::rotate_copy_result<I, O>
       ranges::rotate_copy(I first, I middle, S last, O result);                                     // since C++20
 
   template<forward_range R, weakly_incrementable O>
     requires indirectly_copyable<iterator_t<R>, O>
     constexpr ranges::rotate_copy_result<borrowed_iterator_t<R>, O>
       ranges::rotate_copy(R&& r, iterator_t<R> middle, O result);                                   // since C++20
 
   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Gen>
     requires (forward_iterator<I> || random_access_iterator<O>) &&
             indirectly_copyable<I, O> &&
             uniform_random_bit_generator<remove_reference_t<Gen>>
-    O sample(I first, S last, O out, iter_difference_t<I> n, Gen&& g);                              // Since C++20
+    O sample(I first, S last, O out, iter_difference_t<I> n, Gen&& g);                              // since C++20
 
   template<input_range R, weakly_incrementable O, class Gen>
     requires (forward_range<R> || random_access_iterator<O>) &&
             indirectly_copyable<iterator_t<R>, O> &&
             uniform_random_bit_generator<remove_reference_t<Gen>>
-    O sample(R&& r, O out, range_difference_t<R> n, Gen&& g);                                       // Since C++20
+    O sample(R&& r, O out, range_difference_t<R> n, Gen&& g);                                       // since C++20
 
   template<random_access_iterator I, sentinel_for<I> S, class Gen>
     requires permutable<I> &&
             uniform_random_bit_generator<remove_reference_t<Gen>>
-    I shuffle(I first, S last, Gen&& g);                                                           // Since C++20
+    I shuffle(I first, S last, Gen&& g);                                                            // since C++20
 
   template<random_access_range R, class Gen>
     requires permutable<iterator_t<R>> &&
             uniform_random_bit_generator<remove_reference_t<Gen>>
-    borrowed_iterator_t<R> shuffle(R&& r, Gen&& g);                                                // Since C++20
+    borrowed_iterator_t<R> shuffle(R&& r, Gen&& g);                                                 // since C++20
 
   template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
          sentinel_for<I2> S2, class Proj1 = identity, class Proj2 = identity,
          indirect_equivalence_relation<projected<I1, Proj1>,
                                        projected<I2, Proj2>> Pred = ranges::equal_to>
   constexpr bool ranges::is_permutation(I1 first1, S1 last1, I2 first2, S2 last2,
                                         Pred pred = {},
-                                        Proj1 proj1 = {}, Proj2 proj2 = {});                       // Since C++20
+                                        Proj1 proj1 = {}, Proj2 proj2 = {});                       // since C++20
 
   template<forward_range R1, forward_range R2,
          class Proj1 = identity, class Proj2 = identity,
          indirect_equivalence_relation<projected<iterator_t<R1>, Proj1>,
                                        projected<iterator_t<R2>, Proj2>> Pred = ranges::equal_to>
   constexpr bool ranges::is_permutation(R1&& r1, R2&& r2, Pred pred = {},
-                                        Proj1 proj1 = {}, Proj2 proj2 = {});                       // Since C++20
+                                        Proj1 proj1 = {}, Proj2 proj2 = {});                       // since C++20
 
   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>
     constexpr subrange<I1>
       ranges::search(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
                      Proj1 proj1 = {}, Proj2 proj2 = {});                                           // since C++20
constexpr set_union_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
       set_union(R1&& r1, R2&& r2, O result, Comp comp = {},
                 Proj1 proj1 = {}, Proj2 proj2 = {});                                                // since C++20
 
   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
            class Proj1 = identity, class Proj2 = identity,
            indirect_strict_weak_order<projected<I1, Proj1>, projected<I2, Proj2>> Comp =
              ranges::less>
     constexpr bool includes(I1 first1, S1 last1, I2 first2, S2 last2, Comp comp = {},
-                            Proj1 proj1 = {}, Proj2 proj2 = {});                                   // Since C++20
+                            Proj1 proj1 = {}, Proj2 proj2 = {});                                   // since C++20
 
   template<input_range R1, input_range R2, class Proj1 = identity,
            class Proj2 = identity,
            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
                                       projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
     constexpr bool includes(R1&& r1, R2&& r2, Comp comp = {},
-                            Proj1 proj1 = {}, Proj2 proj2 = {});                                   // Since C++20
+                            Proj1 proj1 = {}, Proj2 proj2 = {});                                   // since C++20
 
   template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
            class Proj = identity>
     requires sortable<I, Comp, Proj>
-    I inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {});                    // Since C++20
+    I inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {});                    // since C++20
 
   template<bidirectional_range R, class Comp = ranges::less, class Proj = identity>
     requires sortable<iterator_t<R>, Comp, Proj>
     borrowed_iterator_t<R>
       inplace_merge(R&& r, iterator_t<R> middle, Comp comp = {},
-                    Proj proj = {});                                                               // Since C++20
+                    Proj proj = {});                                                               // since C++20
 
   template<permutable I, sentinel_for<I> S, class Proj = identity,
            indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
-    constexpr subrange<I> unique(I first, S last, C comp = {}, Proj proj = {});                    // Since C++20
+    constexpr subrange<I> unique(I first, S last, C comp = {}, Proj proj = {});                    // since C++20
 
   template<forward_range R, class Proj = identity,
            indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
     requires permutable<iterator_t<R>>
     constexpr borrowed_subrange_t<R>
-      unique(R&& r, C comp = {}, Proj proj = {});                                                  // Since C++20
+      unique(R&& r, C comp = {}, Proj proj = {});                                                  // since C++20
 
   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
            indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
     requires indirectly_copyable<I, O> &&
              (forward_iterator<I> ||
               (input_iterator<O> && same_as<iter_value_t<I>, iter_value_t<O>>) ||
               indirectly_copyable_storable<I, O>)
     constexpr unique_copy_result<I, O>
-      unique_copy(I first, S last, O result, C comp = {}, Proj proj = {});                         // Since C++20
+      unique_copy(I first, S last, O result, C comp = {}, Proj proj = {});                         // since C++20
 
   template<input_range R, weakly_incrementable O, class Proj = identity,
            indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
     requires indirectly_copyable<iterator_t<R>, O> &&
              (forward_iterator<iterator_t<R>> ||
               (input_iterator<O> && same_as<range_value_t<R>, iter_value_t<O>>) ||
               indirectly_copyable_storable<iterator_t<R>, O>)
     constexpr unique_copy_result<borrowed_iterator_t<R>, O>
-      unique_copy(R&& r, O result, C comp = {}, Proj proj = {});                                   // Since C++20
+      unique_copy(R&& r, O result, C comp = {}, Proj proj = {});                                   // since C++20
 
   template<class I, class O>
-      using remove_copy_result = in_out_result<I, O>;                                              // Since C++20
+      using remove_copy_result = in_out_result<I, O>;                                              // since C++20
 
   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class T,
            class Proj = identity>
              indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
     constexpr remove_copy_result<I, O>
-      remove_copy(I first, S last, O result, const T& value, Proj proj = {});                      // Since C++20
+      remove_copy(I first, S last, O result, const T& value, Proj proj = {});                      // since C++20
 
   template<input_range R, weakly_incrementable O, class T, class Proj = identity>
     requires indirectly_copyable<iterator_t<R>, O> &&
              indirect_binary_predicate<ranges::equal_to,
                                        projected<iterator_t<R>, Proj>, const T*>
     constexpr remove_copy_result<borrowed_iterator_t<R>, O>
-      remove_copy(R&& r, O result, const T& value, Proj proj = {});                                // Since C++20
+      remove_copy(R&& r, O result, const T& value, Proj proj = {});                                // since C++20
 
   template<class I, class O>
-      using remove_copy_if_result = in_out_result<I, O>;                                           // Since C++20
+      using remove_copy_if_result = in_out_result<I, O>;                                           // since C++20
 
   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
            class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
     requires indirectly_copyable<I, O>
     constexpr remove_copy_if_result<I, O>
-      remove_copy_if(I first, S last, O result, Pred pred, Proj proj = {});                        // Since C++20
+      remove_copy_if(I first, S last, O result, Pred pred, Proj proj = {});                        // since C++20
 
   template<input_range R, weakly_incrementable O, class Proj = identity,
            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
     requires indirectly_copyable<iterator_t<R>, O>
     constexpr remove_copy_if_result<borrowed_iterator_t<R>, O>
-      remove_copy_if(R&& r, O result, Pred pred, Proj proj = {});                                  // Since C++20
+      remove_copy_if(R&& r, O result, Pred pred, Proj proj = {});                                  // since C++20
 
   template<class I, class O>
-      using replace_copy_result = in_out_result<I, O>;                                             // Since C++20
+      using replace_copy_result = in_out_result<I, O>;                                             // since C++20
 
   template<input_iterator I, sentinel_for<I> S, class T1, class T2,
            output_iterator<const T2&> O, class Proj = identity>
     requires indirectly_copyable<I, O> &&
              indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
     constexpr replace_copy_result<I, O>
       replace_copy(I first, S last, O result, const T1& old_value, const T2& new_value,
-                   Proj proj = {});                                                                // Since C++20
+                   Proj proj = {});                                                                // since C++20
 
   template<input_range R, class T1, class T2, output_iterator<const T2&> O,
            class Proj = identity>
     requires indirectly_copyable<iterator_t<R>, O> &&
              indirect_binary_predicate<ranges::equal_to,
                                        projected<iterator_t<R>, Proj>, const T1*>
     constexpr replace_copy_result<borrowed_iterator_t<R>, O>
       replace_copy(R&& r, O result, const T1& old_value, const T2& new_value,
-                   Proj proj = {});                                                                // Since C++20
+                   Proj proj = {});                                                                // since C++20
 
   template<class I, class O>
-      using replace_copy_if_result = in_out_result<I, O>;                                          // Since C++20
+      using replace_copy_if_result = in_out_result<I, O>;                                          // since C++20
 
   template<input_iterator I, sentinel_for<I> S, class T, output_iterator<const T&> O,
            class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
     requires indirectly_copyable<I, O>
     constexpr replace_copy_if_result<I, O>
       replace_copy_if(I first, S last, O result, Pred pred, const T& new_value,
-                      Proj proj = {});                                                             // Since C++20
+                      Proj proj = {});                                                             // since C++20
 
   template<input_range R, class T, output_iterator<const T&> O, class Proj = identity,
            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
     requires indirectly_copyable<iterator_t<R>, O>
     constexpr replace_copy_if_result<borrowed_iterator_t<R>, O>
       replace_copy_if(R&& r, O result, Pred pred, const T& new_value,
-                      Proj proj = {});                                                             // Since C++20
+                      Proj proj = {});                                                             // since C++20
 
   template<class I>
-    using prev_permutation_result = in_found_result<I>;                                            // Since C++20
+    using prev_permutation_result = in_found_result<I>;                                            // since C++20
 
   template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
            class Proj = identity>
     requires sortable<I, Comp, Proj>
     constexpr ranges::prev_permutation_result<I>
-      ranges::prev_permutation(I first, S last, Comp comp = {}, Proj proj = {});                   // Since C++20
+      ranges::prev_permutation(I first, S last, Comp comp = {}, Proj proj = {});                   // since C++20
 
   template<bidirectional_range R, class Comp = ranges::less,
            class Proj = identity>
     requires sortable<iterator_t<R>, Comp, Proj>
     constexpr ranges::prev_permutation_result<borrowed_iterator_t<R>>
-      ranges::prev_permutation(R&& r, Comp comp = {}, Proj proj = {});                             // Since C++20
+      ranges::prev_permutation(R&& r, Comp comp = {}, Proj proj = {});                             // since C++20
 
   template<class I>
-    using next_permutation_result = in_found_result<I>;                                            // Since C++20
+    using next_permutation_result = in_found_result<I>;                                            // since C++20
 
   template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
            class Proj = identity>
     requires sortable<I, Comp, Proj>
     constexpr ranges::next_permutation_result<I>
-      ranges::next_permutation(I first, S last, Comp comp = {}, Proj proj = {});                   // Since C++20
+      ranges::next_permutation(I first, S last, Comp comp = {}, Proj proj = {});                   // since C++20
 
   template<bidirectional_range R, class Comp = ranges::less,
            class Proj = identity>
     requires sortable<iterator_t<R>, Comp, Proj>
     constexpr ranges::next_permutation_result<borrowed_iterator_t<R>>
-      ranges::next_permutation(R&& r, Comp comp = {}, Proj proj = {});                             // Since C++20
+      ranges::next_permutation(R&& r, Comp comp = {}, Proj proj = {});                             // since C++20
 
 }
 
 template <class InputIterator, class Predicate>
     constexpr bool     // constexpr in C++20
     all_of(InputIterator first, InputIterator last, Predicate pred);
 
 template <class InputIterator, class Predicate>

libcxx/include/functional

protected:
     typename Operation::first_argument_type value;
 public:
     binder1st(const Operation& x, const typename Operation::first_argument_type y);
     typename Operation::result_type operator()(      typename Operation::second_argument_type& x) const;
     typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const;
 };
 
 template <class Operation, class T>
-binder1st<Operation> bind1st(const Operation& op, const T& x);  // deprecated in C++11, removed in C++17
+binder1st<Operation> bind1st(const Operation& op, const T& x);                  // deprecated in C++11, removed in C++17
 
 template <class Operation>
-class binder2nd     // deprecated in C++11, removed in C++17
+class binder2nd                                                                 // deprecated in C++11, removed in C++17
     : public unary_function<typename Operation::first_argument_type,
                             typename Operation::result_type>
 {
 protected:
     Operation                                op;
     typename Operation::second_argument_type value;
 public:
     binder2nd(const Operation& x, const typename Operation::second_argument_type y);
     typename Operation::result_type operator()(      typename Operation::first_argument_type& x) const;
     typename Operation::result_type operator()(const typename Operation::first_argument_type& x) const;
 };
 
 template <class Operation, class T>
-binder2nd<Operation> bind2nd(const Operation& op, const T& x);  // deprecated in C++11, removed in C++17
+binder2nd<Operation> bind2nd(const Operation& op, const T& x);                  // deprecated in C++11, removed in C++17
 
-template <class Arg, class Result>      // deprecated in C++11, removed in C++17
+template <class Arg, class Result>                                              // deprecated in C++11, removed in C++17
 class pointer_to_unary_function : public unary_function<Arg, Result>
 {
 public:
     explicit pointer_to_unary_function(Result (*f)(Arg));
     Result operator()(Arg x) const;
 };
 
 template <class Arg, class Result>
-pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg));      // deprecated in C++11, removed in C++17
+pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg));                // deprecated in C++11, removed in C++17
 
-template <class Arg1, class Arg2, class Result>      // deprecated in C++11, removed in C++17
+template <class Arg1, class Arg2, class Result>                                 // deprecated in C++11, removed in C++17
 class pointer_to_binary_function : public binary_function<Arg1, Arg2, Result>
 {
 public:
     explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2));
     Result operator()(Arg1 x, Arg2 y) const;
 };
 
 template <class Arg1, class Arg2, class Result>
-pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1,Arg2));      // deprecated in C++11, removed in C++17
+pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1,Arg2));   // deprecated in C++11, removed in C++17
 
-template<class S, class T>      // deprecated in C++11, removed in C++17
+template<class S, class T>                                                      // deprecated in C++11, removed in C++17
 class mem_fun_t : public unary_function<T*, S>
 {
 public:
     explicit mem_fun_t(S (T::*p)());
     S operator()(T* p) const;
 };
 
 template<class S, class T, class A>
-class mem_fun1_t : public binary_function<T*, A, S>      // deprecated in C++11, removed in C++17
+class mem_fun1_t : public binary_function<T*, A, S>                             // deprecated in C++11, removed in C++17
 {
 public:
     explicit mem_fun1_t(S (T::*p)(A));
     S operator()(T* p, A x) const;
 };
 
-template<class S, class T>          mem_fun_t<S,T>    mem_fun(S (T::*f)());      // deprecated in C++11, removed in C++17
-template<class S, class T, class A> mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A));     // deprecated in C++11, removed in C++17
+template<class S, class T>          mem_fun_t<S,T>    mem_fun(S (T::*f)());     // deprecated in C++11, removed in C++17
+template<class S, class T, class A> mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A));    // deprecated in C++11, removed in C++17
 
 template<class S, class T>
-class mem_fun_ref_t : public unary_function<T, S>      // deprecated in C++11, removed in C++17
+class mem_fun_ref_t : public unary_function<T, S>                               // deprecated in C++11, removed in C++17
 {
 public:
     explicit mem_fun_ref_t(S (T::*p)());
     S operator()(T& p) const;
 };
 
 template<class S, class T, class A>
-class mem_fun1_ref_t : public binary_function<T, A, S>      // deprecated in C++11, removed in C++17
+class mem_fun1_ref_t : public binary_function<T, A, S>                          // deprecated in C++11, removed in C++17
 {
 public:
     explicit mem_fun1_ref_t(S (T::*p)(A));
     S operator()(T& p, A x) const;
 };
 
-template<class S, class T>          mem_fun_ref_t<S,T>    mem_fun_ref(S (T::*f)());      // deprecated in C++11, removed in C++17
-template<class S, class T, class A> mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A));     // deprecated in C++11, removed in C++17
+template<class S, class T>
+mem_fun_ref_t<S,T>    mem_fun_ref(S (T::*f)());                                 // deprecated in C++11, removed in C++17
+template<class S, class T, class A>
+mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A));                                // deprecated in C++11, removed in C++17
 
 template <class S, class T>
-class const_mem_fun_t : public unary_function<const T*, S>      // deprecated in C++11, removed in C++17
+class const_mem_fun_t : public unary_function<const T*, S>                      // deprecated in C++11, removed in C++17
 {
 public:
     explicit const_mem_fun_t(S (T::*p)() const);
     S operator()(const T* p) const;
 };
 
 template <class S, class T, class A>
-class const_mem_fun1_t : public binary_function<const T*, A, S>      // deprecated in C++11, removed in C++17
+class const_mem_fun1_t : public binary_function<const T*, A, S>                 // deprecated in C++11, removed in C++17
 {
 public:
     explicit const_mem_fun1_t(S (T::*p)(A) const);
     S operator()(const T* p, A x) const;
 };
 
-template <class S, class T>          const_mem_fun_t<S,T>    mem_fun(S (T::*f)() const);      // deprecated in C++11, removed in C++17
-template <class S, class T, class A> const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const);     // deprecated in C++11, removed in C++17
+template <class S, class T>
+const_mem_fun_t<S,T>    mem_fun(S (T::*f)() const);                             // deprecated in C++11, removed in C++17
+template <class S, class T, class A>
+const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const);                            // deprecated in C++11, removed in C++17
 
 template <class S, class T>
-class const_mem_fun_ref_t : public unary_function<T, S>      // deprecated in C++11, removed in C++17
+class const_mem_fun_ref_t : public unary_function<T, S>                         // deprecated in C++11, removed in C++17
 {
 public:
     explicit const_mem_fun_ref_t(S (T::*p)() const);
     S operator()(const T& p) const;
 };
 
 template <class S, class T, class A>
-class const_mem_fun1_ref_t : public binary_function<T, A, S>      // deprecated in C++11, removed in C++17
+class const_mem_fun1_ref_t : public binary_function<T, A, S>                    // deprecated in C++11, removed in C++17
 {
 public:
     explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
     S operator()(const T& p, A x) const;
 };
 
-template <class S, class T>          const_mem_fun_ref_t<S,T>    mem_fun_ref(S (T::*f)() const);   // deprecated in C++11, removed in C++17
-template <class S, class T, class A> const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const);  // deprecated in C++11, removed in C++17
+template <class S, class T>
+const_mem_fun_ref_t<S,T>    mem_fun_ref(S (T::*f)() const);                     // deprecated in C++11, removed in C++17
+template <class S, class T, class A>
+const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const);                    // deprecated in C++11, removed in C++17
 
-template<class R, class T>
-constexpr unspecified mem_fn(R T::*); // constexpr in C++20
+template<class R, class T> constexpr unspecified mem_fn(R T::*);                // constexpr in C++20
 
 class bad_function_call
     : public exception
 {
 };
 
 template<class> class function; // undefined
 

libcxx/include/utility

 template<class T1, class T2, class U1, class U2, template<class> class TQual, template<class> class UQual>
 struct basic_common_reference<pair<T1, T2>, pair<U1, U2>, TQual, UQual>;         // since C++23
 
 template<class T1, class T2, class U1, class U2>
 struct common_type<pair<T1, T2>, pair<U1, U2>>;                                  // since C++23
 
 template<class T1, class T2> pair(T1, T2) -> pair<T1, T2>;
 
-template <class T1, class T2> bool operator==(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
-template <class T1, class T2> bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20
-template <class T1, class T2> bool operator< (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20
-template <class T1, class T2> bool operator> (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20
-template <class T1, class T2> bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20
-template <class T1, class T2> bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20
+template <class T1, class T2>
+bool operator==(const pair<T1,T2>&, const pair<T1,T2>&);                         // constexpr in C++14
+template <class T1, class T2>
+bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&);                         // constexpr in C++14, removed in C++20
+template <class T1, class T2>
+bool operator< (const pair<T1,T2>&, const pair<T1,T2>&);                         // constexpr in C++14, removed in C++20
+template <class T1, class T2>
+bool operator> (const pair<T1,T2>&, const pair<T1,T2>&);                         // constexpr in C++14, removed in C++20
+template <class T1, class T2>
+bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&);                         // constexpr in C++14, removed in C++20
+template <class T1, class T2>
+bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&);                         // constexpr in C++14, removed in C++20
 template <class T1, class T2>
   constexpr common_comparison_type_t<synth-three-way-result<T1>,
                                      synth-three-way-result<T2>>
-    operator<=>(const pair<T1,T2>&, const pair<T1,T2>&);                               // C++20
+    operator<=>(const pair<T1,T2>&, const pair<T1,T2>&);                         // C++20
 
 template <class T1, class T2> pair<V1, V2> make_pair(T1&&, T2&&);                // constexpr in C++14
 template <class T1, class T2>
 void
 swap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));            // constexpr in C++20
 
-template<class T1, class T2>
-constexpr void swap(const pair<T1, T2>& x, const pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));    // since C++23
+template<class T1, class T2>                                                     // since C++23
+constexpr void swap(const pair<T1, T2>& x, const pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));
 
 struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
 inline constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
 
 template <class T> struct tuple_size;
 template <size_t I, class T> struct tuple_element;
 
 template <class T1, class T2> struct tuple_size<pair<T1, T2> >;
template<class T, T N>
   using make_integer_sequence = integer_sequence<T, 0, 1, ..., N-1>;
 template<size_t N>
   using make_index_sequence = make_integer_sequence<size_t, N>;
 
 template<class... T>
   using index_sequence_for = make_index_sequence<sizeof...(T)>;
 
 template<class T, class U=T>
-    constexpr T exchange(T& obj, U&& new_value)
-      noexcept(is_nothrow_move_constructible<T>::value && is_nothrow_assignable<T&, U>::value); // constexpr in C++17, noexcept in C++23
+    constexpr T exchange(T& obj, U&& new_value)                                 // constexpr in C++17, noexcept in C++23
+      noexcept(is_nothrow_move_constructible<T>::value && is_nothrow_assignable<T&, U>::value);
 
 // 20.2.7, in-place construction // C++17
 struct in_place_t {
   explicit in_place_t() = default;
 };
 inline constexpr in_place_t in_place{};
 template <class T>
   struct in_place_type_t {

libcxx/test/.clang-format

+BasedOnStyle: InheritParentConfig
+
+# Disable formatting options which may break tests.
+SortIncludes: false
+ReflowComments: false