Update apply to std 17

Author: spectre-ns

include/xtensor/utils/xutils.hpp

@@ -55,7 +55,7 @@ namespace xt
     constexpr decltype(auto) argument(Args&&... args) noexcept;
 
     template <class R, class F, class... S>
-    R apply(std::size_t index, F&& func, const std::tuple<S...>& s) NOEXCEPT(noexcept(func(std::get<0>(s))));
+    R apply(std::size_t index, F&& func, const std::tuple<S...>& s);
 
     template <class T, class S>
     void nested_copy(T&& iter, const S& s);
@@ -283,29 +283,28 @@ namespace xt
      * apply implementation *
      ************************/
 
-    namespace detail
-    {
-        template <class R, class F, std::size_t I, class... S>
-        R apply_one(F&& func, const std::tuple<S...>& s) NOEXCEPT(noexcept(func(std::get<I>(s))))
-        {
-            return static_cast<R>(func(std::get<I>(s)));
-        }
-
-        template <class R, class F, std::size_t... I, class... S>
-        R apply(std::size_t index, F&& func, std::index_sequence<I...> /*seq*/, const std::tuple<S...>& s)
-            NOEXCEPT(noexcept(func(std::get<0>(s))))
-        {
-            using FT = std::add_pointer_t<R(F&&, const std::tuple<S...>&)>;
-            static const std::array<FT, sizeof...(I)> ar = {{&apply_one<R, F, I, S...>...}};
-            return ar[index](std::forward<F>(func), s);
-        }
-    }
-
     template <class R, class F, class... S>
     inline R apply(std::size_t index, F&& func, const std::tuple<S...>& s)
-        NOEXCEPT(noexcept(func(std::get<0>(s))))
     {
-        return detail::apply<R>(index, std::forward<F>(func), std::make_index_sequence<sizeof...(S)>(), s);
+        XTENSOR_ASSERT(sizeof...(S) > index);
+        return std::apply(
+            [&](const S&... args) -> R
+            {
+                auto f_impl = [&](auto&& self, auto&& i, auto&& h, auto&&... t) -> R
+                {
+                    if (i == index)
+                    {
+                        return static_cast<R>(func(h));
+                    }
+                    if constexpr (sizeof...(t) > 0)
+                    {
+                        return self(self, std::size_t{i + 1}, t...);
+                    }
+                };
+                return f_impl(f_impl, std::size_t{0}, args...);
+            },
+            s
+        );
     }
 
     /***************************

test/test_xutils.cpp

@@ -110,11 +110,8 @@ namespace xt
             return i;
         };
         auto t = std::make_tuple(1, 2, 3);
-#if (_MSC_VER >= 1910)
+        // This can always throw if the runtime index exceeds the length of the tuple
         EXPECT_FALSE(noexcept(apply<int>(1, func_ne, t)));
-#else
-        EXPECT_TRUE(noexcept(apply<int>(1, func_ne, t)));
-#endif
     }
 
     TEST(utils, conditional_cast)