From e546e19a6376dab6545ae833a7f54fb23ddef501 Mon Sep 17 00:00:00 2001
From: Drew Hubley <dahubley@hotmail.ca>
Date: Tue, 18 Nov 2025 20:09:11 -0400
Subject: [PATCH 1/2] Updated for_each to use a fold over recurssion

---
 include/xtensor/utils/xutils.hpp | 51 +++++++++++---------------------
 1 file changed, 18 insertions(+), 33 deletions(-)

diff --git a/include/xtensor/utils/xutils.hpp b/include/xtensor/utils/xutils.hpp
index 8f40b0c05..85ef31d5d 100644
--- a/include/xtensor/utils/xutils.hpp
+++ b/include/xtensor/utils/xutils.hpp
@@ -163,52 +163,37 @@ namespace xt
 
     namespace detail
     {
-        template <std::size_t I, class F, class... T>
-        inline typename std::enable_if<I == sizeof...(T), void>::type
-        for_each_impl(F&& /*f*/, std::tuple<T...>& /*t*/) noexcept
+        template <class F, size_t... I, class... Ts>
+        void for_each(F&& f, std::tuple<Ts...>& t, std::index_sequence<I...>) noexcept(
+            (noexcept(f(std::get<I>(t))) && ...)
+        )
         {
+            (f(std::get<I>(t)), ...);
         }
 
-        template <std::size_t I, class F, class... T>
-            inline typename std::enable_if < I<sizeof...(T), void>::type
-            for_each_impl(F&& f, std::tuple<T...>& t) noexcept(noexcept(f(std::get<I>(t))))
+        template <class F, size_t... I, class... Ts>
+        void for_each(F&& f, const std::tuple<Ts...>& t, std::index_sequence<I...>) noexcept(
+            (noexcept(f(std::get<I>(t))) && ...)
+        )
         {
-            f(std::get<I>(t));
-            for_each_impl<I + 1, F, T...>(std::forward<F>(f), t);
+            (f(std::get<I>(t)), ...);
         }
     }
 
-    template <class F, class... T>
-    inline void for_each(F&& f, std::tuple<T...>& t) noexcept(
-        noexcept(detail::for_each_impl<0, F, T...>(std::forward<F>(f), t))
+    template <class F, class... Ts>
+    inline void for_each(F&& f, std::tuple<Ts...>& t) noexcept(
+        noexcept(detail::for_each(std::forward<F>(f), t, std::make_index_sequence<sizeof...(Ts)>{}))
     )
     {
-        detail::for_each_impl<0, F, T...>(std::forward<F>(f), t);
+        detail::for_each(std::forward<F>(f), t, std::make_index_sequence<sizeof...(Ts)>{});
     }
 
-    namespace detail
-    {
-        template <std::size_t I, class F, class... T>
-        inline typename std::enable_if<I == sizeof...(T), void>::type
-        for_each_impl(F&& /*f*/, const std::tuple<T...>& /*t*/) noexcept
-        {
-        }
-
-        template <std::size_t I, class F, class... T>
-            inline typename std::enable_if < I<sizeof...(T), void>::type
-            for_each_impl(F&& f, const std::tuple<T...>& t) noexcept(noexcept(f(std::get<I>(t))))
-        {
-            f(std::get<I>(t));
-            for_each_impl<I + 1, F, T...>(std::forward<F>(f), t);
-        }
-    }
-
-    template <class F, class... T>
-    inline void for_each(F&& f, const std::tuple<T...>& t) noexcept(
-        noexcept(detail::for_each_impl<0, F, T...>(std::forward<F>(f), t))
+    template <class F, class... Ts>
+    inline void for_each(F&& f, const std::tuple<Ts...>& t) noexcept(
+        noexcept(detail::for_each(std::forward<F>(f), t, std::make_index_sequence<sizeof...(Ts)>{}))
     )
     {
-        detail::for_each_impl<0, F, T...>(std::forward<F>(f), t);
+        detail::for_each(std::forward<F>(f), t, std::make_index_sequence<sizeof...(Ts)>{});
     }
 
     /*****************************

From 1fb92a74df814e3df3dd0487bf75b461f2406f77 Mon Sep 17 00:00:00 2001
From: Drew Hubley <dahubley@hotmail.ca>
Date: Tue, 18 Nov 2025 21:20:53 -0400
Subject: [PATCH 2/2] Updated accumulate to use C++17 folds rather than
 recursion

---
 include/xtensor/utils/xutils.hpp | 27 +++++++++++++--------------
 test/test_xutils.cpp             |  3 +++
 2 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/include/xtensor/utils/xutils.hpp b/include/xtensor/utils/xutils.hpp
index 85ef31d5d..2e97f67db 100644
--- a/include/xtensor/utils/xutils.hpp
+++ b/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
diff --git a/test/test_xutils.cpp b/test/test_xutils.cpp
index 5a88baa39..62df3144e 100644
--- a/test/test_xutils.cpp
+++ b/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>