#6224, fold algorithms

libs/core/algorithms/CMakeLists.txt

@@ -50,6 +50,7 @@ set(algorithms_headers
     hpx/parallel/algorithms/exclusive_scan.hpp
     hpx/parallel/algorithms/fill.hpp
     hpx/parallel/algorithms/find.hpp
+    hpx/parallel/algorithms/fold.hpp
     hpx/parallel/algorithms/for_each.hpp
     hpx/parallel/algorithms/for_loop.hpp
     hpx/parallel/algorithms/for_loop_induction.hpp

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

@@ -22,6 +22,7 @@
 #include <hpx/parallel/algorithms/equal.hpp>
 #include <hpx/parallel/algorithms/fill.hpp>
 #include <hpx/parallel/algorithms/find.hpp>
+#include <hpx/parallel/algorithms/fold.hpp>
 #include <hpx/parallel/algorithms/for_each.hpp>
 #include <hpx/parallel/algorithms/generate.hpp>
 #include <hpx/parallel/algorithms/includes.hpp>

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

@@ -0,0 +1,253 @@
+#pragma once
+
+#include <hpx/concepts/concepts.hpp>
+#include <hpx/datastructures/optional.hpp>
+#include <hpx/parallel/algorithms/reduce.hpp>
+
+#include <iterator>
+#include <numeric>
+
+namespace hpx::parallel { namespace detail {
+
+    template <typename T_>
+    struct fold_left : public algorithm<fold_left<T_>, T_>
+    {
+        constexpr fold_left() noexcept
+          : algorithm<fold_left, T_>("fold_left")
+        {
+        }
+
+        template <typename ExPolicy, typename FwdIter, typename Sent,
+            typename T, typename F>
+        HPX_HOST_DEVICE static constexpr T sequential(
+            ExPolicy&&, FwdIter first, Sent last, T&& init, 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 constexpr auto parallel(
+            ExPolicy&& policy, FwdIter first, Sent last, T&& init, F&& f)
+        {
+#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
+            HPX_UNUSED(policy);    // TODO : par support
+            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 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_>
+    {
+        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(HPX_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)));
+        }
+
+        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(HPX_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(HPX_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(HPX_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
+
+namespace hpx::parallel { namespace detail {
+
+    template <typename T_>
+    struct fold_right : public algorithm<fold_right<T_>, T_>
+    {
+        constexpr fold_right() noexcept
+          : algorithm<fold_right, T_>("fold_right")
+        {
+        }
+
+        template <typename ExPolicy, typename FwdIter, typename Sent,
+            typename T, typename F>
+        HPX_HOST_DEVICE static constexpr auto sequential(
+            ExPolicy&&, FwdIter first, Sent last, T&& init, F&& f)
+        {
+            using U = std::decay_t<std::invoke_result_t<F&,
+                hpx::traits::iter_reference_t<FwdIter>, T>>;
+            if (first == last)
+                return U(HPX_MOVE(init));
+
+            U accum = f(*--last, HPX_MOVE(init));
+            while (first != last)
+                accum = f(*--last, HPX_MOVE(accum));
+            return accum;
+        }
+
+        template <typename ExPolicy, typename FwdIter, typename Sent,
+            typename T, typename F>
+        static constexpr auto parallel(
+            ExPolicy&& policy, FwdIter first, Sent last, T&& init, F&& f)
+        {
+            HPX_UNUSED(policy);
+            HPX_UNUSED(first);
+            HPX_UNUSED(last);
+            HPX_UNUSED(init);
+            HPX_UNUSED(f);
+
+            exit(
+                1);    // parallel version of fold_right has not been implemented
+            return f(first, init);
+        }
+    };
+
+}}    // namespace hpx::parallel::detail
+
+namespace hpx {
+inline constexpr struct fold_right_t final
+  : hpx::detail::tag_parallel_algorithm<fold_right_t>
+{
+private:
+    template <typename ExPolicy, typename FwdIter, typename T,
+        typename F>    // TODO : add concept
+    friend T tag_fallback_invoke(fold_right_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_right<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_right_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_right<T>().call(hpx::execution::seq,
+            first, last, HPX_FORWARD(T, init), HPX_FORWARD(F, f));
+    }
+} fold_right{};
+}    // 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,24 @@
+#pragma once
+
+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