for each test 1

Author: Sai Charan

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

@@ -324,6 +324,14 @@ namespace hpx::parallel {
                 util::loop_n<execution_policy_type>(part_begin, part_size,
                     util::invoke_projected_ind<fun_type, proj_type>{f_, proj_});
             }
+
+            // Overload for stdexec bulk: receives single index
+            // called when using stdexec bulk with a single size_t index
+            HPX_HOST_DEVICE HPX_FORCEINLINE constexpr void operator()(
+                std::size_t idx)
+            {
+                HPX_INVOKE(f_, HPX_INVOKE(proj_, idx));
+            }
         };
 
         template <typename ExPolicy, typename F>
@@ -390,6 +398,14 @@ namespace hpx::parallel {
             {
                 return (*this)(part_begin, part_size);
             }
+
+            // Overload for stdexec bulk: receives single index
+            // called when using stdexec bulk with a single size_t index
+            HPX_HOST_DEVICE HPX_FORCEINLINE constexpr void operator()(
+                std::size_t idx)
+            {
+                HPX_INVOKE(f_, idx);
+            }
         };
 
         ///////////////////////////////////////////////////////////////////////

libs/core/algorithms/include/hpx/parallel/util/detail/partitioner_iteration.hpp

@@ -16,19 +16,45 @@
 ///////////////////////////////////////////////////////////////////////////////
 namespace hpx::parallel::util::detail {
 
+    // Helper to detect if a type is tuple-like
+    template <typename T, typename = void>
+    struct is_tuple_like : std::false_type
+    {
+    };
+
+    template <typename T>
+    struct is_tuple_like<T,
+        std::void_t<decltype(hpx::tuple_size<std::decay_t<T>>::value)>>
+      : std::true_type
+    {
+    };
+
+    template <typename T>
+    inline constexpr bool is_tuple_like_v = is_tuple_like<T>::value;
+
     // Hand-crafted function object allowing to replace a more complex
     // bind(hpx::functional::invoke_fused(), f1, _1)
     template <typename Result, typename F>
     struct partitioner_iteration
     {
         std::decay_t<F> f_;
 
-        template <typename T>
+        // Overload for tuple-like types
+        template <typename T,
+            typename = std::enable_if_t<is_tuple_like_v<T>>>
         HPX_HOST_DEVICE HPX_FORCEINLINE constexpr Result operator()(T&& t)
         {
             return hpx::invoke_fused_r<Result>(f_, HPX_FORWARD(T, t));
         }
 
+        // Overload for non-tuple types (std::size_t from stdexec bulk)
+        template <typename T,
+            typename = std::enable_if_t<!is_tuple_like_v<T>>, typename = void>
+        HPX_HOST_DEVICE HPX_FORCEINLINE constexpr Result operator()(T&& t)
+        {
+            return HPX_INVOKE_R(Result, f_, HPX_FORWARD(T, t));
+        }
+
         template <std::size_t... Is, typename... Ts>
         HPX_HOST_DEVICE HPX_FORCEINLINE constexpr Result operator()(
             hpx::util::index_pack<Is...>, hpx::tuple<Ts...>& t)