Fix element_type initialization logic for parallel projections

The parallel implementations of min_element, max_element, and
minmax_element previously deduced element_type solely from the
underlying iterator, ignoring the projection. This resulted in hard
initialization failures when projections returned a different type
than the iterator's value type, causing CI to break when the SFINAE
paths instantiated the tag_invoke dispatch bodies for parallel executions.

By explicitly inferring element_type directly from the decayed
decltype mapped to the projection invocation, the element_type
now robustly propagates and enables projection polymorphism.

Author: dasaneek007-cpu

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

@@ -404,11 +404,11 @@ namespace hpx::parallel {
             if (count == 0 || count == 1)
                 return it;
 
-            using element_type = hpx::traits::proxy_value_t<
-                typename std::iterator_traits<FwdIter>::value_type>;
-
             auto smallest = it;
 
+            using element_type = hpx::traits::proxy_value_t<
+                std::decay_t<decltype(HPX_INVOKE(proj, *smallest))>>;
+
             element_type value = HPX_INVOKE(proj, *smallest);
             util::loop_n<std::decay_t<ExPolicy>>(
                 ++it, count - 1, [&](FwdIter const& curr) -> void {
@@ -443,9 +443,8 @@ namespace hpx::parallel {
 
                 auto smallest = *it;
 
-                using element_type =
-                    hpx::traits::proxy_value_t<typename std::iterator_traits<
-                        decltype(smallest)>::value_type>;
+                using element_type = hpx::traits::proxy_value_t<
+                    std::decay_t<decltype(HPX_INVOKE(proj, *smallest))>>;
 
                 element_type value = HPX_INVOKE(proj, *smallest);
                 util::loop_n<std::decay_t<ExPolicy>>(
@@ -474,11 +473,11 @@ namespace hpx::parallel {
                 if (first == last)
                     return first;
 
-                using element_type = hpx::traits::proxy_value_t<
-                    typename std::iterator_traits<FwdIter>::value_type>;
-
                 auto smallest = first;
 
+                using element_type = hpx::traits::proxy_value_t<
+                    std::decay_t<decltype(HPX_INVOKE(proj, *smallest))>>;
+
                 element_type value = HPX_INVOKE(proj, *smallest);
                 util::loop(HPX_FORWARD(ExPolicy, policy), ++first, last,
                     [&](FwdIter const& curr) -> void {
@@ -557,11 +556,11 @@ namespace hpx::parallel {
             if (count == 0 || count == 1)
                 return it;
 
-            using element_type = hpx::traits::proxy_value_t<
-                typename std::iterator_traits<FwdIter>::value_type>;
-
             auto largest = it;
 
+            using element_type = hpx::traits::proxy_value_t<
+                std::decay_t<decltype(HPX_INVOKE(proj, *largest))>>;
+
             element_type value = HPX_INVOKE(proj, *largest);
             util::loop_n<std::decay_t<ExPolicy>>(
                 ++it, count - 1, [&](FwdIter const& curr) -> void {
@@ -596,9 +595,8 @@ namespace hpx::parallel {
 
                 auto largest = *it;
 
-                using element_type =
-                    hpx::traits::proxy_value_t<typename std::iterator_traits<
-                        decltype(largest)>::value_type>;
+                using element_type = hpx::traits::proxy_value_t<
+                    std::decay_t<decltype(HPX_INVOKE(proj, *largest))>>;
 
                 element_type value = HPX_INVOKE(proj, *largest);
                 util::loop_n<std::decay_t<ExPolicy>>(
@@ -627,11 +625,11 @@ namespace hpx::parallel {
                 if (first == last)
                     return first;
 
-                using element_type = hpx::traits::proxy_value_t<
-                    typename std::iterator_traits<FwdIter>::value_type>;
-
                 auto largest = first;
 
+                using element_type = hpx::traits::proxy_value_t<
+                    std::decay_t<decltype(HPX_INVOKE(proj, *largest))>>;
+
                 element_type value = HPX_INVOKE(proj, *largest);
                 util::loop(HPX_FORWARD(ExPolicy, policy), ++first, last,
                     [&](FwdIter const& curr) -> void {
@@ -713,7 +711,7 @@ namespace hpx::parallel {
                 return result;
 
             using element_type = hpx::traits::proxy_value_t<
-                typename std::iterator_traits<FwdIter>::value_type>;
+                std::decay_t<decltype(HPX_INVOKE(proj, *it))>>;
 
             element_type min_value = HPX_INVOKE(proj, *it);
             element_type max_value = min_value;
@@ -754,11 +752,11 @@ namespace hpx::parallel {
                 if (count == 1)
                     return *it;
 
-                using element_type = hpx::traits::proxy_value_t<
-                    typename std::iterator_traits<Iter>::value_type>;
-
                 auto result = *it;
 
+                using element_type = hpx::traits::proxy_value_t<
+                    std::decay_t<decltype(HPX_INVOKE(proj, *result.min))>>;
+
                 element_type min_value = HPX_INVOKE(proj, *result.min);
                 element_type max_value = HPX_INVOKE(proj, *result.max);
                 util::loop_n<std::decay_t<ExPolicy>>(
@@ -803,7 +801,7 @@ namespace hpx::parallel {
                 }
 
                 using element_type = hpx::traits::proxy_value_t<
-                    typename std::iterator_traits<FwdIter>::value_type>;
+                    std::decay_t<decltype(HPX_INVOKE(proj, *min))>>;
 
                 element_type min_value = HPX_INVOKE(proj, *min);
                 element_type max_value = HPX_INVOKE(proj, *max);