Apply C++17 fold to accumulation (#2874)

# Checklist

- [x] The title and commit message(s) are descriptive.
- [x] Small commits made to fix your PR have been squashed to avoid
history pollution.
- [x] Tests have been added for new features or bug fixes.
- [x] API of new functions and classes are documented.

# Description

<!---
Give any relevant description here.
If your PR fixes an issue, please include "Fixes #ISSUE" (substituting
the relevant issue ID).
-->

Author: spectre-ns

include/xtensor/utils/xutils.hpp

@@ -204,28 +204,27 @@ namespace xt
 
     namespace detail
     {
-        template <std::size_t I, class F, class R, class... T>
-        inline std::enable_if_t<I == sizeof...(T), R>
-        accumulate_impl(F&& /*f*/, R init, const std::tuple<T...>& /*t*/) noexcept
-        {
-            return init;
-        }
-
-        template <std::size_t I, class F, class R, class... T>
-            inline std::enable_if_t < I<sizeof...(T), R>
-            accumulate_impl(F&& f, R init, const std::tuple<T...>& t) noexcept(noexcept(f(init, std::get<I>(t))))
+        template <class F, class R, class... T, size_t... I>
+        R accumulate_impl(F&& f, R init, const std::tuple<T...>& t, std::index_sequence<I...> /*I*/) noexcept(
+            (noexcept(f(init, std::get<I>(t))) && ...)
+        )
         {
-            R res = f(init, std::get<I>(t));
-            return accumulate_impl<I + 1, F, R, T...>(std::forward<F>(f), res, t);
+            R res = init;
+            auto wrapper = [&](const auto& i, const auto& j)
+            {
+                res = f(i, j);
+            };
+            (wrapper(res, std::get<I>(t)), ...);
+            return res;
         }
     }
 
     template <class F, class R, class... T>
     inline R accumulate(F&& f, R init, const std::tuple<T...>& t) noexcept(
-        noexcept(detail::accumulate_impl<0, F, R, T...>(std::forward<F>(f), init, t))
+        noexcept(detail::accumulate_impl(std::forward<F>(f), init, t, std::make_index_sequence<sizeof...(T)>{}))
     )
     {
-        return detail::accumulate_impl<0, F, R, T...>(std::forward<F>(f), init, t);
+        return detail::accumulate_impl(std::forward<F>(f), init, t, std::make_index_sequence<sizeof...(T)>{});
     }
 
     /// @endcond

test/test_xutils.cpp

@@ -84,6 +84,9 @@ namespace xt
         };
         EXPECT_EQ(8, accumulate(func_ne, 0, t));
         EXPECT_TRUE(noexcept(accumulate(func_ne, 0, t)));
+
+        const std::tuple<> t_empty{};
+        EXPECT_EQ(8, accumulate(func_ne, 8, t_empty));
     }
 
     template <class... T>