Use standard C++20 traits in minmax algorithms as requested by maintainer

Author: dasaneek007-cpu

libs/core/algorithms/include/hpx/parallel/algorithms/minmax.hpp

@@ -403,9 +403,8 @@ namespace hpx::parallel {
             if (count == 0 || count == 1)
                 return it;
 
-            using element_type = hpx::traits::proxy_value_t<
-                std::decay_t<hpx::util::invoke_result_t<Proj,
-                    hpx::traits::iter_reference_t<FwdIter>>>>;
+            using element_type = hpx::traits::proxy_value_t<std::decay_t<
+                std::invoke_result_t<Proj, std::iter_reference_t<FwdIter>>>>;
 
             auto smallest = it;
 
@@ -443,9 +442,8 @@ namespace hpx::parallel {
 
                 auto smallest = *it;
 
-                using element_type = hpx::traits::proxy_value_t<
-                    std::decay_t<hpx::util::invoke_result_t<Proj,
-                        hpx::traits::iter_reference_t<Iter>>>>;
+                using element_type = hpx::traits::proxy_value_t<std::decay_t<
+                    std::invoke_result_t<Proj, std::iter_reference_t<Iter>>>>;
 
                 element_type value = HPX_INVOKE(proj, *smallest);
                 util::loop_n<std::decay_t<ExPolicy>>(
@@ -475,8 +473,8 @@ namespace hpx::parallel {
                     return first;
 
                 using element_type = hpx::traits::proxy_value_t<
-                    std::decay_t<hpx::util::invoke_result_t<Proj,
-                        hpx::traits::iter_reference_t<FwdIter>>>>;
+                    std::decay_t<std::invoke_result_t<Proj,
+                        std::iter_reference_t<FwdIter>>>>;
 
                 auto smallest = first;
 
@@ -558,9 +556,8 @@ namespace hpx::parallel {
             if (count == 0 || count == 1)
                 return it;
 
-            using element_type = hpx::traits::proxy_value_t<
-                std::decay_t<hpx::util::invoke_result_t<Proj,
-                    hpx::traits::iter_reference_t<FwdIter>>>>;
+            using element_type = hpx::traits::proxy_value_t<std::decay_t<
+                std::invoke_result_t<Proj, std::iter_reference_t<FwdIter>>>>;
 
             auto largest = it;
 
@@ -597,9 +594,8 @@ namespace hpx::parallel {
 
                 auto largest = *it;
 
-                using element_type = hpx::traits::proxy_value_t<
-                    std::decay_t<hpx::util::invoke_result_t<Proj,
-                        hpx::traits::iter_reference_t<Iter>>>>;
+                using element_type = hpx::traits::proxy_value_t<std::decay_t<
+                    std::invoke_result_t<Proj, std::iter_reference_t<Iter>>>>;
 
                 element_type value = HPX_INVOKE(proj, *largest);
                 util::loop_n<std::decay_t<ExPolicy>>(
@@ -629,8 +625,8 @@ namespace hpx::parallel {
                     return first;
 
                 using element_type = hpx::traits::proxy_value_t<
-                    std::decay_t<hpx::util::invoke_result_t<Proj,
-                        hpx::traits::iter_reference_t<FwdIter>>>>;
+                    std::decay_t<std::invoke_result_t<Proj,
+                        std::iter_reference_t<FwdIter>>>>;
 
                 auto largest = first;
 
@@ -714,9 +710,8 @@ namespace hpx::parallel {
             if (count == 0 || count == 1)
                 return result;
 
-            using element_type = hpx::traits::proxy_value_t<
-                std::decay_t<hpx::util::invoke_result_t<Proj,
-                    hpx::traits::iter_reference_t<FwdIter>>>>;
+            using element_type = hpx::traits::proxy_value_t<std::decay_t<
+                std::invoke_result_t<Proj, std::iter_reference_t<FwdIter>>>>;
 
             element_type min_value = HPX_INVOKE(proj, *it);
             element_type max_value = min_value;
@@ -756,9 +751,8 @@ namespace hpx::parallel {
                 if (count == 1)
                     return *it;
 
-                using element_type = hpx::traits::proxy_value_t<
-                    std::decay_t<hpx::util::invoke_result_t<Proj,
-                        hpx::traits::iter_reference_t<Iter>>>>;
+                using element_type = hpx::traits::proxy_value_t<std::decay_t<
+                    std::invoke_result_t<Proj, std::iter_reference_t<Iter>>>>;
 
                 auto result = *it;
 
@@ -806,8 +800,8 @@ namespace hpx::parallel {
                 }
 
                 using element_type = hpx::traits::proxy_value_t<
-                    std::decay_t<hpx::util::invoke_result_t<Proj,
-                        hpx::traits::iter_reference_t<FwdIter>>>>;
+                    std::decay_t<std::invoke_result_t<Proj,
+                        std::iter_reference_t<FwdIter>>>>;
 
                 element_type min_value = HPX_INVOKE(proj, *min);
                 element_type max_value = HPX_INVOKE(proj, *max);