Rename make_projection_compare in projection_compare

Author: Morwenn

docs/Comparator-adapters.md

@@ -44,7 +44,7 @@ constexpr auto base() const
 `cppsort::flip` takes a *Callable* `f` of type `F` and returns an instance of `flip_t<std::decay_t<F>>` except in the following cases:
 * When given a `flip_t<F>`, it returns a `F`.
 * When given a `not_fn_t<flip_t<F>>`, it returns a `not_fn_t<F>`.
-* When given a `projection_compare` it returns `make_projection_compare(flip(f.comparison()), f.projection())`.
+* When given a `projection_compare_t` it returns `projection_compare(flip(f.comparison()), f.projection())`.
 
 `flip_t<F>` is [*transparent*][transparent-func] when `F` is *transparent*.
 
@@ -82,7 +82,7 @@ constexpr auto base() const
 `cppsort::not_fn` takes a *Callable* `f` of type `F` and returns an instance of `not_fn_t<std::decay_t<F>>` except in the following cases:
 * When given a `not_fn_t<F>`, it returns a `F`.
 * When given a `flip_t<not_fn_t<F>>`, it returns a `flip_t<F>`.
-* When given a `projection_compare` it returns `make_projection_compare(not_fn(f.comparison()), f.projection())`.
+* When given a `projection_compare_t` it returns `projection_compare(not_fn(f.comparison()), f.projection())`.
 
 `not_fn_t<F>` is [*transparent*][transparent-func] when `F` is *transparent*.
 
@@ -94,24 +94,24 @@ constexpr auto base() const
 #include <cpp-sort/comparators/projection_compare.h>
 ```
 
-The class template `projection_compare` can be used to embed a comparison and a projection in a single comparison object, allowing to provide projection support to algorithms that only support comparisons, such as standard library algorithms prior to C++20. Both the passed comparison and projection functions can be [*Callable*][callable].
+The class template `projection_compare_t` can be used to embed a comparison and a projection in a single comparison object, allowing to provide projection support to algorithms that only support comparisons, such as standard library algorithms prior to C++20. Both the passed comparison and projection functions can be [*Callable*][callable].
 
-It is accompanied by a `make_projection_compare` function template to avoid having to pass the template parameters by hand.
+It is accompanied by a `projection_compare` function template to avoid having to pass the template parameters by hand, and to perform a few optimizations.
 
 **Example:**
 
 ```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::projection_compare(std::greater{}, &Person::age));
 ```
 
-`projection_compare<C, P>` has the following member functions:
+`projection_compare_t<C, P>` has the following member functions:
 
 ```cpp
 // Construction
-projection_compare() = default;
-projection_compare(C comp, P proj);
+projection_compare_t() = default;
+projection_compare_t(C comp, P proj);
 
 // Call
 template<typename T1, typename T2>
