diff --git a/src/core/loops/apply.hh b/src/core/loops/apply.hh
index b0daadc..39976ad 100644
--- a/src/core/loops/apply.hh
+++ b/src/core/loops/apply.hh
@@ -1,142 +1,89 @@
 /**
  * @file
  *
  * @author Lucas Frérot <lucas.frerot@epfl.ch>
  *
  * @section LICENSE
  *
  * Copyright (©)  2017 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Tamaas is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Tamaas is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Tamaas. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef __APPLY_HH__
 #define __APPLY_HH__
 /* -------------------------------------------------------------------------- */
 #include "tamaas.hh"
 #include <cstddef>
 #include <thrust/tuple.h>
 #include <utility>
 /* -------------------------------------------------------------------------- */
 
 __BEGIN_TAMAAS__
 
 namespace detail {
 
 /// Helper function for application of a functor on a thrust::tuple
 template <size_t nargs>
-struct Apply;
-
-template <>
-struct Apply<0> {
-  template <typename Functor, typename Tuple>
-  __host__ __device__ static auto apply(Functor&& func,
-                                        Tuple&& t[[gnu::unused]])
-      -> decltype(func()) {
-    return func();
-  }
-};
-
-template <>
-struct Apply<1> {
-  template <typename Functor, typename Tuple>
-  __host__ __device__ static auto apply(Functor&& func, Tuple&& t)
-      -> decltype(func(thrust::get<0>(std::forward<Tuple>(t)))) {
-    return func(thrust::get<0>(std::forward<Tuple>(t)));
-  }
-};
-
-template <>
-struct Apply<2> {
-  template <typename Functor, typename Tuple>
-  __host__ __device__ static auto apply(Functor&& func, Tuple&& t)
-      -> decltype(func(thrust::get<0>(std::forward<Tuple>(t)),
-                       thrust::get<1>(std::forward<Tuple>(t)))) {
-    return func(thrust::get<0>(std::forward<Tuple>(t)),
-                thrust::get<1>(std::forward<Tuple>(t)));
-  }
-};
-
-template <>
-struct Apply<3> {
-  template <typename Functor, typename Tuple>
-  __host__ __device__ static auto apply(Functor&& func, Tuple&& t)
-      -> decltype(func(thrust::get<0>(std::forward<Tuple>(t)),
-                       thrust::get<1>(std::forward<Tuple>(t)),
-                       thrust::get<2>(std::forward<Tuple>(t)))) {
-    return func(thrust::get<0>(std::forward<Tuple>(t)),
-                thrust::get<1>(std::forward<Tuple>(t)),
-                thrust::get<2>(std::forward<Tuple>(t)));
+struct Apply {
+  template <typename Functor, typename Tuple, typename... Args>
+  __host__ __device__ static auto apply(Functor&& func, Tuple&& t,
+                                        Args&&... args)
+      -> decltype(Apply<nargs - 1>::apply(std::forward<Functor>(func),
+                                          std::forward<Tuple>(t),
+                                          thrust::get<nargs - 1>(t),
+                                          std::forward<Args>(args)...)) {
+    return Apply<nargs - 1>::apply(
+        std::forward<Functor>(func), std::forward<Tuple>(t),
+        thrust::get<nargs - 1>(t), std::forward<Args>(args)...);
   }
 };
 
 template <>
-struct Apply<4> {
-  template <typename Functor, typename Tuple>
-  __host__ __device__ static auto apply(Functor&& func, Tuple&& t)
-      -> decltype(func(thrust::get<0>(std::forward<Tuple>(t)),
-                       thrust::get<1>(std::forward<Tuple>(t)),
-                       thrust::get<2>(std::forward<Tuple>(t)),
-                       thrust::get<3>(std::forward<Tuple>(t)))) {
-    return func(thrust::get<0>(std::forward<Tuple>(t)),
-                thrust::get<1>(std::forward<Tuple>(t)),
-                thrust::get<2>(std::forward<Tuple>(t)),
-                thrust::get<3>(std::forward<Tuple>(t)));
-  }
-};
-
-template <>
-struct Apply<5> {
-  template <typename Functor, typename Tuple>
-  __host__ __device__ static auto apply(Functor&& func, Tuple&& t)
-      -> decltype(func(thrust::get<0>(std::forward<Tuple>(t)),
-                       thrust::get<1>(std::forward<Tuple>(t)),
-                       thrust::get<2>(std::forward<Tuple>(t)),
-                       thrust::get<3>(std::forward<Tuple>(t)),
-                       thrust::get<4>(std::forward<Tuple>(t)))) {
-    return func(thrust::get<0>(std::forward<Tuple>(t)),
-                thrust::get<1>(std::forward<Tuple>(t)),
-                thrust::get<2>(std::forward<Tuple>(t)),
-                thrust::get<3>(std::forward<Tuple>(t)),
-                thrust::get<4>(std::forward<Tuple>(t)));
+struct Apply<0> {
+  template <typename Functor, typename Tuple, typename... Args>
+  __host__ __device__ static auto
+  apply(Functor&& func, Tuple&& t[[gnu::unused]], Args&&... args)
+      -> decltype(func(std::forward<Args>(args)...)) {
+    return func(std::forward<Args>(args)...);
   }
 };
 
 /// Helper class for functor application in thrust
 template <typename Functor, typename ret_type = void>
 class ApplyFunctor {
 
 public:
   __host__ __device__ ApplyFunctor(const Functor& functor) : functor(functor) {}
   __host__ __device__ ApplyFunctor(const ApplyFunctor& o)
       : functor(o.functor) {}
 
   template <typename Tuple>
   __host__ __device__ ret_type operator()(Tuple&& t) const {
     return Apply<thrust::tuple_size<typename std::remove_reference<
         Tuple>::type>::value>::apply(functor, std::forward<Tuple>(t));
   }
 
 private:
   const Functor& functor;
 };
 
 }  // namespace detail
 
 __END_TAMAAS__
 
 #endif