Remove template diamond when unneeded

Author: Morwenn

README.md

@@ -69,8 +69,8 @@ int main()
     > sorter;
 
     // Sort li and vec in reverse order using their value member
-    sorter(li, std::greater<>{}, &wrapper::value);
-    sorter(vec, std::greater<>{}, &wrapper::value);
+    sorter(li, std::greater{}, &wrapper::value);
+    sorter(vec, std::greater{}, &wrapper::value);
 
     assert(std::equal(
         li.begin(), li.end(),

docs/Comparator-adapters.md

@@ -103,7 +103,7 @@ It is accompanied by a `make_projection_compare` function template to avoid havi
 ```cpp
 // Sort a family from older to younger member
 std::vector<Person> family = { /* ... */ };
-std::sort(family.begin(), family.end(), cppsort::make_projection_compare(std::greater<>{}, &Person::age));
+std::sort(family.begin(), family.end(), cppsort::make_projection_compare(std::greater{}, &Person::age));
 ```
 
 `projection_compare<C, P>` has the following member functions:

docs/Library-nomenclature.md

@@ -8,7 +8,7 @@
 
 * *Comparison function*: most of the sorting algorithms in the library are comparison sorts. It means that the algorithm uses a comparison function to know the order of the elements and sort them accordingly; such a comparison function shall take two values and have a return type convertible to `bool`. The available sorting algorithms transform comparison functions on the fly so that some pointers to member functions can also be used as comparison functions, as if called with [`std::invoke`][std-invoke]. The default comparison function used by the sorting algorithms is [`std::less<>`][std-less-void]. Many sorters can take a comparison function as an additional parameter. For example, using `std::greater<>` instead of the default comparison function would sort a collection in descending order.
 
-        cppsort::heap_sort(collection, std::greater<>{});
+        cppsort::heap_sort(collection, std::greater{});
 
     Some algorithms don't accept such an additional parameter. It may be because they implement a non-comparison sort instead, a sorting algorithm that uses other properties of the elements to perform the sort rather than a comparison function (for example a [radix sort][radix-sort]).
 
@@ -43,7 +43,7 @@
 * *Sorter*: [sorters][sorters] are the protagonists in this library. They are function objects implementing specific sorting algorithms. Their `operator()` is overloaded so that it can handle iterables or pairs of iterators, and conditionally overloaded so that it can handle user-provided comparison and/or projection functions (see *unified sorting interface*).
 
         cppsort::pdq_sorter{}(std::begin(collection), std::end(collection),
-                              std::greater<>{}, &wrapper::value);
+                              std::greater{}, &wrapper::value);
 
 * *Sorter adapter*: [sorter adapters][sorter-adapters] are class templates that take one or several sorters and produce a new sorter from the parameters. What a sorter adapter can do is not constrained, but they are generally expected to behave like sorters themselves. For example, **cpp-sort** contains adapters to count the number of comparisons performed by a sorting algorithms or to aggregate several sorters together. The best way to learn more about them is still to read the dedicated section of the documentation.
 

docs/Measures-of-presortedness.md

@@ -43,8 +43,8 @@ In **cpp-sort**, measures of presortedness are implemented as instances of some
 using namespace cppsort;
 auto a = probe::inv(collection);
 auto b = probe::rem(vec.begin(), vec.end());
-auto c = probe::ham(li, std::greater<>{});
-auto d = probe::runs(integers, std::negate<>{});
+auto c = probe::ham(li, std::greater{});
+auto d = probe::runs(integers, std::negate{});
 ```
 
 Note however that most of these algorithms can be expensive. Using them before an actual sorting algorithm has little interest if any. They are instead meant to be profiling tools: when sorting is a critical part of your application, you can use these measures on typical data and check whether it is mostly sorted according to one measure or another, then you may be able to find a sorting algorithm known to be optimal with regard to this specific measure.

docs/Quickstart.md

@@ -51,11 +51,11 @@ int main()
     // Sort using operator<(Person, Person)
     quick_sort(persons);
     // Sort in reverse order usinig operator<(Person, Person)
-    quick_sort(persons, cppsort::flip(std::less<>{}));
+    quick_sort(persons, cppsort::flip(std::less{}));
     // Sort the first half of the collection from youngest to oldest
     quick_sort(std::begin(persons), persons+50, &Person::age);
     // Sort the second half of the collection from older to youngest
-    quick_sort(persons+50, std::end(persons), std::greater<>{}, &Person::age);
+    quick_sort(persons+50, std::end(persons), std::greater{}, &Person::age);
 
     std::list<Person> li(std::begin(persons), std::end(persons));
     // quick_sort also works on bidirectional (and forward) iterators

docs/Writing-a-sorter.md

@@ -153,7 +153,7 @@ This kind of comparison sorters help to compare things that don't have an overlo
 
 ```cpp
 // Sort collection in reverse order with std::sort
-cppsort::std_sort(collection, std::greater<>{});
+cppsort::std_sort(collection, std::greater{});
 ```
 
 It is worth noting that every *comparison sorter* provided by the library transforms the comparison parameter with [`utility::as_function`][utility-as-function] before actually using it. It allows to use pointers to member functions of the `lhs.compare_to(rhs)` kind out-of-the-box.
@@ -278,7 +278,7 @@ struct counting_sorter_impl
 Until there, everything is fine. However, imagine that the library where we found the `counting_sort` function also provides its evil twin, to which we will give the inventive name of `reverse_counting_sort`, meant to sort a collection of integers in descending order. We would like to take advantage of this function too, but all the rules defined in the previous sections make it pretty clear that we can't write a `reverse_counting_sorter` since such a sorter wouldn't satisfy the `std::is_sorted` guarantee that every sorter should satisfy. Note however that, after having reverse-sorted a collection of integers, the following assertion should hold:
 
 ```cpp
-assert( std::is_sorted(std::begin(collection), std::end(collection), std::greater<>{}) );
+assert( std::is_sorted(std::begin(collection), std::end(collection), std::greater{}) );
 ```
 
 We would like our `counting_sorter` to reverse-sort a collection when given `std::greater<>` as a comparison function, but there is no way it can handle arbitrary comparison functions. Well... let's just make it handle specific comparison functions then:

examples/bubble_sorter.cpp

@@ -121,6 +121,6 @@ int main()
         // Bubble sort the collection
         bubble_sort(to_sort, projection);
         // Check that it is sorted in descending order
-        assert(std::is_sorted(to_sort.begin(), to_sort.end(), std::greater<>{}));
+        assert(std::is_sorted(to_sort.begin(), to_sort.end(), std::greater{}));
     } while (std::next_permutation(collection.begin(), collection.end()));
 }

examples/readme_example.cpp

@@ -25,8 +25,8 @@ int main()
     > sorter;
 
     // Sort li and vec in reverse order using their value member
-    sorter(li, std::greater<>{}, &wrapper::value);
-    sorter(vec, std::greater<>{}, &wrapper::value);
+    sorter(li, std::greater{}, &wrapper::value);
+    sorter(vec, std::greater{}, &wrapper::value);
 
     assert(std::equal(
         li.begin(), li.end(),

include/cpp-sort/adapters/container_aware_adapter.h

@@ -201,12 +201,12 @@ namespace cppsort
                         Stability,
                         std::false_type,
                         decltype(detail::adl_despair{}(this->get(), iterable,
-                                                       std::less<>{}, std::move(projection)))
+                                                       std::less{}, std::move(projection)))
                     >
                 >
             {
                 return detail::adl_despair{}(this->get(), iterable,
-                                             std::less<>{}, std::move(projection));
+                                             std::less{}, std::move(projection));
             }
 
             template<
@@ -227,12 +227,12 @@ namespace cppsort
                         Stability,
                         std::false_type,
                         decltype(detail::adl_despair{}(this->get(), iterable,
-                                                       make_projection_compare(std::less<>{}, std::move(projection))))
+                                                       make_projection_compare(std::less{}, std::move(projection))))
                     >
                 >
             {
                 return detail::adl_despair{}(this->get(), iterable,
-                                             make_projection_compare(std::less<>{}, std::move(projection)));
+                                             make_projection_compare(std::less{}, std::move(projection)));
             }
 
             template<

include/cpp-sort/detail/container_aware/insertion_sort.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2021 Morwenn
+ * Copyright (c) 2016-2025 Morwenn
  * SPDX-License-Identifier: MIT
  */
 #ifndef CPPSORT_DETAIL_CONTAINER_AWARE_INSERTION_SORT_H_
@@ -116,7 +116,7 @@ namespace cppsort
         auto operator()(std::list<Args...>& iterable) const
             -> void
         {
-            detail::list_insertion_sort(iterable, std::less<>{}, utility::identity{});
+            detail::list_insertion_sort(iterable, std::less{}, utility::identity{});
         }
 
         template<typename Compare, typename... Args>
@@ -134,7 +134,7 @@ namespace cppsort
                 is_projection_v<Projection, std::list<Args...>>
             >
         {
-            detail::list_insertion_sort(iterable, std::less<>{}, std::move(projection));
+            detail::list_insertion_sort(iterable, std::less{}, std::move(projection));
         }
 
         template<
@@ -159,7 +159,7 @@ namespace cppsort
         auto operator()(std::forward_list<Args...>& iterable) const
             -> void
         {
-            detail::flist_insertion_sort(iterable, std::less<>{}, utility::identity{});
+            detail::flist_insertion_sort(iterable, std::less{}, utility::identity{});
         }
 
         template<typename Compare, typename... Args>
@@ -177,7 +177,7 @@ namespace cppsort
                 is_projection_v<Projection, std::forward_list<Args...>>
             >
         {
-            detail::flist_insertion_sort(iterable, std::less<>{}, std::move(projection));
+            detail::flist_insertion_sort(iterable, std::less{}, std::move(projection));
         }
 
         template<