@@ -132,12 +132,12 @@ constexpr auto projection() const
     -> P;
 ```
 
-`cppsort::make_projection_compare` takes two *Callable* of types `C` and `P` and returns an instance of `projection_compare<std::decay_t<C>, std::decay_t<P>>` except in the following cases:
+`cppsort::projection_compare` takes two *Callable* types `C` and `P` and returns an instance of `projection_compare_t<std::decay_t<C>, std::decay_t<P>>` except in the following cases:
 * When `std::decay_t<P>` is of type [`utility::identity`][utility-identity] or [`std::identity`][std-identity], it returns `C` directly.
 
-`projection_compare` is [*transparent*][transparent-func] when the passed comparison and projection are both *transparent*.
+`projection_compare_t` is [*transparent*][transparent-func] when the passed comparison and projection are both *transparent*.
 
-`projection_compare` is considered [branchless][branchless-traits] when the projection it wraps is considered branchless and the comparison it wraps is considered branchless when called with the result of the projection.
+`projection_compare_t` is considered [branchless][branchless-traits] when the projection it wraps is considered branchless and the comparison it wraps is considered branchless when called with the result of the projection.
 
 *New in version 1.9.0*
 

include/cpp-sort/adapters/container_aware_adapter.h

@@ -221,18 +221,18 @@ namespace cppsort
                     detail::can_comparison_sort<
                         Sorter,
                         Iterable,
-                        projection_compare<std::less<>, Projection>
+                        projection_compare_t<std::less<>, Projection>
                     >::value,
                     conditional_t<
                         Stability,
                         std::false_type,
                         decltype(detail::adl_despair{}(this->get(), iterable,
-                                                       make_projection_compare(std::less{}, std::move(projection))))
+                                                       projection_compare(std::less{}, std::move(projection))))
                     >
                 >
             {
                 return detail::adl_despair{}(this->get(), iterable,
-                                             make_projection_compare(std::less{}, std::move(projection)));
+                                             projection_compare(std::less{}, std::move(projection)));
             }
 
             template<
@@ -248,7 +248,7 @@ namespace cppsort
                     not detail::can_comparison_sort<
                         Sorter,
                         Iterable,
-                        projection_compare<std::less<>, Projection>
+                        projection_compare_t<std::less<>, Projection>
                     >::value,
                     conditional_t<
                         Stability,
@@ -293,18 +293,18 @@ namespace cppsort
                     detail::can_comparison_sort<
                         Sorter,
                         Iterable,
-                        projection_compare<Compare, Projection>
+                        projection_compare_t<Compare, Projection>
                     >::value,
                     conditional_t<
                         Stability,
                         std::false_type,
                         decltype(detail::adl_despair{}(this->get(), iterable,
-                                                       make_projection_compare(std::move(compare), std::move(projection))))
+                                                       projection_compare(std::move(compare), std::move(projection))))
                     >
                 >
             {
                 return detail::adl_despair{}(this->get(), iterable,
-                                             make_projection_compare(std::move(compare), std::move(projection)));
+                                             projection_compare(std::move(compare), std::move(projection)));
             }
 
             template<
@@ -319,7 +319,7 @@ namespace cppsort
                     not detail::can_comparison_sort<
                         Sorter,
                         Iterable,
-                        projection_compare<Compare, Projection>
+                        projection_compare_t<Compare, Projection>
                     >::value,
                     conditional_t<
                         Stability,

include/cpp-sort/comparators/flip.h

@@ -19,7 +19,7 @@ namespace cppsort
     template<typename F>
     struct not_fn_t;
     template<typename F1, typename F2>
-    class projection_compare;
+    class projection_compare_t;
 
     ////////////////////////////////////////////////////////////
     // flip_t
@@ -153,13 +153,13 @@ namespace cppsort
         };
 
         template<typename F1, typename F2>
-        struct flip_impl<projection_compare<F1, F2>>
+        struct flip_impl<projection_compare_t<F1, F2>>
         {
-            using type = projection_compare<
+            using type = projection_compare_t<
                 typename detail::flip_impl<F1>::type, F2
             >;
 
-            static constexpr auto construct(const projection_compare<F1, F2>& func)
+            static constexpr auto construct(const projection_compare_t<F1, F2>& func)
                 -> type
             {
                 return type(

include/cpp-sort/comparators/not_fn.h

@@ -18,7 +18,7 @@ namespace cppsort
     template<typename F>
     struct flip_t;
     template<typename F1, typename F2>
-    class projection_compare;
+    class projection_compare_t;
 
     ////////////////////////////////////////////////////////////
     // not_fn_t
@@ -152,13 +152,13 @@ namespace cppsort
         };
 
         template<typename F1, typename F2>
-        struct not_fn_impl<projection_compare<F1, F2>>
+        struct not_fn_impl<projection_compare_t<F1, F2>>
         {
-            using type = projection_compare<
+            using type = projection_compare_t<
                 typename detail::not_fn_impl<F1>::type, F2
             >;
 
-            static constexpr auto construct(const projection_compare<F1, F2>& func)
+            static constexpr auto construct(const projection_compare_t<F1, F2>& func)
                 -> type
             {
                 return type(

include/cpp-sort/comparators/projection_compare.h

@@ -19,7 +19,7 @@
 namespace cppsort
 {
     template<typename Compare, typename Projection>
-    class projection_compare:
+    class projection_compare_t:
         public detail::raw_check_is_transparent<Compare, Projection>
     {
         private:
@@ -28,9 +28,9 @@ namespace cppsort
 
         public:
 
-            projection_compare() = default;
+            projection_compare_t() = default;
 
-            projection_compare(Compare compare, Projection projection):
+            projection_compare_t(Compare compare, Projection projection):
                 data(std::move(compare), std::move(projection))
             {}
 
@@ -117,14 +117,14 @@ namespace cppsort
     };
 
     ////////////////////////////////////////////////////////////
-    // Helper for projection_compare construction
+    // Helper for projection_compare_t construction
 
     namespace detail
     {
         template<typename Compare, typename Projection>
         struct proj_comp_impl
         {
-            using type = projection_compare<Compare, Projection>;
+            using type = projection_compare_t<Compare, Projection>;
 
             template<typename C, typename P>
             static constexpr auto construct(C&& comp, P&& proj)
@@ -174,10 +174,10 @@ namespace cppsort
     }
 
     ////////////////////////////////////////////////////////////
-    // make_projection_compare
+    // projection_compare
 
     template<typename Compare, typename Projection>
-    constexpr auto make_projection_compare(Compare&& compare, Projection&& projection)
+    constexpr auto projection_compare(Compare&& compare, Projection&& projection)
         -> typename detail::proj_comp_impl<std::decay_t<Compare>, std::decay_t<Projection>>::type
     {
         return detail::proj_comp_impl<std::decay_t<Compare>, std::decay_t<Projection>>::construct(
@@ -188,7 +188,7 @@ namespace cppsort
     namespace utility
     {
         template<typename Compare, typename Projection, typename T>
-        struct is_probably_branchless_comparison<projection_compare<Compare, Projection>, T>:
+        struct is_probably_branchless_comparison<projection_compare_t<Compare, Projection>, T>:
             std::conjunction<
                 is_probably_branchless_projection<Projection, T>,
                 is_probably_branchless_comparison<

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

@@ -80,14 +80,14 @@ namespace cppsort
                 if (lists.size() % 2 != 0) {
                     auto last_it = std::prev(lists.end());
                     auto last_1_it = std::prev(last_it);
-                    last_1_it->merge(*last_it, make_projection_compare(comp, proj));
+                    last_1_it->merge(*last_it, projection_compare(comp, proj));
                     lists.pop_back();
                 }
 
                 auto first_it = lists.begin();
                 auto half_it = first_it + lists.size() / 2;
                 while (half_it != lists.end()) {
-                    first_it->merge(*half_it, make_projection_compare(comp, proj));
+                    first_it->merge(*half_it, projection_compare(comp, proj));
                     ++first_it;
                     ++half_it;
                 }
@@ -172,14 +172,14 @@ namespace cppsort
                 if (lists.size() % 2 != 0) {
                     auto last_it = std::prev(lists.end());
                     auto last_1_it = std::prev(last_it);
-                    last_1_it->list.merge(last_it->list, make_projection_compare(comp, proj));
+                    last_1_it->list.merge(last_it->list, projection_compare(comp, proj));
                     lists.pop_back();
                 }
 
                 auto first_it = lists.begin();
                 auto half_it = first_it + lists.size() / 2;
                 while (half_it != lists.end()) {
-                    first_it->list.merge(half_it->list, make_projection_compare(comp, proj));
+                    first_it->list.merge(half_it->list, projection_compare(comp, proj));
                     ++first_it;
                     ++half_it;
                 }

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

@@ -42,8 +42,8 @@ namespace cppsort
             // Recursively sort, then merge
             list_merge_sort(left, compare, projection);
             list_merge_sort(collection, compare, projection);
-            collection.merge(std::move(left), make_projection_compare(std::move(compare),
-                                                                      std::move(projection)));
+            collection.merge(std::move(left), projection_compare(std::move(compare),
+                                                                 std::move(projection)));
         }
 
         template<typename Compare, typename Projection,
@@ -63,8 +63,8 @@ namespace cppsort
             // Recursively sort, then merge
             flist_merge_sort(left, size / 2, compare, projection);
             flist_merge_sort(collection, size - size / 2, compare, projection);
-            collection.merge(std::move(left), make_projection_compare(std::move(compare),
-                                                                      std::move(projection)));
+            collection.merge(std::move(left), projection_compare(std::move(compare),
+                                                                 std::move(projection)));
         }
     }