Updated async_distributed, collectives, segmented_algorithms to use c++20 concepts

Signed-off-by: Hartmut Kaiser <hartmut.kaiser@gmail.com>

Author: sidhikumari5

libs/core/type_support/include/hpx/type_support/relocate_at.hpp

@@ -89,21 +89,21 @@ namespace hpx::experimental {
 
         // P1144 also proposes a version of relocate that does not call the
         // move constructor and instead memmoves the bytes of src to dest.
-        // 
+        //
         // Giving an interface like:
-        // 
+        //
         //     T dest = relocate(std::addressof(src));
-        // 
+        //
         // That results in a valid T object (dest) without calling any
         // constructor or destructor.
-        // 
+        //
         // This is not possible to do with the current C++ standard.
-        // 
+        //
         // One of the proposed ways to implement this uses a hypothetical
         // attribute "do_not_construct" and NRVO.
-        // 
+        //
         // Implementation:
-        // 
+        //
         // template <class T, std::enable_if_t<relocate_using_memmove<T>, int> = 0>
         // T relocate(T* source)
         // {

libs/full/async_distributed/include/hpx/async_distributed/dataflow.hpp

@@ -1,4 +1,4 @@
-//  Copyright (c) 2007-2022 Hartmut Kaiser
+//  Copyright (c) 2007-2025 Hartmut Kaiser
 //
 //  SPDX-License-Identifier: BSL-1.0
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -115,12 +115,8 @@ namespace hpx { namespace lcos { namespace detail {
 ///////////////////////////////////////////////////////////////////////////////
 namespace hpx {
 
-    // clang-format off
-    template <typename Action, typename F, typename... Ts,
-        HPX_CONCEPT_REQUIRES_(
-            traits::is_action_v<Action> &&
-           !traits::is_launch_policy_v<F>
-        )>
+    template <typename Action, typename F, typename... Ts>
+        requires(traits::is_action_v<Action> && !traits::is_launch_policy_v<F>)
     HPX_DEPRECATED_V(1, 9,
         "hpx::dataflow<Action>(...) is deprecated, use hpx::dataflow(Action{}, "
         "...) instead")
@@ -132,12 +128,8 @@ namespace hpx {
             HPX_FORWARD(Ts, ts)...);
     }
 
-    // clang-format off
-    template <typename Action, typename F, typename... Ts,
-        HPX_CONCEPT_REQUIRES_(
-            traits::is_action_v<Action> &&
-            traits::is_launch_policy_v<F>
-        )>
+    template <typename Action, typename F, typename... Ts>
+        requires(traits::is_action_v<Action> && traits::is_launch_policy_v<F>)
     HPX_DEPRECATED_V(1, 9,
         "hpx::dataflow<Action>(policy, ...) is deprecated, use "
         "hpx::dataflow(policy, Action{}, ...) instead")

libs/full/collectives/include/hpx/collectives/exclusive_scan.hpp

@@ -283,6 +283,7 @@ namespace hpx { namespace collectives {
 #include <hpx/modules/futures.hpp>
 #include <hpx/modules/type_support.hpp>
 
+#include <concepts>
 #include <cstddef>
 #include <type_traits>
 #include <utility>
@@ -356,7 +357,7 @@ namespace hpx::traits {
                         std::vector<T_> dest;
                         dest.resize(data.size());
 
-                        if constexpr (!std::is_same_v<T_, bool>)
+                        if constexpr (!std::same_as<T_, bool>)
                         {
                             collectives::detail::exclusive_scan<T_>(
                                 data.begin(), data.end(), dest.begin(),
@@ -409,7 +410,7 @@ namespace hpx::traits {
                         std::vector<T_> dest;
                         dest.resize(data.size());
 
-                        if constexpr (!std::is_same_v<T_, bool>)
+                        if constexpr (!std::same_as<T_, bool>)
                         {
                             hpx::exclusive_scan(data.begin(), data.end(),
                                 dest.begin(), HPX_FORWARD(Init, init),
@@ -557,7 +558,7 @@ namespace hpx::collectives {
     ////////////////////////////////////////////////////////////////////////////
     // Version of exclusive scan that takes an initial value for element 0.
     template <typename T, typename Init, typename F>
-        requires(!std::is_same_v<this_site_arg, std::decay_t<F>>)
+        requires(!std::same_as<this_site_arg, std::decay_t<F>>)
     hpx::future<std::decay_t<T>> exclusive_scan(communicator fid,
         T&& local_result, Init&& init, F&& op,
         this_site_arg this_site = this_site_arg(),
@@ -621,7 +622,7 @@ namespace hpx::collectives {
     }
 
     template <typename T, typename Init, typename F>
-        requires(!std::is_same_v<generation_arg, std::decay_t<F>>)
+        requires(!std::same_as<generation_arg, std::decay_t<F>>)
     hpx::future<std::decay_t<T>> exclusive_scan(communicator fid,
         T&& local_result, Init&& init, F&& op, generation_arg generation,
         this_site_arg this_site = this_site_arg())
@@ -631,7 +632,7 @@ namespace hpx::collectives {
     }
 
     template <typename T, typename Init, typename F>
-        requires(!std::is_same_v<num_sites_arg, std::decay_t<F>>)
+        requires(!std::same_as<num_sites_arg, std::decay_t<F>>)
     hpx::future<std::decay_t<T>> exclusive_scan(char const* basename,
         T&& local_result, Init&& init, F&& op,
         num_sites_arg const num_sites = num_sites_arg(),
@@ -646,7 +647,7 @@ namespace hpx::collectives {
     }
 
     template <typename T, typename Init, typename F>
-        requires(!std::is_same_v<this_site_arg, std::decay_t<F>>)
+        requires(!std::same_as<this_site_arg, std::decay_t<F>>)
     decltype(auto) exclusive_scan(hpx::launch::sync_policy, communicator fid,
         T&& local_result, Init&& init, F&& op,
         this_site_arg const this_site = this_site_arg(),
@@ -658,7 +659,7 @@ namespace hpx::collectives {
     }
 
     template <typename T, typename Init, typename F>
-        requires(!std::is_same_v<generation_arg, std::decay_t<F>>)
+        requires(!std::same_as<generation_arg, std::decay_t<F>>)
     decltype(auto) exclusive_scan(hpx::launch::sync_policy, communicator fid,
         T&& local_result, Init&& init, F&& op, generation_arg const generation,
         this_site_arg const this_site = this_site_arg())
@@ -669,7 +670,7 @@ namespace hpx::collectives {
     }
 
     template <typename T, typename Init, typename F>
-        requires(!std::is_same_v<num_sites_arg, std::decay_t<F>>)
+        requires(!std::same_as<num_sites_arg, std::decay_t<F>>)
     decltype(auto) exclusive_scan(hpx::launch::sync_policy,
         char const* basename, T&& local_result, Init&& init, F&& op,
         num_sites_arg const num_sites = num_sites_arg(),

libs/full/collectives/include/hpx/collectives/spmd_block.hpp

@@ -336,8 +336,8 @@ namespace hpx { namespace lcos {
         };
     }    // namespace detail
 
-    template <typename F, typename... Args,
-        HPX_CONCEPT_REQUIRES_(hpx::traits::is_action<F>::value)>
+    template <typename F, typename... Args>
+        requires(hpx::traits::is_action_v<F>)
     hpx::future<void> define_spmd_block(std::string&& name,
         std::size_t images_per_locality, F&& /* f */, Args&&... args)
     {
@@ -370,4 +370,5 @@ namespace hpx { namespace lcos {
             HPX_FORWARD(Args, args)...);
     }
 }}    // namespace hpx::lcos
+
 #endif

libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/adjacent_difference.hpp

@@ -1,6 +1,6 @@
 //  Copyright (c) 2017 Ajai V George
 //  Copyright (c) 2021 Karame M.Shokooh
-//  Copyright (c) 2024 Hartmut Kaiser
+//  Copyright (c) 2024-2025 Hartmut Kaiser
 //
 //  SPDX-License-Identifier: BSL-1.0
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -246,17 +246,13 @@ namespace hpx::parallel {
 // The segmented iterators we support all live in namespace hpx::segmented
 namespace hpx::segmented {
 
-    // clang-format off
     template <typename ExPolicy, typename FwdIter1, typename FwdIter2,
-        typename Op,
-        HPX_CONCEPT_REQUIRES_(
-            hpx::is_execution_policy_v<ExPolicy> &&
+        typename Op>
+        requires(hpx::is_execution_policy_v<ExPolicy> &&
             hpx::traits::is_iterator_v<FwdIter1> &&
             hpx::traits::is_segmented_iterator_v<FwdIter1> &&
             hpx::traits::is_iterator_v<FwdIter2> &&
-            hpx::traits::is_segmented_iterator_v<FwdIter2>
-        )>
-    // clang-format on
+            hpx::traits::is_segmented_iterator_v<FwdIter2>)
     hpx::parallel::util::detail::algorithm_result_t<ExPolicy, FwdIter2>
     tag_invoke(hpx::adjacent_difference_t, ExPolicy&& policy, FwdIter1 first,
         FwdIter1 last, FwdIter2 dest, Op&& op)
@@ -284,15 +280,11 @@ namespace hpx::segmented {
             HPX_FORWARD(Op, op), is_seq());
     }
 
-    // clang-format off
-    template <typename InIter1, typename InIter2, typename Op,
-        HPX_CONCEPT_REQUIRES_(
-            hpx::traits::is_iterator_v<InIter1> &&
+    template <typename InIter1, typename InIter2, typename Op>
+        requires(hpx::traits::is_iterator_v<InIter1> &&
             hpx::traits::is_segmented_iterator_v<InIter1> &&
             hpx::traits::is_iterator_v<InIter2> &&
-            hpx::traits::is_segmented_iterator_v<InIter2>
-        )>
-    // clang-format on
+            hpx::traits::is_segmented_iterator_v<InIter2>)
     InIter2 tag_invoke(hpx::adjacent_difference_t, InIter1 first, InIter1 last,
         InIter2 dest, Op&& op)
     {

libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/adjacent_find.hpp

@@ -1,4 +1,5 @@
 //  Copyright (c) 2017 Ajai V George
+//  Copyright (c) 2025 Hartmut Kaiser
 //
 //  SPDX-License-Identifier: BSL-1.0
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -274,18 +275,13 @@ namespace hpx::parallel {
 // The segmented iterators we support all live in namespace hpx::segmented
 namespace hpx::segmented {
 
-    // clang-format off
-    template<typename InIter,
-        typename Pred,
-        HPX_CONCEPT_REQUIRES_(
-            hpx::traits::is_iterator<InIter>::value &&
-            hpx::traits::is_segmented_iterator<InIter>::value
-        )>
-    // clang-format on
+    template <typename InIter, typename Pred>
+        requires(hpx::traits::is_iterator_v<InIter> &&
+            hpx::traits::is_segmented_iterator_v<InIter>)
     InIter tag_invoke(
         hpx::adjacent_find_t, InIter first, InIter last, Pred&& pred = Pred())
     {
-        static_assert((hpx::traits::is_input_iterator<InIter>::value),
+        static_assert((hpx::traits::is_input_iterator_v<InIter>),
             "Requires at least input iterator.");
 
         if (first == last)
@@ -303,21 +299,15 @@ namespace hpx::segmented {
             hpx::identity_v, std::true_type());
     }
 
-    // clang-format off
-    template<typename ExPolicy, typename SegIter,
-        typename Pred,
-        HPX_CONCEPT_REQUIRES_(
-            hpx::is_execution_policy_v<ExPolicy> &&
+    template <typename ExPolicy, typename SegIter, typename Pred>
+        requires(hpx::is_execution_policy_v<ExPolicy> &&
             hpx::traits::is_iterator_v<SegIter> &&
-            hpx::traits::is_segmented_iterator_v<SegIter>
-        )>
-    // clang-format on
-    typename hpx::parallel::util::detail::algorithm_result<ExPolicy,
-        SegIter>::type
+            hpx::traits::is_segmented_iterator_v<SegIter>)
+    hpx::parallel::util::detail::algorithm_result_t<ExPolicy, SegIter>
     tag_invoke(hpx::adjacent_find_t, ExPolicy&& policy, SegIter first,
         SegIter last, Pred&& pred)
     {
-        static_assert((hpx::traits::is_forward_iterator<SegIter>::value),
+        static_assert((hpx::traits::is_forward_iterator_v<SegIter>),
             "Requires at least forward iterator.");
 
         using is_seq = hpx::is_sequenced_execution_policy<ExPolicy>;