#6224, fold algorithms

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

@@ -2,6 +2,10 @@
 
 #include <hpx/concepts/concepts.hpp>
 #include <hpx/parallel/algorithms/reduce.hpp>
+#include <hpx/datastructures/optional.hpp>
+
+#include <iterator>
+#include <numeric>
 
 namespace hpx::parallel { namespace detail {
 
@@ -18,57 +22,156 @@ namespace hpx::parallel { namespace detail {
         HPX_HOST_DEVICE static constexpr T sequential(
             ExPolicy&&, FwdIter first, Sent last, T&& init, F&& f)
         {
-            hpx::reduce(first, last, HPX_FORWARD(T, init), HPX_FORWARD(F, f));
+            if (first == last)
+                return HPX_MOVE(init);
+            T acc = HPX_MOVE(init);
+            while (first != last)
+                acc = HPX_MOVE(f(HPX_MOVE(acc), *first++));
+            return HPX_MOVE(acc);
         }
 
         template <typename ExPolicy, typename FwdIter, typename Sent,
             typename T, typename F>
-        static util::detail::algorithm_result_t<ExPolicy, FwdIter> parallel(
+        static constexpr auto parallel(
             ExPolicy&& policy, FwdIter first, Sent last, T&& init, F&& f)
         {
-            hpx::reduce(HPX_FORWARD(ExPolicy, policy), first, last,
+#ifdef HPX_WITH_CXX17_STD_EXECUTION_POLICES
+            return std::reduce(HPX_FORWARD(ExPolicy, policy), first, last,
                 HPX_FORWARD(T, init), HPX_FORWARD(F, f));
+#else
+            return std::reduce(
+                first, last, HPX_FORWARD(T, init), HPX_FORWARD(F, f));
+#endif
         }
     };
 
 }}    // namespace hpx::parallel::detail
 
 namespace hpx {
-inline constexpr struct fold_left_t final
-  : hpx::detail::tag_parallel_algorithm<fold_left_t>
-{
-private:
-    template <typename ExPolicy, typename FwdIter, typename T,
-        typename F>    // TODO : add concept
-    friend
-        typename hpx::parallel::util::detail::algorithm_result<ExPolicy>::type
-        tag_fallback_invoke(fold_left_t, ExPolicy&& policy, FwdIter first,
-            FwdIter last, T init, F f)
+    inline constexpr struct fold_left_t final
+      : hpx::detail::tag_parallel_algorithm<fold_left_t>
     {
-        static_assert(hpx::traits::is_forward_iterator_v<FwdIter>,
-            "Requires at least forward iterator.");
-
-        using result_type =
-            typename hpx::parallel::util::detail::algorithm_result<
-                ExPolicy>::type;
-
-        return hpx::util::void_guard<result_type>(),
-               hpx::parallel::detail::fold_left<FwdIter>().call(
-                   HPX_FORWARD(ExPolicy, policy), first, last,
-                   HPX_FORWARD(T, init), HPX_FORWARD(F, f));
-    }
-
-    template <typename FwdIter, typename T,
-        typename F>    // TODO : add concept
-    // clang-format on
-    friend T tag_fallback_invoke(
-        fold_left_t, FwdIter first, FwdIter last, T init, F f)
+    private:
+        template <typename ExPolicy, typename FwdIter, typename T,
+            typename F>    // TODO : add concept
+        friend T tag_fallback_invoke(fold_left_t, ExPolicy&& policy,
+            FwdIter first, FwdIter last, T init, F f)
+        {
+            static_assert(hpx::traits::is_forward_iterator_v<FwdIter>,
+                "Requires at least forward iterator.");
+
+            return hpx::parallel::detail::fold_left<T>().call(
+                HPX_FORWARD(ExPolicy, policy), first, last,
+                HPX_FORWARD(T, init), HPX_FORWARD(F, f));
+        }
+
+        template <typename FwdIter, typename T,
+            typename F>    // TODO : add concept
+        friend T tag_fallback_invoke(
+            fold_left_t, FwdIter first, FwdIter last, T init, F f)
+        {
+            static_assert(hpx::traits::is_forward_iterator_v<FwdIter>,
+                "Requires at least forward iterator.");
+
+            return hpx::parallel::detail::fold_left<T>().call(
+                hpx::execution::seq, first, last, HPX_FORWARD(T, init),
+                HPX_FORWARD(F, f));
+        }
+    } fold_left{};
+}    // namespace hpx
+
+namespace hpx::parallel { namespace detail {
+
+    template <typename T_>
+    struct fold_left_first : public algorithm<fold_left_first<T_>, T_>
     {
-        static_assert(hpx::traits::is_forward_iterator_v<FwdIter>,
-            "Requires at least forward iterator.");
+        constexpr fold_left_first() noexcept
+          : algorithm<fold_left_first, T_>("fold_left_first")
+        {
+        }
+
+        template <typename ExPolicy, typename FwdIter, typename Sent,
+            typename F>
+        HPX_HOST_DEVICE static constexpr auto sequential(
+            ExPolicy&&, FwdIter first, Sent last, F&& f)
+        {
+            using T = ::hpx::traits::iter_value_t<FwdIter>;
+            using U =
+                decltype(hpx::fold_left(std::move(first), last, T(*first), f));
+
+            if (first == last)
+                return hpx::optional<U>();
+
+            T init = *first;
+
+            std::advance(first, 1);
+
+            return hpx::optional<U>(
+                hpx::parallel::detail::fold_left<T>().call(hpx::execution::seq,
+                    first, last, HPX_FORWARD(T, init), HPX_FORWARD(F, f)));
+        }
 
-        return hpx::parallel::detail::fold_left<T>().call(hpx::execution::seq,
-            first, last, HPX_FORWARD(T, init), HPX_FORWARD(F, f));
-    }
-} fold_left{};
+        template <typename ExPolicy, typename FwdIter, typename Sent,
+            typename F>
+        static constexpr auto parallel(
+            ExPolicy&& policy, FwdIter first, Sent last, F&& f)
+        {
+            using T = ::hpx::traits::iter_value_t<FwdIter>;
+            using U =
+                decltype(hpx::fold_left(std::move(first), last, T(*first), f));
+
+            if (first == last)
+                return hpx::optional<U>();
+
+            T init = *first;
+
+            std::advance(first, 1);
+
+            return hpx::optional<U>(hpx::parallel::detail::fold_left<T>().call(
+                HPX_FORWARD(ExPolicy, policy), first, last,
+                HPX_FORWARD(T, init), HPX_FORWARD(F, f)));
+        }
+    };
+
+}}    // namespace hpx::parallel::detail
+
+namespace hpx {
+    inline constexpr struct fold_left_first_t final
+      : hpx::detail::tag_parallel_algorithm<fold_left_first_t>
+    {
+    private:
+        template <typename ExPolicy, typename FwdIter,
+            typename F>    // TODO : add concept
+        friend auto tag_fallback_invoke(fold_left_first_t, ExPolicy&& policy,
+            FwdIter first, FwdIter last, F f)
+        {
+            static_assert(hpx::traits::is_forward_iterator_v<FwdIter>,
+                "Requires at least forward iterator.");
+
+            using result_type =
+                typename hpx::parallel::util::detail::algorithm_result<
+                    ExPolicy>::type;
+
+            using U = decltype(hpx::fold_left(std::move(first), last,
+                ::hpx::traits::iter_value_t<FwdIter>(*first), f));
+
+            return hpx::parallel::detail::fold_left_first<hpx::optional<U>>()
+                .call(HPX_FORWARD(ExPolicy, policy), first, last,
+                    HPX_FORWARD(F, f));
+        }
+
+        template <typename FwdIter, typename F>    // TODO : add concept
+        friend auto tag_fallback_invoke(
+            fold_left_first_t, FwdIter first, FwdIter last, F f)
+        {
+            static_assert(hpx::traits::is_forward_iterator_v<FwdIter>,
+                "Requires at least forward iterator.");
+
+            using U = decltype(hpx::fold_left(std::move(first), last,
+                ::hpx::traits::iter_value_t<FwdIter>(*first), f));
+
+            return hpx::parallel::detail::fold_left_first<hpx::optional<U>>()
+                .call(hpx::execution::seq, first, last, HPX_FORWARD(F, f));
+        }
+    } fold_left_first{};
 }    // namespace hpx

libs/core/datastructures/CMakeLists.txt

@@ -55,6 +55,7 @@ set(datastructures_headers
     hpx/datastructures/member_pack.hpp
     hpx/datastructures/optional.hpp
     hpx/datastructures/tuple.hpp
+    hpx/datastructures/in_value_result.hpp
     hpx/datastructures/traits/supports_streaming_with_any.hpp
     hpx/datastructures/traits/is_tuple_like.hpp
     hpx/datastructures/variant.hpp

libs/core/datastructures/include/hpx/datastructures/in_value_result.hpp

@@ -0,0 +1,22 @@
+namespace hpx::experimental { namespace ranges {
+    template <typename Iter, typename T>
+    struct in_value_result
+    {
+        [[no_unique_address]] Iter in;
+        [[no_unique_address]] T value;
+
+        template <class I2, class T2>
+        // hpx::convertible?
+        constexpr operator in_value_result<I2, T2>() const&
+        {
+            return {in, value};
+        }
+
+        template <class I2, class T2>
+        // hpx::convertible?
+        constexpr operator in_value_result<I2, T2>() &&
+        {
+            return {std::move(in), std::move(value)};
+        }
+    };
+}}    // namespace hpx::experimental::ranges