From a6aaa4860ddb67746af9ad16a2a68c98cdbed72b Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Thu, 16 Dec 2021 10:10:12 +0100
Subject: [PATCH 01/19] removing tuple_util::make

---
 include/gridtools/common/array.hpp            |  3 ++
 include/gridtools/common/hymap.hpp            | 54 ++++++++++++++-----
 include/gridtools/common/pair.hpp             |  2 +
 include/gridtools/reduction/frontend.hpp      |  2 +-
 include/gridtools/sid/composite.hpp           |  5 +-
 include/gridtools/stencil/core/grid.hpp       |  7 +--
 .../stencil/cpu_ifirst/entry_point.hpp        |  4 +-
 include/gridtools/stencil/cpu_kfirst.hpp      | 18 +++----
 include/gridtools/stencil/gpu/entry_point.hpp |  2 +-
 include/gridtools/stencil/gpu/ij_cache.hpp    |  5 +-
 .../gridtools/stencil/gpu/tmp_storage_sid.hpp | 16 +++---
 .../stencil/gpu_horizontal/entry_point.hpp    |  3 +-
 include/gridtools/stencil/naive.hpp           |  9 ++--
 include/gridtools/storage/builder.hpp         | 10 ++--
 .../regression/gcl/test_halo_exchange_3D.cpp  |  2 +-
 tests/unit_tests/common/test_hymap.cpp        | 20 ++++---
 .../common/test_hypercube_iterator.cpp        | 11 ++--
 tests/unit_tests/common/test_stride_util.cpp  | 10 ++--
 .../test_layout_transformation.cpp            | 21 +++-----
 tests/unit_tests/sid/test_sid_block.cpp       | 15 +++---
 tests/unit_tests/sid/test_sid_composite.cpp   | 14 ++---
 tests/unit_tests/sid/test_sid_delegate.cpp    |  4 +-
 tests/unit_tests/sid/test_sid_loop.cpp        |  8 ++-
 tests/unit_tests/sid/test_sid_multi_shift.cpp |  8 ++-
 .../sid/test_sid_rename_dimensions.cpp        |  8 +--
 .../sid/test_sid_shift_sid_origin.cpp         |  8 +--
 .../unit_tests/storage/test_storage_info.cpp  | 36 ++++++-------
 27 files changed, 162 insertions(+), 143 deletions(-)

diff --git a/include/gridtools/common/array.hpp b/include/gridtools/common/array.hpp
index a36d76620a..429b910d85 100644
--- a/include/gridtools/common/array.hpp
+++ b/include/gridtools/common/array.hpp
@@ -89,6 +89,9 @@ namespace gridtools {
         GT_FUNCTION static constexpr size_t size() { return D; }
     };
 
+    template <class T, class... Ts>
+    array(T, Ts...) -> array<T, 1 + sizeof...(Ts)>;
+
     namespace array_impl_ {
         template <class... Ts>
         struct deduce_array_type : std::common_type<Ts...> {};
diff --git a/include/gridtools/common/hymap.hpp b/include/gridtools/common/hymap.hpp
index 748de35e05..110a296baa 100644
--- a/include/gridtools/common/hymap.hpp
+++ b/include/gridtools/common/hymap.hpp
@@ -85,7 +85,7 @@
  *  - transforming the values of the hymap:
  *    `auto dst_hymap = tuple_util::transform(change_value_functor, src_hymap);`
  *  - making a map:
- *    `auto a_map = tuple_util::make<hymap::keys<a, b>::values>('a', 42)`
+ *    `auto a_map = hymap::keys<a, b>::values('a', 42)`
  *  - converting to a map:
  *    `auto a_map = tuple_util::convert_to<hymap::keys<a, b>::values>(a_tuple_with_values)`
  */
@@ -164,15 +164,15 @@ namespace gridtools {
         using element_at = tuple_util::element<meta::st_position<get_keys<Map>, Key>::value, Map>;
 
         template <class T, class Keys = get_keys<T>>
-        struct keys_are_legit_sfinae : bool_constant<
-            meta::is_set<Keys>::value && meta::length<Keys>::value == tuple_util::size<T>::value> {};
+        struct keys_are_legit_sfinae
+            : bool_constant<meta::is_set<Keys>::value && meta::length<Keys>::value == tuple_util::size<T>::value> {};
 
         template <class, class = void>
         struct keys_are_legit : std::false_type {};
 
         template <class T>
         struct keys_are_legit<T, std::enable_if_t<keys_are_legit_sfinae<T>::value>> : std::true_type {};
-        
+
     } // namespace hymap_impl_
 
     template <class T>
@@ -193,19 +193,47 @@ namespace gridtools {
     using has_key = meta::st_contains<hymap_impl_::get_keys<Map>, Key>;
 
     namespace hymap {
-        template <class... Keys>
+        template <class...>
         struct keys {
-            template <class... Vals>
-            struct values {
-                static_assert(sizeof...(Vals) == sizeof...(Keys), "invalid hymap");
+            template <class...>
+            struct values;
 
-                tuple<Vals...> m_vals;
+#if defined(__clang__) && __clang_major__ <= 13
+            template <class... Vs>
+            values(Vs const&...) -> values<Vs...>;
+#endif            
+        };
 
-                GT_TUPLE_UTIL_FORWARD_CTORS_TO_MEMBER(values, m_vals);
-                GT_TUPLE_UTIL_FORWARD_GETTER_TO_MEMBER(values, m_vals);
+        template <class... Keys>
+        template <class... Vals>
+        struct keys<Keys...>::values {
+            static_assert(sizeof...(Vals) == sizeof...(Keys), "invalid hymap");
 
-                friend keys hymap_get_keys(values const &) { return {}; }
-            };
+            tuple<Vals...> m_vals;
+
+            template <class... Args, std::enable_if_t<(... && std::is_constructible_v<Vals, Args>), int> = 0>
+            constexpr GT_FUNCTION values(Args &&...args) noexcept : m_vals{wstd::forward<Args>(args)...} {}
+
+            constexpr GT_FUNCTION values(Vals const &...args) noexcept : m_vals(args...) {}
+
+            constexpr GT_FUNCTION values(tuple<Vals...>&& args) noexcept : m_vals(wstd::move(args)) {}
+            constexpr GT_FUNCTION values(tuple<Vals...> const & args) noexcept : m_vals(args) {}
+
+            values() = default;
+            values(values const &) = default;
+            values(values &&) = default;
+            values &operator=(values const &) = default;
+            values &operator=(values &&) = default;
+
+            GT_TUPLE_UTIL_FORWARD_GETTER_TO_MEMBER(values, m_vals);
+
+            friend keys hymap_get_keys(values const &) { return {}; }
+        };
+
+        template <>
+        template <>
+        struct keys<>::values<> {
+            friend values tuple_getter(values const &) { return {}; }
         };
 
         template <class HyMap>
diff --git a/include/gridtools/common/pair.hpp b/include/gridtools/common/pair.hpp
index 55661e4335..a3927e02e8 100644
--- a/include/gridtools/common/pair.hpp
+++ b/include/gridtools/common/pair.hpp
@@ -40,6 +40,8 @@ namespace gridtools {
         template <class U1, class U2>
         GT_CONSTEXPR GT_FUNCTION pair(std::pair<U1, U2> &&p) : pair(wstd::move(p.first), wstd::move(p.second)) {}
 
+        GT_CONSTEXPR GT_FUNCTION pair(T1 const &t1_, T2 const &t2_) : first(t1_), second(t2_) {}
+
         template <class U1, class U2>
         GT_CONSTEXPR GT_FUNCTION pair(U1 &&t1_, U2 &&t2_)
             : first(wstd::forward<U1>(t1_)), second(wstd::forward<U2>(t2_)) {}
diff --git a/include/gridtools/reduction/frontend.hpp b/include/gridtools/reduction/frontend.hpp
index 5ad4319081..e9037971fc 100644
--- a/include/gridtools/reduction/frontend.hpp
+++ b/include/gridtools/reduction/frontend.hpp
@@ -60,7 +60,7 @@ namespace gridtools {
             auto make_reducible(T const &neutral_value, Dims... dims) {
                 auto alloc = sid::host_device::make_cached_allocator(
                     [](size_t size) { return storage::traits::allocate<StorageTraits, char>(size); });
-                auto lengths = tuple_util::make<tuple>(dims...);
+                auto lengths = tuple(dims...);
                 auto info = storage::traits::make_info<StorageTraits, T>(lengths);
                 auto strides = info.native_strides();
                 size_t data_size = info.length();
diff --git a/include/gridtools/sid/composite.hpp b/include/gridtools/sid/composite.hpp
index 828c60edd9..c3858b129c 100644
--- a/include/gridtools/sid/composite.hpp
+++ b/include/gridtools/sid/composite.hpp
@@ -173,8 +173,11 @@ namespace gridtools {
                     static_assert(sizeof...(Keys) == sizeof...(Ptrs), GT_INTERNAL_ERROR);
 
                     tuple<Ptrs...> m_vals;
-                    GT_TUPLE_UTIL_FORWARD_GETTER_TO_MEMBER(composite_ptr, m_vals);
+
                     GT_TUPLE_UTIL_FORWARD_CTORS_TO_MEMBER(composite_ptr, m_vals);
+                    
+                    GT_TUPLE_UTIL_FORWARD_GETTER_TO_MEMBER(composite_ptr, m_vals);
+
                     GT_CONSTEXPR GT_FUNCTION decltype(auto) operator*() const {
                         return tuple_util::host_device::convert_to<hymap::keys<Keys...>::template values>(
                             tuple_util::host_device::transform([](auto const &ptr)
diff --git a/include/gridtools/stencil/core/grid.hpp b/include/gridtools/stencil/core/grid.hpp
index 6ae1937edd..118bf8eef2 100644
--- a/include/gridtools/stencil/core/grid.hpp
+++ b/include/gridtools/stencil/core/grid.hpp
@@ -89,8 +89,7 @@ namespace gridtools {
                 }
 
                 auto origin() const {
-                    return tuple_util::make<hymap::keys<dim::i, dim::j, dim::k>::values>(
-                        m_i_start, m_j_start, offset());
+                    return hymap::keys<dim::i, dim::j, dim::k>::values(m_i_start, m_j_start, offset());
                 }
 
                 template <class Extent = extent<>>
@@ -123,9 +122,7 @@ namespace gridtools {
                     return extent.extend(dim::k(), 1_c + splitter_size(x) + offset(To()) - offset(From()));
                 }
 
-                auto size() const {
-                    return tuple_util::make<hymap::keys<dim::i, dim::j, dim::k>::values>(i_size(), j_size(), k_size());
-                }
+                auto size() const { return hymap::keys<dim::i, dim::j, dim::k>::values(i_size(), j_size(), k_size()); }
             };
 
             template <class T>
diff --git a/include/gridtools/stencil/cpu_ifirst/entry_point.hpp b/include/gridtools/stencil/cpu_ifirst/entry_point.hpp
index 3f827ffbdd..eabb5003d4 100644
--- a/include/gridtools/stencil/cpu_ifirst/entry_point.hpp
+++ b/include/gridtools/stencil/cpu_ifirst/entry_point.hpp
@@ -61,8 +61,8 @@ namespace gridtools {
                         });
 
                     auto blocked_externals = tuple_util::transform(
-                        [block_size = tuple_util::make<hymap::keys<dim::i, dim::j>::values>(
-                             info.i_block_size(), info.j_block_size())](auto &&data_store) {
+                        [block_size = hymap::keys<dim::i, dim::j>::values(info.i_block_size(), info.j_block_size())](
+                            auto &&data_store) {
                             return sid::block(std::forward<decltype(data_store)>(data_store), block_size);
                         },
                         std::move(external_data_stores));
diff --git a/include/gridtools/stencil/cpu_kfirst.hpp b/include/gridtools/stencil/cpu_kfirst.hpp
index 8fb15bb0d0..de87716b4e 100644
--- a/include/gridtools/stencil/cpu_kfirst.hpp
+++ b/include/gridtools/stencil/cpu_kfirst.hpp
@@ -104,16 +104,14 @@ namespace gridtools {
                     auto extent = info.extent();
                     auto interval = stages_t::interval();
                     auto num_colors = info.num_colors();
-                    auto offsets =
-                        tuple_util::make<hymap::keys<dim::i, dim::j, dim::k>::values>(-extent.minus(dim::i()),
-                            -extent.minus(dim::j()),
-                            -grid.k_start(interval) - extent.minus(dim::k()));
-                    auto sizes =
-                        tuple_util::make<hymap::keys<dim::c, dim::k, dim::j, dim::i, dim::thread>::values>(num_colors,
-                            grid.k_size(interval, extent),
-                            extent.extend(dim::j(), JBlockSize()),
-                            extent.extend(dim::i(), IBlockSize()),
-                            thread_pool::get_max_threads(ThreadPool()));
+                    auto offsets = hymap::keys<dim::i, dim::j, dim::k>::values(-extent.minus(dim::i()),
+                        -extent.minus(dim::j()),
+                        -grid.k_start(interval) - extent.minus(dim::k()));
+                    auto sizes = hymap::keys<dim::c, dim::k, dim::j, dim::i, dim::thread>::values(num_colors,
+                        grid.k_size(interval, extent),
+                        extent.extend(dim::j(), JBlockSize()),
+                        extent.extend(dim::i(), IBlockSize()),
+                        thread_pool::get_max_threads(ThreadPool()));
 
                     using stride_kind = meta::list<decltype(extent), decltype(num_colors)>;
                     return sid::shift_sid_origin(
diff --git a/include/gridtools/stencil/gpu/entry_point.hpp b/include/gridtools/stencil/gpu/entry_point.hpp
index 11b71179f3..ece838f18a 100644
--- a/include/gridtools/stencil/gpu/entry_point.hpp
+++ b/include/gridtools/stencil/gpu/entry_point.hpp
@@ -179,7 +179,7 @@ namespace gridtools {
                     return tuple_util::transform(
                         [=](auto &&src) {
                             return sid::block(std::forward<decltype(src)>(src),
-                                tuple_util::make<hymap::keys<dim::i, dim::j>::values>(IBlockSize(), JBlockSize()));
+                                hymap::keys<dim::i, dim::j>::values(IBlockSize(), JBlockSize()));
                         },
                         std::move(data_stores));
                 }
diff --git a/include/gridtools/stencil/gpu/ij_cache.hpp b/include/gridtools/stencil/gpu/ij_cache.hpp
index 3574640b02..ab1b89ab20 100644
--- a/include/gridtools/stencil/gpu/ij_cache.hpp
+++ b/include/gridtools/stencil/gpu/ij_cache.hpp
@@ -25,13 +25,12 @@ namespace gridtools {
             namespace ij_cache_impl_ {
                 template <class Extent>
                 auto origin_offset(Extent) {
-                    return tuple_util::make<hymap::keys<dim::i, dim::j>::values>(
-                        -Extent::minus(dim::i()), -Extent::minus(dim::j()));
+                    return hymap::keys<dim::i, dim::j>::values(-Extent::minus(dim::i()), -Extent::minus(dim::j()));
                 }
 
                 template <class NumColors, class IBlockSize, class JBlockSize, class Extent>
                 auto sizes(NumColors num_colors, IBlockSize i_block_size, JBlockSize j_block_size, Extent) {
-                    return tuple_util::make<hymap::keys<dim::c, dim::i, dim::j>::values>(
+                    return hymap::keys<dim::c, dim::i, dim::j>::values(
                         num_colors, Extent::extend(dim::i(), i_block_size), Extent::extend(dim::j(), j_block_size));
                 }
 
diff --git a/include/gridtools/stencil/gpu/tmp_storage_sid.hpp b/include/gridtools/stencil/gpu/tmp_storage_sid.hpp
index c7462ccdee..da459f4151 100644
--- a/include/gridtools/stencil/gpu/tmp_storage_sid.hpp
+++ b/include/gridtools/stencil/gpu/tmp_storage_sid.hpp
@@ -38,14 +38,14 @@ namespace gridtools {
                     int_t n_blocks_i,
                     int_t n_blocks_j,
                     int_t k_size) {
-                    return tuple_util::make<hymap::
-                            keys<dim::i, dim::j, dim::c, sid::blocked_dim<dim::i>, sid::blocked_dim<dim::j>, dim::k>::
-                                values>(Extent::extend(dim::i(), i_block_size),
-                        Extent::extend(dim::j(), j_block_size),
-                        num_colors,
-                        n_blocks_i,
-                        n_blocks_j,
-                        Extent::extend(dim::k(), k_size));
+                    return hymap::
+                        keys<dim::i, dim::j, dim::c, sid::blocked_dim<dim::i>, sid::blocked_dim<dim::j>, dim::k>::
+                            values(Extent::extend(dim::i(), i_block_size),
+                                Extent::extend(dim::j(), j_block_size),
+                                num_colors,
+                                n_blocks_i,
+                                n_blocks_j,
+                                Extent::extend(dim::k(), k_size));
                 }
             } // namespace tmp_impl_
 
diff --git a/include/gridtools/stencil/gpu_horizontal/entry_point.hpp b/include/gridtools/stencil/gpu_horizontal/entry_point.hpp
index 17aff8f9d0..355ab3045a 100644
--- a/include/gridtools/stencil/gpu_horizontal/entry_point.hpp
+++ b/include/gridtools/stencil/gpu_horizontal/entry_point.hpp
@@ -176,8 +176,7 @@ namespace gridtools {
                             [&](std::false_type, auto info) {
                                 return sid::add_const(info.is_const(),
                                     sid::block(at_key<decltype(info.plh())>(data_stores),
-                                        tuple_util::make<hymap::keys<dim::i, dim::j>::values>(
-                                            IBlockSize(), JBlockSize())));
+                                        hymap::keys<dim::i, dim::j>::values(IBlockSize(), JBlockSize())));
                             }),
                         meta::transform<be_api::get_is_tmp, plh_map_t>(),
                         plh_map_t()));
diff --git a/include/gridtools/stencil/naive.hpp b/include/gridtools/stencil/naive.hpp
index 75f327f69c..3a375e28dc 100644
--- a/include/gridtools/stencil/naive.hpp
+++ b/include/gridtools/stencil/naive.hpp
@@ -39,11 +39,10 @@ namespace gridtools {
                     auto extent = info.extent();
                     auto interval = stages_t::interval();
                     auto num_colors = info.num_colors();
-                    auto offsets =
-                        tuple_util::make<hymap::keys<dim::i, dim::j, dim::k>::values>(-extent.minus(dim::i()),
-                            -extent.minus(dim::j()),
-                            -grid.k_start(interval) - extent.minus(dim::k()));
-                    auto sizes = tuple_util::make<hymap::keys<dim::c, dim::k, dim::j, dim::i>::values>(
+                    auto offsets = hymap::keys<dim::i, dim::j, dim::k>::values(-extent.minus(dim::i()),
+                        -extent.minus(dim::j()),
+                        -grid.k_start(interval) - extent.minus(dim::k()));
+                    auto sizes = hymap::keys<dim::c, dim::k, dim::j, dim::i>::values(
                         num_colors, grid.k_size(interval, extent), grid.j_size(extent), grid.i_size(extent));
                     using stride_kind = meta::list<decltype(extent), decltype(num_colors)>;
                     return sid::shift_sid_origin(
diff --git a/include/gridtools/storage/builder.hpp b/include/gridtools/storage/builder.hpp
index 8586c7bdbc..61ed569323 100644
--- a/include/gridtools/storage/builder.hpp
+++ b/include/gridtools/storage/builder.hpp
@@ -122,7 +122,7 @@ namespace gridtools {
                         class... Args,
                         std::enable_if_t<std::is_constructible<std::tuple<Vals...>, Arg &&, Args &&...>::value, int> =
                             0>
-                    constexpr values(Arg &&arg, Args &&... args) noexcept
+                    constexpr values(Arg &&arg, Args &&...args) noexcept
                         : m_vals{std::forward<Arg>(arg), std::forward<Args>(args)...} {}
 
                     values() = default;
@@ -270,22 +270,22 @@ namespace gridtools {
                 }
 
                 template <class... Args>
-                auto dimensions(Args const &... values) const {
+                auto dimensions(Args const &...values) const {
                     static_assert(!has<param::lengths>::value, "storage dimensions are set twice");
                     static_assert(conjunction<std::is_convertible<Args const &, uint_t>...>::value,
                         "builder.dimensions(...) arguments should be convertible to unsigned int");
                     check_dimensions_number<sizeof...(Args)>();
                     return add_value<param::lengths>(
-                        tuple_util::make<tuple>(normalize_dimension(values, is_integral_constant<Args>())...));
+                        tuple(normalize_dimension(values, is_integral_constant<Args>())...));
                 }
 
                 template <class... Args>
-                auto halos(Args const &... values) const {
+                auto halos(Args const &...values) const {
                     static_assert(!has<param::halos>::value, "storage dimensions are set twice");
                     static_assert(conjunction<std::is_convertible<Args const &, int>...>::value,
                         "builder.halos(...) arguments should be convertible to int");
                     check_dimensions_number<sizeof...(Args)>();
-                    return add_value<param::halos>(tuple_util::make<array, int>(values...));
+                    return add_value<param::halos>(array{static_cast<int>(values)...});
                 }
 
                 template <class Fun>
diff --git a/tests/regression/gcl/test_halo_exchange_3D.cpp b/tests/regression/gcl/test_halo_exchange_3D.cpp
index 04d4801f3c..45ee36b92c 100644
--- a/tests/regression/gcl/test_halo_exchange_3D.cpp
+++ b/tests/regression/gcl/test_halo_exchange_3D.cpp
@@ -99,7 +99,7 @@ class halo_exchange_3D_test : public testing::TestWithParam<test_spec> {
                     })
                     .build();
         };
-        return tuple_util::make<array>(make_storage(0), make_storage(1), make_storage(2));
+        return array{make_storage(0), make_storage(1), make_storage(2)};
     }
 
     template <class Storages>
diff --git a/tests/unit_tests/common/test_hymap.cpp b/tests/unit_tests/common/test_hymap.cpp
index 0b2973cb6b..92acf3d3c2 100644
--- a/tests/unit_tests/common/test_hymap.cpp
+++ b/tests/unit_tests/common/test_hymap.cpp
@@ -28,6 +28,8 @@ namespace gridtools {
         static_assert(!is_hymap<void>::value, "");
         static_assert(is_hymap<std::array<int, 3>>::value, "");
         static_assert(is_hymap<tuple<int, double>>::value, "");
+        static_assert(is_hymap<hymap::keys<>::values<>>::value, "");
+        static_assert(is_hymap<hymap::keys<a>::values<int>>::value, "");
         static_assert(is_hymap<hymap::keys<a, b>::values<int, double>>::value, "");
 
         TEST(tuple_like, smoke) {
@@ -86,15 +88,19 @@ namespace gridtools {
             EXPECT_EQ(7.3, at_key<b>(dst));
         }
 
-        TEST(make_hymap, smoke) {
-            auto testee = tuple_util::make<hymap::keys<a, b>::values>(42, 5.3);
+        TEST(deduction, smoke) {
+            auto testee = hymap::keys<a, b>::values(42, 5.3);
 
             EXPECT_EQ(42, at_key<a>(testee));
             EXPECT_EQ(5.3, at_key<b>(testee));
+
+            EXPECT_EQ(42, at_key<a>(hymap::keys<a>::values(42)));
         }
 
+        TEST(deduction, empty) { hymap::keys<>::values(); }
+
         TEST(convert_hymap, smoke) {
-            hymap::keys<a, b>::values<int, double> src = {42, 5.3};
+            auto src = hymap::keys<a, b>::values(42, 5.3);
 
             auto dst = tuple_util::convert_to<hymap::keys<b, c>::values>(src);
 
@@ -161,8 +167,8 @@ namespace gridtools {
         }
 
         TEST(merge, smoke) {
-            auto m1 = tuple_util::make<hymap::keys<a, b>::values>(1, 2);
-            auto m2 = tuple_util::make<hymap::keys<b, c>::values>(3.5, 16);
+            auto m1 = hymap::keys<a, b>::values(1, 2);
+            auto m2 = hymap::keys<b, c>::values(3.5, 16);
             auto testee = hymap::merge(m1, m2);
 
             EXPECT_EQ(1, at_key<a>(testee));
@@ -171,8 +177,8 @@ namespace gridtools {
         }
 
         TEST(concat, smoke) {
-            auto m1 = tuple_util::make<hymap::keys<a, b>::values>(1, 2);
-            auto m2 = tuple_util::make<hymap::keys<c>::values>(3.5);
+            auto m1 = hymap::keys<a, b>::values(1, 2);
+            auto m2 = hymap::keys<c>::values(3.5);
 
             auto testee = hymap::concat(m1, m2);
             EXPECT_EQ(1, at_key<a>(testee));
diff --git a/tests/unit_tests/common/test_hypercube_iterator.cpp b/tests/unit_tests/common/test_hypercube_iterator.cpp
index 309ae79347..26dd720679 100644
--- a/tests/unit_tests/common/test_hypercube_iterator.cpp
+++ b/tests/unit_tests/common/test_hypercube_iterator.cpp
@@ -19,7 +19,6 @@
 #include <gtest/gtest.h>
 
 using namespace gridtools;
-using tuple_util::make;
 
 class hypercube_iteration : public ::testing::Test {
     using range_t = std::array<size_t, 2>;
@@ -48,27 +47,27 @@ class hypercube_iteration : public ::testing::Test {
 
 TEST_F(hypercube_iteration, view_from_array_of_ranges) {
     expect_ranges({1, 3}, {4, 8}, {2, 10});
-    call_testee(make<array>(make<pair>(1, 3), make<pair>(4, 8), make<pair>(2, 10)));
+    call_testee(array{pair(1, 3), pair(4, 8), pair(2, 10)});
 }
 
 TEST_F(hypercube_iteration, view_from_tuple_of_ranges) {
     expect_ranges({1, 3}, {4, 8}, {2, 10});
-    call_testee(make<tuple>(make<pair>(1, 3), make<pair>(4, 8), make<pair>(2, 10)));
+    call_testee(tuple(pair(1, 3), pair(4, 8), pair(2, 10)));
 }
 
 TEST_F(hypercube_iteration, from_array_of_integers) {
     expect_ranges({0, 3}, {0, 8}, {0, 10});
-    call_testee(make<array>(3, 8, 10));
+    call_testee(array{3, 8, 10});
 }
 
 TEST_F(hypercube_iteration, from_zero_to_zero) {
     expect_ranges({}, {}, {});
-    call_testee(make<array>(make<pair>(0, 0), make<pair>(0, 0), make<pair>(0, 0)));
+    call_testee(array{pair(0, 0), pair(0, 0), pair(0, 0)});
 }
 
 TEST_F(hypercube_iteration, from_one_to_one) {
     expect_ranges({}, {}, {});
-    call_testee(make<array>(0, 0, 0));
+    call_testee(array{0, 0, 0});
 }
 
 TEST(hypercube_view_empty_iteration_space, zero_dimensional_range) {
diff --git a/tests/unit_tests/common/test_stride_util.cpp b/tests/unit_tests/common/test_stride_util.cpp
index 3020410eea..9f9d2065ff 100644
--- a/tests/unit_tests/common/test_stride_util.cpp
+++ b/tests/unit_tests/common/test_stride_util.cpp
@@ -26,7 +26,7 @@ namespace gridtools {
             namespace tu = tuple_util;
 
             TEST(make_strides_from_sizes, smoke) {
-                auto testee = make_strides_from_sizes(tu::make<tuple>(20, 30, 40));
+                auto testee = make_strides_from_sizes(tuple(20, 30, 40));
                 static_assert(std::is_same<decltype(testee), tuple<integral_constant<int, 1>, int, int>>{}, "");
 
                 EXPECT_EQ(1, tu::get<0>(testee));
@@ -35,7 +35,7 @@ namespace gridtools {
             }
 
             TEST(make_strides_from_sizes, integral_constants) {
-                auto testee = make_strides_from_sizes(tu::make<tuple>(20_c, 30_c, 40));
+                auto testee = make_strides_from_sizes(tuple(20_c, 30_c, 40));
                 static_assert(
                     std::is_same<decltype(testee),
                         tuple<integral_constant<int, 1>, integral_constant<int, 20>, integral_constant<int, 600>>>{},
@@ -51,7 +51,7 @@ namespace gridtools {
             struct c;
 
             TEST(make_strides_from_sizes, hymap) {
-                auto testee = make_strides_from_sizes(tu::make<hymap::keys<a, b, c>::values>(20, 30, 40));
+                auto testee = make_strides_from_sizes(hymap::keys<a, b, c>::values(20, 30, 40));
                 static_assert(
                     std::is_same<decltype(testee), hymap::keys<a, b, c>::values<integral_constant<int, 1>, int, int>>{},
                     "");
@@ -62,12 +62,12 @@ namespace gridtools {
             }
 
             TEST(total_size, smoke) {
-                auto testee = total_size(tu::make<tuple>(20, 30, 40));
+                auto testee = total_size(tuple(20, 30, 40));
                 EXPECT_EQ(24000, testee);
             }
 
             TEST(total_size, integral_constants) {
-                auto testee = total_size(tu::make<tuple>(20_c, 30_c, 40_c));
+                auto testee = total_size(tuple(20_c, 30_c, 40_c));
                 static_assert(std::is_same<decltype(testee), integral_constant<int, 24000>>{}, "");
 
                 EXPECT_EQ(24000, testee);
diff --git a/tests/unit_tests/layout_transformation/test_layout_transformation.cpp b/tests/unit_tests/layout_transformation/test_layout_transformation.cpp
index d525454016..4606b8ecff 100644
--- a/tests/unit_tests/layout_transformation/test_layout_transformation.cpp
+++ b/tests/unit_tests/layout_transformation/test_layout_transformation.cpp
@@ -14,7 +14,6 @@
 #include <gridtools/common/array.hpp>
 #include <gridtools/common/for_each.hpp>
 #include <gridtools/common/hypercube_iterator.hpp>
-#include <gridtools/common/tuple_util.hpp>
 #include <gridtools/meta.hpp>
 
 #ifdef GT_CUDACC
@@ -23,7 +22,6 @@
 
 namespace {
     using namespace gridtools;
-    using tuple_util::make;
 
     struct host {};
 
@@ -65,12 +63,12 @@ namespace {
             constexpr size_t Nx = 4, Ny = 5, Nz = 6;
             double src[Nx][Ny][Nz];
             double dst[Nz][Ny][Nx];
-            auto dims = make<array>(Nx, Ny, Nz);
+            auto dims = array{Nx, Ny, Nz};
             for (auto i : make_hypercube_view(dims)) {
                 src[i[0]][i[1]][i[2]] = 100 * i[0] + 10 * i[1] + i[2];
                 dst[i[2]][i[1]][i[0]] = -1;
             }
-            testee(env, dst, src, dims, make<array>(1, Nx, Nx * Ny), make<array>(Ny * Nz, Nz, 1));
+            testee(env, dst, src, dims, array{1, Nx, Nx * Ny}, array{Ny * Nz, Nz, 1});
             for (auto i : make_hypercube_view(dims))
                 EXPECT_DOUBLE_EQ(dst[i[2]][i[1]][i[0]], src[i[0]][i[1]][i[2]]);
         });
@@ -81,17 +79,12 @@ namespace {
             constexpr size_t Nx = 4, Ny = 5, Nz = 6, Nw = 7;
             double src[Nx][Ny][Nz][Nw];
             double dst[Nw][Nz][Ny][Nx];
-            auto dims = make<array>(Nx, Ny, Nz, Nw);
+            auto dims = array{Nx, Ny, Nz, Nw};
             for (auto i : make_hypercube_view(dims)) {
                 src[i[0]][i[1]][i[2]][i[3]] = 1000 * i[0] + 100 * i[1] + 10 * i[2] + i[3];
                 dst[i[3]][i[2]][i[1]][i[0]] = -1;
             }
-            testee(env,
-                dst,
-                src,
-                dims,
-                make<array>(1, Nx, Nx * Ny, Nx * Ny * Nz),
-                make<array>(Ny * Nz * Nw, Nz * Nw, Nw, 1));
+            testee(env, dst, src, dims, array{1, Nx, Nx * Ny, Nx * Ny * Nz}, array{Ny * Nz * Nw, Nz * Nw, Nw, 1});
             for (auto i : make_hypercube_view(dims))
                 EXPECT_DOUBLE_EQ(dst[i[3]][i[2]][i[1]][i[0]], src[i[0]][i[1]][i[2]][i[3]]);
         });
@@ -102,12 +95,12 @@ namespace {
             constexpr size_t Nx = 4, Ny = 5;
             double src[Nx][Ny];
             double dst[Ny][Nx];
-            auto dims = make<array>(Nx, Ny);
+            auto dims = array{Nx, Ny};
             for (auto i : make_hypercube_view(dims)) {
                 src[i[0]][i[1]] = 100 * i[0] + 10 * i[1];
                 dst[i[1]][i[0]] = -1;
             }
-            testee(env, dst, src, dims, make<array>(1, Nx), make<array>(Ny, 1));
+            testee(env, dst, src, dims, array{1, Nx}, array{Ny, 1});
             for (auto i : make_hypercube_view(dims))
                 EXPECT_DOUBLE_EQ(dst[i[1]][i[0]], src[i[0]][i[1]]);
         });
@@ -122,7 +115,7 @@ namespace {
                 src[i] = i;
                 dst[i][0] = dst[i][1] = -1;
             }
-            testee(env, dst, src, make<array>(Nx), make<array>(2), make<array>(1));
+            testee(env, dst, src, array{Nx}, array{2}, array{1});
             for (size_t i = 0; i != Nx; ++i) {
                 EXPECT_DOUBLE_EQ(dst[i][0], src[i]); // the indexable elements match
                 EXPECT_DOUBLE_EQ(dst[i][1], -1);     // the non-indexable are not touched
diff --git a/tests/unit_tests/sid/test_sid_block.cpp b/tests/unit_tests/sid/test_sid_block.cpp
index aa9592f53d..be2b1b3b9f 100644
--- a/tests/unit_tests/sid/test_sid_block.cpp
+++ b/tests/unit_tests/sid/test_sid_block.cpp
@@ -35,7 +35,7 @@ namespace gridtools {
             constexpr int block_size_i = 3;
             const int block_size_j = 7;
 
-            auto blocks = tuple_util::make<hymap::keys<dim::i, dim::j, some_dim>::values>(
+            auto blocks = hymap::keys<dim::i, dim::j, some_dim>::values(
                 integral_constant<int_t, block_size_i>{}, block_size_j, 5);
 
             positional_t s;
@@ -73,10 +73,9 @@ namespace gridtools {
             const int domain_size = 20;
             const int block_size_1 = 5;
             const int block_size_2 = 2;
-            auto blocked_s = sid::block(s, tuple_util::make<hymap::keys<dim::i>::values>(block_size_1));
+            auto blocked_s = sid::block(s, hymap::keys<dim::i>::values(block_size_1));
             static_assert(is_sid<decltype(blocked_s)>(), "");
-            auto blocked_blocked_s =
-                sid::block(blocked_s, tuple_util::make<hymap::keys<sid::blocked_dim<dim::i>>::values>(block_size_2));
+            auto blocked_blocked_s = sid::block(blocked_s, hymap::keys<sid::blocked_dim<dim::i>>::values(block_size_2));
             static_assert(is_sid<decltype(blocked_blocked_s)>(), "");
 
             auto ptr = sid::get_origin(blocked_blocked_s)();
@@ -100,7 +99,7 @@ namespace gridtools {
         TEST(sid_block, do_nothing) {
             positional_t s;
 
-            auto same_s = sid::block(s, tuple_util::make<hymap::keys<some_dim>::values>(42));
+            auto same_s = sid::block(s, hymap::keys<some_dim>::values(42));
             static_assert(std::is_same<decltype(s), decltype(same_s)>(), "");
         }
 
@@ -109,7 +108,7 @@ namespace gridtools {
 
             const int domain_size = 20;
             const int block_size = 5;
-            auto blocked_s = sid::block(std::ref(s), tuple_util::make<hymap::keys<dim::i>::values>(block_size));
+            auto blocked_s = sid::block(std::ref(s), hymap::keys<dim::i>::values(block_size));
             static_assert(is_sid<decltype(blocked_s)>(), "");
 
             auto ptr = sid::get_origin(blocked_s)();
@@ -131,8 +130,8 @@ namespace gridtools {
 
             using dims_t = hymap::keys<dim::i, dim::j, dim::k, some_dim>;
 
-            auto strides = tuple_util::make<dims_t::values>(1, 2, 4_c, 8_c);
-            auto blocks = tuple_util::make<dims_t::values>(2, 2_c, 2, 2_c);
+            auto strides = dims_t::values(1, 2, 4_c, 8_c);
+            auto blocks = dims_t::values(2, 2_c, 2, 2_c);
 
             auto s = sid::synthetic()
                          .set<sid::property::origin>(sid::simple_ptr_holder<int *>{nullptr})
diff --git a/tests/unit_tests/sid/test_sid_composite.cpp b/tests/unit_tests/sid/test_sid_composite.cpp
index 0012a3f8c5..c890b7f02c 100644
--- a/tests/unit_tests/sid/test_sid_composite.cpp
+++ b/tests/unit_tests/sid/test_sid_composite.cpp
@@ -73,12 +73,12 @@ namespace gridtools {
             double three[4][3][5] = {};
             char four[4][3][5] = {};
 
-            auto my_strides = tu::make<array>(1, 5, 15);
+            auto my_strides = array{1, 5, 15};
 
             auto testee = sid::composite::make<a, b, c, d>(                                           //
                 sid::synthetic()                                                                      //
                     .set<property::origin>(sid::host_device::make_simple_ptr_holder(&one[0]))         //
-                    .set<property::strides>(tuple_util::make<tuple>(1_c))                             //
+                    .set<property::strides>(tuple(1_c))                                               //
                 ,                                                                                     //
                 sid::synthetic()                                                                      //
                     .set<property::origin>(sid::host_device::make_simple_ptr_holder(&two))            //
@@ -155,15 +155,15 @@ namespace gridtools {
 
         TEST(composite, custom_dims) {
             double const one[5] = {0, 10, 20, 30, 40};
-            auto strides_one = tu::make<hymap::keys<dim_x>::values>(1_c);
+            auto strides_one = hymap::keys<dim_x>::values(1_c);
 
             double two = -1;
 
             double three[4][3][5] = {};
-            auto strides_three = tu::make<hymap::keys<dim_z, dim_y, dim_x>::values>(1_c, 5_c, 15_c);
+            auto strides_three = hymap::keys<dim_z, dim_y, dim_x>::values(1_c, 5_c, 15_c);
 
             char four[6][4][5] = {};
-            auto strides_four = tu::make<hymap::keys<dim_y, dim_z, dim_x>::values>(1_c, 5_c, 20_c);
+            auto strides_four = hymap::keys<dim_y, dim_z, dim_x>::values(1_c, 5_c, 20_c);
 
             auto testee = sid::composite::make<a, b, c, d>(                                           //
                 sid::synthetic()                                                                      //
@@ -206,11 +206,11 @@ namespace gridtools {
             auto testee = sid::composite::make<a, b>(                                            //
                 sid::synthetic()                                                                 //
                     .set<property::origin>(sid::host_device::make_simple_ptr_holder(&one[0]))    //
-                    .set<property::strides>(tuple_util::make<tuple>(1))                          //
+                    .set<property::strides>(tuple(1))                                            //
                     .set<property::strides_kind, sid::unknown_kind>(),                           //
                 sid::synthetic()                                                                 //
                     .set<property::origin>(sid::host_device::make_simple_ptr_holder(&two[0][0])) //
-                    .set<property::strides>(tuple_util::make<tuple>(1, 1))                       //
+                    .set<property::strides>(tuple(1, 1))                                         //
                     .set<property::strides_kind, sid::unknown_kind>());
 
             auto &&strides = sid::get_strides(testee);
diff --git a/tests/unit_tests/sid/test_sid_delegate.cpp b/tests/unit_tests/sid/test_sid_delegate.cpp
index ce800c492c..4a20ae115f 100644
--- a/tests/unit_tests/sid/test_sid_delegate.cpp
+++ b/tests/unit_tests/sid/test_sid_delegate.cpp
@@ -47,7 +47,7 @@ namespace gridtools {
             double data[3][5];
             auto src = sid::synthetic()
                            .set<property::origin>(sid::host_device::make_simple_ptr_holder(&data[0][0]))
-                           .set<property::strides>(tu::make<tuple>(5_c, 1_c));
+                           .set<property::strides>(tuple(5_c, 1_c));
             EXPECT_EQ(&data[0][0], sid::get_origin(src)());
 
             auto testee = i_shift(std::move(src));
@@ -78,7 +78,7 @@ namespace gridtools {
             double data[3][5];
             auto src = sid::synthetic()
                            .set<property::origin>(sid::host_device::make_simple_ptr_holder(&data[0][0]))
-                           .set<property::strides>(tu::make<tuple>(5_c, 1_c));
+                           .set<property::strides>(tuple(5_c, 1_c));
             auto testee = just_delegate(src);
             static_assert(is_sid<decltype(testee)>(), "");
         }
diff --git a/tests/unit_tests/sid/test_sid_loop.cpp b/tests/unit_tests/sid/test_sid_loop.cpp
index c80073863d..d9b4336580 100644
--- a/tests/unit_tests/sid/test_sid_loop.cpp
+++ b/tests/unit_tests/sid/test_sid_loop.cpp
@@ -15,12 +15,10 @@
 #include <gridtools/common/compose.hpp>
 #include <gridtools/common/integral_constant.hpp>
 #include <gridtools/common/tuple.hpp>
-#include <gridtools/common/tuple_util.hpp>
 
 namespace gridtools {
     namespace {
         using namespace literals;
-        namespace tu = tuple_util::host_device;
 
         struct assignment_f {
             double m_val;
@@ -35,7 +33,7 @@ namespace gridtools {
 
         TEST(make_loop, smoke) {
             double data[10][10] = {};
-            auto strides = tu::make<tuple>(10_c, 1_c);
+            auto strides = tuple(10_c, 1_c);
 
             double *ptr = &data[0][0];
             sid::make_loop<i_t>(5, 1)(assignment_f{42})(ptr, strides);
@@ -63,7 +61,7 @@ namespace gridtools {
         TEST(nest_loops, smoke) {
             double data[10][10] = {};
             double *ptr = &data[0][0];
-            auto strides = tu::make<tuple>(10_c, 1_c);
+            auto strides = tuple(10_c, 1_c);
 
             auto testee = host_device::compose(sid::make_loop<i_t>(10_c), sid::make_loop<j_t>(10_c));
 
@@ -77,7 +75,7 @@ namespace gridtools {
         TEST(range, smoke) {
             double data[10][10] = {};
             double *ptr = &data[0][0];
-            auto strides = tu::make<tuple>(10_c, 1_c);
+            auto strides = tuple(10_c, 1_c);
 
             auto testee = sid::make_range(ptr, strides, sid::make_loop<i_t>(10_c), sid::make_loop<j_t>(10_c));
 
diff --git a/tests/unit_tests/sid/test_sid_multi_shift.cpp b/tests/unit_tests/sid/test_sid_multi_shift.cpp
index acb34b16be..0e3a886855 100644
--- a/tests/unit_tests/sid/test_sid_multi_shift.cpp
+++ b/tests/unit_tests/sid/test_sid_multi_shift.cpp
@@ -14,13 +14,11 @@
 
 #include <gridtools/common/integral_constant.hpp>
 #include <gridtools/common/tuple.hpp>
-#include <gridtools/common/tuple_util.hpp>
 #include <gridtools/sid/concept.hpp>
 
 namespace gridtools {
     namespace {
         using namespace literals;
-        namespace tu = tuple_util;
 
         TEST(multi_shift, smoke) {
             double data[15][42];
@@ -28,13 +26,13 @@ namespace gridtools {
             auto ptr = sid::get_origin(data)();
             auto strides = sid::get_strides(data);
 
-            sid::multi_shift(ptr, strides, tu::make<tuple>(3_c, 5_c, 2_c));
+            sid::multi_shift(ptr, strides, tuple(3_c, 5_c, 2_c));
             EXPECT_EQ(&data[3][5], ptr);
 
-            sid::multi_shift(ptr, strides, tu::make<tuple>(0_c, -2_c));
+            sid::multi_shift(ptr, strides, tuple(0_c, -2_c));
             EXPECT_EQ(&data[3][3], ptr);
 
-            sid::multi_shift(ptr, strides, tu::make<tuple>(-2));
+            sid::multi_shift(ptr, strides, tuple(-2));
             EXPECT_EQ(&data[1][3], ptr);
         }
     } // namespace
diff --git a/tests/unit_tests/sid/test_sid_rename_dimensions.cpp b/tests/unit_tests/sid/test_sid_rename_dimensions.cpp
index a072cccbfb..83d872cb8f 100644
--- a/tests/unit_tests/sid/test_sid_rename_dimensions.cpp
+++ b/tests/unit_tests/sid/test_sid_rename_dimensions.cpp
@@ -35,8 +35,8 @@ namespace gridtools {
 
             auto src = sid::synthetic()
                            .set<property::origin>(sid::make_simple_ptr_holder(&data[0][0][0]))
-                           .set<property::strides>(tu::make<hymap::keys<a, b, c>::values>(5_c * 7_c, 7_c, 1_c))
-                           .set<property::upper_bounds>(tu::make<hymap::keys<a, b>::values>(3, 5));
+                           .set<property::strides>(hymap::keys<a, b, c>::values(5_c * 7_c, 7_c, 1_c))
+                           .set<property::upper_bounds>(hymap::keys<a, b>::values(3, 5));
 
             auto testee = sid::rename_dimensions<b, d>(src);
             using testee_t = decltype(testee);
@@ -78,8 +78,8 @@ namespace gridtools {
             double data[3][5][7];
             auto src = sid::synthetic()
                            .set<property::origin>(sid::host_device::make_simple_ptr_holder(&data[0][0][0]))
-                           .set<property::strides>(tu::make<hymap::keys<a, b, c>::values>(5_c * 7_c, 7_c, 1_c))
-                           .set<property::upper_bounds>(tu::make<hymap::keys<a, b>::values>(3, 5));
+                           .set<property::strides>(hymap::keys<a, b, c>::values(5_c * 7_c, 7_c, 1_c))
+                           .set<property::upper_bounds>(hymap::keys<a, b>::values(3, 5));
             auto testee = sid::rename_dimensions<a, c, b, d>(src);
             static_assert(sid::is_sid<decltype(testee)>::value, "");
             auto composite = tu::make<sid::composite::keys<void>::values>(testee);
diff --git a/tests/unit_tests/sid/test_sid_shift_sid_origin.cpp b/tests/unit_tests/sid/test_sid_shift_sid_origin.cpp
index fdf09533e4..248a0fef8e 100644
--- a/tests/unit_tests/sid/test_sid_shift_sid_origin.cpp
+++ b/tests/unit_tests/sid/test_sid_shift_sid_origin.cpp
@@ -29,10 +29,10 @@ namespace gridtools {
 
             auto src = sid::synthetic()
                            .set<property::origin>(sid::make_simple_ptr_holder(&data[0][0][0]))
-                           .set<property::strides>(tu::make<tuple>(5_c * 7_c, 7_c, 1_c))
-                           .set<property::upper_bounds>(tu::make<tuple>(3));
+                           .set<property::strides>(tuple(5_c * 7_c, 7_c, 1_c))
+                           .set<property::upper_bounds>(tuple(3));
 
-            auto offset = tuple_util::make<tuple>(1_c, 2);
+            auto offset = tuple(1_c, 2);
             auto testee = sid::shift_sid_origin(src, offset);
 
             static_assert(is_sid<decltype(testee)>(), "");
@@ -46,7 +46,7 @@ namespace gridtools {
         TEST(shift_sid_origin, c_array) {
             double data[3][5][7];
 
-            auto offset = tuple_util::make<tuple>(1_c, 2);
+            auto offset = tuple(1_c, 2);
             auto testee = sid::shift_sid_origin(data, offset);
 
             static_assert(is_sid<decltype(testee)>(), "");
diff --git a/tests/unit_tests/storage/test_storage_info.cpp b/tests/unit_tests/storage/test_storage_info.cpp
index 9178e07b0d..40071fdbf9 100644
--- a/tests/unit_tests/storage/test_storage_info.cpp
+++ b/tests/unit_tests/storage/test_storage_info.cpp
@@ -14,47 +14,45 @@
 
 #include <gridtools/common/integral_constant.hpp>
 #include <gridtools/common/tuple.hpp>
-#include <gridtools/common/tuple_util.hpp>
 
 namespace gridtools {
     namespace storage {
         namespace {
             using testing::ElementsAre;
-            namespace tu = tuple_util;
             using namespace literals;
 
             TEST(StorageInfo, Strides) {
                 {
-                    auto si = make_info<layout_map<0, 1, 2>>(1_c, tu::make<tuple>(3, 4, 5));
+                    auto si = make_info<layout_map<0, 1, 2>>(1_c, tuple(3, 4, 5));
                     EXPECT_THAT(si.strides(), ElementsAre(20, 5, 1));
                     EXPECT_EQ(si.length(), 3 * 4 * 5);
                 }
                 {
-                    auto si = make_info<layout_map<2, 0, 1>>(1_c, tu::make<tuple>(3, 4, 5));
+                    auto si = make_info<layout_map<2, 0, 1>>(1_c, tuple(3, 4, 5));
                     EXPECT_THAT(si.strides(), ElementsAre(1, 15, 3));
                     EXPECT_EQ(si.length(), 3 * 4 * 5);
                 }
                 {
-                    auto si = make_info<layout_map<-1, 0, 1>>(1_c, tu::make<tuple>(3, 4, 5));
+                    auto si = make_info<layout_map<-1, 0, 1>>(1_c, tuple(3, 4, 5));
                     EXPECT_THAT(si.strides(), ElementsAre(0, 5, 1));
                     EXPECT_EQ(si.length(), 4 * 5);
                 }
             }
             TEST(StorageInfo, StridesAlignment) {
                 {
-                    auto si = make_info<layout_map<0, 1, 2>>(32_c, tu::make<tuple>(3, 4, 5));
+                    auto si = make_info<layout_map<0, 1, 2>>(32_c, tuple(3, 4, 5));
                     EXPECT_THAT(si.strides(), ElementsAre(128, 32, 1));
                     EXPECT_GE(si.length(), 3 * 4 * 5);
                     EXPECT_LE(si.length(), 3 * 4 * 32);
                 }
                 {
-                    auto si = make_info<layout_map<2, 0, 1>>(32_c, tu::make<tuple>(3, 4, 5));
+                    auto si = make_info<layout_map<2, 0, 1>>(32_c, tuple(3, 4, 5));
                     EXPECT_THAT(si.strides(), ElementsAre(1, 32 * 5, 32));
                     EXPECT_GE(si.length(), 3 * 4 * 5);
                     EXPECT_LE(si.length(), 32 * 4 * 5);
                 }
                 {
-                    auto si = make_info<layout_map<-1, 0, 1>>(32_c, tu::make<tuple>(3, 4, 5));
+                    auto si = make_info<layout_map<-1, 0, 1>>(32_c, tuple(3, 4, 5));
                     EXPECT_THAT(si.strides(), ElementsAre(0, 32, 1));
                     EXPECT_GE(si.length(), 4 * 5);
                     EXPECT_LE(si.length(), 4 * 32);
@@ -62,21 +60,21 @@ namespace gridtools {
             }
             TEST(StorageInfo, IndexVariadic) {
                 {
-                    auto si = make_info<layout_map<0, 1, 2>>(1_c, tu::make<tuple>(3, 4, 5));
+                    auto si = make_info<layout_map<0, 1, 2>>(1_c, tuple(3, 4, 5));
                     EXPECT_EQ(si.index(0, 0, 0), 0);
                     EXPECT_EQ(si.index(0, 0, 1), 1);
                     EXPECT_EQ(si.index(0, 1, 0), 5);
                     EXPECT_EQ(si.index(1, 0, 0), 20);
                 }
                 {
-                    auto si = make_info<layout_map<2, 0, 1>>(1_c, tu::make<tuple>(3, 4, 5));
+                    auto si = make_info<layout_map<2, 0, 1>>(1_c, tuple(3, 4, 5));
                     EXPECT_EQ(si.index(0, 0, 0), 0);
                     EXPECT_EQ(si.index(0, 0, 1), 3);
                     EXPECT_EQ(si.index(0, 1, 0), 15);
                     EXPECT_EQ(si.index(1, 0, 0), 1);
                 }
                 {
-                    auto si = make_info<layout_map<-1, 0, 1>>(1_c, tu::make<tuple>(3, 4, 5));
+                    auto si = make_info<layout_map<-1, 0, 1>>(1_c, tuple(3, 4, 5));
                     EXPECT_EQ(si.index(0, 0, 0), 0);
                     EXPECT_EQ(si.index(0, 0, 1), 1);
                     EXPECT_EQ(si.index(0, 1, 0), 5);
@@ -87,7 +85,7 @@ namespace gridtools {
 
             TEST(StorageInfo, Simple) {
                 {
-                    auto si = make_info<layout_map<2, 1, 0>>(1_c, tu::make<tuple>(3, 3, 3));
+                    auto si = make_info<layout_map<2, 1, 0>>(1_c, tuple(3, 3, 3));
                     EXPECT_EQ(si.index(0, 0, 0), 0);
                     EXPECT_EQ(si.index(0, 0, 1), 9);
                     EXPECT_EQ(si.index(0, 0, 2), 18);
@@ -105,7 +103,7 @@ namespace gridtools {
                     EXPECT_EQ(si.index(1, 0, 2), 19);
                 }
                 {
-                    auto si = make_info<layout_map<0, 1, 2>>(1_c, tu::make<tuple>(3, 3, 3));
+                    auto si = make_info<layout_map<0, 1, 2>>(1_c, tuple(3, 3, 3));
                     EXPECT_EQ(si.index(0, 0, 0), 0);
                     EXPECT_EQ(si.index(0, 0, 1), 1);
                     EXPECT_EQ(si.index(0, 0, 2), 2);
@@ -123,7 +121,7 @@ namespace gridtools {
                     EXPECT_EQ(si.index(1, 0, 2), 11);
                 }
                 {
-                    auto si = make_info<layout_map<1, 0, 2>>(1_c, tu::make<tuple>(3, 3, 3));
+                    auto si = make_info<layout_map<1, 0, 2>>(1_c, tuple(3, 3, 3));
                     EXPECT_EQ(si.index(0, 0, 0), 0);
                     EXPECT_EQ(si.index(0, 0, 1), 1);
                     EXPECT_EQ(si.index(0, 0, 2), 2);
@@ -142,19 +140,19 @@ namespace gridtools {
                 }
 
                 // test with different dims
-                auto x = make_info<layout_map<1, 2, 3, 0>>(1_c, tu::make<tuple>(5, 7, 8, 2));
+                auto x = make_info<layout_map<1, 2, 3, 0>>(1_c, tuple(5, 7, 8, 2));
                 EXPECT_THAT(x.lengths(), ElementsAre(5, 7, 8, 2));
                 EXPECT_THAT(x.strides(), ElementsAre(56, 8, 1, 280));
             }
 
             TEST(StorageInfo, Alignment) {
                 {
-                    auto x = make_info<layout_map<1, 2, 3, 0>>(32_c, tu::make<tuple>(5, 7, 32, 2));
+                    auto x = make_info<layout_map<1, 2, 3, 0>>(32_c, tuple(5, 7, 32, 2));
                     EXPECT_THAT(x.lengths(), ElementsAre(5, 7, 32, 2));
                     EXPECT_THAT(x.strides(), ElementsAre(32 * 7, 32, 1, 5 * 32 * 7));
                 }
                 {
-                    auto x = make_info<layout_map<1, 2, 3, 0>>(32_c, tu::make<tuple>(7, 11, 3, 10));
+                    auto x = make_info<layout_map<1, 2, 3, 0>>(32_c, tuple(7, 11, 3, 10));
                     EXPECT_THAT(x.lengths(), ElementsAre(7, 11, 3, 10));
                     EXPECT_THAT(x.strides(), ElementsAre(32 * 11, 32, 1, 32 * 11 * 7));
                     EXPECT_EQ(x.index(0, 0, 0, 0), 0);
@@ -162,7 +160,7 @@ namespace gridtools {
                     EXPECT_EQ(x.index(0, 0, 2, 0), 2);
                 }
                 {
-                    auto x = make_info<layout_map<3, 2, 1, 0>>(32_c, tu::make<tuple>(3, 11, 14, 10));
+                    auto x = make_info<layout_map<3, 2, 1, 0>>(32_c, tuple(3, 11, 14, 10));
                     EXPECT_THAT(x.lengths(), ElementsAre(3, 11, 14, 10));
                     EXPECT_THAT(x.strides(), ElementsAre(1, 32, 32 * 11, 32 * 11 * 14));
                     EXPECT_EQ(x.index(0, 0, 0, 0), 0);
@@ -171,7 +169,7 @@ namespace gridtools {
                     EXPECT_EQ(x.index(0, 0, 0, 1), 32 * 11 * 14);
                 }
                 {
-                    auto x = make_info<layout_map<1, -1, -1, 0>>(32_c, tu::make<tuple>(7, 7, 8, 10));
+                    auto x = make_info<layout_map<1, -1, -1, 0>>(32_c, tuple(7, 7, 8, 10));
                     EXPECT_THAT(x.lengths(), ElementsAre(7, 7, 8, 10));
                     EXPECT_THAT(x.strides(), ElementsAre(1, 0, 0, 32));
                     EXPECT_EQ(x.index(0, 0, 0, 0), 0);

From 026789f84df9a385a63d8c36b3a5f8be9680784f Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Mon, 20 Dec 2021 12:42:54 +0100
Subject: [PATCH 02/19] add make_values

---
 include/gridtools/boundaries/bound_bc.hpp     |  11 +-
 .../boundaries/distributed_boundaries.hpp     |   2 +-
 include/gridtools/common/enable_maker.hpp     |  29 ++
 include/gridtools/common/hymap.hpp            |  13 +-
 include/gridtools/common/tuple_util.hpp       | 147 +++---
 .../gcl/high_level/descriptors_manual_gpu.hpp |  24 +-
 .../gcl/high_level/empty_field_base.hpp       |   8 +-
 include/gridtools/sid/composite.hpp           | 457 ++++++++++--------
 include/gridtools/stencil/core/grid.hpp       |   6 +-
 include/gridtools/stencil/gpu/entry_point.hpp |   2 +-
 include/gridtools/stencil/gpu/ij_cache.hpp    |   4 +-
 .../gridtools/stencil/gpu/tmp_storage_sid.hpp |   2 +-
 .../stencil/gpu_horizontal/entry_point.hpp    |   2 +-
 include/gridtools/stencil/naive.hpp           |   4 +-
 include/gridtools/storage/info.hpp            |   2 +-
 tests/unit_tests/CMakeLists.txt               |   1 +
 .../boundaries/test_bindbc_utilities.cpp      |  20 +-
 tests/unit_tests/common/test_hymap.cpp        |  12 +-
 tests/unit_tests/common/test_int_vector.cpp   |  62 +--
 tests/unit_tests/common/test_int_vector.cu    |  13 +-
 tests/unit_tests/common/test_stride_util.cpp  |   2 +-
 tests/unit_tests/common/test_tuple_util.cpp   | 139 +++---
 tests/unit_tests/sid/test_sid_block.cpp       |  15 +-
 tests/unit_tests/sid/test_sid_composite.cpp   |  25 +-
 tests/unit_tests/sid/test_sid_concept.cpp     |   5 +-
 .../sid/test_sid_rename_dimensions.cpp        |  10 +-
 26 files changed, 530 insertions(+), 487 deletions(-)
 create mode 100644 include/gridtools/common/enable_maker.hpp

diff --git a/include/gridtools/boundaries/bound_bc.hpp b/include/gridtools/boundaries/bound_bc.hpp
index 6e1facf565..27b67328bc 100644
--- a/include/gridtools/boundaries/bound_bc.hpp
+++ b/include/gridtools/boundaries/bound_bc.hpp
@@ -82,19 +82,20 @@ namespace gridtools {
             */
             template <typename ROTuple, typename AllTuple, std::size_t... IDs>
             auto substitute_placeholders(ROTuple const &ro_tuple, AllTuple const &all, std::index_sequence<IDs...>) {
-                return std::make_tuple(select_element<IDs>(ro_tuple,
+                return std::tuple(select_element<IDs>(ro_tuple,
                     all,
                     typename PlcOrNot<std::is_placeholder<std::tuple_element_t<IDs, AllTuple>>::value>::type{})...);
             }
 
-            inline std::tuple<> rest_tuple(std::tuple<>, std::index_sequence<>) { return {}; }
+            template <typename... Elems>
+            std::tuple<> rest_tuple(std::tuple<Elems...> const&, std::index_sequence<>) { return {}; }
 
             /** \internal
-                Small facility to obtain a tuple with the elements of am input  tuple execpt the first.
+                Small facility to obtain a tuple with the elements of an input  tuple execpt the first.
             */
             template <typename... Elems, std::size_t... IDs>
             auto rest_tuple(std::tuple<Elems...> const &x, std::index_sequence<IDs...>) {
-                return std::make_tuple(std::get<IDs + 1u>(x)...);
+                return std::tuple(std::get<IDs + 1u>(x)...);
             }
 
             /**
@@ -229,7 +230,7 @@ namespace gridtools {
              */
             template <typename... ReadOnly>
             auto associate(ReadOnly &&... ro_stores) const -> bound_bc<BCApply,
-                decltype(_impl::substitute_placeholders(std::make_tuple(ro_stores...),
+                decltype(_impl::substitute_placeholders(std::tuple(ro_stores...),
                     m_stores,
                     std::make_index_sequence<std::tuple_size<decltype(m_stores)>::value>{})),
                 typename _impl::comm_indices<stores_type>::type> {
diff --git a/include/gridtools/boundaries/distributed_boundaries.hpp b/include/gridtools/boundaries/distributed_boundaries.hpp
index 20a48966e0..9e55ca89e5 100644
--- a/include/gridtools/boundaries/distributed_boundaries.hpp
+++ b/include/gridtools/boundaries/distributed_boundaries.hpp
@@ -228,7 +228,7 @@ namespace gridtools {
             template <typename FirstJob>
             static auto collect_stores(
                 FirstJob const &first_job, std::enable_if_t<not is_bound_bc<FirstJob>::value, void *> = nullptr) {
-                return std::make_tuple(first_job);
+                return std::tuple(first_job);
             }
 
             template <typename Stores, uint_t... Ids>
diff --git a/include/gridtools/common/enable_maker.hpp b/include/gridtools/common/enable_maker.hpp
new file mode 100644
index 0000000000..f3d030b56e
--- /dev/null
+++ b/include/gridtools/common/enable_maker.hpp
@@ -0,0 +1,29 @@
+/*
+ * GridTools
+ *
+ * Copyright (c) 2014-2021, ETH Zurich
+ * All rights reserved.
+ *
+ * Please, refer to the LICENSE file in the root directory.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#pragma once
+
+#include "host_device.hpp"
+
+namespace gridtools {
+    // NVCC 11 fails to do class template deduction in the case of nested templates
+    // The only puropse of this helper is to factor out the workaround against it.
+    // See hymap.hpp for the usage exapmle.
+    class enable_maker {
+      protected:
+        template <template <class...> class L>
+        struct maker {
+            template <class... Args>
+            constexpr GT_FUNCTION L<Args...> operator()(Args const &...args) const {
+                return {args...};
+            }
+        };
+    };
+} // namespace gridtools
diff --git a/include/gridtools/common/hymap.hpp b/include/gridtools/common/hymap.hpp
index b065d68f9f..16166216a5 100644
--- a/include/gridtools/common/hymap.hpp
+++ b/include/gridtools/common/hymap.hpp
@@ -99,6 +99,7 @@
 
 #include "../meta.hpp"
 #include "defs.hpp"
+#include "enable_maker.hpp"
 #include "host_device.hpp"
 #include "integral_constant.hpp"
 #include "tuple.hpp"
@@ -195,14 +196,16 @@ namespace gridtools {
 
     namespace hymap {
         template <class...>
-        struct keys {
+        struct keys : private enable_maker {
             template <class...>
             struct values;
 
 #if defined(__clang__) && __clang_major__ <= 13
             template <class... Vs>
-            values(Vs const&...) -> values<Vs...>;
-#endif            
+            values(Vs const &...) -> values<Vs...>;
+#endif
+
+            static constexpr maker<values> make_values = {};
         };
 
         template <class... Keys>
@@ -217,8 +220,8 @@ namespace gridtools {
 
             constexpr GT_FUNCTION values(Vals const &...args) noexcept : m_vals(args...) {}
 
-            constexpr GT_FUNCTION values(tuple<Vals...>&& args) noexcept : m_vals(wstd::move(args)) {}
-            constexpr GT_FUNCTION values(tuple<Vals...> const & args) noexcept : m_vals(args) {}
+            constexpr GT_FUNCTION values(tuple<Vals...> &&args) noexcept : m_vals(wstd::move(args)) {}
+            constexpr GT_FUNCTION values(tuple<Vals...> const &args) noexcept : m_vals(args) {}
 
             values() = default;
             values(values const &) = default;
diff --git a/include/gridtools/common/tuple_util.hpp b/include/gridtools/common/tuple_util.hpp
index 513aa0e1e4..2715bb102d 100644
--- a/include/gridtools/common/tuple_util.hpp
+++ b/include/gridtools/common/tuple_util.hpp
@@ -119,18 +119,6 @@
 #include "implicit_cast.hpp"
 #include "utility.hpp"
 
-#define GT_TUPLE_UTIL_FORWARD_CTORS_TO_MEMBER(class_name, member_name)                                          \
-    template <class Arg,                                                                                        \
-        class... Args,                                                                                          \
-        ::std::enable_if_t<::std::is_constructible<decltype(member_name), Arg &&, Args &&...>::value, int> = 0> \
-    GT_CONSTEXPR GT_FUNCTION class_name(Arg &&arg, Args &&... args) noexcept                                    \
-        : member_name{::gridtools::wstd::forward<Arg>(arg), ::gridtools::wstd::forward<Args>(args)...} {}       \
-    class_name() = default;                                                                                     \
-    class_name(class_name const &) = default;                                                                   \
-    class_name(class_name &&) = default;                                                                        \
-    class_name &operator=(class_name const &) = default;                                                        \
-    class_name &operator=(class_name &&) = default
-
 #define GT_TUPLE_UTIL_FORWARD_GETTER_TO_MEMBER(class_name, member_name)                                    \
     struct class_name##_tuple_util_getter {                                                                \
         template <::std::size_t I>                                                                         \
@@ -251,7 +239,7 @@ namespace gridtools {
             // from_types
 
             template <class T>
-            meta::always<T> tuple_from_types(T); 
+            meta::always<T> tuple_from_types(T);
 
             // generic `tuple_from_types` that works for `std::tuple`, `std::pair` and its clones.
             // meta constructor 'L' is extracted and used to build the new "tuple like"
@@ -369,7 +357,8 @@ namespace gridtools {
             template <class Fun>
             struct get_fun_result {
                 template <class... Ts>
-                using apply = decltype(std::declval<std::add_lvalue_reference_t<std::add_const_t<Fun>>>()(std::declval<Ts>()...));
+                using apply =
+                    decltype(std::declval<std::add_lvalue_reference_t<std::add_const_t<Fun>>>()(std::declval<Ts>()...));
             };
 
             template <class Tup>
@@ -463,7 +452,7 @@ namespace gridtools {
 
         template <class T>
         struct is_tuple_like<T, std::enable_if_t<_impl::is_tuple_like<T>::value>> : std::true_type {};
-    }     // namespace tuple_util
+    } // namespace tuple_util
 
     using tuple_util::is_tuple_like;
 
@@ -475,7 +464,7 @@ namespace gridtools {
         template <class T, class... Ts>
         concept tuple_like_of = tuple_like<T> &&
             std::is_same_v<meta::rename<meta::list, tuple_util::traits::to_types<T>>, meta::list<Ts...>>;
-    }
+    } // namespace concepts
 #endif
 
 } // namespace gridtools
@@ -490,11 +479,11 @@ namespace gridtools {
 
 #ifdef GT_TARGET_HAS_DEVICE
 
-#define DEFINE_FUNCTOR_INSTANCE(name, functor)                                           \
-    template <class... Args>                                                             \
-    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) name(Args &&... args) { \
-        return functor()(wstd::forward<Args>(args)...);                                  \
-    }                                                                                    \
+#define DEFINE_FUNCTOR_INSTANCE(name, functor)                                          \
+    template <class... Args>                                                            \
+    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) name(Args &&...args) { \
+        return functor()(wstd::forward<Args>(args)...);                                 \
+    }                                                                                   \
     static_assert(1, "")
 
 #ifdef __NVCC__
@@ -547,7 +536,7 @@ namespace gridtools {
                 struct transform_elem_index_f {
                     template <class Fun, class... Tups>
                     GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) operator()(
-                        Fun &&fun, Tups &&... tups) const {
+                        Fun &&fun, Tups &&...tups) const {
                         return wstd::forward<Fun>(fun).template operator()<I>(
                             GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tups>(tups))...);
                     }
@@ -561,7 +550,7 @@ namespace gridtools {
                 template <template <class...> class L, class... Generators, class Res>
                 struct generate_f<L<Generators...>, Res> {
                     template <class... Args>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Args &&... args) const {
+                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Args &&...args) const {
                         return Res{Generators{}(wstd::forward<Args>(args)...)...};
                     }
                 };
@@ -574,7 +563,7 @@ namespace gridtools {
                     Fun m_fun;
 
                     template <class Tup, class... Tups>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto operator()(Tup &&tup, Tups &&... tups) const {
+                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto operator()(Tup &&tup, Tups &&...tups) const {
                         using indices_t = meta::make_indices<size<std::decay_t<Tup>>>;
                         using res_t =
                             from_types<Tup, get_results_t<indices_t, get_accessors<Tup>, get_accessors<Tups>...>>;
@@ -589,7 +578,7 @@ namespace gridtools {
                     Fun m_fun;
 
                     template <size_t I, class... Args>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto operator()(Args &&... args) const
+                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto operator()(Args &&...args) const
                         -> decltype(m_fun(wstd::forward<Args>(args)...)) {
                         return m_fun(wstd::forward<Args>(args)...);
                     }
@@ -603,7 +592,7 @@ namespace gridtools {
                     Fun m_fun;
                     template <size_t I, class... Args>
                     GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR meta::lazy::id<void> operator()(
-                        Args &&... args) const {
+                        Args &&...args) const {
                         m_fun(wstd::forward<Args>(args)...);
                         return {};
                     }
@@ -614,7 +603,7 @@ namespace gridtools {
                     Fun m_fun;
                     template <size_t I, class... Args>
                     GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR meta::lazy::id<void> operator()(
-                        Args &&... args) const {
+                        Args &&...args) const {
                         m_fun.template operator()<I>(wstd::forward<Args>(args)...);
                         return {};
                     }
@@ -627,7 +616,7 @@ namespace gridtools {
                 struct apply_to_elements_f<L<Is...>> {
                     template <class Fun, class... Tups>
                     GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) operator()(
-                        Fun &&fun, Tups &&... tups) const {
+                        Fun &&fun, Tups &&...tups) const {
                         return wstd::forward<Fun>(fun)(
                             GT_TARGET_NAMESPACE_NAME::get<Is::value>(wstd::forward<Tups>(tups))...);
                     }
@@ -639,7 +628,7 @@ namespace gridtools {
                 template <template <class...> class Outer, class... Inners>
                 struct for_each_in_cartesian_product_impl_f<Outer<Inners...>> {
                     template <class Fun, class... Tups>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void operator()(Fun &&fun, Tups &&... tups) const {
+                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void operator()(Fun &&fun, Tups &&...tups) const {
                         using loop_t = int[sizeof...(Inners)];
                         void(loop_t{
                             (apply_to_elements_f<Inners>{}(wstd::forward<Fun>(fun), wstd::forward<Tups>(tups)...),
@@ -651,7 +640,7 @@ namespace gridtools {
                 struct for_each_in_cartesian_product_f {
                     Fun m_fun;
                     template <class... Tups>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void operator()(Tups &&... tups) const {
+                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void operator()(Tups &&...tups) const {
                         for_each_in_cartesian_product_impl_f<
                             meta::cartesian_product<meta::make_indices_c<size<std::decay_t<Tups>>::value>...>>{}(
                             m_fun, wstd::forward<Tups>(tups)...);
@@ -683,7 +672,7 @@ namespace gridtools {
                     template <class OuterI, class InnerI>
                     struct generator_f {
                         template <class... Tups>
-                        GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) operator()(Tups &&... tups) const {
+                        GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) operator()(Tups &&...tups) const {
                             return GT_TARGET_NAMESPACE_NAME::get<InnerI::value>(
                                 select_arg_f<std::make_index_sequence<OuterI::value>>{}(wstd::forward<Tups>(tups)...));
                         }
@@ -694,7 +683,7 @@ namespace gridtools {
                         meta::make_indices_for<InnerTup>>;
 
                     template <class... Tups>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto operator()(Tups &&... tups) const {
+                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto operator()(Tups &&...tups) const {
                         using accessors_t = meta::transform<get_accessors, meta::list<Tups...>>;
                         using res_t =
                             typename ResultMaker::template apply<meta::flatten<accessors_t>, meta::list<Tups...>>;
@@ -751,7 +740,7 @@ namespace gridtools {
                 template <template <class T, T...> class L, class Int, Int... Is, class Res>
                 struct push_back_impl_f<L<Int, Is...>, Res> {
                     template <class Tup, class... Args>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup, Args &&... args) const {
+                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup, Args &&...args) const {
                         return Res{GT_TARGET_NAMESPACE_NAME::get<Is>(wstd::forward<Tup>(tup))...,
                             wstd::forward<Args>(args)...};
                     }
@@ -762,7 +751,7 @@ namespace gridtools {
                         class... Args,
                         class Accessors = get_accessors<Tup>,
                         class Res = from_types<Tup, meta::push_back<Accessors, Args &&...>>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup, Args &&... args) const {
+                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup, Args &&...args) const {
                         return push_back_impl_f<std::make_index_sequence<size<Accessors>::value>, Res>{}(
                             wstd::forward<Tup>(tup), wstd::forward<Args>(args)...);
                     }
@@ -774,7 +763,7 @@ namespace gridtools {
                 template <template <class T, T...> class L, class Int, Int... Is, class Res>
                 struct push_front_impl_f<L<Int, Is...>, Res> {
                     template <class Tup, class... Args>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup, Args &&... args) const {
+                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup, Args &&...args) const {
                         return Res{wstd::forward<Args>(args)...,
                             GT_TARGET_NAMESPACE_NAME::get<Is>(wstd::forward<Tup>(tup))...};
                     }
@@ -785,7 +774,7 @@ namespace gridtools {
                         class... Args,
                         class Accessors = get_accessors<Tup>,
                         class Res = from_types<Tup, meta::push_front<Accessors, Args &&...>>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup, Args &&... args) const {
+                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup, Args &&...args) const {
                         return push_front_impl_f<std::make_index_sequence<size<Accessors>::value>, Res>{}(
                             wstd::forward<Tup>(tup), wstd::forward<Args>(args)...);
                     }
@@ -923,25 +912,25 @@ namespace gridtools {
                     }
 
                     template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 1 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&... tups) const {
+                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&...tups) const {
                         return m_fun(GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tups>(tups))...);
                     }
 
                     template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 2 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&... tups) const {
+                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&...tups) const {
                         return m_fun(GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tups>(tups))...) &&
                                m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tups>(tups))...);
                     }
 
                     template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 3 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&... tups) const {
+                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&...tups) const {
                         return m_fun(GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tups>(tups))...) &&
                                m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tups>(tups))...) &&
                                m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 2>(wstd::forward<Tups>(tups))...);
                     }
 
                     template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 4 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&... tups) const {
+                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&...tups) const {
                         return m_fun(GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tups>(tups))...) &&
                                m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tups>(tups))...) &&
                                m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 2>(wstd::forward<Tups>(tups))...) &&
@@ -949,7 +938,7 @@ namespace gridtools {
                     }
 
                     template <size_t I, size_t N, class... Tups, std::enable_if_t<(I + 4 < N), int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&... tups) const {
+                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&...tups) const {
                         return m_fun(GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tups>(tups))...) &&
                                m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tups>(tups))...) &&
                                m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 2>(wstd::forward<Tups>(tups))...) &&
@@ -958,7 +947,7 @@ namespace gridtools {
                     }
 
                     template <class Tup, class... Tups>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool operator()(Tup &&tup, Tups &&... tups) const {
+                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool operator()(Tup &&tup, Tups &&...tups) const {
                         return impl<0, size<std::decay_t<Tup>>::value>(
                             wstd::forward<Tup>(tup), wstd::forward<Tups>(tups)...);
                     }
@@ -1100,19 +1089,19 @@ namespace gridtools {
              * };
              *
              * // Unary function, like boost::fusion::transform
-             * auto tup = std::make_tuple(1, 2, 3.5);
+             * auto tup = std::tuple(1, 2, 3.5);
              * auto fun = std::bind(add{}, 2, _1);
              * auto res = transform(fun, tup);
              * // res == {3, 4, 5.5}
              *
              * // Binary function
-             * auto tup2 = std::make_tuple(1.5, 3, 4.1);
+             * auto tup2 = std::tuple(1.5, 3, 4.1);
              * auto res2 = transform(add{}, tup, tup2);
              * // res2 == {2.5, 5, 7.6}
              * @endcode
              */
             template <class Fun, class Tup, class... Tups>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto transform(Fun && fun, Tup && tup, Tups && ... tups) {
+            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto transform(Fun && fun, Tup && tup, Tups && ...tups) {
                 return detail::transform_f<Fun>{{wstd::forward<Fun>(fun)}}(
                     wstd::forward<Tup>(tup), wstd::forward<Tups>(tups)...);
             }
@@ -1139,8 +1128,8 @@ namespace gridtools {
              * // Composable usage with only a function argument
              * auto addtuples = transform(add{});
              * // addtuples takes now two tuples as arguments
-             * auto tup1 = std::make_tuple(1, 2, 3.5);
-             * auto tup2 = std::make_tuple(1.5, 3, 4.1);
+             * auto tup1 = std::tuple(1, 2, 3.5);
+             * auto tup2 = std::tuple(1.5, 3, 4.1);
              * auto res = addtuples(tup1, tup2)
              * // res == {2.5, 5, 7.6}
              * @endcode
@@ -1152,7 +1141,7 @@ namespace gridtools {
 
             template <class Fun, class Tup, class... Tups>
             GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto transform_index(
-                Fun && fun, Tup && tup, Tups && ... tups) {
+                Fun && fun, Tup && tup, Tups && ...tups) {
                 return detail::transform_index_f<Fun>{wstd::forward<Fun>(fun)}(
                     wstd::forward<Tup>(tup), wstd::forward<Tups>(tups)...);
             }
@@ -1188,20 +1177,20 @@ namespace gridtools {
              * };
              *
              * // Unary function, like boost::fusion::for_each
-             * auto tup = std::make_tuple(1, 2, 3.5);
+             * auto tup = std::tuple(1, 2, 3.5);
              * double sum_value = 0.0;
              * for_each(sum{sum_value}, tup);
              * // sum_value == 6.5
              *
              * // Binary function
-             * auto tup2 = std::make_tuple(false, true, true);
+             * auto tup2 = std::tuple(false, true, true);
              * sum_value = 0.0;
              * for_each(sum{sum_value}, tup, tup2);
              * // sum_value == 5.5
              * @endcode
              */
             template <class Fun, class Tup, class... Tups>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void for_each(Fun && fun, Tup && tup, Tups && ... tups) {
+            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void for_each(Fun && fun, Tup && tup, Tups && ...tups) {
                 transform_index(detail::for_each_adaptor_f<Fun>{wstd::forward<Fun>(fun)},
                     wstd::forward<Tup>(tup),
                     wstd::forward<Tups>(tups)...);
@@ -1232,8 +1221,8 @@ namespace gridtools {
              * sum_value = 0.0;
              * auto sumtuples = for_each(sum{sum_value});
              * // sumtuples takes now two tuples as arguments
-             * auto tup1 = std::make_tuple(1, 2, 3.5);
-             * auto tup2 = std::make_tuple(false, true, true);
+             * auto tup1 = std::tuple(1, 2, 3.5);
+             * auto tup2 = std::tuple(false, true, true);
              * auto res = sumtuples(tup1, tup2)
              * // sum_value == 5.5
              * @endcode
@@ -1245,8 +1234,7 @@ namespace gridtools {
             }
 
             template <class Fun, class Tup, class... Tups>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void for_each_index(
-                Fun && fun, Tup && tup, Tups && ... tups) {
+            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void for_each_index(Fun && fun, Tup && tup, Tups && ...tups) {
                 transform_index(detail::for_each_index_adaptor_f<Fun>{wstd::forward<Fun>(fun)},
                     wstd::forward<Tup>(tup),
                     wstd::forward<Tups>(tups)...);
@@ -1284,13 +1272,13 @@ namespace gridtools {
              *
              * // Binary function
              * sum_value = 0.;
-             * for_each_in_cartesian_product(sum{sum_value}, std::make_tuple(1, 2, 3), std::make_tuple(1, 10));
+             * for_each_in_cartesian_product(sum{sum_value}, std::tuple(1, 2, 3), std::tuple(1, 10));
              * // sum_value == 66.
              * @endcode
              */
             template <class Fun, class Tup, class... Tups>
             GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void for_each_in_cartesian_product(
-                Fun && fun, Tup && tup, Tups && ... tups) {
+                Fun && fun, Tup && tup, Tups && ...tups) {
                 detail::for_each_in_cartesian_product_f<Fun>{wstd::forward<Fun>(fun)}(
                     wstd::forward<Tup>(tup), wstd::forward<Tups>(tups)...);
             }
@@ -1330,8 +1318,8 @@ namespace gridtools {
              *
              * Example:
              * @code
-             * auto tup1 = std::make_tuple(1, 2);
-             * auto tup2 = std::make_tuple(3, 4, 5);
+             * auto tup1 = std::tuple(1, 2);
+             * auto tup2 = std::tuple(3, 4, 5);
              * auto flat = flatten(tup1, tup2);
              * // flat == {1, 2, 3, 4, 5}
              * @endcode
@@ -1386,7 +1374,7 @@ namespace gridtools {
              * @endcode
              */
             template <class Generators, class Res, class... Args>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res generate(Args && ... args) {
+            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res generate(Args && ...args) {
                 return detail::generate_f<Generators, Res>{}(wstd::forward<Args>(args)...);
             }
 
@@ -1400,7 +1388,7 @@ namespace gridtools {
              *
              * Example:
              * @code
-             * auto tup = std::make_tuple(1, 2, 3, 4);
+             * auto tup = std::tuple(1, 2, 3, 4);
              * auto res = drop_front<2>(tup);
              * // res == {3, 4}
              * @endcode
@@ -1419,7 +1407,7 @@ namespace gridtools {
              *
              * Example:
              * @code
-             * auto tup = std::make_tuple(1, 2);
+             * auto tup = std::tuple(1, 2);
              * auto res = push_back(tup, 3, 4);
              * // res = {1, 2, 3, 4}
              * @endcode
@@ -1460,7 +1448,7 @@ namespace gridtools {
              *
              * Example:
              * @code
-             * auto tup = std::make_tuple(1, 2, 3);
+             * auto tup = std::tuple(1, 2, 3);
              *
              * // Three arguments
              * auto res = fold(std::plus<int>{}, 0, tup);
@@ -1472,8 +1460,7 @@ namespace gridtools {
              * @endcode
              */
             template <class Fun, class Arg, class... Args>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) fold(
-                Fun && fun, Arg && arg, Args && ... args) {
+            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) fold(Fun && fun, Arg && arg, Args && ...args) {
                 return detail::fold_f<Fun>{wstd::forward<Fun>(fun)}(
                     wstd::forward<Arg>(arg), wstd::forward<Args>(args)...);
             }
@@ -1490,7 +1477,7 @@ namespace gridtools {
              *
              * Example:
              * @code
-             * auto tup = std::make_tuple(1, 2, 3);
+             * auto tup = std::tuple(1, 2, 3);
              * auto folder = fold(std::plus<int>{});
              *
              * // Three arguments
@@ -1508,7 +1495,7 @@ namespace gridtools {
             }
 
             template <class Pred, class... Tups>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool all_of(Pred && pred, Tups && ... tups) {
+            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool all_of(Pred && pred, Tups && ...tups) {
                 return detail::all_of_f<Pred>{wstd::forward<Pred>(pred)}(wstd::forward<Tups>(tups)...);
             }
 
@@ -1521,8 +1508,8 @@ namespace gridtools {
              * transposes a `tuple like` of `tuple like`.
              *
              * Ex.
-             *   transpose(make<array>(make<array>(1, 2, 3), make<array>(10, 20, 30))) returns the same as
-             *   make<array>(make<array>(1, 10), make<array>(2, 20), make<array>(3, 30));
+             *   transpose(array{array{1, 2, 3}, array{10, 20, 30}}) returns the same as
+             *   array{array{1, 10}, array{2, 20}, array{3, 30}};
              */
             DEFINE_FUNCTOR_INSTANCE(transpose, detail::transpose_f);
 
@@ -1546,7 +1533,7 @@ namespace gridtools {
             namespace detail {
                 // in impl as it is not as powerful as std::invoke (does not support invoking member functions)
                 template <class Fun, class... Args>
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) invoke_impl(Fun &&f, Args &&... args) {
+                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) invoke_impl(Fun &&f, Args &&...args) {
                     return wstd::forward<Fun>(f)(wstd::forward<Args>(args)...);
                 }
 
@@ -1574,31 +1561,13 @@ namespace gridtools {
                     std::make_index_sequence<size<std::decay_t<Tup>>::value>{});
             }
 
-            /// Generalization of `std::make_tuple`
-            //
-            template <template <class...> class L, class... Ts>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR L<Ts...> make(Ts const &... elems) {
-                return L<Ts...>{elems...};
-            }
-
             /// Generalization of `std::tie`
             //
             template <template <class...> class L, class... Ts>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR L<Ts &...> tie(Ts & ... elems) {
+            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR L<Ts &...> tie(Ts & ...elems) {
                 return L<Ts &...>{elems...};
             }
 
-            /// Generalization of `std::experimental::make_array`
-            //
-            template <template <class, size_t> class Arr, class D = void, class... Ts>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR
-                Arr<typename _impl::make_array_helper<D, Ts...>::type, sizeof...(Ts)>
-                make(Ts && ... elems) {
-                using common_type_t = typename _impl::make_array_helper<D, Ts...>::type;
-                return {
-                    {gridtools::GT_TARGET_NAMESPACE_NAME::implicit_cast<common_type_t>(wstd::forward<Ts>(elems))...}};
-            }
-
             /**
              *   The family of `convert_to` functions.
              *
diff --git a/include/gridtools/gcl/high_level/descriptors_manual_gpu.hpp b/include/gridtools/gcl/high_level/descriptors_manual_gpu.hpp
index 00e75feeba..b53d512cc4 100644
--- a/include/gridtools/gcl/high_level/descriptors_manual_gpu.hpp
+++ b/include/gridtools/gcl/high_level/descriptors_manual_gpu.hpp
@@ -345,32 +345,32 @@ namespace gridtools {
                 auto ints = std::make_integer_sequence<unsigned int, sizeof...(Pointers)>{};
                 if (send_size[translate()(0, 0, -1)]) {
                     m_packZL_variadic(
-                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::make_tuple(fields...), ints);
+                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::tuple(fields...), ints);
                 }
 
                 if (send_size[translate()(0, 0, 1)]) {
                     m_packZU_variadic(
-                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::make_tuple(fields...), ints);
+                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::tuple(fields...), ints);
                 }
 
                 if (send_size[translate()(0, -1, 0)]) {
                     m_packYL_variadic(
-                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::make_tuple(fields...), ints);
+                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::tuple(fields...), ints);
                 }
 
                 if (send_size[translate()(0, 1, 0)]) {
                     m_packYU_variadic(
-                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::make_tuple(fields...), ints);
+                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::tuple(fields...), ints);
                 }
 
                 if (send_size[translate()(-1, 0, 0)]) {
                     m_packXL_variadic(
-                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::make_tuple(fields...), ints);
+                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::tuple(fields...), ints);
                 }
 
                 if (send_size[translate()(1, 0, 0)]) {
                     m_packXU_variadic(
-                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::make_tuple(fields...), ints);
+                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::tuple(fields...), ints);
                 }
 
                 for (int ii = -1; ii <= 1; ++ii)
@@ -406,27 +406,27 @@ namespace gridtools {
                 typedef translate_t<3> translate;
                 if (recv_size[translate()(0, 0, -1)]) {
                     m_unpackZL_variadic(
-                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::make_tuple(fields...), ints);
+                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::tuple(fields...), ints);
                 }
                 if (recv_size[translate()(0, 0, 1)]) {
                     m_unpackZU_variadic(
-                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::make_tuple(fields...), ints);
+                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::tuple(fields...), ints);
                 }
                 if (recv_size[translate()(0, -1, 0)]) {
                     m_unpackYL_variadic(
-                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::make_tuple(fields...), ints);
+                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::tuple(fields...), ints);
                 }
                 if (recv_size[translate()(0, 1, 0)]) {
                     m_unpackYU_variadic(
-                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::make_tuple(fields...), ints);
+                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::tuple(fields...), ints);
                 }
                 if (recv_size[translate()(-1, 0, 0)]) {
                     m_unpackXL_variadic(
-                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::make_tuple(fields...), ints);
+                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::tuple(fields...), ints);
                 }
                 if (recv_size[translate()(1, 0, 0)]) {
                     m_unpackXU_variadic(
-                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::make_tuple(fields...), ints);
+                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::tuple(fields...), ints);
                 }
             }
 
diff --git a/include/gridtools/gcl/high_level/empty_field_base.hpp b/include/gridtools/gcl/high_level/empty_field_base.hpp
index 300e557be6..4cb6fea8ec 100644
--- a/include/gridtools/gcl/high_level/empty_field_base.hpp
+++ b/include/gridtools/gcl/high_level/empty_field_base.hpp
@@ -35,7 +35,7 @@ namespace gridtools {
                     }
 
                     if (ssz == 0)
-                        return std::make_pair(MPI_INT, false);
+                        return {MPI_INT, false};
 
                     MPI_Datatype res;
                     MPI_Type_create_subarray(d,
@@ -46,7 +46,7 @@ namespace gridtools {
                         type(),
                         &res);
                     MPI_Type_commit(&res);
-                    return std::make_pair(res, true);
+                    return {res, true};
                 }
 
                 template <typename arraytype, typename arraytype2>
@@ -64,7 +64,7 @@ namespace gridtools {
                     }
 
                     if (ssz == 0)
-                        return std::make_pair(MPI_INT, false);
+                        return {MPI_INT, false};
 
                     MPI_Datatype res;
                     MPI_Type_create_subarray(d,
@@ -75,7 +75,7 @@ namespace gridtools {
                         type(),
                         &res);
                     MPI_Type_commit(&res);
-                    return std::make_pair(res, true);
+                    return {res, true};
                 }
             };
 
diff --git a/include/gridtools/sid/composite.hpp b/include/gridtools/sid/composite.hpp
index 14eae8d41f..a1d87f1035 100644
--- a/include/gridtools/sid/composite.hpp
+++ b/include/gridtools/sid/composite.hpp
@@ -14,6 +14,7 @@
 #include <utility>
 
 #include "../common/defs.hpp"
+#include "../common/enable_maker.hpp"
 #include "../common/for_each.hpp"
 #include "../common/host_device.hpp"
 #include "../common/hymap.hpp"
@@ -165,270 +166,318 @@ namespace gridtools {
              * This  means that the composite stride doesn't hold duplicate strides.
              *
              */
+            template <class...>
+            struct keys : private enable_maker {
+                template <class...>
+                struct composite_ptr;
+                template <class...>
+                struct composite_ptr_holder;
+                template <class>
+                struct compressed;
+                template <class...>
+                struct values;
+#if defined(__clang__) && __clang_major__ <= 13
+                template <class... Sids>
+                values(Sids const &...) -> values<Sids...>;
+#endif
+                static constexpr maker<values> make_values = {};
+            };
+
             template <class... Keys>
-            struct keys {
+            template <class... Ptrs>
+            struct keys<Keys...>::composite_ptr {
+                static_assert(sizeof...(Keys) == sizeof...(Ptrs), GT_INTERNAL_ERROR);
 
-                template <class... Ptrs>
-                struct composite_ptr {
-                    static_assert(sizeof...(Keys) == sizeof...(Ptrs), GT_INTERNAL_ERROR);
+                tuple<Ptrs...> m_vals;
 
-                    tuple<Ptrs...> m_vals;
+                template <class... Args, std::enable_if_t<(... && std::is_constructible_v<Ptrs, Args>), int> = 0>
+                constexpr GT_FUNCTION composite_ptr(Args &&...args) noexcept : m_vals{wstd::forward<Args>(args)...} {}
 
-                    GT_TUPLE_UTIL_FORWARD_CTORS_TO_MEMBER(composite_ptr, m_vals);
-                    
-                    GT_TUPLE_UTIL_FORWARD_GETTER_TO_MEMBER(composite_ptr, m_vals);
+                constexpr GT_FUNCTION composite_ptr(Ptrs const &...args) noexcept : m_vals(args...) {}
 
-                    GT_CONSTEXPR GT_FUNCTION decltype(auto) operator*() const {
-                        return tuple_util::host_device::convert_to<hymap::keys<Keys...>::template values>(
-                            tuple_util::host_device::transform([](auto const &ptr)
+                constexpr GT_FUNCTION composite_ptr(tuple<Ptrs...> &&args) noexcept : m_vals(wstd::move(args)) {}
+                constexpr GT_FUNCTION composite_ptr(tuple<Ptrs...> const &args) noexcept : m_vals(args) {}
+
+                composite_ptr() = default;
+                composite_ptr(composite_ptr const &) = default;
+                composite_ptr(composite_ptr &&) = default;
+                composite_ptr &operator=(composite_ptr const &) = default;
+                composite_ptr &operator=(composite_ptr &&) = default;
+
+                GT_TUPLE_UTIL_FORWARD_GETTER_TO_MEMBER(composite_ptr, m_vals);
+
+                GT_CONSTEXPR GT_FUNCTION decltype(auto) operator*() const {
+                    return tuple_util::host_device::convert_to<hymap::keys<Keys...>::template values>(
+                        tuple_util::host_device::transform([](auto const &ptr)
 // Workaround for GCC 9 bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90333
 // The failure is observed with 9.3 as well even though they say it was already fixed there.
 // gcc 10.1, 10.2 fails here as well. Disabling for all gcc 9 and 10 versions...
 #if defined(__clang__) || !defined(__GNUC__) || (__GNUC__ != 9 && __GNUC__ != 10)
-                                                                   GT_FORCE_INLINE_LAMBDA
+                                                               GT_FORCE_INLINE_LAMBDA
 #endif
-                                -> decltype(auto) { return *ptr; },
-                                m_vals));
-                    }
+                            -> decltype(auto) { return *ptr; },
+                            m_vals));
+                }
 
-                    friend keys hymap_get_keys(composite_ptr const &) { return {}; }
-                };
+                friend keys hymap_get_keys(composite_ptr const &) { return {}; }
+            };
 
-                template <class... PtrHolders>
-                struct composite_ptr_holder {
-                    static_assert(sizeof...(Keys) == sizeof...(PtrHolders), GT_INTERNAL_ERROR);
+            template <class... Keys>
+            template <class... PtrHolders>
+            struct keys<Keys...>::composite_ptr_holder {
+                static_assert(sizeof...(Keys) == sizeof...(PtrHolders), GT_INTERNAL_ERROR);
 
-                    tuple<PtrHolders...> m_vals;
-                    GT_TUPLE_UTIL_FORWARD_GETTER_TO_MEMBER(composite_ptr_holder, m_vals);
-                    GT_TUPLE_UTIL_FORWARD_CTORS_TO_MEMBER(composite_ptr_holder, m_vals);
+                tuple<PtrHolders...> m_vals;
 
-                    GT_CONSTEXPR GT_FUNCTION auto operator()() const {
-                        return tuple_util::host_device::convert_to<composite_ptr>(tuple_util::host_device::transform(
-                            [](auto const &obj) GT_FORCE_INLINE_LAMBDA { return obj(); }, m_vals));
-                    }
+                template <class... Args, std::enable_if_t<(... && std::is_constructible_v<PtrHolders, Args>), int> = 0>
+                constexpr GT_FUNCTION composite_ptr_holder(Args &&...args) noexcept
+                    : m_vals{wstd::forward<Args>(args)...} {}
 
-                    friend keys hymap_get_keys(composite_ptr_holder const &) { return {}; }
-                };
+                constexpr GT_FUNCTION composite_ptr_holder(PtrHolders const &...args) noexcept : m_vals(args...) {}
+
+                constexpr GT_FUNCTION composite_ptr_holder(tuple<PtrHolders...> &&args) noexcept
+                    : m_vals(wstd::move(args)) {}
+                constexpr GT_FUNCTION composite_ptr_holder(tuple<PtrHolders...> const &args) noexcept : m_vals(args) {}
+
+                composite_ptr_holder() = default;
+                composite_ptr_holder(composite_ptr_holder const &) = default;
+                composite_ptr_holder(composite_ptr_holder &&) = default;
+                composite_ptr_holder &operator=(composite_ptr_holder const &) = default;
+                composite_ptr_holder &operator=(composite_ptr_holder &&) = default;
+
+                GT_TUPLE_UTIL_FORWARD_GETTER_TO_MEMBER(composite_ptr_holder, m_vals);
 
+                GT_CONSTEXPR GT_FUNCTION auto operator()() const {
+                    return tuple_util::host_device::convert_to<composite_ptr>(tuple_util::host_device::transform(
+                        [](auto const &obj) GT_FORCE_INLINE_LAMBDA { return obj(); }, m_vals));
+                }
+
+                friend keys hymap_get_keys(composite_ptr_holder const &) { return {}; }
+            };
+
+            /**
+             *  Implements strides and ptr_diffs compression based on skipping the objects of the
+             *  same kind.
+             *
+             *  `composite` objects pretend to be a tuples of `uncompressed` types (aka external tuple), but
+             * internally they store a tuple of `compressed` types (aka internal tuple).
+             *
+             *  @tparam Map - compile time map from the index in external tuple to the index of internal tuple.
+             *                `compile time map` here is a tuple of tuples: `tuple<tuple<Key, Value>...>`
+             */
+            template <class... Keys>
+            template <class Map>
+            struct keys<Keys...>::compressed {
                 /**
-                 *  Implements strides and ptr_diffs compression based on skipping the objects of the
-                 *  same kind.
+                 *  Inverse map is like that: tuple<tuple<Value, Keys...>...>, where values and keys are taken
+                 *  from the source.
                  *
-                 *  `composite` objects pretend to be a tuples of `uncompressed` types (aka external tuple), but
-                 * internally they store a tuple of `compressed` types (aka internal tuple).
+                 *  In the concrete case of the map of indices it would be:
+                 *  tuple<tuple<CompressedIndex, UncompressedIndices...>>
+                 *
+                 *  Note that it could be several UncompressedIndices per one CompressedIndex
                  *
-                 *  @tparam Map - compile time map from the index in external tuple to the index of internal tuple.
-                 *                `compile time map` here is a tuple of tuples: `tuple<tuple<Key, Value>...>`
                  */
-                template <class Map>
-                struct compressed {
-                    /**
-                     *  Inverse map is like that: tuple<tuple<Value, Keys...>...>, where values and keys are taken
-                     *  from the source.
-                     *
-                     *  In the concrete case of the map of indices it would be:
-                     *  tuple<tuple<CompressedIndex, UncompressedIndices...>>
-                     *
-                     *  Note that it could be several UncompressedIndices per one CompressedIndex
-                     *
-                     */
-                    using inversed_map_t = meta::mp_inverse<Map>;
-                    /**
-                     *  A tuple of the first of UncompressedIndices per each CompressedIndex
-                     */
-                    using primary_indices_t = meta::transform<meta::second, inversed_map_t>;
-
-                    using generators_t = meta::transform<impl_::item_generator, inversed_map_t>;
-
-                    template <size_t I,
-                        class T,
-                        class Item = meta::mp_find<Map, std::integral_constant<size_t, I>>,
-                        class Pos = meta::second<Item>>
-                    static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(T &&obj) {
-                        return tuple_util::host_device::get<Pos::value>(wstd::forward<T>(obj).m_vals);
-                    }
-
-                    template <class... Ts>
-                    struct composite_entity {
-                        static_assert(sizeof...(Keys) == sizeof...(Ts), GT_INTERNAL_ERROR);
+                using inversed_map_t = meta::mp_inverse<Map>;
+                /**
+                 *  A tuple of the first of UncompressedIndices per each CompressedIndex
+                 */
+                using primary_indices_t = meta::transform<meta::second, inversed_map_t>;
 
-                        template <class I>
-                        using get_compressed_type = meta::at<meta::list<Ts...>, I>;
+                using generators_t = meta::transform<impl_::item_generator, inversed_map_t>;
 
-                        using vals_t = meta::transform<get_compressed_type, primary_indices_t>;
+                template <size_t I,
+                    class T,
+                    class Item = meta::mp_find<Map, std::integral_constant<size_t, I>>,
+                    class Pos = meta::second<Item>>
+                static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(T &&obj) {
+                    return tuple_util::host_device::get<Pos::value>(wstd::forward<T>(obj).m_vals);
+                }
 
-                        vals_t m_vals;
+                template <class... Ts>
+                struct composite_entity {
+                    static_assert(sizeof...(Keys) == sizeof...(Ts), GT_INTERNAL_ERROR);
 
-                        template <template <class...> class L, class... Args>
-                        composite_entity(impl_::ctor_tag, L<Args...> &&tup) noexcept
-                            : m_vals{tuple_util::generate<generators_t, vals_t>(std::move(tup))} {
-                            static_assert(sizeof...(Args) == sizeof...(Keys), GT_INTERNAL_ERROR);
-                        }
+                    template <class I>
+                    using get_compressed_type = meta::at<meta::list<Ts...>, I>;
 
-                        composite_entity() = default;
-                        composite_entity(composite_entity const &) = default;
-                        composite_entity(composite_entity &&) noexcept = default;
-                        composite_entity &operator=(composite_entity const &) = default;
-                        composite_entity &operator=(composite_entity &&) noexcept = default;
+                    using vals_t = meta::transform<get_compressed_type, primary_indices_t>;
 
-                        friend compressed tuple_getter(composite_entity const &) { return {}; }
+                    vals_t m_vals;
 
-                        template <class... Ptrs>
-                        friend GT_CONSTEXPR GT_FUNCTION composite_ptr<Ptrs...> operator+(
-                            composite_ptr<Ptrs...> const &lhs, composite_entity const &rhs) {
-                            return tuple_util::host_device::transform(impl_::sum(), lhs, rhs);
-                        }
+                    template <template <class...> class L, class... Args>
+                    composite_entity(impl_::ctor_tag, L<Args...> &&tup) noexcept
+                        : m_vals{tuple_util::generate<generators_t, vals_t>(std::move(tup))} {
+                        static_assert(sizeof...(Args) == sizeof...(Keys), GT_INTERNAL_ERROR);
+                    }
 
-                        template <class... PtrHolders>
-                        friend composite_ptr_holder<PtrHolders...> operator+(
-                            composite_ptr_holder<PtrHolders...> const &lhs, composite_entity const &rhs) {
-                            return tuple_util::transform(impl_::sum(), lhs, rhs);
-                        }
+                    composite_entity() = default;
+                    composite_entity(composite_entity const &) = default;
+                    composite_entity(composite_entity &&) noexcept = default;
+                    composite_entity &operator=(composite_entity const &) = default;
+                    composite_entity &operator=(composite_entity &&) noexcept = default;
 
-                        template <class... Ptrs, class Offset>
-                        friend GT_FUNCTION void sid_shift(
-                            composite_ptr<Ptrs...> &ptr, composite_entity const &stride, Offset offset) {
-                            impl_::composite_shift_impl(ptr.m_vals, stride, offset);
-                        }
+                    friend compressed tuple_getter(composite_entity const &) { return {}; }
 
-                        template <class... Ptrs, class Offset>
-                        friend GT_FUNCTION void sid_shift(
-                            composite_ptr<Ptrs...> &ptr, composite_entity &&stride, Offset offset) {
-                            impl_::composite_shift_impl(ptr.m_vals, wstd::move(stride), offset);
-                        }
+                    template <class... Ptrs>
+                    friend GT_CONSTEXPR GT_FUNCTION composite_ptr<Ptrs...> operator+(
+                        composite_ptr<Ptrs...> const &lhs, composite_entity const &rhs) {
+                        return tuple_util::host_device::transform(impl_::sum(), lhs, rhs);
+                    }
 
-                        friend keys hymap_get_keys(composite_entity const &) { return {}; }
-                    };
+                    template <class... PtrHolders>
+                    friend composite_ptr_holder<PtrHolders...> operator+(
+                        composite_ptr_holder<PtrHolders...> const &lhs, composite_entity const &rhs) {
+                        return tuple_util::transform(impl_::sum(), lhs, rhs);
+                    }
 
-                    template <class... PtrDiffs, class... Strides, class Offset>
-                    friend GT_FUNCTION void sid_shift(composite_entity<PtrDiffs...> &ptr_diff,
-                        composite_entity<Strides...> const &stride,
-                        Offset offset) {
-                        impl_::composite_shift_impl(ptr_diff.m_vals, stride.m_vals, offset);
+                    template <class... Ptrs, class Offset>
+                    friend GT_FUNCTION void sid_shift(
+                        composite_ptr<Ptrs...> &ptr, composite_entity const &stride, Offset offset) {
+                        impl_::composite_shift_impl(ptr.m_vals, stride, offset);
                     }
 
-                    template <class... PtrDiffs, class... Strides, class Offset>
+                    template <class... Ptrs, class Offset>
                     friend GT_FUNCTION void sid_shift(
-                        composite_entity<PtrDiffs...> &ptr_diff, composite_entity<Strides...> &&stride, Offset offset) {
-                        impl_::composite_shift_impl(ptr_diff.m_vals, wstd::move(stride.m_vals), offset);
+                        composite_ptr<Ptrs...> &ptr, composite_entity &&stride, Offset offset) {
+                        impl_::composite_shift_impl(ptr.m_vals, wstd::move(stride), offset);
                     }
 
-                    struct convert_f {
-                        template <template <class...> class L, class... Ts>
-                        composite_entity<std::remove_reference_t<Ts>...> operator()(L<Ts...> &&tup) const {
-                            return {impl_::ctor_tag(), std::move(tup)};
-                        }
-                    };
+                    friend keys hymap_get_keys(composite_entity const &) { return {}; }
                 };
 
-                template <class... Sids>
-                struct values {
-                    static_assert(sizeof...(Keys) == sizeof...(Sids), GT_INTERNAL_ERROR);
+                template <class... PtrDiffs, class... Strides, class Offset>
+                friend GT_FUNCTION void sid_shift(composite_entity<PtrDiffs...> &ptr_diff,
+                    composite_entity<Strides...> const &stride,
+                    Offset offset) {
+                    impl_::composite_shift_impl(ptr_diff.m_vals, stride.m_vals, offset);
+                }
+
+                template <class... PtrDiffs, class... Strides, class Offset>
+                friend GT_FUNCTION void sid_shift(
+                    composite_entity<PtrDiffs...> &ptr_diff, composite_entity<Strides...> &&stride, Offset offset) {
+                    impl_::composite_shift_impl(ptr_diff.m_vals, wstd::move(stride.m_vals), offset);
+                }
+
+                struct convert_f {
+                    template <template <class...> class L, class... Ts>
+                    composite_entity<std::remove_reference_t<Ts>...> operator()(L<Ts...> &&tup) const {
+                        return {impl_::ctor_tag(), std::move(tup)};
+                    }
+                };
+            };
+
+            template <class... Keys>
+            template <class... Sids>
+            struct keys<Keys...>::values {
+                static_assert(sizeof...(Keys) == sizeof...(Sids), GT_INTERNAL_ERROR);
 #if defined(__CUDACC_VER_MAJOR__) && __CUDACC_VER_MAJOR__ == 11 && __CUDACC_VER_MINOR__ < 1
 #else
-                    static_assert(std::conjunction<is_sid<Sids>...>::value, GT_INTERNAL_ERROR);
+                static_assert(std::conjunction<is_sid<Sids>...>::value, GT_INTERNAL_ERROR);
 #endif
-                    static_assert(meta::all<meta::mp_make<impl_::check_strides_of_the_same_kind,
-                                      meta::list<meta::list<strides_kind<Sids>, strides_type<Sids>>...>>>(),
-                        "");
+                static_assert(meta::all<meta::mp_make<impl_::check_strides_of_the_same_kind,
+                                  meta::list<meta::list<strides_kind<Sids>, strides_type<Sids>>...>>>(),
+                    "");
 
-                    tuple<Sids...> m_sids;
+                tuple<Sids...> m_sids;
 
-                    // Extracted lists of raw kinds (uncompressed)
-                    using strides_kinds_t = meta::list<strides_kind<Sids>...>;
+                // Extracted lists of raw kinds (uncompressed)
+                using strides_kinds_t = meta::list<strides_kind<Sids>...>;
 
-                    // The index map that is needed to build compressed composite objects
-                    using map_t = impl_::make_index_map<impl_::replace_unknown_kinds<strides_kinds_t>>;
-                    using compressed_t = compressed<map_t>;
+                // The index map that is needed to build compressed composite objects
+                using map_t = impl_::make_index_map<impl_::replace_unknown_kinds<strides_kinds_t>>;
+                using compressed_t = compressed<map_t>;
 
-                    template <class... Ts>
-                    using compress = typename compressed_t::template composite_entity<Ts...>;
+                template <class... Ts>
+                using compress = typename compressed_t::template composite_entity<Ts...>;
 
-                    using stride_keys_t = meta::dedup<meta::concat<get_keys<strides_type<Sids>>...>>;
+                using stride_keys_t = meta::dedup<meta::concat<get_keys<strides_type<Sids>>...>>;
 
-                    using stride_hymap_keys_t = meta::rename<hymap::keys, stride_keys_t>;
+                using stride_hymap_keys_t = meta::rename<hymap::keys, stride_keys_t>;
 
-                    template <class... Values>
-                    using stride_hymap_ctor = typename stride_hymap_keys_t::template values<Values...>;
+                template <class... Values>
+                using stride_hymap_ctor = typename stride_hymap_keys_t::template values<Values...>;
 
-                    // A helper for generating strides_t
-                    // It is a meta function from the stride key to the stride type
-                    template <class Key>
-                    using get_stride_type =
-                        compress<impl_::normalized_stride_type<Key, std::decay_t<strides_type<Sids>>>...>;
+                // A helper for generating strides_t
+                // It is a meta function from the stride key to the stride type
+                template <class Key>
+                using get_stride_type =
+                    compress<impl_::normalized_stride_type<Key, std::decay_t<strides_type<Sids>>>...>;
 
-                    // all `SID` types are here
-                    using ptr_holder_t = composite_ptr_holder<ptr_holder_type<Sids>...>;
-                    using ptr_t = composite_ptr<ptr_type<Sids>...>;
-                    using strides_t = meta::rename<stride_hymap_ctor, meta::transform<get_stride_type, stride_keys_t>>;
-                    using ptr_diff_t = compress<ptr_diff_type<Sids>...>;
+                // all `SID` types are here
+                using ptr_holder_t = composite_ptr_holder<ptr_holder_type<Sids>...>;
+                using ptr_t = composite_ptr<ptr_type<Sids>...>;
+                using strides_t = meta::rename<stride_hymap_ctor, meta::transform<get_stride_type, stride_keys_t>>;
+                using ptr_diff_t = compress<ptr_diff_type<Sids>...>;
 
-                    // Here the `SID` concept is modeled
+                // Here the `SID` concept is modeled
 
-                    friend ptr_holder_t sid_get_origin(values &obj) {
-                        return tuple_util::transform(
-                            [](auto &obj) GT_FORCE_INLINE_LAMBDA { return get_origin(obj); }, obj.m_sids);
-                    }
+                friend ptr_holder_t sid_get_origin(values &obj) {
+                    return tuple_util::transform(
+                        [](auto &obj) GT_FORCE_INLINE_LAMBDA { return get_origin(obj); }, obj.m_sids);
+                }
 
-                    template <class U = strides_t, std::enable_if_t<!meta::is_empty<U>::value, int> = 0>
-                    friend strides_t sid_get_strides(values const &obj) {
-                        return tuple_util::transform(typename compressed_t::convert_f(),
-                            tuple_util::transpose(
-                                tuple_util::transform(impl_::normalize_strides_f<stride_keys_t>(), obj.m_sids)));
-                    }
+                template <class U = strides_t, std::enable_if_t<!meta::is_empty<U>::value, int> = 0>
+                friend strides_t sid_get_strides(values const &obj) {
+                    return tuple_util::transform(typename compressed_t::convert_f(),
+                        tuple_util::transpose(
+                            tuple_util::transform(impl_::normalize_strides_f<stride_keys_t>(), obj.m_sids)));
+                }
 
-                    template <class U = strides_t, std::enable_if_t<meta::is_empty<U>::value, int> = 0>
-                    friend strides_t sid_get_strides(values const &) {
-                        return {};
-                    }
+                template <class U = strides_t, std::enable_if_t<meta::is_empty<U>::value, int> = 0>
+                friend strides_t sid_get_strides(values const &) {
+                    return {};
+                }
 
-                    friend ptr_diff_t sid_get_ptr_diff(values const &) { return {}; }
-
-                    friend unknown_kind sid_get_strides_kind(values const &) { return {}; }
-
-                    // Here the `tuple_like` concept is modeled
-                    struct getter {
-                        template <size_t I>
-                        static decltype(auto) get(values const &obj) noexcept {
-                            return tuple_util::get<I>(obj.m_sids);
-                        }
-                        template <size_t I>
-                        static decltype(auto) get(values &obj) noexcept {
-                            return tuple_util::get<I>(obj.m_sids);
-                        }
-                        template <size_t I>
-                        static decltype(auto) get(values &&obj) noexcept {
-                            return tuple_util::get<I>(std::move(obj).m_sids);
-                        }
-                    };
-                    friend getter tuple_getter(values const &) { return {}; }
-
-                    template <class Arg,
-                        class... Args,
-                        std::enable_if_t<std::is_constructible<tuple<Sids...>, Arg &&, Args &&...>::value, int> = 0>
-                    values(Arg &&arg, Args &&... args) noexcept
-                        : m_sids(std::forward<Arg>(arg), std::forward<Args>(args)...) {}
-                    values() = default;
-                    values(values const &) = default;
-                    values(values &&) = default;
-                    values &operator=(values const &) = default;
-                    values &operator=(values &&) = default;
-
-                    // hymap concept
-                    friend keys hymap_get_keys(values const &) { return {}; }
+                friend ptr_diff_t sid_get_ptr_diff(values const &) { return {}; }
+
+                friend unknown_kind sid_get_strides_kind(values const &) { return {}; }
+
+                // Here the `tuple_like` concept is modeled
+                struct getter {
+                    template <size_t I>
+                    static decltype(auto) get(values const &obj) noexcept {
+                        return tuple_util::get<I>(obj.m_sids);
+                    }
+                    template <size_t I>
+                    static decltype(auto) get(values &obj) noexcept {
+                        return tuple_util::get<I>(obj.m_sids);
+                    }
+                    template <size_t I>
+                    static decltype(auto) get(values &&obj) noexcept {
+                        return tuple_util::get<I>(std::move(obj).m_sids);
+                    }
                 };
-            };
+                friend getter tuple_getter(values const &) { return {}; }
 
-            template <class... Keys>
-            struct make_f {
-                template <class... Sids>
-                constexpr auto operator()(Sids &&... sids) const {
-                    return tuple_util::make<keys<Keys...>::template values>(std::forward<Sids>(sids)...);
-                }
+                template <class... Args, std::enable_if_t<(... && std::is_constructible_v<Sids, Args>), int> = 0>
+                constexpr values(Args &&...args) noexcept : m_sids{std::forward<Args>(args)...} {}
+
+                constexpr values(Sids const &...args) noexcept : m_sids(args...) {}
+
+                constexpr values(tuple<Sids...> &&args) noexcept : m_sids(std::move(args)) {}
+                constexpr values(tuple<Sids...> const &args) noexcept : m_sids(args) {}
+
+                values() = default;
+                values(values const &) = default;
+                values(values &&) = default;
+                values &operator=(values const &) = default;
+                values &operator=(values &&) = default;
+
+                // hymap concept
+                friend keys hymap_get_keys(values const &) { return {}; }
             };
 
-            template <class... Keys>
-            constexpr make_f<Keys...> make = {};
+            template <>
+            template <>
+            struct keys<>::values<> {
+                constexpr GT_FUNCTION values operator()() const { return {}; }
+                constexpr GT_FUNCTION values operator*() const { return {}; }
+                friend constexpr GT_FUNCTION values operator+(values, values) { return {}; }
+                friend values sid_get_origin(values) { return {}; }
+                friend values sid_get_ptr_diff(values) { return {}; }
+                friend values tuple_getter(values) { return {}; }
+            };
         } // namespace composite
     }     // namespace sid
 } // namespace gridtools
diff --git a/include/gridtools/stencil/core/grid.hpp b/include/gridtools/stencil/core/grid.hpp
index 118bf8eef2..656e40e7fd 100644
--- a/include/gridtools/stencil/core/grid.hpp
+++ b/include/gridtools/stencil/core/grid.hpp
@@ -89,7 +89,7 @@ namespace gridtools {
                 }
 
                 auto origin() const {
-                    return hymap::keys<dim::i, dim::j, dim::k>::values(m_i_start, m_j_start, offset());
+                    return hymap::keys<dim::i, dim::j, dim::k>::make_values(m_i_start, m_j_start, offset());
                 }
 
                 template <class Extent = extent<>>
@@ -122,7 +122,9 @@ namespace gridtools {
                     return extent.extend(dim::k(), 1_c + splitter_size(x) + offset(To()) - offset(From()));
                 }
 
-                auto size() const { return hymap::keys<dim::i, dim::j, dim::k>::values(i_size(), j_size(), k_size()); }
+                auto size() const {
+                    return hymap::keys<dim::i, dim::j, dim::k>::make_values(i_size(), j_size(), k_size());
+                }
             };
 
             template <class T>
diff --git a/include/gridtools/stencil/gpu/entry_point.hpp b/include/gridtools/stencil/gpu/entry_point.hpp
index ece838f18a..67fcf4c8d8 100644
--- a/include/gridtools/stencil/gpu/entry_point.hpp
+++ b/include/gridtools/stencil/gpu/entry_point.hpp
@@ -179,7 +179,7 @@ namespace gridtools {
                     return tuple_util::transform(
                         [=](auto &&src) {
                             return sid::block(std::forward<decltype(src)>(src),
-                                hymap::keys<dim::i, dim::j>::values(IBlockSize(), JBlockSize()));
+                                hymap::keys<dim::i, dim::j>::make_values(IBlockSize(), JBlockSize()));
                         },
                         std::move(data_stores));
                 }
diff --git a/include/gridtools/stencil/gpu/ij_cache.hpp b/include/gridtools/stencil/gpu/ij_cache.hpp
index ab1b89ab20..a41bca4fb2 100644
--- a/include/gridtools/stencil/gpu/ij_cache.hpp
+++ b/include/gridtools/stencil/gpu/ij_cache.hpp
@@ -25,12 +25,12 @@ namespace gridtools {
             namespace ij_cache_impl_ {
                 template <class Extent>
                 auto origin_offset(Extent) {
-                    return hymap::keys<dim::i, dim::j>::values(-Extent::minus(dim::i()), -Extent::minus(dim::j()));
+                    return hymap::keys<dim::i, dim::j>::make_values(-Extent::minus(dim::i()), -Extent::minus(dim::j()));
                 }
 
                 template <class NumColors, class IBlockSize, class JBlockSize, class Extent>
                 auto sizes(NumColors num_colors, IBlockSize i_block_size, JBlockSize j_block_size, Extent) {
-                    return hymap::keys<dim::c, dim::i, dim::j>::values(
+                    return hymap::keys<dim::c, dim::i, dim::j>::make_values(
                         num_colors, Extent::extend(dim::i(), i_block_size), Extent::extend(dim::j(), j_block_size));
                 }
 
diff --git a/include/gridtools/stencil/gpu/tmp_storage_sid.hpp b/include/gridtools/stencil/gpu/tmp_storage_sid.hpp
index da459f4151..dba3805810 100644
--- a/include/gridtools/stencil/gpu/tmp_storage_sid.hpp
+++ b/include/gridtools/stencil/gpu/tmp_storage_sid.hpp
@@ -40,7 +40,7 @@ namespace gridtools {
                     int_t k_size) {
                     return hymap::
                         keys<dim::i, dim::j, dim::c, sid::blocked_dim<dim::i>, sid::blocked_dim<dim::j>, dim::k>::
-                            values(Extent::extend(dim::i(), i_block_size),
+                            make_values(Extent::extend(dim::i(), i_block_size),
                                 Extent::extend(dim::j(), j_block_size),
                                 num_colors,
                                 n_blocks_i,
diff --git a/include/gridtools/stencil/gpu_horizontal/entry_point.hpp b/include/gridtools/stencil/gpu_horizontal/entry_point.hpp
index 355ab3045a..e5bb3a0502 100644
--- a/include/gridtools/stencil/gpu_horizontal/entry_point.hpp
+++ b/include/gridtools/stencil/gpu_horizontal/entry_point.hpp
@@ -176,7 +176,7 @@ namespace gridtools {
                             [&](std::false_type, auto info) {
                                 return sid::add_const(info.is_const(),
                                     sid::block(at_key<decltype(info.plh())>(data_stores),
-                                        hymap::keys<dim::i, dim::j>::values(IBlockSize(), JBlockSize())));
+                                        hymap::keys<dim::i, dim::j>::make_values(IBlockSize(), JBlockSize())));
                             }),
                         meta::transform<be_api::get_is_tmp, plh_map_t>(),
                         plh_map_t()));
diff --git a/include/gridtools/stencil/naive.hpp b/include/gridtools/stencil/naive.hpp
index 3a375e28dc..c114070113 100644
--- a/include/gridtools/stencil/naive.hpp
+++ b/include/gridtools/stencil/naive.hpp
@@ -39,10 +39,10 @@ namespace gridtools {
                     auto extent = info.extent();
                     auto interval = stages_t::interval();
                     auto num_colors = info.num_colors();
-                    auto offsets = hymap::keys<dim::i, dim::j, dim::k>::values(-extent.minus(dim::i()),
+                    auto offsets = hymap::keys<dim::i, dim::j, dim::k>::make_values(-extent.minus(dim::i()),
                         -extent.minus(dim::j()),
                         -grid.k_start(interval) - extent.minus(dim::k()));
-                    auto sizes = hymap::keys<dim::c, dim::k, dim::j, dim::i>::values(
+                    auto sizes = hymap::keys<dim::c, dim::k, dim::j, dim::i>::make_values(
                         num_colors, grid.k_size(interval, extent), grid.j_size(extent), grid.i_size(extent));
                     using stride_kind = meta::list<decltype(extent), decltype(num_colors)>;
                     return sid::shift_sid_origin(
diff --git a/include/gridtools/storage/info.hpp b/include/gridtools/storage/info.hpp
index 7ca16f05e6..19417a5c80 100644
--- a/include/gridtools/storage/info.hpp
+++ b/include/gridtools/storage/info.hpp
@@ -119,7 +119,7 @@ namespace gridtools {
                                          std::conjunction<std::is_convertible<Is, int_t>...>::value,
                         int> = 0>
                 GT_FUNCTION auto index(Is... indices) const {
-                    return index_from_tuple(tuple_util::host_device::make<tuple>(indices...));
+                    return index_from_tuple(tuple(indices...));
                 }
 
                 template <class Indices>
diff --git a/tests/unit_tests/CMakeLists.txt b/tests/unit_tests/CMakeLists.txt
index 6d73d7bde2..29e1eb6082 100644
--- a/tests/unit_tests/CMakeLists.txt
+++ b/tests/unit_tests/CMakeLists.txt
@@ -24,6 +24,7 @@ function(gridtools_add_unit_test tgt)
     if(NOT ARGS_NO_NVCC AND TARGET _gridtools_nvcc AND NOT nvcc_compilation_checked)
         _gt_convert_to_cuda_source(sources ${ARGS_SOURCES})
         add_library(${tgt}_nvcc OBJECT ${sources})
+        target_compile_options(${tgt}_nvcc PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--expt-relaxed-constexpr>)
         target_link_libraries(${tgt}_nvcc GridToolsTest gtest_main gmock ${ARGS_LIBRARIES})
     endif()
 
diff --git a/tests/unit_tests/boundaries/test_bindbc_utilities.cpp b/tests/unit_tests/boundaries/test_bindbc_utilities.cpp
index d905740b10..734c9b2af3 100644
--- a/tests/unit_tests/boundaries/test_bindbc_utilities.cpp
+++ b/tests/unit_tests/boundaries/test_bindbc_utilities.cpp
@@ -22,8 +22,8 @@ namespace gt = gridtools;
 namespace bd = gt::boundaries;
 
 TEST(DistributedBoundaries, SelectElement) {
-    auto all = std::make_tuple(1, _1, 3, _2);
-    auto sub = std::make_tuple(2, 4);
+    auto all = std::tuple(1, _1, 3, _2);
+    auto sub = std::tuple(2, 4);
 
     EXPECT_EQ(bd::_impl::select_element<0>(sub, all, bd::_impl::NotPlc{}), 1);
     EXPECT_EQ(bd::_impl::select_element<1>(sub, all, bd::_impl::Plc{}), 2);
@@ -43,15 +43,15 @@ namespace collect_indices {
 } // namespace collect_indices
 
 TEST(DistributedBoundaries, RestTuple) {
-    EXPECT_EQ(bd::_impl::rest_tuple(std::make_tuple(), std::make_index_sequence<0>{}), std::make_tuple());
-    EXPECT_EQ(bd::_impl::rest_tuple(std::make_tuple(1), std::make_index_sequence<0>{}), std::make_tuple());
-    EXPECT_EQ(bd::_impl::rest_tuple(std::make_tuple(1, 2), std::make_index_sequence<1>{}), std::make_tuple(2));
+    EXPECT_EQ(bd::_impl::rest_tuple(std::tuple<>(), std::make_index_sequence<0>{}), std::tuple<>());
+    EXPECT_EQ(bd::_impl::rest_tuple(std::tuple(1), std::make_index_sequence<0>{}), std::tuple<>());
+    EXPECT_EQ(bd::_impl::rest_tuple(std::tuple(1, 2), std::make_index_sequence<1>{}), std::tuple(2));
 }
 
-static_assert(!bd::_impl::contains_placeholders<decltype(std::make_tuple(3, 4, 5))>::value, "");
-static_assert(!bd::_impl::contains_placeholders<decltype(std::make_tuple())>::value, "");
-static_assert(bd::_impl::contains_placeholders<decltype(std::make_tuple(3, 4, _1))>::value, "");
-static_assert(bd::_impl::contains_placeholders<decltype(std::make_tuple(3, _2, 5))>::value, "");
+static_assert(!bd::_impl::contains_placeholders<decltype(std::tuple(3, 4, 5))>::value, "");
+static_assert(!bd::_impl::contains_placeholders<decltype(std::tuple<>())>::value, "");
+static_assert(bd::_impl::contains_placeholders<decltype(std::tuple(3, 4, _1))>::value, "");
+static_assert(bd::_impl::contains_placeholders<decltype(std::tuple(3, _2, 5))>::value, "");
 
 TEST(DistributedBoundaries, BoundBC) {
     const auto builder = gt::storage::builder<gt::storage::cpu_kfirst>.type<double>().dimensions(3, 3, 3);
@@ -63,7 +63,7 @@ TEST(DistributedBoundaries, BoundBC) {
     using ds = decltype(a);
 
     bd::bound_bc<bd::zero_boundary, std::tuple<ds, ds, ds>, std::index_sequence<1>> bbc{
-        bd::zero_boundary{}, std::make_tuple(a, b, c)};
+        bd::zero_boundary{}, std::tuple(a, b, c)};
 
     auto x = bbc.stores();
 
diff --git a/tests/unit_tests/common/test_hymap.cpp b/tests/unit_tests/common/test_hymap.cpp
index 92acf3d3c2..fc670e103d 100644
--- a/tests/unit_tests/common/test_hymap.cpp
+++ b/tests/unit_tests/common/test_hymap.cpp
@@ -88,6 +88,7 @@ namespace gridtools {
             EXPECT_EQ(7.3, at_key<b>(dst));
         }
 
+#if !defined(__NVCC__)
         TEST(deduction, smoke) {
             auto testee = hymap::keys<a, b>::values(42, 5.3);
 
@@ -98,9 +99,10 @@ namespace gridtools {
         }
 
         TEST(deduction, empty) { hymap::keys<>::values(); }
+#endif
 
         TEST(convert_hymap, smoke) {
-            auto src = hymap::keys<a, b>::values(42, 5.3);
+            auto src = hymap::keys<a, b>::make_values(42, 5.3);
 
             auto dst = tuple_util::convert_to<hymap::keys<b, c>::values>(src);
 
@@ -167,8 +169,8 @@ namespace gridtools {
         }
 
         TEST(merge, smoke) {
-            auto m1 = hymap::keys<a, b>::values(1, 2);
-            auto m2 = hymap::keys<b, c>::values(3.5, 16);
+            auto m1 = hymap::keys<a, b>::make_values(1, 2);
+            auto m2 = hymap::keys<b, c>::make_values(3.5, 16);
             auto testee = hymap::merge(m1, m2);
 
             EXPECT_EQ(1, at_key<a>(testee));
@@ -177,8 +179,8 @@ namespace gridtools {
         }
 
         TEST(concat, smoke) {
-            auto m1 = hymap::keys<a, b>::values(1, 2);
-            auto m2 = hymap::keys<c>::values(3.5);
+            auto m1 = hymap::keys<a, b>::make_values(1, 2);
+            auto m2 = hymap::keys<c>::make_values(3.5);
 
             auto testee = hymap::concat(m1, m2);
             EXPECT_EQ(1, at_key<a>(testee));
diff --git a/tests/unit_tests/common/test_int_vector.cpp b/tests/unit_tests/common/test_int_vector.cpp
index ec0f26075c..3d1b8f54ba 100644
--- a/tests/unit_tests/common/test_int_vector.cpp
+++ b/tests/unit_tests/common/test_int_vector.cpp
@@ -8,7 +8,6 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "gridtools/meta/debug.hpp"
 #include <gridtools/common/int_vector.hpp>
 
 #include <tuple>
@@ -20,25 +19,26 @@
 #include <gridtools/common/hymap.hpp>
 #include <gridtools/common/integral_constant.hpp>
 #include <gridtools/common/tuple.hpp>
-#include <gridtools/common/tuple_util.hpp>
 #include <gridtools/meta.hpp>
 
 namespace gridtools {
     namespace {
+        using namespace literals;
         struct a;
         struct b;
         struct c;
 
         TEST(plus, integrals) {
-            auto m1 = tuple_util::make<hymap::keys<a, b>::values>(1, 2l);
-            auto m2 = tuple_util::make<hymap::keys<b, c>::values>(10, 20u);
-            auto m3 = tuple_util::make<hymap::keys<b>::values>(100);
+            auto m1 = hymap::keys<a, b>::make_values(1, 2l);
+            auto m2 = hymap::keys<b, c>::make_values(10, 20u);
+            auto m3 = hymap::keys<b>::make_values(100);
 
             auto testee = int_vector::plus(m1, m2, m3);
 
-            static_assert(std::is_same<int, std::decay_t<decltype(at_key<a>(testee))>>::value);
-            static_assert(std::is_same<long int, std::decay_t<decltype(at_key<b>(testee))>>::value);
-            static_assert(std::is_same<unsigned int, std::decay_t<decltype(at_key<c>(testee))>>::value);
+            using testee_t = decltype(testee);
+            static_assert(std::is_same_v<int, element_at<a, testee_t>>);
+            static_assert(std::is_same_v<long int, element_at<b, testee_t>>);
+            static_assert(std::is_same_v<unsigned int, element_at<c, testee_t>>);
 
             EXPECT_EQ(1, at_key<a>(testee));
             EXPECT_EQ(112, at_key<b>(testee));
@@ -52,13 +52,14 @@ namespace gridtools {
         }
 
         TEST(plus, integral_constants) {
-            auto m1 = hymap::keys<a, b>::values<integral_constant<int, 1>, integral_constant<int, 2>>{};
-            auto m2 = tuple_util::make<hymap::keys<a, b>::values>(integral_constant<int, 11>{}, 12);
+            auto m1 = hymap::keys<a, b>::make_values(1_c, 2_c);
+            auto m2 = hymap::keys<a, b>::make_values(11_c, 12);
 
             auto testee = int_vector::plus(m1, m2);
 
-            static_assert(std::is_same<integral_constant<int, 12>, std::decay_t<decltype(at_key<a>(testee))>>::value);
-            static_assert(std::is_same<int, std::decay_t<decltype(at_key<b>(testee))>>::value);
+            using testee_t = decltype(testee);
+            static_assert(std::is_same_v<integral_constant<int, 12>, element_at<a, testee_t>>);
+            static_assert(std::is_same_v<int, element_at<b, testee_t>>);
 
             EXPECT_EQ(14, at_key<b>(testee));
         }
@@ -73,7 +74,7 @@ namespace gridtools {
         }
 
         TEST(multiply, integrals) {
-            auto vec = tuple_util::make<hymap::keys<a, b>::values>(integral_constant<int, 1>{}, 2);
+            auto vec = hymap::keys<a, b>::make_values(1_c, 2);
 
             auto testee = int_vector::multiply(vec, 2);
 
@@ -91,53 +92,56 @@ namespace gridtools {
         }
 
         TEST(multiply, integral_constants) {
-            auto vec = tuple_util::make<hymap::keys<a, b>::values>(integral_constant<int, 1>{}, 2);
+            auto vec = hymap::keys<a, b>::make_values(1_c, 2);
 
-            auto testee = int_vector::multiply(vec, integral_constant<int, 2>{});
+            auto testee = int_vector::multiply(vec, 2_c);
 
-            static_assert(std::is_same<integral_constant<int, 2>, std::decay_t<decltype(at_key<a>(testee))>>::value);
+            using testee_t = decltype(testee);
+            static_assert(std::is_same_v<integral_constant<int, 2>, element_at<a, testee_t>>);
             EXPECT_EQ(4, at_key<b>(testee));
         }
 
         TEST(prune_zeros, smoke) {
-            auto vec = tuple_util::make<hymap::keys<a, b, c>::values>(
-                1, integral_constant<int, 0>{}, integral_constant<int, 2>{});
+            auto vec = hymap::keys<a, b, c>::make_values(1, 0_c, 2_c);
 
             auto testee = int_vector::prune_zeros(vec);
 
             EXPECT_EQ(1, at_key<a>(testee));
-            EXPECT_FALSE((has_key<decltype(testee), b>{}));
-            static_assert(std::is_same<integral_constant<int, 2>, std::decay_t<decltype(at_key<c>(testee))>>::value);
+            using testee_t = decltype(testee);
+            static_assert(!has_key<testee_t, b>());
+            static_assert(std::is_same_v<integral_constant<int, 2>, element_at<c, testee_t>>);
         }
 
         TEST(unary_ops, smoke) {
             using namespace int_vector::arithmetic;
 
-            auto vec = tuple_util::make<hymap::keys<a, b, c>::values>(
-                1, integral_constant<int, 0>{}, integral_constant<int, 2>{});
+            auto vec = hymap::keys<a, b, c>::make_values(1, 0_c, 2_c);
 
             auto testee = -vec;
 
             EXPECT_EQ(-1, at_key<a>(testee));
-            static_assert(std::is_same<integral_constant<int, 0>, std::decay_t<decltype(at_key<b>(testee))>>::value);
-            static_assert(std::is_same<integral_constant<int, -2>, std::decay_t<decltype(at_key<c>(testee))>>::value);
+            using testee_t = decltype(testee);
+            static_assert(std::is_same_v<integral_constant<int, 0>, element_at<b, testee_t>>);
+            static_assert(std::is_same_v<integral_constant<int, -2>, element_at<c, testee_t>>);
 
             auto testee2 = +vec;
             EXPECT_EQ(1, at_key<a>(testee2));
-            static_assert(std::is_same<integral_constant<int, 0>, std::decay_t<decltype(at_key<b>(testee2))>>::value);
-            static_assert(std::is_same<integral_constant<int, 2>, std::decay_t<decltype(at_key<c>(testee2))>>::value);
+            using testee2_t = decltype(testee2);
+            static_assert(std::is_same_v<integral_constant<int, 0>, element_at<b, testee2_t>>);
+            static_assert(std::is_same_v<integral_constant<int, 2>, element_at<c, testee2_t>>);
         }
 
         TEST(minus_op, smoke) {
             using namespace int_vector::arithmetic;
 
-            auto m1 = tuple_util::make<hymap::keys<a, b>::values>(1, integral_constant<int, 2>{});
-            auto m2 = tuple_util::make<hymap::keys<a, b, c>::values>(1, integral_constant<int, 1>{}, 3);
+            auto m1 = hymap::keys<a, b>::make_values(1, 2_c);
+            auto m2 = hymap::keys<a, b, c>::make_values(1, 1_c, 3);
 
             auto testee = m1 - m2;
 
             EXPECT_EQ(0, at_key<a>(testee));
-            static_assert(std::is_same<integral_constant<int, 1>, std::decay_t<decltype(at_key<b>(testee))>>::value);
+            using testee_t = decltype(testee);
+            static_assert(std::is_same_v<integral_constant<int, 1>, element_at<b, testee_t>>);
             EXPECT_EQ(-3, at_key<c>(testee));
         }
 
diff --git a/tests/unit_tests/common/test_int_vector.cu b/tests/unit_tests/common/test_int_vector.cu
index d92e2c344e..ac020dfcc1 100644
--- a/tests/unit_tests/common/test_int_vector.cu
+++ b/tests/unit_tests/common/test_int_vector.cu
@@ -16,12 +16,12 @@
 
 #include <gridtools/common/hymap.hpp>
 #include <gridtools/common/integral_constant.hpp>
-#include <gridtools/common/tuple_util.hpp>
 
 #include <cuda_test_helper.hpp>
 
 namespace gridtools {
     namespace {
+        using namespace literals;
         struct a;
         struct b;
         struct c;
@@ -33,8 +33,8 @@ namespace gridtools {
         }
 
         TEST(plus, device) {
-            auto m1 = tuple_util::make<hymap::keys<a, b>::values>(1, 2l);
-            auto m2 = tuple_util::make<hymap::keys<b, c>::values>(10, 20u);
+            auto m1 = hymap::keys<a, b>::make_values(1, 2l);
+            auto m2 = hymap::keys<b, c>::make_values(10, 20u);
 
             auto testee = on_device::exec(GT_MAKE_INTEGRAL_CONSTANT_FROM_VALUE(&plus_device), m1, m2);
 
@@ -53,7 +53,7 @@ namespace gridtools {
         }
 
         TEST(multiply, device) {
-            auto vec = tuple_util::make<hymap::keys<a, b>::values>(integral_constant<int, 1>{}, 2);
+            auto vec = hymap::keys<a, b>::make_values(1_c, 2);
 
             auto testee = on_device::exec(GT_MAKE_INTEGRAL_CONSTANT_FROM_VALUE(&multiply_device), vec, 2);
 
@@ -67,13 +67,12 @@ namespace gridtools {
         }
 
         TEST(prune_zeros, device) {
-            auto vec = tuple_util::make<hymap::keys<a, b, c>::values>(
-                1, integral_constant<int, 0>{}, integral_constant<int, 2>{});
+            auto vec = hymap::keys<a, b, c>::make_values(1, 0_c, 2_c);
 
             auto testee = on_device::exec(GT_MAKE_INTEGRAL_CONSTANT_FROM_VALUE(&normalize_device), vec);
 
             EXPECT_EQ(1, at_key<a>(testee));
-            EXPECT_FALSE((has_key<decltype(testee), b>{}));
+            static_assert(!has_key<decltype(testee), b>());
             static_assert(std::is_same<integral_constant<int, 2>, std::decay_t<decltype(at_key<c>(testee))>>::value);
         }
 
diff --git a/tests/unit_tests/common/test_stride_util.cpp b/tests/unit_tests/common/test_stride_util.cpp
index 9f9d2065ff..848a4ba7e7 100644
--- a/tests/unit_tests/common/test_stride_util.cpp
+++ b/tests/unit_tests/common/test_stride_util.cpp
@@ -51,7 +51,7 @@ namespace gridtools {
             struct c;
 
             TEST(make_strides_from_sizes, hymap) {
-                auto testee = make_strides_from_sizes(hymap::keys<a, b, c>::values(20, 30, 40));
+                auto testee = make_strides_from_sizes(hymap::keys<a, b, c>::make_values(20, 30, 40));
                 static_assert(
                     std::is_same<decltype(testee), hymap::keys<a, b, c>::values<integral_constant<int, 1>, int, int>>{},
                     "");
diff --git a/tests/unit_tests/common/test_tuple_util.cpp b/tests/unit_tests/common/test_tuple_util.cpp
index aed322cf44..e7de8a1e52 100644
--- a/tests/unit_tests/common/test_tuple_util.cpp
+++ b/tests/unit_tests/common/test_tuple_util.cpp
@@ -40,7 +40,7 @@ namespace gridtools {
     static_assert(is_tuple_like<array<int, 42>>::value, "");
     static_assert(is_tuple_like<pair<int, double>>::value, "");
     static_assert(is_tuple_like<custom::foo>::value, "");
-    static_assert(is_tuple_like<std::tuple<int, int const, int&&, int&, int const&>>::value, "");
+    static_assert(is_tuple_like<std::tuple<int, int const, int &&, int &, int const &>>::value, "");
 
 #ifdef __cpp_concepts
     static_assert(!concepts::tuple_like<int>);
@@ -52,7 +52,7 @@ namespace gridtools {
 
     namespace tuple_util {
         TEST(get, std_tuple) {
-            auto obj = std::make_tuple(1, 2.);
+            auto obj = std::tuple(1, 2.);
             EXPECT_EQ(get<0>(obj), 1);
             EXPECT_EQ(get<1>(obj), 2);
             get<0>(obj) = 42;
@@ -60,7 +60,7 @@ namespace gridtools {
         }
 
         TEST(get, std_pair) {
-            auto obj = std::make_pair(1, 2.);
+            auto obj = std::pair(1, 2.);
             EXPECT_EQ(get<0>(obj), 1);
             EXPECT_EQ(get<1>(obj), 2);
             get<0>(obj) = 42;
@@ -68,7 +68,7 @@ namespace gridtools {
         }
 
         TEST(get, std_array) {
-            auto obj = make<std::array>(1, 2);
+            auto obj = std::array{1, 2};
             EXPECT_EQ(get<0>(obj), 1);
             EXPECT_EQ(get<1>(obj), 2);
             get<0>(obj) = 42;
@@ -98,34 +98,33 @@ namespace gridtools {
         }
 
         TEST(transform, functional) {
-            auto src = std::make_tuple(42, 5.3);
+            auto src = std::tuple(42, 5.3);
             auto res = transform(add_2_f{}, src);
             static_assert(std::is_same<decltype(res), decltype(src)>{}, "");
-            EXPECT_EQ(res, std::make_tuple(44, 7.3));
+            EXPECT_EQ(res, std::tuple(44, 7.3));
         }
 
         TEST(transform, array) {
-            auto src = make<std::array>(42, 5);
+            auto src = std::array{42, 5};
             auto res = transform(add_2_f{}, src);
             static_assert(std::is_same<decltype(res), decltype(src)>{}, "");
             EXPECT_THAT(res, testing::ElementsAre(44, 7));
         }
 
         TEST(transform, gt_array) {
-            auto src = make<gridtools::array>(42, 5);
+            auto src = gridtools::array{42, 5};
             auto res = host_device::transform(add_2_f{}, src);
             static_assert(std::is_same<decltype(res), decltype(src)>{}, "");
             EXPECT_THAT(res, testing::ElementsAre(44, 7));
         }
 
         TEST(transform, multiple_inputs) {
-            EXPECT_EQ(std::make_tuple(11, 22),
-                transform([](int lhs, int rhs) { return lhs + rhs; }, std::make_tuple(1, 2), std::make_tuple(10, 20)));
+            EXPECT_EQ(std::tuple(11, 22),
+                transform([](int lhs, int rhs) { return lhs + rhs; }, std::tuple(1, 2), std::tuple(10, 20)));
         }
 
         TEST(transform, multiple_arrays) {
-            EXPECT_THAT(
-                transform([](int lhs, int rhs) { return lhs + rhs; }, make<std::array>(1, 2), make<std::array>(10, 20)),
+            EXPECT_THAT(transform([](int lhs, int rhs) { return lhs + rhs; }, std::array{1, 2}, std::array{10, 20}),
                 testing::ElementsAre(11, 22));
         }
 
@@ -137,10 +136,10 @@ namespace gridtools {
         };
 
         TEST(transform_index, functional) {
-            auto src = std::make_tuple(42, 5.3);
+            auto src = std::tuple(42, 5.3);
             auto res = transform_index(add_index_f{}, src);
             static_assert(std::is_same<decltype(res), decltype(src)>{}, "");
-            EXPECT_EQ(res, std::make_tuple(42, 6.3));
+            EXPECT_EQ(res, std::tuple(42, 6.3));
         }
 
         struct accumulate_f {
@@ -153,13 +152,13 @@ namespace gridtools {
 
         TEST(for_each, functional) {
             double acc = 0;
-            for_each(accumulate_f{acc}, std::make_tuple(42, 5.3));
+            for_each(accumulate_f{acc}, std::tuple(42, 5.3));
             EXPECT_EQ(47.3, acc);
         }
 
         TEST(for_each, array) {
             double acc = 0;
-            for_each(accumulate_f{acc}, make<std::array>(42, 5.3));
+            for_each(accumulate_f{acc}, std::array{42., 5.3});
             EXPECT_EQ(47.3, acc);
         }
 
@@ -173,13 +172,13 @@ namespace gridtools {
 
         TEST(for_each_index, functional) {
             int acc = 0;
-            for_each_index(accumulate_index_f{acc}, std::make_tuple(42, 5));
+            for_each_index(accumulate_index_f{acc}, std::tuple(42, 5));
             EXPECT_EQ(52, acc);
         }
 
         TEST(for_each, multiple_inputs) {
             int acc = 0;
-            for_each([&](int lhs, int rhs) { acc += lhs + rhs; }, std::make_tuple(1, 2), std::make_tuple(10, 20));
+            for_each([&](int lhs, int rhs) { acc += lhs + rhs; }, std::tuple(1, 2), std::tuple(10, 20));
             EXPECT_EQ(33, acc);
         }
 
@@ -193,82 +192,72 @@ namespace gridtools {
 
         TEST(for_each_in_cartesian_product, functional) {
             double acc = 0;
-            for_each_in_cartesian_product(accumulate2_f{acc}, std::make_tuple(1, 2), std::make_tuple(10, 20));
+            for_each_in_cartesian_product(accumulate2_f{acc}, std::tuple(1, 2), std::tuple(10, 20));
             EXPECT_EQ(90, acc);
         }
 
         TEST(for_each_in_cartesian_product, array) {
             double acc = 0;
-            for_each_in_cartesian_product(accumulate2_f{acc}, make<std::array>(1, 2), make<std::array>(10, 20));
+            for_each_in_cartesian_product(accumulate2_f{acc}, std::array{1, 2}, std::array{10, 20});
             EXPECT_EQ(90, acc);
         }
 
-        TEST(concat, functional) {
-            EXPECT_EQ(concat(std::make_tuple(1, 2), std::make_tuple(3, 4)), std::make_tuple(1, 2, 3, 4));
-        }
+        TEST(concat, functional) { EXPECT_EQ(concat(std::tuple(1, 2), std::tuple(3, 4)), std::tuple(1, 2, 3, 4)); }
 
-        TEST(concat, mixed) { EXPECT_EQ(concat(std::tuple<>(), make<std::array>(3, 4)), std::make_tuple(3, 4)); }
+        TEST(concat, mixed) { EXPECT_EQ(concat(std::tuple<>(), std::array{3, 4}), std::tuple(3, 4)); }
 
         TEST(concat, array) {
-            EXPECT_THAT(concat(make<std::array>(1, 2), make<std::array>(3, 4)), testing::ElementsAre(1, 2, 3, 4));
+            EXPECT_THAT(concat(std::array{1, 2}, std::array{3, 4}), testing::ElementsAre(1, 2, 3, 4));
         }
 
         TEST(flatten, functional) {
-            EXPECT_EQ(
-                flatten(std::make_tuple(std::make_tuple(1, 2), std::make_tuple(3, 4))), std::make_tuple(1, 2, 3, 4));
+            EXPECT_EQ(flatten(std::tuple(std::tuple(1, 2), std::tuple(3, 4))), std::tuple(1, 2, 3, 4));
         }
 
         TEST(flatten, array) {
-            EXPECT_THAT(flatten(std::make_tuple(make<std::array>(1, 2), make<std::array>(3, 4))),
-                testing::ElementsAre(1, 2, 3, 4));
+            EXPECT_THAT(flatten(std::tuple(std::array{1, 2}, std::array{3, 4})), testing::ElementsAre(1, 2, 3, 4));
         }
 
         TEST(flatten, ref) {
-            auto orig = std::make_tuple(std::make_tuple(1, 2), std::make_tuple(3, 4));
+            auto orig = std::tuple(std::tuple(1, 2), std::tuple(3, 4));
             auto flat = flatten(orig);
-            EXPECT_EQ(flat, std::make_tuple(1, 2, 3, 4));
+            EXPECT_EQ(flat, std::tuple(1, 2, 3, 4));
             get<0>(flat) = 42;
             EXPECT_EQ(get<0>(get<0>(orig)), 42);
         }
 
-        TEST(drop_front, functional) { EXPECT_EQ(drop_front<2>(std::make_tuple(1, 2, 3, 4)), std::make_tuple(3, 4)); }
+        TEST(drop_front, functional) { EXPECT_EQ(drop_front<2>(std::tuple(1, 2, 3, 4)), std::tuple(3, 4)); }
 
-        TEST(drop_front, array) {
-            EXPECT_THAT(drop_front<2>(make<std::array>(1, 2, 3, 4)), testing::ElementsAre(3, 4));
-        }
+        TEST(drop_front, array) { EXPECT_THAT(drop_front<2>(std::array{1, 2, 3, 4}), testing::ElementsAre(3, 4)); }
 
-        TEST(push_back, functional) { EXPECT_EQ(push_back(std::make_tuple(1, 2), 3, 4), std::make_tuple(1, 2, 3, 4)); }
+        TEST(push_back, functional) { EXPECT_EQ(push_back(std::tuple(1, 2), 3, 4), std::tuple(1, 2, 3, 4)); }
 
-        TEST(push_back, array) {
-            EXPECT_THAT(push_back(make<std::array>(1, 2), 3, 4), testing::ElementsAre(1, 2, 3, 4));
-        }
+        TEST(push_back, array) { EXPECT_THAT(push_back(std::array{1, 2}, 3, 4), testing::ElementsAre(1, 2, 3, 4)); }
 
-        TEST(push_front, functional) {
-            EXPECT_EQ(push_front(std::make_tuple(1, 2), 3, 4), std::make_tuple(3, 4, 1, 2));
-        }
+        TEST(push_front, functional) { EXPECT_EQ(push_front(std::tuple(1, 2), 3, 4), std::tuple(3, 4, 1, 2)); }
 
-        TEST(pop_back, functional) { EXPECT_EQ(pop_back(std::make_tuple(1, 2, 3, 4)), std::make_tuple(1, 2, 3)); }
+        TEST(pop_back, functional) { EXPECT_EQ(pop_back(std::tuple(1, 2, 3, 4)), std::tuple(1, 2, 3)); }
 
-        TEST(pop_front, functional) { EXPECT_EQ(pop_front(std::make_tuple(1, 2, 3, 4)), std::make_tuple(2, 3, 4)); }
+        TEST(pop_front, functional) { EXPECT_EQ(pop_front(std::tuple(1, 2, 3, 4)), std::tuple(2, 3, 4)); }
 
         TEST(fold, functional) {
             auto f = [](int x, int y) { return x + y; };
-            EXPECT_EQ(fold(f, std::make_tuple(1, 2, 3, 4, 5, 6)), 21);
+            EXPECT_EQ(fold(f, std::tuple(1, 2, 3, 4, 5, 6)), 21);
         }
 
         TEST(fold, with_state) {
             auto f = [](int x, int y) { return x + y; };
-            EXPECT_EQ(fold(f, 100, std::make_tuple(1, 2, 3, 4, 5, 6)), 121);
+            EXPECT_EQ(fold(f, 100, std::tuple(1, 2, 3, 4, 5, 6)), 121);
         }
 
         TEST(fold, array) {
             auto f = [](int x, int y) { return x + y; };
-            EXPECT_EQ(fold(f, make<std::array>(1, 2, 3, 4, 5, 6)), 21);
+            EXPECT_EQ(fold(f, std::array{1, 2, 3, 4, 5, 6}), 21);
         }
 
         TEST(apply, lambda) {
             auto f = [](int x, int y) { return x + y; };
-            auto t = std::make_tuple(1, 2);
+            auto t = std::tuple(1, 2);
 
             EXPECT_EQ(
                 3, gridtools::tuple_util::apply(f, t)); // fully qualified to resolve ambiguity with c++17 std::apply
@@ -277,69 +266,53 @@ namespace gridtools {
         TEST(apply, array) {
             EXPECT_EQ(3,
                 gridtools::tuple_util::apply([](int x, int y) { return x + y; },
-                    make<std::array>(1, 2))); // fully qualified to resolve ambiguity with c++17 std::apply
+                    std::array{1, 2})); // fully qualified to resolve ambiguity with c++17 std::apply
         }
 
-        TEST(make, functional) { EXPECT_EQ(make<std::tuple>(42, 5.3), std::make_tuple(42, 5.3)); }
-
-        TEST(make, pair) { EXPECT_EQ(make<std::pair>(42, 5.3), std::make_pair(42, 5.3)); }
-
         TEST(tie, functional) {
             int x = 0, y = 0;
-            tie<std::tuple>(x, y) = std::make_tuple(3, 4);
+            tie<std::tuple>(x, y) = std::tuple(3, 4);
             EXPECT_EQ(3, x);
             EXPECT_EQ(4, y);
         }
 
         TEST(tie, pair) {
             int x = 0, y = 0;
-            tie<std::pair>(x, y) = std::make_pair(3, 4);
+            tie<std::pair>(x, y) = std::pair(3, 4);
             EXPECT_EQ(3, x);
             EXPECT_EQ(4, y);
         }
 
-        TEST(make, array) {
-            EXPECT_THAT(make<std::array>(3, 4), testing::ElementsAre(3, 4));
-            EXPECT_THAT((make<std::array>(3.5, 4)), testing::ElementsAre(3.5, 4.));
-            EXPECT_THAT((make<std::array, int>(3, 4.2)), testing::ElementsAre(3, 4));
-        }
-
         TEST(convert_to, tuple) {
-            EXPECT_EQ(make<std::tuple>(1, 2), convert_to<std::tuple>(make<std::array>(1, 2)));
-            EXPECT_EQ(make<std::tuple>(1, 2), convert_to<std::tuple>(make<gridtools::pair>(1, 2)));
-            EXPECT_EQ(make<std::pair>(1, 2), convert_to<std::pair>(make<gridtools::array>(1, 2)));
+            EXPECT_EQ(std::tuple(1, 2), convert_to<std::tuple>(std::array{1, 2}));
+            EXPECT_EQ(std::tuple(1, 2), convert_to<std::tuple>(gridtools::pair(1, 2)));
+            EXPECT_EQ(std::pair(1, 2), convert_to<std::pair>(gridtools::array{1, 2}));
         }
 
         TEST(convert_to, array) {
-            EXPECT_THAT(convert_to<std::array>()(make<std::tuple>(3, 4)), testing::ElementsAre(3, 4));
-            EXPECT_THAT(convert_to<std::array>(make<std::tuple>(3, 4)), testing::ElementsAre(3, 4));
-            EXPECT_THAT(convert_to<std::array>(make<std::tuple>(3.5, 4)), testing::ElementsAre(3.5, 4.));
-            EXPECT_THAT((convert_to<std::array, int>(make<std::tuple>(3.5, 4))), testing::ElementsAre(3, 4));
-            EXPECT_THAT((convert_to<std::array, int>()(make<std::tuple>(3.5, 4))), testing::ElementsAre(3, 4));
-            EXPECT_THAT((convert_to<std::array, int>(make<std::array>(3.5, 4))), testing::ElementsAre(3, 4));
+            EXPECT_THAT(convert_to<std::array>()(std::tuple(3, 4)), testing::ElementsAre(3, 4));
+            EXPECT_THAT(convert_to<std::array>(std::tuple(3, 4)), testing::ElementsAre(3, 4));
+            EXPECT_THAT(convert_to<std::array>(std::tuple(3.5, 4)), testing::ElementsAre(3.5, 4.));
+            EXPECT_THAT((convert_to<std::array, int>(std::tuple(3.5, 4))), testing::ElementsAre(3, 4));
+            EXPECT_THAT((convert_to<std::array, int>()(std::tuple(3.5, 4))), testing::ElementsAre(3, 4));
+            EXPECT_THAT((convert_to<std::array, int>(std::array{3.5, 4.})), testing::ElementsAre(3, 4));
         }
 
         TEST(transpose, functional) {
-            EXPECT_EQ(
-                transpose(make<std::array>(make<std::pair>(1, 10), make<std::pair>(2, 20), make<std::pair>(3, 30))),
-                make<std::pair>(make<std::array>(1, 2, 3), make<std::array>(10, 20, 30)));
+            EXPECT_EQ(transpose(std::array{std::pair(1, 10), std::pair(2, 20), std::pair(3, 30)}),
+                std::pair(std::array{1, 2, 3}, std::array{10, 20, 30}));
         }
 
         TEST(all_of, functional) {
             auto testee = all_of([](int i) { return i % 2; });
-            EXPECT_TRUE(testee(make<std::tuple>(1, 3, 99, 7)));
-            EXPECT_FALSE(testee(make<std::tuple>(1, 3, 2, 7, 100)));
+            EXPECT_TRUE(testee(std::tuple(1, 3, 99, 7)));
+            EXPECT_FALSE(testee(std::tuple(1, 3, 2, 7, 100)));
 
-            EXPECT_TRUE(all_of(
-                [](int l, int r) { return l == r; }, make<std::tuple>(1, 3, 99, 7), make<std::tuple>(1, 3, 99, 7)));
+            EXPECT_TRUE(all_of([](int l, int r) { return l == r; }, std::tuple(1, 3, 99, 7), std::tuple(1, 3, 99, 7)));
         }
 
-        TEST(reverse, functional) {
-            EXPECT_TRUE(reverse(make<std::tuple>(1, 'a', 42.5)) == make<std::tuple>(42.5, 'a', 1));
-        }
+        TEST(reverse, functional) { EXPECT_TRUE(reverse(std::tuple(1, 'a', 42.5)) == std::tuple(42.5, 'a', 1)); }
 
-        TEST(insert, functional) {
-            EXPECT_TRUE(insert<2>('a', make<std::tuple>(1, 2, 3)) == make<std::tuple>(1, 2, 'a', 3));
-        }
+        TEST(insert, functional) { EXPECT_TRUE(insert<2>('a', std::tuple(1, 2, 3)) == std::tuple(1, 2, 'a', 3)); }
     } // namespace tuple_util
 } // namespace gridtools
diff --git a/tests/unit_tests/sid/test_sid_block.cpp b/tests/unit_tests/sid/test_sid_block.cpp
index be2b1b3b9f..f0979361aa 100644
--- a/tests/unit_tests/sid/test_sid_block.cpp
+++ b/tests/unit_tests/sid/test_sid_block.cpp
@@ -35,7 +35,7 @@ namespace gridtools {
             constexpr int block_size_i = 3;
             const int block_size_j = 7;
 
-            auto blocks = hymap::keys<dim::i, dim::j, some_dim>::values(
+            auto blocks = hymap::keys<dim::i, dim::j, some_dim>::make_values(
                 integral_constant<int_t, block_size_i>{}, block_size_j, 5);
 
             positional_t s;
@@ -73,9 +73,10 @@ namespace gridtools {
             const int domain_size = 20;
             const int block_size_1 = 5;
             const int block_size_2 = 2;
-            auto blocked_s = sid::block(s, hymap::keys<dim::i>::values(block_size_1));
+            auto blocked_s = sid::block(s, hymap::keys<dim::i>::make_values(block_size_1));
             static_assert(is_sid<decltype(blocked_s)>(), "");
-            auto blocked_blocked_s = sid::block(blocked_s, hymap::keys<sid::blocked_dim<dim::i>>::values(block_size_2));
+            auto blocked_blocked_s =
+                sid::block(blocked_s, hymap::keys<sid::blocked_dim<dim::i>>::make_values(block_size_2));
             static_assert(is_sid<decltype(blocked_blocked_s)>(), "");
 
             auto ptr = sid::get_origin(blocked_blocked_s)();
@@ -99,7 +100,7 @@ namespace gridtools {
         TEST(sid_block, do_nothing) {
             positional_t s;
 
-            auto same_s = sid::block(s, hymap::keys<some_dim>::values(42));
+            auto same_s = sid::block(s, hymap::keys<some_dim>::make_values(42));
             static_assert(std::is_same<decltype(s), decltype(same_s)>(), "");
         }
 
@@ -108,7 +109,7 @@ namespace gridtools {
 
             const int domain_size = 20;
             const int block_size = 5;
-            auto blocked_s = sid::block(std::ref(s), hymap::keys<dim::i>::values(block_size));
+            auto blocked_s = sid::block(std::ref(s), hymap::keys<dim::i>::make_values(block_size));
             static_assert(is_sid<decltype(blocked_s)>(), "");
 
             auto ptr = sid::get_origin(blocked_s)();
@@ -130,8 +131,8 @@ namespace gridtools {
 
             using dims_t = hymap::keys<dim::i, dim::j, dim::k, some_dim>;
 
-            auto strides = dims_t::values(1, 2, 4_c, 8_c);
-            auto blocks = dims_t::values(2, 2_c, 2, 2_c);
+            auto strides = dims_t::make_values(1, 2, 4_c, 8_c);
+            auto blocks = dims_t::make_values(2, 2_c, 2, 2_c);
 
             auto s = sid::synthetic()
                          .set<sid::property::origin>(sid::simple_ptr_holder<int *>{nullptr})
diff --git a/tests/unit_tests/sid/test_sid_composite.cpp b/tests/unit_tests/sid/test_sid_composite.cpp
index c890b7f02c..fcc5e181fb 100644
--- a/tests/unit_tests/sid/test_sid_composite.cpp
+++ b/tests/unit_tests/sid/test_sid_composite.cpp
@@ -43,11 +43,22 @@ namespace gridtools {
             *sid::get_origin(testee)();
         }
 
+#if !defined(__NVCC__)
+        TEST(composite, deduction) {
+            sid::composite::keys<>::values();
+            double const src = 42;
+            double dst = 0;
+            sid::composite::keys<a, b>::values(
+                sid::synthetic().set<property::origin>(sid::host_device::make_simple_ptr_holder(&src)),
+                sid::synthetic().set<property::origin>(sid::host_device::make_simple_ptr_holder(&dst)));
+        }
+#endif
+
         TEST(composite, deref) {
             double const src = 42;
             double dst = 0;
 
-            auto testee = sid::composite::make<a, b>(
+            auto testee = sid::composite::keys<a, b>::make_values(
                 sid::synthetic().set<property::origin>(sid::host_device::make_simple_ptr_holder(&src)),
                 sid::synthetic().set<property::origin>(sid::host_device::make_simple_ptr_holder(&dst)));
             static_assert(is_sid<decltype(testee)>(), "");
@@ -75,7 +86,7 @@ namespace gridtools {
 
             auto my_strides = array{1, 5, 15};
 
-            auto testee = sid::composite::make<a, b, c, d>(                                           //
+            auto testee = sid::composite::keys<a, b, c, d>::make_values(                              //
                 sid::synthetic()                                                                      //
                     .set<property::origin>(sid::host_device::make_simple_ptr_holder(&one[0]))         //
                     .set<property::strides>(tuple(1_c))                                               //
@@ -155,17 +166,17 @@ namespace gridtools {
 
         TEST(composite, custom_dims) {
             double const one[5] = {0, 10, 20, 30, 40};
-            auto strides_one = hymap::keys<dim_x>::values(1_c);
+            auto strides_one = hymap::keys<dim_x>::make_values(1_c);
 
             double two = -1;
 
             double three[4][3][5] = {};
-            auto strides_three = hymap::keys<dim_z, dim_y, dim_x>::values(1_c, 5_c, 15_c);
+            auto strides_three = hymap::keys<dim_z, dim_y, dim_x>::make_values(1_c, 5_c, 15_c);
 
             char four[6][4][5] = {};
-            auto strides_four = hymap::keys<dim_y, dim_z, dim_x>::values(1_c, 5_c, 20_c);
+            auto strides_four = hymap::keys<dim_y, dim_z, dim_x>::make_values(1_c, 5_c, 20_c);
 
-            auto testee = sid::composite::make<a, b, c, d>(                                           //
+            auto testee = sid::composite::keys<a, b, c, d>::make_values(                              //
                 sid::synthetic()                                                                      //
                     .set<property::origin>(sid::host_device::make_simple_ptr_holder(&one[0]))         //
                     .set<property::strides>(strides_one)                                              //
@@ -203,7 +214,7 @@ namespace gridtools {
             int one[1] = {};
             int two[1][1] = {};
 
-            auto testee = sid::composite::make<a, b>(                                            //
+            auto testee = sid::composite::keys<a, b>::make_values(                               //
                 sid::synthetic()                                                                 //
                     .set<property::origin>(sid::host_device::make_simple_ptr_holder(&one[0]))    //
                     .set<property::strides>(tuple(1))                                            //
diff --git a/tests/unit_tests/sid/test_sid_concept.cpp b/tests/unit_tests/sid/test_sid_concept.cpp
index b1da9c904a..62397a9c27 100644
--- a/tests/unit_tests/sid/test_sid_concept.cpp
+++ b/tests/unit_tests/sid/test_sid_concept.cpp
@@ -133,9 +133,8 @@ namespace gridtools {
         };
 
         TEST(shift, default_overloads) {
-            namespace tu = tuple_util;
-            auto samples = tu::host_device::make<tuple>(2, 3, -2_c, -1_c, 0_c, 1_c, 2_c);
-            tu::host::for_each_in_cartesian_product(verify_shift_f{}, samples, samples);
+            auto samples = tuple(2, 3, -2_c, -1_c, 0_c, 1_c, 2_c);
+            tuple_util::for_each_in_cartesian_product(verify_shift_f{}, samples, samples);
         }
 
         TEST(shift, noop) {
diff --git a/tests/unit_tests/sid/test_sid_rename_dimensions.cpp b/tests/unit_tests/sid/test_sid_rename_dimensions.cpp
index 83d872cb8f..b9ec877c8a 100644
--- a/tests/unit_tests/sid/test_sid_rename_dimensions.cpp
+++ b/tests/unit_tests/sid/test_sid_rename_dimensions.cpp
@@ -35,8 +35,8 @@ namespace gridtools {
 
             auto src = sid::synthetic()
                            .set<property::origin>(sid::make_simple_ptr_holder(&data[0][0][0]))
-                           .set<property::strides>(hymap::keys<a, b, c>::values(5_c * 7_c, 7_c, 1_c))
-                           .set<property::upper_bounds>(hymap::keys<a, b>::values(3, 5));
+                           .set<property::strides>(hymap::keys<a, b, c>::make_values(5_c * 7_c, 7_c, 1_c))
+                           .set<property::upper_bounds>(hymap::keys<a, b>::make_values(3, 5));
 
             auto testee = sid::rename_dimensions<b, d>(src);
             using testee_t = decltype(testee);
@@ -78,11 +78,11 @@ namespace gridtools {
             double data[3][5][7];
             auto src = sid::synthetic()
                            .set<property::origin>(sid::host_device::make_simple_ptr_holder(&data[0][0][0]))
-                           .set<property::strides>(hymap::keys<a, b, c>::values(5_c * 7_c, 7_c, 1_c))
-                           .set<property::upper_bounds>(hymap::keys<a, b>::values(3, 5));
+                           .set<property::strides>(hymap::keys<a, b, c>::make_values(5_c * 7_c, 7_c, 1_c))
+                           .set<property::upper_bounds>(hymap::keys<a, b>::make_values(3, 5));
             auto testee = sid::rename_dimensions<a, c, b, d>(src);
             static_assert(sid::is_sid<decltype(testee)>::value, "");
-            auto composite = tu::make<sid::composite::keys<void>::values>(testee);
+            auto composite = sid::composite::keys<void>::make_values(testee);
             static_assert(sid::is_sid<decltype(composite)>::value, "");
             sid::get_origin(composite);
         }

From 8e122e8596a4a2036186cd6245e315f124fa5fd0 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Mon, 20 Dec 2021 12:57:22 +0100
Subject: [PATCH 03/19] fix new tests

---
 tests/unit_tests/fn/test_extents.cpp | 6 +++---
 tests/unit_tests/fn/test_extents.cu  | 4 ++--
 tests/unit_tests/fn/test_fn_scan.cpp | 2 +-
 tests/unit_tests/fn/test_fn_scan.cu  | 2 +-
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/tests/unit_tests/fn/test_extents.cpp b/tests/unit_tests/fn/test_extents.cpp
index dc9f205436..f8492ad7a4 100644
--- a/tests/unit_tests/fn/test_extents.cpp
+++ b/tests/unit_tests/fn/test_extents.cpp
@@ -14,8 +14,8 @@
 
 #include <gtest/gtest.h>
 
+#include <gridtools/common/hymap.hpp>
 #include <gridtools/common/integral_constant.hpp>
-#include <gridtools/common/tuple_util.hpp>
 
 namespace gridtools::fn {
     namespace {
@@ -51,7 +51,7 @@ namespace gridtools::fn {
 
         TEST(extents, extend_offsets) {
             using ext = extents<extent<a, -1, 0>, extent<b, 0, 2>, extent<c, 1, 1>>;
-            auto offsets = tuple_util::make<hymap::keys<a, b, c>::values>(0, 1, 2);
+            auto offsets = hymap::keys<a, b, c>::make_values(0, 1, 2);
 
             auto testee = extend_offsets<ext>(offsets);
 
@@ -62,7 +62,7 @@ namespace gridtools::fn {
 
         TEST(extents, extend_sizes) {
             using ext = extents<extent<a, -1, 0>, extent<b, 0, 2>, extent<c, 1, 1>>;
-            auto sizes = tuple_util::make<hymap::keys<a, b, c>::values>(4, 5, 6);
+            auto sizes = hymap::keys<a, b, c>::make_values(4, 5, 6);
 
             auto testee = extend_sizes<ext>(sizes);
 
diff --git a/tests/unit_tests/fn/test_extents.cu b/tests/unit_tests/fn/test_extents.cu
index 86d6aa3b22..1ce8420ae5 100644
--- a/tests/unit_tests/fn/test_extents.cu
+++ b/tests/unit_tests/fn/test_extents.cu
@@ -33,7 +33,7 @@ namespace gridtools::fn {
 
         TEST(extend_offsets, device) {
             using ext = extents<extent<a, -1, 0>, extent<b, 0, 2>, extent<c, 1, 1>>;
-            auto offsets = tuple_util::make<hymap::keys<a, b, c>::values>(0, 1, 2);
+            auto offsets = hymap::keys<a, b, c>::make_values(0, 1, 2);
 
             auto testee = on_device::exec(GT_MAKE_INTEGRAL_CONSTANT_FROM_VALUE(&extend_offsets_device<ext>), offsets);
 
@@ -50,7 +50,7 @@ namespace gridtools::fn {
 
         TEST(extend_sizes, device) {
             using ext = extents<extent<a, -1, 0>, extent<b, 0, 2>, extent<c, 1, 1>>;
-            auto sizes = tuple_util::make<hymap::keys<a, b, c>::values>(4, 5, 6);
+            auto sizes = hymap::keys<a, b, c>::make_values(4, 5, 6);
 
             auto testee = on_device::exec(GT_MAKE_INTEGRAL_CONSTANT_FROM_VALUE(&extend_sizes_device<ext>), sizes);
 
diff --git a/tests/unit_tests/fn/test_fn_scan.cpp b/tests/unit_tests/fn/test_fn_scan.cpp
index c33905c27e..9a2abc5fa0 100644
--- a/tests/unit_tests/fn/test_fn_scan.cpp
+++ b/tests/unit_tests/fn/test_fn_scan.cpp
@@ -54,7 +54,7 @@ namespace gridtools::fn {
 
             column_t a = {0, 0, 0, 0, 0};
             column_t b = {1, 2, 3, 4, 5};
-            auto composite = sid::composite::make<integral_constant<int, 0>, integral_constant<int, 1>>(
+            auto composite = sid::composite::keys<integral_constant<int, 0>, integral_constant<int, 1>>::make_values(
                 sid::synthetic()
                     .set<property::origin>(sid::host_device::make_simple_ptr_holder(&a[0]))
                     .set<property::strides>(tuple(1_c)),
diff --git a/tests/unit_tests/fn/test_fn_scan.cu b/tests/unit_tests/fn/test_fn_scan.cu
index 82d52a28e9..76315043b6 100644
--- a/tests/unit_tests/fn/test_fn_scan.cu
+++ b/tests/unit_tests/fn/test_fn_scan.cu
@@ -50,7 +50,7 @@ namespace gridtools::fn {
             auto b = cuda_util::cuda_malloc<int>(5);
             int bh[5] = {1, 2, 3, 4, 5};
             cudaMemcpy(b.get(), bh, 5 * sizeof(int), cudaMemcpyHostToDevice);
-            auto composite = sid::composite::make<integral_constant<int, 0>, integral_constant<int, 1>>(
+            auto composite = sid::composite::keys<integral_constant<int, 0>, integral_constant<int, 1>>::make_values(
                 sid::synthetic()
                     .set<property::origin>(sid::host_device::make_simple_ptr_holder(a.get()))
                     .set<property::strides>(tuple(1_c)),

From ae979fef33cb38de19ce75bd78c2884d6804ce8b Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Mon, 20 Dec 2021 13:41:20 +0100
Subject: [PATCH 04/19] try to fix clang10+nvcc

---
 include/gridtools/common/hymap.hpp  | 2 +-
 include/gridtools/sid/composite.hpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/gridtools/common/hymap.hpp b/include/gridtools/common/hymap.hpp
index 16166216a5..48522445e8 100644
--- a/include/gridtools/common/hymap.hpp
+++ b/include/gridtools/common/hymap.hpp
@@ -200,7 +200,7 @@ namespace gridtools {
             template <class...>
             struct values;
 
-#if defined(__clang__) && __clang_major__ <= 13
+#if !defined(__NVCC__) && defined(__clang__) && __clang_major__ <= 13
             template <class... Vs>
             values(Vs const &...) -> values<Vs...>;
 #endif
diff --git a/include/gridtools/sid/composite.hpp b/include/gridtools/sid/composite.hpp
index a1d87f1035..4632bd2ec6 100644
--- a/include/gridtools/sid/composite.hpp
+++ b/include/gridtools/sid/composite.hpp
@@ -176,7 +176,7 @@ namespace gridtools {
                 struct compressed;
                 template <class...>
                 struct values;
-#if defined(__clang__) && __clang_major__ <= 13
+#if !defined(__NVCC__) && defined(__clang__) && __clang_major__ <= 13
                 template <class... Sids>
                 values(Sids const &...) -> values<Sids...>;
 #endif

From 397c8750360bdcb898c8302397425e76b83b3b6e Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Mon, 20 Dec 2021 15:09:30 +0100
Subject: [PATCH 05/19] try to fix dom build

---
 tests/unit_tests/common/test_int_vector.cpp | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/tests/unit_tests/common/test_int_vector.cpp b/tests/unit_tests/common/test_int_vector.cpp
index 3d1b8f54ba..53c56b98c7 100644
--- a/tests/unit_tests/common/test_int_vector.cpp
+++ b/tests/unit_tests/common/test_int_vector.cpp
@@ -97,7 +97,7 @@ namespace gridtools {
             auto testee = int_vector::multiply(vec, 2_c);
 
             using testee_t = decltype(testee);
-            static_assert(std::is_same_v<integral_constant<int, 2>, element_at<a, testee_t>>);
+            static_assert(element_at<a, testee_t>::value == 2);
             EXPECT_EQ(4, at_key<b>(testee));
         }
 
@@ -109,7 +109,7 @@ namespace gridtools {
             EXPECT_EQ(1, at_key<a>(testee));
             using testee_t = decltype(testee);
             static_assert(!has_key<testee_t, b>());
-            static_assert(std::is_same_v<integral_constant<int, 2>, element_at<c, testee_t>>);
+            static_assert(element_at<c, testee_t>::value == 2);
         }
 
         TEST(unary_ops, smoke) {
@@ -121,14 +121,14 @@ namespace gridtools {
 
             EXPECT_EQ(-1, at_key<a>(testee));
             using testee_t = decltype(testee);
-            static_assert(std::is_same_v<integral_constant<int, 0>, element_at<b, testee_t>>);
-            static_assert(std::is_same_v<integral_constant<int, -2>, element_at<c, testee_t>>);
+            static_assert(element_at<b, testee_t>::value == 0);
+            static_assert(element_at<c, testee_t>::value == -2);
 
             auto testee2 = +vec;
             EXPECT_EQ(1, at_key<a>(testee2));
             using testee2_t = decltype(testee2);
-            static_assert(std::is_same_v<integral_constant<int, 0>, element_at<b, testee2_t>>);
-            static_assert(std::is_same_v<integral_constant<int, 2>, element_at<c, testee2_t>>);
+            static_assert(element_at<b, testee2_t>::value == 0);
+            static_assert(element_at<c, testee2_t>::value == 2);
         }
 
         TEST(minus_op, smoke) {
@@ -141,9 +141,8 @@ namespace gridtools {
 
             EXPECT_EQ(0, at_key<a>(testee));
             using testee_t = decltype(testee);
-            static_assert(std::is_same_v<integral_constant<int, 1>, element_at<b, testee_t>>);
+            static_assert(element_at<b, testee_t>::value == 1);
             EXPECT_EQ(-3, at_key<c>(testee));
         }
-
     } // namespace
 } // namespace gridtools

From 868c73f1bedbcc3f71a7af69ef2d03e040420824 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Mon, 20 Dec 2021 15:46:26 +0100
Subject: [PATCH 06/19] try to fix tsa build

---
 tests/unit_tests/common/test_hymap.cpp      | 3 ++-
 tests/unit_tests/sid/test_sid_composite.cpp | 2 ++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/unit_tests/common/test_hymap.cpp b/tests/unit_tests/common/test_hymap.cpp
index fc670e103d..e83a5f1204 100644
--- a/tests/unit_tests/common/test_hymap.cpp
+++ b/tests/unit_tests/common/test_hymap.cpp
@@ -97,8 +97,9 @@ namespace gridtools {
 
             EXPECT_EQ(42, at_key<a>(hymap::keys<a>::values(42)));
         }
-
+#if defined(__clang__) || defined(__GNUC__) && __GNUC__ > 8
         TEST(deduction, empty) { hymap::keys<>::values(); }
+#endif
 #endif
 
         TEST(convert_hymap, smoke) {
diff --git a/tests/unit_tests/sid/test_sid_composite.cpp b/tests/unit_tests/sid/test_sid_composite.cpp
index fcc5e181fb..7e491649d0 100644
--- a/tests/unit_tests/sid/test_sid_composite.cpp
+++ b/tests/unit_tests/sid/test_sid_composite.cpp
@@ -45,7 +45,9 @@ namespace gridtools {
 
 #if !defined(__NVCC__)
         TEST(composite, deduction) {
+#if defined(__clang__) || defined(__GNUC__) && __GNUC__ > 8
             sid::composite::keys<>::values();
+#endif
             double const src = 42;
             double dst = 0;
             sid::composite::keys<a, b>::values(

From 174f40cb2b6d57075d818e52c21d47bde850076d Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Mon, 20 Dec 2021 18:02:08 +0100
Subject: [PATCH 07/19] try to fix daint nvcc build

---
 include/gridtools/boundaries/bound_bc.hpp     | 11 ++++-----
 .../boundaries/distributed_boundaries.hpp     |  2 +-
 .../gcl/high_level/descriptors_manual_gpu.hpp | 24 +++++++++----------
 include/gridtools/storage/builder.hpp         |  2 +-
 .../boundaries/test_bindbc_utilities.cpp      | 20 ++++++++--------
 5 files changed, 29 insertions(+), 30 deletions(-)

diff --git a/include/gridtools/boundaries/bound_bc.hpp b/include/gridtools/boundaries/bound_bc.hpp
index 27b67328bc..6e1facf565 100644
--- a/include/gridtools/boundaries/bound_bc.hpp
+++ b/include/gridtools/boundaries/bound_bc.hpp
@@ -82,20 +82,19 @@ namespace gridtools {
             */
             template <typename ROTuple, typename AllTuple, std::size_t... IDs>
             auto substitute_placeholders(ROTuple const &ro_tuple, AllTuple const &all, std::index_sequence<IDs...>) {
-                return std::tuple(select_element<IDs>(ro_tuple,
+                return std::make_tuple(select_element<IDs>(ro_tuple,
                     all,
                     typename PlcOrNot<std::is_placeholder<std::tuple_element_t<IDs, AllTuple>>::value>::type{})...);
             }
 
-            template <typename... Elems>
-            std::tuple<> rest_tuple(std::tuple<Elems...> const&, std::index_sequence<>) { return {}; }
+            inline std::tuple<> rest_tuple(std::tuple<>, std::index_sequence<>) { return {}; }
 
             /** \internal
-                Small facility to obtain a tuple with the elements of an input  tuple execpt the first.
+                Small facility to obtain a tuple with the elements of am input  tuple execpt the first.
             */
             template <typename... Elems, std::size_t... IDs>
             auto rest_tuple(std::tuple<Elems...> const &x, std::index_sequence<IDs...>) {
-                return std::tuple(std::get<IDs + 1u>(x)...);
+                return std::make_tuple(std::get<IDs + 1u>(x)...);
             }
 
             /**
@@ -230,7 +229,7 @@ namespace gridtools {
              */
             template <typename... ReadOnly>
             auto associate(ReadOnly &&... ro_stores) const -> bound_bc<BCApply,
-                decltype(_impl::substitute_placeholders(std::tuple(ro_stores...),
+                decltype(_impl::substitute_placeholders(std::make_tuple(ro_stores...),
                     m_stores,
                     std::make_index_sequence<std::tuple_size<decltype(m_stores)>::value>{})),
                 typename _impl::comm_indices<stores_type>::type> {
diff --git a/include/gridtools/boundaries/distributed_boundaries.hpp b/include/gridtools/boundaries/distributed_boundaries.hpp
index 9e55ca89e5..20a48966e0 100644
--- a/include/gridtools/boundaries/distributed_boundaries.hpp
+++ b/include/gridtools/boundaries/distributed_boundaries.hpp
@@ -228,7 +228,7 @@ namespace gridtools {
             template <typename FirstJob>
             static auto collect_stores(
                 FirstJob const &first_job, std::enable_if_t<not is_bound_bc<FirstJob>::value, void *> = nullptr) {
-                return std::tuple(first_job);
+                return std::make_tuple(first_job);
             }
 
             template <typename Stores, uint_t... Ids>
diff --git a/include/gridtools/gcl/high_level/descriptors_manual_gpu.hpp b/include/gridtools/gcl/high_level/descriptors_manual_gpu.hpp
index b53d512cc4..00e75feeba 100644
--- a/include/gridtools/gcl/high_level/descriptors_manual_gpu.hpp
+++ b/include/gridtools/gcl/high_level/descriptors_manual_gpu.hpp
@@ -345,32 +345,32 @@ namespace gridtools {
                 auto ints = std::make_integer_sequence<unsigned int, sizeof...(Pointers)>{};
                 if (send_size[translate()(0, 0, -1)]) {
                     m_packZL_variadic(
-                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::tuple(fields...), ints);
+                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::make_tuple(fields...), ints);
                 }
 
                 if (send_size[translate()(0, 0, 1)]) {
                     m_packZU_variadic(
-                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::tuple(fields...), ints);
+                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::make_tuple(fields...), ints);
                 }
 
                 if (send_size[translate()(0, -1, 0)]) {
                     m_packYL_variadic(
-                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::tuple(fields...), ints);
+                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::make_tuple(fields...), ints);
                 }
 
                 if (send_size[translate()(0, 1, 0)]) {
                     m_packYU_variadic(
-                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::tuple(fields...), ints);
+                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::make_tuple(fields...), ints);
                 }
 
                 if (send_size[translate()(-1, 0, 0)]) {
                     m_packXL_variadic(
-                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::tuple(fields...), ints);
+                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::make_tuple(fields...), ints);
                 }
 
                 if (send_size[translate()(1, 0, 0)]) {
                     m_packXU_variadic(
-                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::tuple(fields...), ints);
+                        d_send_buffer, d_send_size, dangeroushalo, halo_d, std::make_tuple(fields...), ints);
                 }
 
                 for (int ii = -1; ii <= 1; ++ii)
@@ -406,27 +406,27 @@ namespace gridtools {
                 typedef translate_t<3> translate;
                 if (recv_size[translate()(0, 0, -1)]) {
                     m_unpackZL_variadic(
-                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::tuple(fields...), ints);
+                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::make_tuple(fields...), ints);
                 }
                 if (recv_size[translate()(0, 0, 1)]) {
                     m_unpackZU_variadic(
-                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::tuple(fields...), ints);
+                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::make_tuple(fields...), ints);
                 }
                 if (recv_size[translate()(0, -1, 0)]) {
                     m_unpackYL_variadic(
-                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::tuple(fields...), ints);
+                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::make_tuple(fields...), ints);
                 }
                 if (recv_size[translate()(0, 1, 0)]) {
                     m_unpackYU_variadic(
-                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::tuple(fields...), ints);
+                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::make_tuple(fields...), ints);
                 }
                 if (recv_size[translate()(-1, 0, 0)]) {
                     m_unpackXL_variadic(
-                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::tuple(fields...), ints);
+                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::make_tuple(fields...), ints);
                 }
                 if (recv_size[translate()(1, 0, 0)]) {
                     m_unpackXU_variadic(
-                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::tuple(fields...), ints);
+                        d_recv_buffer, d_recv_size, dangeroushalo_r, halo_d_r, std::make_tuple(fields...), ints);
                 }
             }
 
diff --git a/include/gridtools/storage/builder.hpp b/include/gridtools/storage/builder.hpp
index e6e46ba4e8..5854f9e961 100644
--- a/include/gridtools/storage/builder.hpp
+++ b/include/gridtools/storage/builder.hpp
@@ -285,7 +285,7 @@ namespace gridtools {
                     static_assert(std::conjunction<std::is_convertible<Args const &, int>...>::value,
                         "builder.halos(...) arguments should be convertible to int");
                     check_dimensions_number<sizeof...(Args)>();
-                    return add_value<param::halos>(array{static_cast<int>(values)...});
+                    return add_value<param::halos>(array<int, sizeof...(Args)>{static_cast<int>(values)...});
                 }
 
                 template <class Fun>
diff --git a/tests/unit_tests/boundaries/test_bindbc_utilities.cpp b/tests/unit_tests/boundaries/test_bindbc_utilities.cpp
index 734c9b2af3..d905740b10 100644
--- a/tests/unit_tests/boundaries/test_bindbc_utilities.cpp
+++ b/tests/unit_tests/boundaries/test_bindbc_utilities.cpp
@@ -22,8 +22,8 @@ namespace gt = gridtools;
 namespace bd = gt::boundaries;
 
 TEST(DistributedBoundaries, SelectElement) {
-    auto all = std::tuple(1, _1, 3, _2);
-    auto sub = std::tuple(2, 4);
+    auto all = std::make_tuple(1, _1, 3, _2);
+    auto sub = std::make_tuple(2, 4);
 
     EXPECT_EQ(bd::_impl::select_element<0>(sub, all, bd::_impl::NotPlc{}), 1);
     EXPECT_EQ(bd::_impl::select_element<1>(sub, all, bd::_impl::Plc{}), 2);
@@ -43,15 +43,15 @@ namespace collect_indices {
 } // namespace collect_indices
 
 TEST(DistributedBoundaries, RestTuple) {
-    EXPECT_EQ(bd::_impl::rest_tuple(std::tuple<>(), std::make_index_sequence<0>{}), std::tuple<>());
-    EXPECT_EQ(bd::_impl::rest_tuple(std::tuple(1), std::make_index_sequence<0>{}), std::tuple<>());
-    EXPECT_EQ(bd::_impl::rest_tuple(std::tuple(1, 2), std::make_index_sequence<1>{}), std::tuple(2));
+    EXPECT_EQ(bd::_impl::rest_tuple(std::make_tuple(), std::make_index_sequence<0>{}), std::make_tuple());
+    EXPECT_EQ(bd::_impl::rest_tuple(std::make_tuple(1), std::make_index_sequence<0>{}), std::make_tuple());
+    EXPECT_EQ(bd::_impl::rest_tuple(std::make_tuple(1, 2), std::make_index_sequence<1>{}), std::make_tuple(2));
 }
 
-static_assert(!bd::_impl::contains_placeholders<decltype(std::tuple(3, 4, 5))>::value, "");
-static_assert(!bd::_impl::contains_placeholders<decltype(std::tuple<>())>::value, "");
-static_assert(bd::_impl::contains_placeholders<decltype(std::tuple(3, 4, _1))>::value, "");
-static_assert(bd::_impl::contains_placeholders<decltype(std::tuple(3, _2, 5))>::value, "");
+static_assert(!bd::_impl::contains_placeholders<decltype(std::make_tuple(3, 4, 5))>::value, "");
+static_assert(!bd::_impl::contains_placeholders<decltype(std::make_tuple())>::value, "");
+static_assert(bd::_impl::contains_placeholders<decltype(std::make_tuple(3, 4, _1))>::value, "");
+static_assert(bd::_impl::contains_placeholders<decltype(std::make_tuple(3, _2, 5))>::value, "");
 
 TEST(DistributedBoundaries, BoundBC) {
     const auto builder = gt::storage::builder<gt::storage::cpu_kfirst>.type<double>().dimensions(3, 3, 3);
@@ -63,7 +63,7 @@ TEST(DistributedBoundaries, BoundBC) {
     using ds = decltype(a);
 
     bd::bound_bc<bd::zero_boundary, std::tuple<ds, ds, ds>, std::index_sequence<1>> bbc{
-        bd::zero_boundary{}, std::tuple(a, b, c)};
+        bd::zero_boundary{}, std::make_tuple(a, b, c)};
 
     auto x = bbc.stores();
 

From d2ba6a4c9798310ef5d14c16ab6abae33abe19fd Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Mon, 20 Dec 2021 21:16:11 +0100
Subject: [PATCH 08/19] try to fix tsa build again

---
 include/gridtools/common/hymap.hpp  | 3 ++-
 include/gridtools/sid/composite.hpp | 9 ++++++---
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/include/gridtools/common/hymap.hpp b/include/gridtools/common/hymap.hpp
index 48522445e8..053f287f80 100644
--- a/include/gridtools/common/hymap.hpp
+++ b/include/gridtools/common/hymap.hpp
@@ -215,7 +215,8 @@ namespace gridtools {
 
             tuple<Vals...> m_vals;
 
-            template <class... Args, std::enable_if_t<(... && std::is_constructible_v<Vals, Args>), int> = 0>
+            template <class... Args,
+                std::enable_if_t<std::conjunction_v<std::is_constructible<Vals, Args>...>, int> = 0>
             constexpr GT_FUNCTION values(Args &&...args) noexcept : m_vals{wstd::forward<Args>(args)...} {}
 
             constexpr GT_FUNCTION values(Vals const &...args) noexcept : m_vals(args...) {}
diff --git a/include/gridtools/sid/composite.hpp b/include/gridtools/sid/composite.hpp
index 4632bd2ec6..da95d961b7 100644
--- a/include/gridtools/sid/composite.hpp
+++ b/include/gridtools/sid/composite.hpp
@@ -190,7 +190,8 @@ namespace gridtools {
 
                 tuple<Ptrs...> m_vals;
 
-                template <class... Args, std::enable_if_t<(... && std::is_constructible_v<Ptrs, Args>), int> = 0>
+                template <class... Args,
+                    std::enable_if_t<std::conjunction_v<std::is_constructible<Ptrs, Args>...>, int> = 0>
                 constexpr GT_FUNCTION composite_ptr(Args &&...args) noexcept : m_vals{wstd::forward<Args>(args)...} {}
 
                 constexpr GT_FUNCTION composite_ptr(Ptrs const &...args) noexcept : m_vals(args...) {}
@@ -229,7 +230,8 @@ namespace gridtools {
 
                 tuple<PtrHolders...> m_vals;
 
-                template <class... Args, std::enable_if_t<(... && std::is_constructible_v<PtrHolders, Args>), int> = 0>
+                template <class... Args,
+                    std::enable_if_t<std::conjunction_v<std::is_constructible<PtrHolders, Args>...>, int> = 0>
                 constexpr GT_FUNCTION composite_ptr_holder(Args &&...args) noexcept
                     : m_vals{wstd::forward<Args>(args)...} {}
 
@@ -450,7 +452,8 @@ namespace gridtools {
                 };
                 friend getter tuple_getter(values const &) { return {}; }
 
-                template <class... Args, std::enable_if_t<(... && std::is_constructible_v<Sids, Args>), int> = 0>
+                template <class... Args,
+                    std::enable_if_t<std::conjunction_v<std::is_constructible<Sids, Args>...>, int> = 0>
                 constexpr values(Args &&...args) noexcept : m_sids{std::forward<Args>(args)...} {}
 
                 constexpr values(Sids const &...args) noexcept : m_sids(args...) {}

From 20685d7d5eaa70a8d1197b7eaa31110f16d76bb8 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Tue, 21 Dec 2021 13:44:09 +0100
Subject: [PATCH 09/19] save the state

---
 include/gridtools/common/array.hpp                   |  9 +++++++++
 include/gridtools/common/cuda_util.hpp               |  4 ++--
 include/gridtools/common/pair.hpp                    |  7 +++++++
 include/gridtools/common/tuple.hpp                   |  7 +++++++
 include/gridtools/common/utility.hpp                 | 10 ++++++++++
 include/gridtools/sid/concept.hpp                    |  2 +-
 include/gridtools/stencil/global_parameter.hpp       |  2 +-
 include/gridtools/stencil/gpu/launch_kernel.hpp      |  4 ++--
 .../stencil/gpu_horizontal/launch_kernel.hpp         |  2 +-
 .../gridtools/storage/adapter/python_sid_adapter.hpp |  8 ++++----
 tests/include/cuda_test_helper.hpp                   | 10 ++++++----
 .../test_layout_transformation.cpp                   |  8 +++++---
 tests/unit_tests/sid/test_sid_synthetic.cpp          | 12 ++++++------
 13 files changed, 61 insertions(+), 24 deletions(-)

diff --git a/include/gridtools/common/array.hpp b/include/gridtools/common/array.hpp
index 429b910d85..c2f7745486 100644
--- a/include/gridtools/common/array.hpp
+++ b/include/gridtools/common/array.hpp
@@ -12,6 +12,14 @@
 @file
 @brief Implementation of an array class
 */
+
+#include <array>
+
+namespace gridtools {
+    using std::array;
+}
+
+#if 0
 #include <algorithm>
 #include <cassert>
 #include <iterator>
@@ -199,3 +207,4 @@ namespace std {
         using type = T;
     };
 } // namespace std
+#endif
diff --git a/include/gridtools/common/cuda_util.hpp b/include/gridtools/common/cuda_util.hpp
index 30cc3b2574..907f55fbf4 100644
--- a/include/gridtools/common/cuda_util.hpp
+++ b/include/gridtools/common/cuda_util.hpp
@@ -60,14 +60,14 @@ namespace gridtools {
             return unique_cuda_ptr<T>{ptr};
         }
 
-        template <class T, std::enable_if_t<std::is_trivially_copyable<T>::value, int> = 0>
+        template <class T, std::enable_if_t<std::is_trivially_copy_constructible_v<T>, int> = 0>
         unique_cuda_ptr<T> make_clone(T const &src) {
             unique_cuda_ptr<T> res = cuda_malloc<T>();
             GT_CUDA_CHECK(cudaMemcpy(res.get(), &src, sizeof(T), cudaMemcpyHostToDevice));
             return res;
         }
 
-        template <class T, std::enable_if_t<std::is_trivially_copyable<T>::value, int> = 0>
+        template <class T, std::enable_if_t<std::is_trivially_copy_constructible_v<T>, int> = 0>
         T from_clone(unique_cuda_ptr<T> const &clone) {
             T res;
             GT_CUDA_CHECK(cudaMemcpy(&res, clone.get(), sizeof(T), cudaMemcpyDeviceToHost));
diff --git a/include/gridtools/common/pair.hpp b/include/gridtools/common/pair.hpp
index a3927e02e8..7505a86b76 100644
--- a/include/gridtools/common/pair.hpp
+++ b/include/gridtools/common/pair.hpp
@@ -8,7 +8,13 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 #pragma once
+#include <utility>
+
+namespace gridtools{
+    using std::pair;
+}
 
+#if 0
 #include <cstddef>
 #include <tuple>
 #include <type_traits>
@@ -192,3 +198,4 @@ namespace std {
         using type = T2;
     };
 } // namespace std
+#endif
\ No newline at end of file
diff --git a/include/gridtools/common/tuple.hpp b/include/gridtools/common/tuple.hpp
index 0611eb9b4c..bb43153446 100644
--- a/include/gridtools/common/tuple.hpp
+++ b/include/gridtools/common/tuple.hpp
@@ -10,6 +10,12 @@
 
 #pragma once
 
+#include <tuple>
+
+namespace gridtools {
+    using ::std::tuple;
+}
+#if 0
 #include <cstdlib>
 #include <tuple>
 #include <type_traits>
@@ -308,3 +314,4 @@ namespace std {
         using type = gridtools::meta::at_c<::gridtools::tuple<Ts...>, I>;
     };
 } // namespace std
+#endif
diff --git a/include/gridtools/common/utility.hpp b/include/gridtools/common/utility.hpp
index bc71c700f1..5860569cb1 100644
--- a/include/gridtools/common/utility.hpp
+++ b/include/gridtools/common/utility.hpp
@@ -9,7 +9,16 @@
  */
 
 #pragma once
+#include <utility>
+
+namespace gridtools {
+    namespace wstd {
+        using ::std::forward;
+        using ::std::move;
+    } // namespace wstd
+} // namespace gridtools
 
+#if 0
 #include <tuple>
 #include <type_traits>
 #include <utility>
@@ -42,3 +51,4 @@ namespace gridtools {
 
     } // namespace wstd
 } // namespace gridtools
+#endif
\ No newline at end of file
diff --git a/include/gridtools/sid/concept.hpp b/include/gridtools/sid/concept.hpp
index 1d2f2c9892..c5cb1a9906 100644
--- a/include/gridtools/sid/concept.hpp
+++ b/include/gridtools/sid/concept.hpp
@@ -611,7 +611,7 @@ namespace gridtools {
                 class UpperBoundsType = upper_bounds_type<Sid>>
             using is_sid = std::conjunction<
 
-                // `is_trivially_copyable` check is applied to the types that are will be passed from host to device
+                // `is_trivially_copy_constructible` check is applied to the types that are will be passed from host to device
                 std::is_trivially_copy_constructible<PtrHolder>,
                 std::is_trivially_copy_constructible<StridesType>,
 
diff --git a/include/gridtools/stencil/global_parameter.hpp b/include/gridtools/stencil/global_parameter.hpp
index 40ef5944a6..493fa6a317 100644
--- a/include/gridtools/stencil/global_parameter.hpp
+++ b/include/gridtools/stencil/global_parameter.hpp
@@ -22,7 +22,7 @@ namespace gridtools {
 
             template <class T>
             struct global_parameter {
-                static_assert(std::is_trivially_copyable<T>(), "global parameter should be trivially copyable");
+                static_assert(std::is_trivially_copy_constructible_v<T>, "global parameter should be trivially copyable");
 
                 T m_value;
 
diff --git a/include/gridtools/stencil/gpu/launch_kernel.hpp b/include/gridtools/stencil/gpu/launch_kernel.hpp
index e8e275b40f..a9b27e3fbf 100644
--- a/include/gridtools/stencil/gpu/launch_kernel.hpp
+++ b/include/gridtools/stencil/gpu/launch_kernel.hpp
@@ -142,7 +142,7 @@ namespace gridtools {
                     static_assert(Extent::iminus::value <= 0, GT_INTERNAL_ERROR);
                     static_assert(Extent::iplus::value >= 0, GT_INTERNAL_ERROR);
 
-                    static_assert(std::is_trivially_copyable<Fun>::value, GT_INTERNAL_ERROR);
+                    static_assert(std::is_trivially_copy_constructible_v<Fun>, GT_INTERNAL_ERROR);
 
                     static constexpr auto halo_lines = Extent::jplus::value - Extent::jminus::value +
                                                        (Extent::iminus::value < 0 ? 1 : 0) +
@@ -171,7 +171,7 @@ namespace gridtools {
                     std::enable_if_t<is_empty_ij_extents<Extent>(), int> = 0>
                 void launch_kernel(int_t i_size, int_t j_size, uint_t zblocks, Fun fun, size_t shared_memory_size = 0) {
 
-                    static_assert(std::is_trivially_copyable<Fun>::value, GT_INTERNAL_ERROR);
+                    static_assert(std::is_trivially_copy_constructible_v<Fun>, GT_INTERNAL_ERROR);
 
                     static const size_t num_threads = BlockSizeI * BlockSizeJ;
 
diff --git a/include/gridtools/stencil/gpu_horizontal/launch_kernel.hpp b/include/gridtools/stencil/gpu_horizontal/launch_kernel.hpp
index a05625022c..0885a76a8b 100644
--- a/include/gridtools/stencil/gpu_horizontal/launch_kernel.hpp
+++ b/include/gridtools/stencil/gpu_horizontal/launch_kernel.hpp
@@ -55,7 +55,7 @@ namespace gridtools {
 
                 template <int_t BlockSizeI, int_t BlockSizeJ, class Fun>
                 void launch_kernel(int_t i_size, int_t j_size, uint_t zblocks, Fun fun) {
-                    static_assert(std::is_trivially_copyable<Fun>::value, GT_INTERNAL_ERROR);
+                    static_assert(std::is_trivially_copy_constructible_v<Fun>, GT_INTERNAL_ERROR);
 
                     cuda_util::launch(
                         dim3((i_size + BlockSizeI - 1) / BlockSizeI, (j_size + BlockSizeJ - 1) / BlockSizeJ, zblocks),
diff --git a/include/gridtools/storage/adapter/python_sid_adapter.hpp b/include/gridtools/storage/adapter/python_sid_adapter.hpp
index 245d5ce3c8..64bd1f66f0 100644
--- a/include/gridtools/storage/adapter/python_sid_adapter.hpp
+++ b/include/gridtools/storage/adapter/python_sid_adapter.hpp
@@ -113,8 +113,8 @@ namespace gridtools {
 
         template <class T, std::size_t Dim, class Kind = void, size_t UnitStrideDim = size_t(-1)>
         wrapper<T, Dim, Kind, UnitStrideDim> as_sid(pybind11::buffer const &src) {
-            static_assert(
-                std::is_trivially_copyable<T>::value, "as_sid should be instantiated with the trivially copyable type");
+            static_assert(std::is_trivially_copy_constructible_v<T>,
+                "as_sid should be instantiated with the trivially copy constructible type");
             constexpr bool writable = !std::is_const<T>();
             // pybind11::buffer::request accepts writable as an optional parameter (default is false).
             // if writable is true PyBUF_WRITABLE flag is added while delegating to the PyObject_GetBuffer.
@@ -266,8 +266,8 @@ namespace gridtools {
 
         template <class T, size_t Dim, class Kind = void, size_t UnitStrideDim = size_t(-1)>
         auto as_cuda_sid(pybind11::object const &src) {
-            static_assert(std::is_trivially_copyable<T>::value,
-                "as_cuda_sid should be instantiated with the trivially copyable type");
+            static_assert(std::is_trivially_copy_constructible_v<T>,
+                "as_cuda_sid should be instantiated with the trivially copy constructible type");
 
             auto iface = src.attr("__cuda_array_interface__").cast<pybind11::dict>();
 
diff --git a/tests/include/cuda_test_helper.hpp b/tests/include/cuda_test_helper.hpp
index 851b4bf00c..b1e35c12be 100644
--- a/tests/include/cuda_test_helper.hpp
+++ b/tests/include/cuda_test_helper.hpp
@@ -26,11 +26,12 @@ namespace gridtools {
         // integral_constant will be taken instead of explicit conversion
         template <class T, T (*Fun)()>
         __global__ void kernel(T *res, integral_constant<T (*)(), Fun>) {
-            *res = Fun();
+            T in{Fun()};
+            memcpy(res, &in, sizeof(T));
         }
         template <class T, T (*Fun)()>
         T exec_with_shared_memory(size_t shm_size, integral_constant<T (*)(), Fun> fun) {
-            static_assert(std::is_trivially_copyable<T>::value, "");
+            static_assert(std::is_trivially_copy_constructible_v<T>);
             auto res = cuda_util::cuda_malloc<T>();
             kernel<<<1, 1, shm_size>>>(res.get(), fun);
             GT_CUDA_CHECK(cudaDeviceSynchronize());
@@ -39,14 +40,15 @@ namespace gridtools {
 
         template <class Res, class Fun, class... Args>
         __global__ void kernel(Res *res, Fun fun, Args... args) {
-            *res = fun(args...);
+            Res in{fun(std::move(args)...)};
+            memcpy(res, &in, sizeof(Res));
         }
         template <class Fun, class... Args>
         auto exec_with_shared_memory(size_t shm_size, Fun fun, Args... args) {
             static_assert(!std::is_pointer<Fun>::value, "");
             static_assert(std::conjunction<std::negation<std::is_pointer<Args>>...>::value, "");
             using res_t = std::decay_t<decltype(fun(args...))>;
-            static_assert(std::is_trivially_copyable<res_t>::value, "");
+            static_assert(std::is_trivially_copy_constructible_v<res_t>);
             auto res = cuda_util::cuda_malloc<res_t>();
             kernel<<<1, 1, shm_size>>>(res.get(), fun, args...);
             GT_CUDA_CHECK(cudaDeviceSynchronize());
diff --git a/tests/unit_tests/layout_transformation/test_layout_transformation.cpp b/tests/unit_tests/layout_transformation/test_layout_transformation.cpp
index 4606b8ecff..618fff493d 100644
--- a/tests/unit_tests/layout_transformation/test_layout_transformation.cpp
+++ b/tests/unit_tests/layout_transformation/test_layout_transformation.cpp
@@ -58,6 +58,8 @@ namespace {
     using envs_t = meta::list<host>;
 #endif
 
+    static constexpr size_t one = 1;
+
     TEST(layout_transformation, 3D_reverse_layout) {
         for_each<envs_t>([](auto env) {
             constexpr size_t Nx = 4, Ny = 5, Nz = 6;
@@ -68,7 +70,7 @@ namespace {
                 src[i[0]][i[1]][i[2]] = 100 * i[0] + 10 * i[1] + i[2];
                 dst[i[2]][i[1]][i[0]] = -1;
             }
-            testee(env, dst, src, dims, array{1, Nx, Nx * Ny}, array{Ny * Nz, Nz, 1});
+            testee(env, dst, src, dims, array{one, Nx, Nx * Ny}, array{Ny * Nz, Nz, one});
             for (auto i : make_hypercube_view(dims))
                 EXPECT_DOUBLE_EQ(dst[i[2]][i[1]][i[0]], src[i[0]][i[1]][i[2]]);
         });
@@ -84,7 +86,7 @@ namespace {
                 src[i[0]][i[1]][i[2]][i[3]] = 1000 * i[0] + 100 * i[1] + 10 * i[2] + i[3];
                 dst[i[3]][i[2]][i[1]][i[0]] = -1;
             }
-            testee(env, dst, src, dims, array{1, Nx, Nx * Ny, Nx * Ny * Nz}, array{Ny * Nz * Nw, Nz * Nw, Nw, 1});
+            testee(env, dst, src, dims, array{one, Nx, Nx * Ny, Nx * Ny * Nz}, array{Ny * Nz * Nw, Nz * Nw, Nw, one});
             for (auto i : make_hypercube_view(dims))
                 EXPECT_DOUBLE_EQ(dst[i[3]][i[2]][i[1]][i[0]], src[i[0]][i[1]][i[2]][i[3]]);
         });
@@ -100,7 +102,7 @@ namespace {
                 src[i[0]][i[1]] = 100 * i[0] + 10 * i[1];
                 dst[i[1]][i[0]] = -1;
             }
-            testee(env, dst, src, dims, array{1, Nx}, array{Ny, 1});
+            testee(env, dst, src, dims, array{one, Nx}, array{Ny, one});
             for (auto i : make_hypercube_view(dims))
                 EXPECT_DOUBLE_EQ(dst[i[1]][i[0]], src[i[0]][i[1]]);
         });
diff --git a/tests/unit_tests/sid/test_sid_synthetic.cpp b/tests/unit_tests/sid/test_sid_synthetic.cpp
index 29605e94b4..18ddec3ce0 100644
--- a/tests/unit_tests/sid/test_sid_synthetic.cpp
+++ b/tests/unit_tests/sid/test_sid_synthetic.cpp
@@ -62,13 +62,13 @@ namespace gridtools {
 
                 using testee = decltype(the_testee);
 
-                static_assert(is_sid<testee>(), "");
-                static_assert(std::is_trivially_copyable<testee>(), "");
+                static_assert(is_sid<testee>());
+                static_assert(std::is_trivially_copy_constructible_v<testee>);
 
-                static_assert(std::is_same<sid::ptr_type<testee>, ptr>(), "");
-                static_assert(std::is_same<sid::strides_type<testee>, strides>(), "");
-                static_assert(std::is_same<sid::ptr_diff_type<testee>, ptr_diff>(), "");
-                static_assert(std::is_same<sid::strides_kind<testee>, strides_kind>(), "");
+                static_assert(std::is_same<sid::ptr_type<testee>, ptr>());
+                static_assert(std::is_same<sid::strides_type<testee>, strides>());
+                static_assert(std::is_same<sid::ptr_diff_type<testee>, ptr_diff>());
+                static_assert(std::is_same<sid::strides_kind<testee>, strides_kind>());
 
                 EXPECT_EQ(&the_element, sid::get_origin(the_testee)().val);
                 EXPECT_EQ(3, tuple_util::get<0>(sid::get_strides(the_testee)).val);

From 429d076055580cfbc06195dc9ea0581f81719c54 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Tue, 21 Dec 2021 14:30:10 +0100
Subject: [PATCH 10/19] add cmake comments

---
 tests/unit_tests/CMakeLists.txt | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/tests/unit_tests/CMakeLists.txt b/tests/unit_tests/CMakeLists.txt
index 29e1eb6082..6ed9874d90 100644
--- a/tests/unit_tests/CMakeLists.txt
+++ b/tests/unit_tests/CMakeLists.txt
@@ -22,10 +22,12 @@ function(gridtools_add_unit_test tgt)
     _gt_depends_on_nvcc(nvcc_compilation_checked ${tgt})
 
     if(NOT ARGS_NO_NVCC AND TARGET _gridtools_nvcc AND NOT nvcc_compilation_checked)
+        # Additional nvcc target is created here. It exists for checking nvvc compilation only.
+        # Note that it is an `OBJECT` library.
+        # _gridtools_nvcc is added to deps to pickup cuda specific compilation flags.
         _gt_convert_to_cuda_source(sources ${ARGS_SOURCES})
         add_library(${tgt}_nvcc OBJECT ${sources})
-        target_compile_options(${tgt}_nvcc PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--expt-relaxed-constexpr>)
-        target_link_libraries(${tgt}_nvcc GridToolsTest gtest_main gmock ${ARGS_LIBRARIES})
+        target_link_libraries(${tgt}_nvcc GridToolsTest gtest_main gmock _gridtools_nvcc ${ARGS_LIBRARIES})
     endif()
 
     add_test(NAME ${tgt} COMMAND $<TARGET_FILE:${tgt}>)

From ed7baa2f298662447245d111524541bb3d1f7b6d Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Tue, 21 Dec 2021 14:40:01 +0100
Subject: [PATCH 11/19] add forgotten make_values

---
 include/gridtools/stencil/cpu_ifirst/entry_point.hpp | 4 ++--
 include/gridtools/stencil/cpu_kfirst.hpp             | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/include/gridtools/stencil/cpu_ifirst/entry_point.hpp b/include/gridtools/stencil/cpu_ifirst/entry_point.hpp
index 51ea205547..27de606c8f 100644
--- a/include/gridtools/stencil/cpu_ifirst/entry_point.hpp
+++ b/include/gridtools/stencil/cpu_ifirst/entry_point.hpp
@@ -63,8 +63,8 @@ namespace gridtools {
                         });
 
                     auto blocked_externals = tuple_util::transform(
-                        [block_size = hymap::keys<dim::i, dim::j>::values(info.i_block_size(), info.j_block_size())](
-                            auto &&data_store) {
+                        [block_size = hymap::keys<dim::i, dim::j>::make_values(
+                             info.i_block_size(), info.j_block_size())](auto &&data_store) {
                             return sid::block(std::forward<decltype(data_store)>(data_store), block_size);
                         },
                         std::move(external_data_stores));
diff --git a/include/gridtools/stencil/cpu_kfirst.hpp b/include/gridtools/stencil/cpu_kfirst.hpp
index de87716b4e..4b012002fe 100644
--- a/include/gridtools/stencil/cpu_kfirst.hpp
+++ b/include/gridtools/stencil/cpu_kfirst.hpp
@@ -104,10 +104,10 @@ namespace gridtools {
                     auto extent = info.extent();
                     auto interval = stages_t::interval();
                     auto num_colors = info.num_colors();
-                    auto offsets = hymap::keys<dim::i, dim::j, dim::k>::values(-extent.minus(dim::i()),
+                    auto offsets = hymap::keys<dim::i, dim::j, dim::k>::make_values(-extent.minus(dim::i()),
                         -extent.minus(dim::j()),
                         -grid.k_start(interval) - extent.minus(dim::k()));
-                    auto sizes = hymap::keys<dim::c, dim::k, dim::j, dim::i, dim::thread>::values(num_colors,
+                    auto sizes = hymap::keys<dim::c, dim::k, dim::j, dim::i, dim::thread>::make_values(num_colors,
                         grid.k_size(interval, extent),
                         extent.extend(dim::j(), JBlockSize()),
                         extent.extend(dim::i(), IBlockSize()),
@@ -121,7 +121,7 @@ namespace gridtools {
                 auto blocked_external_data_stores = tuple_util::transform(
                     [&](auto &&data_store) GT_FORCE_INLINE_LAMBDA {
                         return sid::block(std::forward<decltype(data_store)>(data_store),
-                            hymap::keys<dim::i, dim::j>::values<IBlockSize, JBlockSize>());
+                            hymap::keys<dim::i, dim::j>::make_values<IBlockSize, JBlockSize>());
                     },
                     std::move(external_data_stores));
 

From 9f741feed1699c3e45a397bec4d4b6ca2751e68d Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Tue, 21 Dec 2021 14:46:02 +0100
Subject: [PATCH 12/19] typo

---
 include/gridtools/stencil/cpu_kfirst.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/gridtools/stencil/cpu_kfirst.hpp b/include/gridtools/stencil/cpu_kfirst.hpp
index 4b012002fe..0a743a5542 100644
--- a/include/gridtools/stencil/cpu_kfirst.hpp
+++ b/include/gridtools/stencil/cpu_kfirst.hpp
@@ -121,7 +121,7 @@ namespace gridtools {
                 auto blocked_external_data_stores = tuple_util::transform(
                     [&](auto &&data_store) GT_FORCE_INLINE_LAMBDA {
                         return sid::block(std::forward<decltype(data_store)>(data_store),
-                            hymap::keys<dim::i, dim::j>::make_values<IBlockSize, JBlockSize>());
+                            hymap::keys<dim::i, dim::j>::values<IBlockSize, JBlockSize>());
                     },
                     std::move(external_data_stores));
 

From 046e54effd9e7f7bc7b82ac7513950711fb8785b Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Tue, 21 Dec 2021 20:56:04 +0100
Subject: [PATCH 13/19] nvcc/gcc is ok

---
 include/gridtools/common/array.hpp     |  51 +++++-------
 include/gridtools/common/tuple.hpp     | 109 +++++++++++--------------
 tests/unit_tests/CMakeLists.txt        |   5 +-
 tests/unit_tests/common/CMakeLists.txt |   2 +-
 tests/unit_tests/common/test_array.cpp |   2 +
 5 files changed, 74 insertions(+), 95 deletions(-)

diff --git a/include/gridtools/common/array.hpp b/include/gridtools/common/array.hpp
index c2f7745486..3ee69c6acc 100644
--- a/include/gridtools/common/array.hpp
+++ b/include/gridtools/common/array.hpp
@@ -13,13 +13,6 @@
 @brief Implementation of an array class
 */
 
-#include <array>
-
-namespace gridtools {
-    using std::array;
-}
-
-#if 0
 #include <algorithm>
 #include <cassert>
 #include <iterator>
@@ -31,9 +24,6 @@ namespace gridtools {
 #include "../meta/list.hpp"
 #include "../meta/macros.hpp"
 #include "../meta/repeat.hpp"
-#include "defs.hpp"
-#include "host_device.hpp"
-#include "utility.hpp"
 
 namespace gridtools {
 
@@ -69,32 +59,32 @@ namespace gridtools {
         using reverse_iterator = std::reverse_iterator<iterator>;
         using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
-        GT_FUNCTION constexpr T const *begin() const { return &m_array[0]; }
+        constexpr T const *begin() const { return &m_array[0]; }
 
-        GT_FUNCTION constexpr T *begin() { return &m_array[0]; }
+        constexpr T *begin() { return &m_array[0]; }
 
-        GT_FUNCTION constexpr T const *end() const { return &m_array[D]; }
+        constexpr T const *end() const { return &m_array[D]; }
 
-        GT_FUNCTION constexpr T *end() { return &m_array[D]; }
+        constexpr T *end() { return &m_array[D]; }
 
-        GT_FUNCTION constexpr const T *data() const noexcept { return m_array; }
-        GT_FUNCTION constexpr T *data() noexcept { return m_array; }
+        constexpr const T *data() const noexcept { return m_array; }
+        constexpr T *data() noexcept { return m_array; }
 
-        GT_FUNCTION GT_CONSTEXPR T const &operator[](size_t i) const { return m_array[i]; }
+        constexpr T const &operator[](size_t i) const { return m_array[i]; }
 
-        GT_FUNCTION T &operator[](size_t i) {
+        constexpr T &operator[](size_t i) {
             assert(i < D);
             return m_array[i];
         }
 
         template <typename A>
-        GT_FUNCTION array &operator=(A const &a) {
+        constexpr array &operator=(A const &a) {
             assert(a.size() == D);
             std::copy(a.begin(), a.end(), m_array);
             return *this;
         }
 
-        GT_FUNCTION static constexpr size_t size() { return D; }
+        static constexpr size_t size() { return D; }
     };
 
     template <class T, class... Ts>
@@ -116,21 +106,21 @@ namespace gridtools {
 
         struct getter {
             template <size_t I, typename T, size_t D>
-            static GT_FUNCTION GT_CONSTEXPR T &get(array<T, D> &arr) noexcept {
+            static constexpr T &get(array<T, D> &arr) noexcept {
                 static_assert(I < D, "index is out of bounds");
                 return arr.m_array[I];
             }
 
             template <size_t I, typename T, size_t D>
-            static GT_FUNCTION GT_CONSTEXPR const T &get(const array<T, D> &arr) noexcept {
+            static constexpr const T &get(const array<T, D> &arr) noexcept {
                 static_assert(I < D, "index is out of bounds");
                 return arr.m_array[I];
             }
 
             template <size_t I, typename T, size_t D>
-            static GT_FUNCTION GT_CONSTEXPR T &&get(array<T, D> &&arr) noexcept {
+            static constexpr T &&get(array<T, D> &&arr) noexcept {
                 static_assert(I < D, "index is out of bounds");
-                return wstd::move(arr.m_array[I]);
+                return std::move(arr.m_array[I]);
             }
         };
     } // namespace array_impl_
@@ -146,7 +136,7 @@ namespace gridtools {
 
     // in case we need a constexpr version we need to implement a recursive one for c++11
     template <typename T, typename U, size_t D>
-    GT_CONSTEXPR GT_FUNCTION bool operator==(array<T, D> const &a, array<U, D> const &b) {
+    constexpr bool operator==(array<T, D> const &a, array<U, D> const &b) {
 #ifndef __GNUC__
 #pragma unroll
 #endif
@@ -158,7 +148,7 @@ namespace gridtools {
     }
 
     template <typename T, typename U, size_t D>
-    GT_CONSTEXPR GT_FUNCTION bool operator!=(array<T, D> const &a, array<U, D> const &b) {
+    constexpr bool operator!=(array<T, D> const &a, array<U, D> const &b) {
         return !(a == b);
     }
 
@@ -175,21 +165,21 @@ namespace gridtools {
     struct is_array_of<array<Value, D>, Value> : std::true_type {};
 
     template <size_t I, typename T, size_t D>
-    GT_FUNCTION T &get(array<T, D> &arr) noexcept {
+    constexpr T &get(array<T, D> &arr) noexcept {
         static_assert(I < D, "index is out of bounds");
         return arr.m_array[I];
     }
 
     template <size_t I, typename T, size_t D>
-    GT_FUNCTION GT_CONSTEXPR const T &get(const array<T, D> &arr) noexcept {
+    constexpr const T &get(const array<T, D> &arr) noexcept {
         static_assert(I < D, "index is out of bounds");
         return arr.m_array[I];
     }
 
     template <size_t I, typename T, size_t D>
-    GT_FUNCTION GT_CONSTEXPR T &&get(array<T, D> &&arr) noexcept {
+    constexpr T &&get(array<T, D> &&arr) noexcept {
         static_assert(I < D, "index is out of bounds");
-        return wstd::move(get<I>(arr));
+        return std::move(get<I>(arr));
     }
 
     /** @} */
@@ -207,4 +197,3 @@ namespace std {
         using type = T;
     };
 } // namespace std
-#endif
diff --git a/include/gridtools/common/tuple.hpp b/include/gridtools/common/tuple.hpp
index bb43153446..0895ea95ee 100644
--- a/include/gridtools/common/tuple.hpp
+++ b/include/gridtools/common/tuple.hpp
@@ -10,20 +10,11 @@
 
 #pragma once
 
-#include <tuple>
-
-namespace gridtools {
-    using ::std::tuple;
-}
-#if 0
 #include <cstdlib>
 #include <tuple>
 #include <type_traits>
 
 #include "../meta/at.hpp"
-#include "defs.hpp"
-#include "host_device.hpp"
-#include "utility.hpp"
 
 namespace gridtools {
 
@@ -37,10 +28,10 @@ namespace gridtools {
             tuple_leaf &operator=(tuple_leaf const &) = default;
             tuple_leaf &operator=(tuple_leaf &&) = default;
 
-            GT_CONSTEXPR GT_FUNCTION tuple_leaf() noexcept : m_value() {}
+            constexpr tuple_leaf() noexcept : m_value() {}
 
             template <class Arg, std::enable_if_t<std::is_constructible<T, Arg &&>::value, int> = 0>
-            GT_CONSTEXPR GT_FUNCTION tuple_leaf(Arg &&arg) noexcept : m_value(wstd::forward<Arg>(arg)) {}
+            constexpr tuple_leaf(Arg &&arg) noexcept : m_value(std::forward<Arg>(arg)) {}
         };
 
         template <size_t I, class T>
@@ -52,37 +43,37 @@ namespace gridtools {
             tuple_leaf &operator=(tuple_leaf &&) = default;
 
             template <class Arg, std::enable_if_t<std::is_constructible<T, Arg &&>::value, int> = 0>
-            GT_CONSTEXPR GT_FUNCTION tuple_leaf(Arg &&arg) noexcept : T(wstd::forward<Arg>(arg)) {}
+            constexpr tuple_leaf(Arg &&arg) noexcept : T(std::forward<Arg>(arg)) {}
         };
 
         struct tuple_leaf_getter {
             template <size_t I, class T>
-            static GT_CONSTEXPR GT_FUNCTION T const &get(tuple_leaf<I, T, false> const &obj) noexcept {
+            static constexpr T const &get(tuple_leaf<I, T, false> const &obj) noexcept {
                 return obj.m_value;
             }
 
             template <size_t I, class T>
-            static GT_CONSTEXPR GT_FUNCTION T &get(tuple_leaf<I, T, false> &obj) noexcept {
+            static constexpr T &get(tuple_leaf<I, T, false> &obj) noexcept {
                 return obj.m_value;
             }
 
             template <size_t I, class T>
-            static GT_CONSTEXPR GT_FUNCTION T&& get(tuple_leaf<I, T, false> &&obj) noexcept {
+            static constexpr T&& get(tuple_leaf<I, T, false> &&obj) noexcept {
                 return static_cast<T &&>(get<I>(obj));
             }
 
             template <size_t I, class T>
-            static GT_CONSTEXPR GT_FUNCTION T const &get(tuple_leaf<I, T, true> const &obj) noexcept {
+            static constexpr T const &get(tuple_leaf<I, T, true> const &obj) noexcept {
                 return obj;
             }
 
             template <size_t I, class T>
-            static GT_CONSTEXPR GT_FUNCTION T &get(tuple_leaf<I, T, true> &obj) noexcept {
+            static constexpr T &get(tuple_leaf<I, T, true> &obj) noexcept {
                 return obj;
             }
 
             template <size_t I, class T>
-            static GT_CONSTEXPR GT_FUNCTION T&& get(tuple_leaf<I, T, true> &&obj) noexcept {
+            static constexpr T&& get(tuple_leaf<I, T, true> &&obj) noexcept {
                 return static_cast<T &&>(obj);
             }
         };
@@ -99,24 +90,23 @@ namespace gridtools {
             tuple_impl &operator=(tuple_impl &&) = default;
 
             template <class... Args>
-            GT_CONSTEXPR GT_FUNCTION tuple_impl(Args &&... args) noexcept
-                : tuple_leaf<Is, Ts>(wstd::forward<Args>(args))... {}
+            constexpr tuple_impl(Args &&... args) noexcept
+                : tuple_leaf<Is, Ts>(std::forward<Args>(args))... {}
 
             template <class Src>
-            GT_CONSTEXPR GT_FUNCTION tuple_impl(Src &&src) noexcept
-                : tuple_leaf<Is, Ts>(tuple_leaf_getter::get<Is>(wstd::forward<Src>(src)))... {}
+            constexpr tuple_impl(Src &&src) noexcept
+                : tuple_leaf<Is, Ts>(tuple_leaf_getter::get<Is>(std::forward<Src>(src)))... {}
 
-            GT_FORCE_INLINE void swap(tuple_impl &other) noexcept {
+            constexpr void swap(tuple_impl &other) noexcept {
                 using std::swap;
-                using loop_t = int[sizeof...(Is)];
-                void(loop_t{(swap(tuple_leaf_getter::get<Is>(*this), tuple_leaf_getter::get<Is>(other)), 0)...});
+                (..., swap(tuple_leaf_getter::get<Is>(*this), tuple_leaf_getter::get<Is>(other)));
             }
 
             template <class... Args,
                 std::enable_if_t<sizeof...(Ts) == sizeof...(Args) &&
                                      std::conjunction<std::is_assignable<Ts &, Args const &>...>::value,
                     int> = 0>
-            GT_CONSTEXPR GT_FUNCTION void assign(tuple_impl<std::index_sequence<Is...>, Args...> const &src) noexcept {
+            constexpr void assign(tuple_impl<std::index_sequence<Is...>, Args...> const &src) noexcept {
                 using loop_t = int[sizeof...(Is)];
                 void(loop_t{(tuple_leaf_getter::get<Is>(*this) = tuple_leaf_getter::get<Is>(src), 0)...});
             }
@@ -125,9 +115,9 @@ namespace gridtools {
                 std::enable_if_t<sizeof...(Ts) == sizeof...(Args) &&
                                      std::conjunction<std::is_assignable<Ts &, Args &&>...>::value,
                     int> = 0>
-            GT_CONSTEXPR GT_FUNCTION void assign(tuple_impl<std::index_sequence<Is...>, Args...> &&src) noexcept {
+            constexpr void assign(tuple_impl<std::index_sequence<Is...>, Args...> &&src) noexcept {
                 using loop_t = int[sizeof...(Is)];
-                void(loop_t{(tuple_leaf_getter::get<Is>(*this) = tuple_leaf_getter::get<Is>(wstd::move(src)), 0)...});
+                void(loop_t{(tuple_leaf_getter::get<Is>(*this) = tuple_leaf_getter::get<Is>(std::move(src)), 0)...});
             }
         };
     } // namespace impl_
@@ -153,18 +143,18 @@ namespace gridtools {
 
         struct getter {
             template <size_t I>
-            static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(tuple const &obj) noexcept {
+            static constexpr decltype(auto) get(tuple const &obj) noexcept {
                 return impl_::tuple_leaf_getter::get<I>(obj.m_impl);
             }
 
             template <size_t I>
-            static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(tuple &obj) noexcept {
+            static constexpr decltype(auto) get(tuple &obj) noexcept {
                 return impl_::tuple_leaf_getter::get<I>(obj.m_impl);
             }
 
             template <size_t I>
-            static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(tuple &&obj) noexcept {
-                return impl_::tuple_leaf_getter::get<I>(wstd::move(obj.m_impl));
+            static constexpr decltype(auto) get(tuple &&obj) noexcept {
+                return impl_::tuple_leaf_getter::get<I>(std::move(obj.m_impl));
             }
         };
         friend getter tuple_getter(tuple const &) { return {}; }
@@ -179,31 +169,31 @@ namespace gridtools {
         tuple &operator=(tuple const &) = default;
         tuple &operator=(tuple &&) = default;
 
-        GT_CONSTEXPR GT_FUNCTION tuple(Ts const &... args) noexcept : m_impl(args...) {}
+        constexpr tuple(Ts const &... args) noexcept : m_impl(args...) {}
 
         template <class... Args,
             std::enable_if_t<sizeof...(Ts) == sizeof...(Args) &&
                                  std::conjunction<std::is_constructible<Ts, Args &&>...>::value,
                 int> = 0>
-        GT_CONSTEXPR GT_FUNCTION tuple(Args &&...args) noexcept : m_impl(wstd::forward<Args>(args)...) {}
+        constexpr tuple(Args &&...args) noexcept : m_impl(std::forward<Args>(args)...) {}
 
         template <class... Args,
             std::enable_if_t<sizeof...(Ts) == sizeof...(Args) &&
                                  std::conjunction<std::is_constructible<Ts, Args const &>...>::value,
                 int> = 0>
-        GT_CONSTEXPR GT_FUNCTION tuple(tuple<Args...> const &src) noexcept : m_impl(src.m_impl) {}
+        constexpr tuple(tuple<Args...> const &src) noexcept : m_impl(src.m_impl) {}
 
         template <class... Args,
             std::enable_if_t<sizeof...(Ts) == sizeof...(Args) &&
                                  std::conjunction<std::is_constructible<Ts, Args &&>...>::value,
                 int> = 0>
-        GT_CONSTEXPR GT_FUNCTION tuple(tuple<Args...> &&src) noexcept : m_impl(wstd::move(src).m_impl) {}
+        constexpr tuple(tuple<Args...> &&src) noexcept : m_impl(std::move(src).m_impl) {}
 
-        GT_FORCE_INLINE void swap(tuple &other) noexcept { m_impl.swap(other.m_impl); }
+        constexpr void swap(tuple &other) noexcept { m_impl.swap(other.m_impl); }
 
         template <class Other>
-        GT_CONSTEXPR GT_FUNCTION tuple &operator=(Other &&other) {
-            m_impl.assign(wstd::forward<Other>(other).m_impl);
+        constexpr tuple &operator=(Other &&other) {
+            m_impl.assign(std::forward<Other>(other).m_impl);
             return *this;
         }
     };
@@ -213,65 +203,65 @@ namespace gridtools {
         T m_value;
         struct getter {
             template <size_t I, std::enable_if_t<I == 0, int> = 0>
-            static GT_CONSTEXPR GT_FUNCTION T const &get(tuple const &obj) noexcept {
+            static constexpr T const &get(tuple const &obj) noexcept {
                 return obj.m_value;
             }
 
             template <size_t I, std::enable_if_t<I == 0, int> = 0>
-            static GT_CONSTEXPR GT_FUNCTION T &get(tuple &obj) noexcept {
+            static constexpr T &get(tuple &obj) noexcept {
                 return obj.m_value;
             }
 
             template <size_t I, std::enable_if_t<I == 0, int> = 0>
-            static GT_CONSTEXPR GT_FUNCTION T &&get(tuple &&obj) noexcept {
+            static constexpr T &&get(tuple &&obj) noexcept {
                 return static_cast<T &&>(obj.m_value);
             }
         };
         friend getter tuple_getter(tuple const &) { return {}; }
 
-        template <class...>
+        template <class...> 
         friend class tuple;
 
       public:
-        GT_CONSTEXPR GT_FUNCTION tuple() noexcept : m_value() {}
+        constexpr tuple() noexcept : m_value() {}
 
         tuple(tuple const &) = default;
         tuple(tuple &&) = default;
         tuple &operator=(tuple const &) = default;
-        tuple &operator=(tuple &&) = default;
+        tuple &operator=(tuple &&) = default; 
 
-        GT_CONSTEXPR GT_FUNCTION tuple(T const &arg) noexcept : m_value(arg) {}
+        constexpr tuple(T const &arg) noexcept : m_value(arg) {}
 
         template <class Arg, std::enable_if_t<std::is_constructible<T, Arg &&>::value, int> = 0>
-        GT_CONSTEXPR GT_FUNCTION tuple(Arg &&arg) noexcept : m_value(wstd::forward<Arg>(arg)) {}
+        constexpr tuple(Arg &&arg) noexcept : m_value(std::forward<Arg>(arg)) {}
 
         template <class Arg,
             std::enable_if_t<std::is_constructible<T, Arg const &>::value &&
                                  !std::is_convertible<tuple<Arg> const &, T>::value &&
                                  !std::is_constructible<T, tuple<Arg> const &>::value && !std::is_same<T, Arg>::value,
                 int> = 0>
-        GT_CONSTEXPR GT_FUNCTION tuple(tuple<Arg> const &src) noexcept : m_value(src.m_value) {}
+        constexpr tuple(tuple<Arg> const &src) noexcept : m_value(src.m_value) {}
 
         template <class Arg,
             std::enable_if_t<std::is_constructible<T, Arg &&>::value && !std::is_convertible<tuple<Arg>, T>::value &&
                                  !std::is_constructible<T, tuple<Arg>>::value && !std::is_same<T, Arg>::value,
                 int> = 0>
-        GT_CONSTEXPR GT_FUNCTION tuple(tuple<Arg> &&src) noexcept : m_value(wstd::move(src).m_value) {}
+        constexpr tuple(tuple<Arg> &&src) noexcept : m_value(std::move(src).m_value) {}
 
-        GT_FORCE_INLINE void swap(tuple &other) noexcept {
+        constexpr void swap(tuple &other) noexcept {
             using std::swap;
             swap(m_value, other.m_value);
         }
 
         template <class Arg, std::enable_if_t<std::is_assignable<T &, Arg const &>::value, int> = 0>
-        GT_CONSTEXPR GT_FUNCTION tuple &operator=(tuple<Arg> const &src) noexcept {
+        constexpr tuple &operator=(tuple<Arg> const &src) noexcept {
             m_value = src.m_value;
             return *this;
         }
 
         template <class Arg, std::enable_if_t<std::is_assignable<T &, Arg &&>::value, int> = 0>
-        GT_CONSTEXPR GT_FUNCTION tuple &operator=(tuple<Arg> &&src) noexcept {
-            m_value = wstd::move(src).m_value;
+        constexpr tuple &operator=(tuple<Arg> &&src) noexcept {
+            m_value = std::move(src).m_value;
             return *this;
         }
     };
@@ -281,27 +271,27 @@ namespace gridtools {
         friend tuple tuple_getter(tuple const &) { return {}; }
 
       public:
-        GT_FORCE_INLINE void swap(tuple &) noexcept {}
+        constexpr void swap(tuple &) noexcept {}
     };
 
     template <class... Ts>
-    GT_FORCE_INLINE void swap(tuple<Ts...> &lhs, tuple<Ts...> &rhs) noexcept {
+    constexpr void swap(tuple<Ts...> &lhs, tuple<Ts...> &rhs) noexcept {
         lhs.swap(rhs);
     }
 
     template <size_t I, class... Ts>
-    GT_CONSTEXPR GT_FUNCTION decltype(auto) get(tuple<Ts...> const &obj) noexcept {
+    constexpr decltype(auto) get(tuple<Ts...> const &obj) noexcept {
         return decltype(tuple_getter(obj))::template get<I>(obj);
     }
 
     template <size_t I, class... Ts>
-    GT_CONSTEXPR GT_FUNCTION decltype(auto) get(tuple<Ts...> &obj) noexcept {
+    constexpr decltype(auto) get(tuple<Ts...> &obj) noexcept {
         return decltype(tuple_getter(std::declval<tuple<Ts...> const &>()))::template get<I>(obj);
     }
 
     template <size_t I, class... Ts>
-    GT_CONSTEXPR GT_FUNCTION decltype(auto) get(tuple<Ts...> &&obj) noexcept {
-        return decltype(tuple_getter(std::declval<tuple<Ts...> const &>()))::template get<I>(wstd::move(obj));
+    constexpr decltype(auto) get(tuple<Ts...> &&obj) noexcept {
+        return decltype(tuple_getter(std::declval<tuple<Ts...> const &>()))::template get<I>(std::move(obj));
     }
 } // namespace gridtools
 
@@ -314,4 +304,3 @@ namespace std {
         using type = gridtools::meta::at_c<::gridtools::tuple<Ts...>, I>;
     };
 } // namespace std
-#endif
diff --git a/tests/unit_tests/CMakeLists.txt b/tests/unit_tests/CMakeLists.txt
index 29e1eb6082..901ffa8915 100644
--- a/tests/unit_tests/CMakeLists.txt
+++ b/tests/unit_tests/CMakeLists.txt
@@ -5,7 +5,7 @@ function(gridtools_check_compilation tgt)
         _gt_convert_to_cuda_source(sources ${ARGN})
         if (NOT sources STREQUAL ARGN)
             add_library(${tgt}_nvcc OBJECT ${sources})
-            target_link_libraries(${tgt}_nvcc gridtools)
+            target_link_libraries(${tgt}_nvcc gridtools _gridtools_nvcc)
         endif()
     endif()
 endfunction()
@@ -24,8 +24,7 @@ function(gridtools_add_unit_test tgt)
     if(NOT ARGS_NO_NVCC AND TARGET _gridtools_nvcc AND NOT nvcc_compilation_checked)
         _gt_convert_to_cuda_source(sources ${ARGS_SOURCES})
         add_library(${tgt}_nvcc OBJECT ${sources})
-        target_compile_options(${tgt}_nvcc PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--expt-relaxed-constexpr>)
-        target_link_libraries(${tgt}_nvcc GridToolsTest gtest_main gmock ${ARGS_LIBRARIES})
+        target_link_libraries(${tgt}_nvcc GridToolsTest gtest_main gmock _gridtools_nvcc ${ARGS_LIBRARIES})
     endif()
 
     add_test(NAME ${tgt} COMMAND $<TARGET_FILE:${tgt}>)
diff --git a/tests/unit_tests/common/CMakeLists.txt b/tests/unit_tests/common/CMakeLists.txt
index 8b8982eab1..995baa3041 100644
--- a/tests/unit_tests/common/CMakeLists.txt
+++ b/tests/unit_tests/common/CMakeLists.txt
@@ -9,7 +9,7 @@ gridtools_add_unit_test(test_array SOURCES test_array.cpp)
 gridtools_add_unit_test(test_compose SOURCES test_compose.cpp)
 gridtools_add_unit_test(test_hugepage_alloc SOURCES test_hugepage_alloc.cpp)
 gridtools_add_unit_test(test_hymap SOURCES test_hymap.cpp)
-gridtools_add_unit_test(test_pair SOURCES test_pair.cpp)
+#gridtools_add_unit_test(test_pair SOURCES test_pair.cpp)
 gridtools_add_unit_test(test_stride_util SOURCES test_stride_util.cpp)
 gridtools_add_unit_test(test_tuple_util SOURCES test_tuple_util.cpp)
 gridtools_add_unit_test(test_for_each SOURCES test_for_each.cpp)
diff --git a/tests/unit_tests/common/test_array.cpp b/tests/unit_tests/common/test_array.cpp
index f28696e1bf..b1a605f033 100644
--- a/tests/unit_tests/common/test_array.cpp
+++ b/tests/unit_tests/common/test_array.cpp
@@ -12,6 +12,8 @@
 
 #include <gtest/gtest.h>
 
+#include <gridtools/common/defs.hpp>
+
 using namespace gridtools;
 
 TEST(array, test_copyctr) {

From 7c3b7e8aba74d7a701cb542faf7b541f80c04acf Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Wed, 22 Dec 2021 15:31:07 +0100
Subject: [PATCH 14/19] nuke host_device dispatch

---
 include/gridtools/boundaries/apply_gpu.hpp    |    2 +-
 include/gridtools/common/compose.hpp          |   69 +-
 include/gridtools/common/for_each.hpp         |   43 +-
 include/gridtools/common/functional.hpp       |  118 +-
 include/gridtools/common/host_device.hpp      |   12 -
 include/gridtools/common/hymap.hpp            |  360 ++-
 .../gridtools/common/hypercube_iterator.hpp   |   11 +-
 include/gridtools/common/implicit_cast.hpp    |   41 -
 include/gridtools/common/int_vector.hpp       |   11 +-
 .../common/iterate_on_host_device.hpp         |    6 +-
 include/gridtools/common/tuple_util.hpp       | 2171 ++++++++---------
 include/gridtools/fn/backend/naive/fencil.hpp |    2 +-
 include/gridtools/fn/scan.hpp                 |   20 +-
 .../gridtools/layout_transformation/gpu.hpp   |   16 +-
 include/gridtools/reduction/frontend.hpp      |    2 +-
 include/gridtools/sid/allocator.hpp           |   79 +-
 include/gridtools/sid/block.hpp               |    3 +-
 include/gridtools/sid/composite.hpp           |   89 +-
 include/gridtools/sid/concept.hpp             |   90 +-
 include/gridtools/sid/loop.hpp                |   82 +-
 include/gridtools/sid/multi_shift.hpp         |   24 +-
 include/gridtools/sid/simple_ptr_holder.hpp   |   48 +-
 include/gridtools/stencil/be_api.hpp          |    2 +-
 include/gridtools/stencil/cpu_kfirst.hpp      |    2 +-
 .../stencil/frontend/cartesian/stage.hpp      |    4 +-
 .../frontend/cartesian/stencil_functions.hpp  |   19 +-
 .../stencil/frontend/icosahedral/stage.hpp    |    8 +-
 include/gridtools/stencil/gpu/entry_point.hpp |    4 +-
 include/gridtools/stencil/gpu/fill_flush.hpp  |   25 +-
 include/gridtools/stencil/gpu/k_cache.hpp     |    4 +-
 .../gridtools/stencil/gpu/make_kernel_fun.hpp |   10 +-
 .../stencil/gpu_horizontal/entry_point.hpp    |    8 +-
 .../stencil/gpu_horizontal/j_cache.hpp        |    7 +-
 include/gridtools/stencil/naive.hpp           |    2 +-
 include/gridtools/stencil/positional.hpp      |   10 +-
 include/gridtools/storage/info.hpp            |   17 +-
 tests/unit_tests/common/test_for_each.cpp     |   11 +-
 tests/unit_tests/common/test_tuple.cpp        |    2 +-
 tests/unit_tests/common/test_tuple.cu         |   16 +-
 tests/unit_tests/common/test_tuple_util.cpp   |    2 +-
 tests/unit_tests/fn/test_fn_scan.cpp          |    4 +-
 tests/unit_tests/fn/test_fn_scan.cu           |    8 +-
 tests/unit_tests/sid/test_sid_as_const.cpp    |    2 +-
 tests/unit_tests/sid/test_sid_composite.cpp   |   89 +-
 tests/unit_tests/sid/test_sid_concept.cpp     |    6 +-
 tests/unit_tests/sid/test_sid_contiguous.cpp  |    8 +-
 tests/unit_tests/sid/test_sid_delegate.cpp    |    7 +-
 tests/unit_tests/sid/test_sid_loop.cpp        |    2 +-
 .../sid/test_sid_rename_dimensions.cpp        |    8 +-
 .../sid/test_sid_shift_sid_origin.cpp         |    4 +-
 tests/unit_tests/sid/test_sid_synthetic.cpp   |    4 +-
 .../test_simple_device_memory_allocator.cu    |    2 +-
 .../stencil/gpu/test_tmp_storage_sid.cpp      |   48 +-
 .../stencil/gpu/test_tmp_storage_sid.cu       |    2 +-
 54 files changed, 1668 insertions(+), 1978 deletions(-)
 delete mode 100644 include/gridtools/common/implicit_cast.hpp

diff --git a/include/gridtools/boundaries/apply_gpu.hpp b/include/gridtools/boundaries/apply_gpu.hpp
index 66cb731f02..0bd33d8aee 100644
--- a/include/gridtools/boundaries/apply_gpu.hpp
+++ b/include/gridtools/boundaries/apply_gpu.hpp
@@ -240,7 +240,7 @@ namespace gridtools {
                 const uint_t i = blockIdx.x * apply_gpu_impl_::threads_per_block_x_t::value + threadIdx.x;
                 const uint_t j = blockIdx.y * apply_gpu_impl_::threads_per_block_y_t::value + threadIdx.y;
                 const uint_t k = blockIdx.z * apply_gpu_impl_::threads_per_block_z_t::value + threadIdx.z;
-                device::for_each<directions_t>([&](auto dir) {
+                for_each<directions_t>([&](auto dir) {
                     if (predicate(dir)) {
                         auto const &shape = conf.shape(dir);
                         if (i < shape.max() && j < shape.median() && k < shape.min()) {
diff --git a/include/gridtools/common/compose.hpp b/include/gridtools/common/compose.hpp
index 4f9c127639..f87a0cbc8a 100644
--- a/include/gridtools/common/compose.hpp
+++ b/include/gridtools/common/compose.hpp
@@ -7,64 +7,23 @@
  * Please, refer to the LICENSE file in the root directory.
  * SPDX-License-Identifier: BSD-3-Clause
  */
+#pragma once
 
-#ifndef GT_TARGET_ITERATING
-// DON'T USE #pragma once HERE!!!
-#ifndef GT_COMMON_COMPOSE_HPP_
-#define GT_COMMON_COMPOSE_HPP_
-
-#include "../meta.hpp"
-#include "defs.hpp"
-#include "host_device.hpp"
-#include "utility.hpp"
-
-#define GT_FILENAME <gridtools/common/compose.hpp>
-#include GT_ITERATE_ON_TARGETS()
-#undef GT_FILENAME
-
-#endif // GT_COMMON_COMPOSE_HPP_
-#else  // GT_TARGET_ITERATING
+#include <utility>
 
 namespace gridtools {
-    GT_TARGET_NAMESPACE {
-        namespace compose_impl_ {
-            template <class... Funs>
-            struct composed_f;
-
-            template <class F, class G>
-            struct composed_f<F, G> {
-                F m_f;
-                G m_g;
-
-                template <class... Args>
-                GT_TARGET_CONSTEXPR GT_TARGET GT_FORCE_INLINE std::result_of_t<F(std::result_of_t<G(Args &&...)>)>
-                operator()(Args &&... args) const {
-                    return m_f(m_g(wstd::forward<Args>(args)...));
-                }
-            };
-
-            template <class F, class... Fs>
-            struct composed_f<F, Fs...> : composed_f<F, composed_f<Fs...>> {
-                GT_TARGET_CONSTEXPR GT_TARGET GT_FORCE_INLINE composed_f(F f, Fs... fs)
-                    : composed_f<F, composed_f<Fs...>>{wstd::move(f), {wstd::move(fs)...}} {}
-            };
-        } // namespace compose_impl_
-
-        /// Make function composition from provided functions
-        ///
-        /// compose(a, b, c)(x, y) <==> a(b(c(x, y)))
-        ///
-        template <class... Funs>
-        GT_TARGET_CONSTEXPR GT_TARGET GT_FORCE_INLINE compose_impl_::composed_f<std::decay_t<Funs>...> compose(
-            Funs && ... funs) {
-            return {wstd::forward<Funs>(funs)...};
-        }
+    /// Make function composition from provided functions
+    ///
+    /// compose(a, b, c)(x, y) <==> a(b(c(x, y)))
+    ///
+    template <class F>
+    constexpr F &&compose(F &&f) {
+        return std::forward<F>(f);
+    }
 
-        template <class Fun>
-        GT_TARGET_CONSTEXPR GT_TARGET GT_FORCE_INLINE Fun compose(Fun && fun) {
-            return fun;
-        }
+    template <class F, class... Fs>
+    constexpr auto compose(F &&f, Fs &&...fs) {
+        return [f = std::forward<F>(f), fs = compose(std::forward<Fs>(fs)...)](
+                   auto &&...args) { return f(fs(std::forward<decltype(args)>(args)...)); };
     }
 } // namespace gridtools
-
-#endif // GT_TARGET_ITERATING
diff --git a/include/gridtools/common/for_each.hpp b/include/gridtools/common/for_each.hpp
index bcf37f445b..bf5be84f1f 100644
--- a/include/gridtools/common/for_each.hpp
+++ b/include/gridtools/common/for_each.hpp
@@ -7,41 +7,24 @@
  * Please, refer to the LICENSE file in the root directory.
  * SPDX-License-Identifier: BSD-3-Clause
  */
-#ifndef GT_TARGET_ITERATING
-// DON'T USE #pragma once HERE!!!
-#ifndef GT_COMMON_GENERIC_METAFUNCTIONS_FOR_EACH_HPP_
-#define GT_COMMON_GENERIC_METAFUNCTIONS_FOR_EACH_HPP_
+#pragma once
 
 #include "host_device.hpp"
 
-#define GT_FILENAME <gridtools/common/for_each.hpp>
-#include GT_ITERATE_ON_TARGETS()
-#undef GT_FILENAME
-
-#endif
-#else
-
 namespace gridtools {
-    GT_TARGET_NAMESPACE {
-        namespace for_each_impl_ {
-            template <class>
-            struct for_each_f;
+    template <class>
+    struct for_each_impl_;
 
-            template <template <class...> class L, class... Ts>
-            struct for_each_f<L<Ts...>> {
-                template <class F>
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void operator()(F &&f) const {
-                    (..., f(Ts()));
-                }
-            };
-        } // namespace for_each_impl_
+    template <template <class...> class L, class... Ts>
+    struct for_each_impl_<L<Ts...>> {
+        template <class F>
+        static GT_FORCE_INLINE constexpr void apply(F const &f) {
+            (..., f(Ts()));
+        }
+    };
 
-        template <class L>
-#if defined(GT_TARGET_HAS_DEVICE) and defined(__NVCC__)
-        GT_DEVICE
-#endif
-        constexpr for_each_impl_::for_each_f<L> for_each = {};
+    template <class L, class F>
+    GT_FORCE_INLINE constexpr void for_each(F const &f) {
+        for_each_impl_<L>::apply(f);
     }
 } // namespace gridtools
-
-#endif
diff --git a/include/gridtools/common/functional.hpp b/include/gridtools/common/functional.hpp
index 817874fa10..87726a6de4 100644
--- a/include/gridtools/common/functional.hpp
+++ b/include/gridtools/common/functional.hpp
@@ -10,29 +10,12 @@
 /**
 @file
 @brief Unstructured collection of small generic purpose functors and related helpers.
-
-   All functors here are supplied with the inner result or result_type to follow boost::result_of requirement
-   for the cases if BOOST_RESULT_OF_USE_DECLTYPE is not defined [It is so for nvcc8]. This makes those functors
-   usable in the context of boost::fuison high order functions.
-
 */
-
-#ifndef GT_TARGET_ITERATING
-// DON'T USE #pragma once HERE!!!
-#ifndef GT_COMMON_FUNCTIONAL_HPP_
-#define GT_COMMON_FUNCTIONAL_HPP_
+#pragma once
 
 #include <utility>
 
 #include "host_device.hpp"
-#include "utility.hpp"
-
-#define GT_FILENAME <gridtools/common/functional.hpp>
-#include GT_ITERATE_ON_TARGETS()
-#undef GT_FILENAME
-
-#endif
-#else
 
 namespace gridtools {
     /** \ingroup common
@@ -40,67 +23,46 @@ namespace gridtools {
         \defgroup functional Functional
         @{
     */
-    GT_TARGET_NAMESPACE {
-
-        /// Forward the args to constructor.
-        //
-        template <typename T>
-        struct ctor {
-            template <typename... Args>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR T operator()(Args &&... args) const {
-                return {wstd::forward<Args>(args)...};
-            }
-        };
-
-        /// Do nothing.
-        //
-        struct noop {
-            template <typename... Args>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void operator()(Args &&...) const {}
-        };
-
-        /// Perfectly forward the argument.
-        //
-        struct identity {
-            template <typename Arg>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Arg operator()(Arg &&arg) const {
-                return arg;
-            }
-        };
-
-        /// Copy the argument.
-        //
-        struct clone {
-            template <typename Arg>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Arg operator()(Arg const &arg) const {
-                return arg;
-            }
-        };
-
-        template <class...>
-        struct overloaded_f;
-
-        template <class F>
-        struct overloaded_f<F> : F {
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR overloaded_f(F f) : F(wstd::move(f)) {}
-            using F::operator();
-        };
-
-        template <class F, class... Fs>
-        struct overloaded_f<F, Fs...> : F, overloaded_f<Fs...> {
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR overloaded_f(F f, Fs... fs)
-                : F(wstd::move(f)), overloaded_f<Fs...>(wstd::move(fs)...) {}
-            using F::operator();
-            using overloaded_f<Fs...>::operator();
-        };
-
-        template <class... Funs>
-        GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR overloaded_f<Funs...> overload(Funs... funs) {
-            return {wstd::move(funs)...};
+    /// Forward the args to constructor.
+    //
+    template <class T>
+    struct ctor {
+        template <class... Args>
+        GT_FORCE_INLINE constexpr T operator()(Args &&...args) const {
+            return {std::forward<Args>(args)...};
         }
-    }
+    };
+
+    /// Do nothing.
+    //
+    struct noop {
+        template <class... Args>
+        GT_FORCE_INLINE constexpr void operator()(Args &&...) const {}
+    };
+
+    /// Perfectly forward the argument.
+    //
+    struct identity {
+        template <class Arg>
+        GT_FORCE_INLINE constexpr Arg operator()(Arg &&arg) const {
+            return arg;
+        }
+    };
+
+    /// Copy the argument.
+    //
+    struct clone {
+        template <class Arg>
+        GT_FORCE_INLINE constexpr Arg operator()(Arg const &arg) const {
+            return arg;
+        }
+    };
+
+    template <class... Fs>
+    struct overload : Fs... {
+        constexpr overload(Fs... fs) : Fs(std::move(fs))... {}
+        using Fs::operator()...;
+    };
     /** @} */
     /** @} */
 } // namespace gridtools
-
-#endif
diff --git a/include/gridtools/common/host_device.hpp b/include/gridtools/common/host_device.hpp
index 40acfe5926..11859cdc00 100644
--- a/include/gridtools/common/host_device.hpp
+++ b/include/gridtools/common/host_device.hpp
@@ -30,9 +30,6 @@
 #elif defined(__GNUC__)
 #define GT_FORCE_INLINE inline __attribute__((always_inline))
 #define GT_FORCE_INLINE_LAMBDA __attribute__((always_inline))
-#elif defined(_MSC_VER)
-#define GT_FORCE_INLINE inline __forceinline
-#define GT_FORCE_INLINE_LAMBDA
 #else
 #define GT_FORCE_INLINE inline
 #define GT_FORCE_INLINE_LAMBDA
@@ -50,11 +47,6 @@
  * @def GT_FUNCTION_DEVICE
  * Function attribute macro to be used for device-only functions.
  */
-/**
- * @def GT_FUNCTION_WARNING
- * Function attribute macro to be used for host-only functions that might call a host-device
- * function. This macro is only needed to supress NVCC warnings.
- */
 
 #ifdef GT_CUDACC
 #define GT_HOST_DEVICE __host__ __device__
@@ -74,10 +66,6 @@
 #define GT_FUNCTION GT_HOST_DEVICE GT_FORCE_INLINE
 #endif
 
-#ifndef GT_FUNCTION_WARNING
-#define GT_FUNCTION_WARNING GT_HOST_DEVICE GT_FORCE_INLINE
-#endif
-
 #ifndef GT_FUNCTION_HOST
 #define GT_FUNCTION_HOST GT_HOST GT_FORCE_INLINE
 #endif
diff --git a/include/gridtools/common/hymap.hpp b/include/gridtools/common/hymap.hpp
index 053f287f80..a591a27cd0 100644
--- a/include/gridtools/common/hymap.hpp
+++ b/include/gridtools/common/hymap.hpp
@@ -89,13 +89,10 @@
  *  - converting to a map:
  *    `auto a_map = tuple_util::convert_to<hymap::keys<a, b>::values>(a_tuple_with_values)`
  */
-
-#ifndef GT_TARGET_ITERATING
-//// DON'T USE #pragma once HERE!!!
-#ifndef GT_COMMON_HYMAP_HPP_
-#define GT_COMMON_HYMAP_HPP_
+#pragma once
 
 #include <type_traits>
+#include <utility>
 
 #include "../meta.hpp"
 #include "defs.hpp"
@@ -104,12 +101,9 @@
 #include "integral_constant.hpp"
 #include "tuple.hpp"
 #include "tuple_util.hpp"
-#include "utility.hpp"
 
 namespace gridtools {
-
     namespace hymap_impl_ {
-
         template <class I>
         using get_key = integral_constant<int_t, I::value>;
 
@@ -194,6 +188,44 @@ namespace gridtools {
     template <class Map, class Key>
     using has_key = meta::st_contains<hymap_impl_::get_keys<Map>, Key>;
 
+    template <class Key,
+        class Map,
+        class Decayed = std::decay_t<Map>,
+        class I = meta::st_position<get_keys<Decayed>, Key>,
+        std::enable_if_t<I::value != tuple_util::size<Decayed>::value, int> = 0>
+    GT_FORCE_INLINE constexpr decltype(auto) at_key(Map &&map) noexcept {
+        return tuple_util::get<I::value>(std::forward<Map>(map));
+    }
+
+    template <class Key,
+        class Map,
+        class Decayed = std::decay_t<Map>,
+        class I = meta::st_position<get_keys<Decayed>, Key>,
+        std::enable_if_t<I::value == tuple_util::size<Decayed>::value, int> = 0>
+    constexpr void at_key(Map &&) noexcept {
+        static_assert(sizeof(Key) != sizeof(Key), "wrong key");
+    }
+
+    template <class Key,
+        class Default,
+        class Map,
+        class Decayed = std::decay_t<Map>,
+        class I = meta::st_position<get_keys<Decayed>, Key>,
+        std::enable_if_t<I::value != tuple_util::size<Decayed>::value, int> = 0>
+    GT_FORCE_INLINE constexpr decltype(auto) at_key_with_default(Map &&map) noexcept {
+        return tuple_util::get<I::value>(std::forward<Map>(map));
+    }
+
+    template <class Key,
+        class Default,
+        class Map,
+        class Decayed = std::decay_t<Map>,
+        class I = meta::st_position<get_keys<Decayed>, Key>,
+        std::enable_if_t<I::value == tuple_util::size<Decayed>::value, int> = 0>
+    GT_FORCE_INLINE constexpr Default at_key_with_default(Map &&) noexcept {
+        return {};
+    }
+
     namespace hymap {
         template <class...>
         struct keys : private enable_maker {
@@ -217,12 +249,12 @@ namespace gridtools {
 
             template <class... Args,
                 std::enable_if_t<std::conjunction_v<std::is_constructible<Vals, Args>...>, int> = 0>
-            constexpr GT_FUNCTION values(Args &&...args) noexcept : m_vals{wstd::forward<Args>(args)...} {}
+            GT_FORCE_INLINE constexpr values(Args &&...args) noexcept : m_vals{std::forward<Args>(args)...} {}
 
-            constexpr GT_FUNCTION values(Vals const &...args) noexcept : m_vals(args...) {}
+            GT_FORCE_INLINE constexpr values(Vals const &...args) noexcept : m_vals(args...) {}
 
-            constexpr GT_FUNCTION values(tuple<Vals...> &&args) noexcept : m_vals(wstd::move(args)) {}
-            constexpr GT_FUNCTION values(tuple<Vals...> const &args) noexcept : m_vals(args) {}
+            GT_FORCE_INLINE constexpr values(tuple<Vals...> &&args) noexcept : m_vals(std::move(args)) {}
+            GT_FORCE_INLINE constexpr values(tuple<Vals...> const &args) noexcept : m_vals(args) {}
 
             values() = default;
             values(values const &) = default;
@@ -253,7 +285,7 @@ namespace gridtools {
                 meta::if_<meta::is_empty<MetaMap>, meta::list<meta::list<>, meta::list<>>, meta::transpose<MetaMap>>>
         using from_meta_map = from_keys_values<meta::first<KeysAndValues>, meta::second<KeysAndValues>, KeyCtor>;
 
-        namespace hymap_impl_ {
+        namespace impl_ {
             template <class Maps>
             using merged_keys = meta::dedup<meta::transform<meta::first, meta::flatten<Maps>>>;
 
@@ -286,222 +318,152 @@ namespace gridtools {
                 template <class Values, class Maps, class Keys = meta::flatten<meta::transform<get_keys, Maps>>>
                 using apply = typename get_from_keys_values<meta::first<Maps>>::template apply<Keys, Values>;
             };
-        } // namespace hymap_impl_
-    }     // namespace hymap
-} // namespace gridtools
-
-#define GT_FILENAME <gridtools/common/hymap.hpp>
-#include GT_ITERATE_ON_TARGETS()
-#undef GT_FILENAME
 
-#endif // GT_COMMON_HYMAP_HPP_
-#else  // GT_TARGET_ITERATING
+            template <class Fun, class Keys>
+            struct adapter_f {
+                Fun m_fun;
+                template <size_t I, class Value, class Key = meta::at_c<Keys, I>>
+                GT_FORCE_INLINE constexpr decltype(auto) operator()(Value &&value) const {
+                    return m_fun.template operator()<Key>(std::forward<Value>(value));
+                }
+            };
+        } // namespace impl_
 
-namespace gridtools {
-    GT_TARGET_NAMESPACE {
-        template <class Key,
-            class Map,
-            class Decayed = std::decay_t<Map>,
-            class I = meta::st_position<get_keys<Decayed>, Key>,
-            std::enable_if_t<I::value != tuple_util::size<Decayed>::value, int> = 0>
-        GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) at_key(Map && map) noexcept {
-            return tuple_util::GT_TARGET_NAMESPACE_NAME::get<I::value>(wstd::forward<Map>(map));
+        template <class Fun, class Map>
+        GT_FORCE_INLINE constexpr auto transform(Fun &&fun, Map &&map) {
+            return tuple_util::transform_index(
+                impl_::adapter_f<Fun, get_keys<std::decay_t<Map>>>{std::forward<Fun>(fun)}, std::forward<Map>(map));
         }
 
-        template <class Key,
-            class Map,
-            class Decayed = std::decay_t<Map>,
-            class I = meta::st_position<get_keys<Decayed>, Key>,
-            std::enable_if_t<I::value == tuple_util::size<Decayed>::value, int> = 0>
-        GT_TARGET void at_key(Map &&) noexcept {
-            static_assert(sizeof(Key) != sizeof(Key), "wrong key");
+        template <class Fun, class Map>
+        GT_FORCE_INLINE constexpr void for_each(Fun &&fun, Map &&map) {
+            tuple_util::for_each_index(
+                impl_::adapter_f<Fun, get_keys<std::decay_t<Map>>>{std::forward<Fun>(fun)}, std::forward<Map>(map));
         }
 
-        template <class Key,
-            class Default,
-            class Map,
-            class Decayed = std::decay_t<Map>,
-            class I = meta::st_position<get_keys<Decayed>, Key>,
-            std::enable_if_t<I::value != tuple_util::size<Decayed>::value, int> = 0>
-        GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) at_key_with_default(Map && map) noexcept {
-            return tuple_util::GT_TARGET_NAMESPACE_NAME::get<I::value>(wstd::forward<Map>(map));
+        // Concatenate several maps into one. The type of the result is infered from the type of the first map.
+        // Precondition: keys should not overlap.
+        template <class... Maps>
+        GT_FORCE_INLINE constexpr auto concat(Maps... maps) {
+            static_assert(meta::is_set_fast<meta::concat<get_keys<Maps>...>>::value, GT_INTERNAL_ERROR);
+            return tuple_util::concat_ex<impl_::concat_result_maker_f>(std::move(maps)...);
         }
 
-        template <class Key,
-            class Default,
-            class Map,
-            class Decayed = std::decay_t<Map>,
-            class I = meta::st_position<get_keys<Decayed>, Key>,
-            std::enable_if_t<I::value == tuple_util::size<Decayed>::value, int> = 0>
-        GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Default at_key_with_default(Map &&) noexcept {
-            return {};
+        template <template <class...> class KeyCtor,
+            class Keys,
+            class Tup,
+            class HyMapKeys = meta::rename<KeyCtor, Keys>>
+        GT_FORCE_INLINE constexpr auto convert_to(Tup &&tup) {
+            return tuple_util::convert_to<HyMapKeys::template values>(std::forward<Tup>(tup));
         }
-    }
-
-    namespace hymap {
-        GT_TARGET_NAMESPACE {
-            namespace hymap_detail {
-                template <class Fun, class Keys>
-                struct adapter_f {
-                    Fun m_fun;
-                    template <size_t I, class Value, class Key = meta::at_c<Keys, I>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) operator()(Value &&value) const {
-                        return m_fun.template operator()<Key>(wstd::forward<Value>(value));
-                    }
-                };
-            } // namespace hymap_detail
-
-            template <class Fun, class Map>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto transform(Fun && fun, Map && map) {
-                return tuple_util::GT_TARGET_NAMESPACE_NAME::transform_index(
-                    hymap_detail::adapter_f<Fun, get_keys<std::decay_t<Map>>>{wstd::forward<Fun>(fun)},
-                    wstd::forward<Map>(map));
-            }
-
-            template <class Fun, class Map>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void for_each(Fun && fun, Map && map) {
-                tuple_util::GT_TARGET_NAMESPACE_NAME::for_each_index(
-                    hymap_detail::adapter_f<Fun, get_keys<std::decay_t<Map>>>{wstd::forward<Fun>(fun)},
-                    wstd::forward<Map>(map));
-            }
-
-            // Concatenate several maps into one. The type of the result is infered from the type of the first map.
-            // Precondition: keys should not overlap.
-            template <class... Maps>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto concat(Maps... maps) {
-                static_assert(meta::is_set_fast<meta::concat<get_keys<Maps>...>>::value, GT_INTERNAL_ERROR);
-                return tuple_util::concat_ex<hymap_impl_::concat_result_maker_f>(wstd::move(maps)...);
-            }
-
-            template <template <class...> class KeyCtor,
-                class Keys,
-                class Tup,
-                class HyMapKeys = meta::rename<KeyCtor, Keys>>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto convert_to(Tup && tup) {
-                return tuple_util::convert_to<HyMapKeys::template values>(wstd::forward<Tup>(tup));
-            }
 
-            // This class holds two maps and models hymap content.
-            // at_key returns the item of the primary map if the key is found there
-            // otherwise it falls back to the secondary map.
-            template <class Primary, class Secondary>
-            class merged : tuple<Primary, Secondary> {
-                using base_t = tuple<Primary, Secondary>;
+        // This class holds two maps and models hymap content.
+        // at_key returns the item of the primary map if the key is found there
+        // otherwise it falls back to the secondary map.
+        template <class Primary, class Secondary>
+        class merged : tuple<Primary, Secondary> {
+            using base_t = tuple<Primary, Secondary>;
 
-                using meta_primary_t = to_meta_map<Primary>;
-                using meta_secondary_t = to_meta_map<Secondary>;
+            using meta_primary_t = to_meta_map<Primary>;
+            using meta_secondary_t = to_meta_map<Secondary>;
 
-                using primary_keys_t = meta::transform<meta::first, meta_primary_t>;
-                using secondary_keys_t = meta::transform<meta::first, meta_secondary_t>;
+            using primary_keys_t = meta::transform<meta::first, meta_primary_t>;
+            using secondary_keys_t = meta::transform<meta::first, meta_secondary_t>;
 
-                template <class Key,
-                    class PrimaryItem = meta::mp_find<meta_primary_t, Key>,
-                    class SecondaryItem = meta::mp_find<meta_secondary_t, Key>>
-                using get_value_type = meta::second<meta::if_<std::is_void<PrimaryItem>, SecondaryItem, PrimaryItem>>;
+            template <class Key,
+                class PrimaryItem = meta::mp_find<meta_primary_t, Key>,
+                class SecondaryItem = meta::mp_find<meta_secondary_t, Key>>
+            using get_value_type = meta::second<meta::if_<std::is_void<PrimaryItem>, SecondaryItem, PrimaryItem>>;
 
-                using keys_t = meta::dedup<meta::concat<primary_keys_t, secondary_keys_t>>;
-                using values_t = meta::transform<get_value_type, keys_t>;
+            using keys_t = meta::dedup<meta::concat<primary_keys_t, secondary_keys_t>>;
+            using values_t = meta::transform<get_value_type, keys_t>;
 
-                template <size_t I, class Key = meta::at_c<keys_t, I>>
-                using is_primary_index = meta::st_contains<primary_keys_t, Key>;
+            template <size_t I, class Key = meta::at_c<keys_t, I>>
+            using is_primary_index = meta::st_contains<primary_keys_t, Key>;
 
-                template <size_t I, class Key = meta::at_c<keys_t, I>>
-                using inner_index = meta::if_<is_primary_index<I>,
-                    meta::st_position<primary_keys_t, Key>,
-                    meta::st_position<secondary_keys_t, Key>>;
+            template <size_t I, class Key = meta::at_c<keys_t, I>>
+            using inner_index = meta::if_<is_primary_index<I>,
+                meta::st_position<primary_keys_t, Key>,
+                meta::st_position<secondary_keys_t, Key>>;
 
-                template <size_t I,
-                    class Key = meta::at_c<keys_t, I>,
-                    class PrimaryPos = meta::st_position<primary_keys_t, Key>,
-                    class SecondaryPos = meta::st_position<secondary_keys_t, Key>>
-                using split_index = meta::if_c<(PrimaryPos::value < meta::length<primary_keys_t>::value),
-                    meta::list<std::integral_constant<size_t, 0>, PrimaryPos>,
-                    meta::list<std::integral_constant<size_t, 1>, SecondaryPos>>;
+            template <size_t I,
+                class Key = meta::at_c<keys_t, I>,
+                class PrimaryPos = meta::st_position<primary_keys_t, Key>,
+                class SecondaryPos = meta::st_position<secondary_keys_t, Key>>
+            using split_index = meta::if_c<(PrimaryPos::value < meta::length<primary_keys_t>::value),
+                meta::list<std::integral_constant<size_t, 0>, PrimaryPos>,
+                meta::list<std::integral_constant<size_t, 1>, SecondaryPos>>;
 
-                friend values_t tuple_to_types(merged const &) { return {}; }
+            friend values_t tuple_to_types(merged const &) { return {}; }
 
-                friend keys_t hymap_get_keys(merged const &) { return {}; }
+            friend keys_t hymap_get_keys(merged const &) { return {}; }
 
-                friend struct merged_getter;
+            friend struct merged_getter;
 
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR base_t const &base() const { return *this; }
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR base_t &base() { return *this; }
+            GT_FORCE_INLINE constexpr base_t const &base() const { return *this; }
+            GT_FORCE_INLINE constexpr base_t &base() { return *this; }
 
-                template <size_t I>
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) source() const {
-                    return tuple_util::GT_TARGET_NAMESPACE_NAME::get < is_primary_index<I>::value ? 0 : 1 > (base());
-                }
-                template <size_t I>
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) source() {
-                    return tuple_util::GT_TARGET_NAMESPACE_NAME::get < is_primary_index<I>::value ? 0 : 1 > (base());
-                }
+            template <size_t I>
+            GT_FORCE_INLINE constexpr decltype(auto) source() const {
+                return tuple_util::get < is_primary_index<I>::value ? 0 : 1 > (base());
+            }
+            template <size_t I>
+            GT_FORCE_INLINE constexpr decltype(auto) source() {
+                return tuple_util::get < is_primary_index<I>::value ? 0 : 1 > (base());
+            }
 
-                template <size_t I>
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) get() const {
-                    return tuple_util::GT_TARGET_NAMESPACE_NAME::get<inner_index<I>::value>(source<I>());
-                }
-                template <size_t I>
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) get() {
-                    return tuple_util::GT_TARGET_NAMESPACE_NAME::get<inner_index<I>::value>(source<I>());
-                }
+            template <size_t I>
+            GT_FORCE_INLINE constexpr decltype(auto) get() const {
+                return tuple_util::get<inner_index<I>::value>(source<I>());
+            }
+            template <size_t I>
+            GT_FORCE_INLINE constexpr decltype(auto) get() {
+                return tuple_util::get<inner_index<I>::value>(source<I>());
+            }
 
-              public:
-                merged() = default;
+          public:
+            merged() = default;
 
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR merged(Primary primary, Secondary secondary)
-                    : base_t(wstd::move(primary), wstd::move(secondary)) {}
+            GT_FORCE_INLINE constexpr merged(Primary primary, Secondary secondary)
+                : base_t(std::move(primary), std::move(secondary)) {}
 
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Primary const &primary() const {
-                    return tuple_util::GT_TARGET_NAMESPACE_NAME::get<0>(base());
-                }
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Primary &primary() {
-                    return tuple_util::GT_TARGET_NAMESPACE_NAME::get<0>(base());
-                }
+            GT_FORCE_INLINE constexpr Primary const &primary() const { return tuple_util::get<0>(base()); }
+            GT_FORCE_INLINE constexpr Primary &primary() { return tuple_util::get<0>(base()); }
 
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Secondary const &secondary() const {
-                    return tuple_util::GT_TARGET_NAMESPACE_NAME::get<1>(base());
-                }
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Secondary &secondary() {
-                    return tuple_util::GT_TARGET_NAMESPACE_NAME::get<1>(base());
-                }
+            GT_FORCE_INLINE constexpr Secondary const &secondary() const { return tuple_util::get<1>(base()); }
+            GT_FORCE_INLINE constexpr Secondary &secondary() { return tuple_util::get<1>(base()); }
 
-                // TODO:
-                // - element wise ctor
-                // - tuple_from_types
-                // - hymap_from_keys_values
-            };
+            // TODO:
+            // - element wise ctor
+            // - tuple_from_types
+            // - hymap_from_keys_values
+        };
 
-            struct merged_getter {
-                template <size_t I, class Primary, class Secondary>
-                static GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) get(
-                    merged<Primary, Secondary> const &obj) {
-                    return obj.template get<I>();
-                }
-                template <size_t I, class Primary, class Secondary>
-                static GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) get(
-                    merged<Primary, Secondary> &obj) {
-                    return obj.template get<I>();
-                }
-            };
+        struct merged_getter {
+            template <size_t I, class Primary, class Secondary>
+            static GT_FORCE_INLINE constexpr decltype(auto) get(merged<Primary, Secondary> const &obj) {
+                return obj.template get<I>();
+            }
+            template <size_t I, class Primary, class Secondary>
+            static GT_FORCE_INLINE constexpr decltype(auto) get(merged<Primary, Secondary> &obj) {
+                return obj.template get<I>();
+            }
+        };
 
-            template <class Primary, class Secondary>
-            merged_getter tuple_getter(merged<Primary, Secondary> const &);
+        template <class Primary, class Secondary>
+        merged_getter tuple_getter(merged<Primary, Secondary> const &);
 
-            // merge the maps
-            // unlike concat keys could overlap
-            // in the case of overlap the value is taken from the primary map
-            template <class Primary, class Secondary>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR merged<Primary, Secondary> merge(
-                Primary primary, Secondary secondary) {
-                return {wstd::move(primary), wstd::move(secondary)};
-            }
+        // merge the maps
+        // unlike concat keys could overlap
+        // in the case of overlap the value is taken from the primary map
+        template <class Primary, class Secondary>
+        GT_FORCE_INLINE constexpr merged<Primary, Secondary> merge(Primary primary, Secondary secondary) {
+            return {std::move(primary), std::move(secondary)};
+        }
 
-            template <class Primary, class... Secondaries>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto merge(Primary primary, Secondaries... secondaries) {
-                return merge(wstd::move(primary), merge(wstd::move(secondaries)...));
-            }
-        } // namespace hymap
-    }     // namespace hymap
+        template <class Primary, class... Secondaries>
+        GT_FORCE_INLINE constexpr auto merge(Primary primary, Secondaries... secondaries) {
+            return merge(std::move(primary), merge(std::move(secondaries)...));
+        }
+    } // namespace hymap
 } // namespace gridtools
-
-#endif // GT_TARGET_ITERATING
diff --git a/include/gridtools/common/hypercube_iterator.hpp b/include/gridtools/common/hypercube_iterator.hpp
index c3a98a0e27..e05d5413e1 100644
--- a/include/gridtools/common/hypercube_iterator.hpp
+++ b/include/gridtools/common/hypercube_iterator.hpp
@@ -10,6 +10,9 @@
 
 #pragma once
 
+#include <utility>
+#include <type_traits>
+
 #include "array.hpp"
 #include "defs.hpp"
 #include "host_device.hpp"
@@ -92,9 +95,9 @@ namespace gridtools {
         std::enable_if_t<OuterD != 0 && meta::all_of<impl_::is_pair_like, tuple_util::traits::to_types<Decayed>>::value,
             int> = 0>
     GT_FUNCTION impl_::hypercube_view<OuterD> make_hypercube_view(Container &&cube) {
-        auto &&transposed = tuple_util::host_device::transpose(wstd::forward<Container>(cube));
-        return {tuple_util::host_device::convert_to<array, size_t>(tuple_util::host_device::get<0>(transposed)),
-            tuple_util::host_device::convert_to<array, size_t>(tuple_util::host_device::get<1>(transposed))};
+        auto &&transposed = tuple_util::transpose(std::forward<Container>(cube));
+        return {tuple_util::convert_to<array, size_t>(tuple_util::get<0>(transposed)),
+            tuple_util::convert_to<array, size_t>(tuple_util::get<1>(transposed))};
     }
 
     /**
@@ -117,6 +120,6 @@ namespace gridtools {
         std::enable_if_t<D != 0 && meta::all_of<impl_::is_size_t_like, tuple_util::traits::to_types<Decayed>>::value,
             int> = 0>
     GT_FUNCTION impl_::hypercube_view<D> make_hypercube_view(Container &&sizes) {
-        return {tuple_util::host_device::convert_to<array, size_t>(wstd::forward<Container>(sizes))};
+        return {tuple_util::convert_to<array, size_t>(std::forward<Container>(sizes))};
     }
 } // namespace gridtools
diff --git a/include/gridtools/common/implicit_cast.hpp b/include/gridtools/common/implicit_cast.hpp
deleted file mode 100644
index 82cc425136..0000000000
--- a/include/gridtools/common/implicit_cast.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * GridTools
- *
- * Copyright (c) 2014-2021, ETH Zurich
- * All rights reserved.
- *
- * Please, refer to the LICENSE file in the root directory.
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#ifndef GT_TARGET_ITERATING
-// DON'T USE #pragma once HERE!!!
-#ifndef GT_COMMON_IMPLICIT_CAST_HPP_
-#define GT_COMMON_IMPLICIT_CAST_HPP_
-
-#include "../meta/id.hpp"
-#include "defs.hpp"
-#include "host_device.hpp"
-
-#define GT_FILENAME <gridtools/common/implicit_cast.hpp>
-#include GT_ITERATE_ON_TARGETS()
-#undef GT_FILENAME
-
-#endif // GT_COMMON_IMPLICIT_CAST_HPP_
-#else
-
-namespace gridtools {
-    GT_TARGET_NAMESPACE {
-        /**
-         * `boost::implicit_cast` clone with constexpr and target specifiers
-         *
-         * The use of identity creates a non-deduced form, so that the explicit template argument must be supplied
-         */
-        template <class T>
-        GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR T implicit_cast(typename meta::lazy::id<T>::type x) {
-            return x;
-        }
-    }
-} // namespace gridtools
-
-#endif
diff --git a/include/gridtools/common/int_vector.hpp b/include/gridtools/common/int_vector.hpp
index d75f8001fd..78bc65e5ef 100644
--- a/include/gridtools/common/int_vector.hpp
+++ b/include/gridtools/common/int_vector.hpp
@@ -49,7 +49,7 @@ namespace gridtools {
         struct add_f {
             template <class... Ts>
             GT_FUNCTION GT_CONSTEXPR decltype(auto) operator()(Ts const &...args) const {
-                return (host_device::at_key_with_default<Key, integral_constant<int, 0>>(args) + ...);
+                return (at_key_with_default<Key, integral_constant<int, 0>>(args) + ...);
             }
         };
 
@@ -60,7 +60,7 @@ namespace gridtools {
         struct at_key_f {
             template <class T>
             GT_FUNCTION GT_CONSTEXPR decltype(auto) operator()(T const &arg) const {
-                return host_device::at_key<Key>(arg);
+                return at_key<Key>(arg);
             }
         };
 
@@ -103,7 +103,7 @@ namespace gridtools {
             using merged_meta_map_t = meta::mp_make<impl_::merger_t, meta::concat<hymap::to_meta_map<Vecs>...>>;
             using keys_t = meta::transform<meta::first, merged_meta_map_t>;
             using generators = meta::transform<impl_::add_f, keys_t>;
-            return tuple_util::host_device::generate<generators, hymap::from_meta_map<merged_meta_map_t>>(
+            return tuple_util::generate<generators, hymap::from_meta_map<merged_meta_map_t>>(
                 wstd::forward<Vecs>(vecs)...);
         }
 
@@ -112,7 +112,7 @@ namespace gridtools {
          */
         template <class Vec, class Scalar>
         GT_FUNCTION GT_CONSTEXPR auto multiply(Vec && vec, Scalar scalar) {
-            return tuple_util::host_device::transform([scalar](auto v) { return v * scalar; }, wstd::forward<Vec>(vec));
+            return tuple_util::transform([scalar](auto v) { return v * scalar; }, wstd::forward<Vec>(vec));
         }
 
         /**
@@ -123,8 +123,7 @@ namespace gridtools {
             using filtered_map_t = meta::filter<meta::not_<impl_::is_constant_zero>::apply, hymap::to_meta_map<Vec>>;
             using keys_t = meta::transform<meta::first, filtered_map_t>;
             using generators = meta::transform<impl_::at_key_f, keys_t>;
-            return tuple_util::host_device::generate<generators, hymap::from_meta_map<filtered_map_t>>(
-                wstd::forward<Vec>(vec));
+            return tuple_util::generate<generators, hymap::from_meta_map<filtered_map_t>>(wstd::forward<Vec>(vec));
         }
 
         namespace arithmetic {
diff --git a/include/gridtools/common/iterate_on_host_device.hpp b/include/gridtools/common/iterate_on_host_device.hpp
index 2e660f3cb4..cb735feb2c 100644
--- a/include/gridtools/common/iterate_on_host_device.hpp
+++ b/include/gridtools/common/iterate_on_host_device.hpp
@@ -48,7 +48,7 @@
 #define GT_TARGET_NAMESPACE_NAME host_device
 #define GT_TARGET_NAMESPACE namespace host_device
 #define GT_TARGET GT_HOST_DEVICE
-#define GT_TARGET_CONSTEXPR
+#define GT_TARGET_CONSTEXPR constexpr
 #define GT_TARGET_HAS_DEVICE
 #include GT_FILENAME
 #undef GT_TARGET_HAS_DEVICE
@@ -61,13 +61,13 @@
 #define GT_TARGET_NAMESPACE namespace device
 #define GT_TARGET GT_DEVICE
 #define GT_TARGET_HAS_DEVICE
-#define GT_TARGET_CONSTEXPR
+#define GT_TARGET_CONSTEXPR constexpr
 #include GT_FILENAME
 #undef GT_TARGET_HAS_DEVICE
 #undef GT_TARGET
 #undef GT_TARGET_NAMESPACE
 #undef GT_TARGET_NAMESPACE_NAME
-#undef GT_TARGET_CONSTEXPR
+#undef GT_TARGET_CONSTEXPR 
 
 #else
 
diff --git a/include/gridtools/common/tuple_util.hpp b/include/gridtools/common/tuple_util.hpp
index 2715bb102d..95b2fc7ad1 100644
--- a/include/gridtools/common/tuple_util.hpp
+++ b/include/gridtools/common/tuple_util.hpp
@@ -95,10 +95,20 @@
  *
  */
 
-#ifndef GT_TARGET_ITERATING
-//// DON'T USE #pragma once HERE!!!
-#ifndef GT_COMMON_TUPLE_UTIL_HPP_
-#define GT_COMMON_TUPLE_UTIL_HPP_
+/*
+vertical_advection_dycore_gpu
+positional_stencil_gpu
+positional_stencil_gpu_horizontal
+alignment_gpu
+alignment_gpu_horizontal
+whole_axis_access_gpu
+whole_axis_access_gpu_horizontal
+test_kcache_fill_gpu
+test_kcache_fill_and_flush_gpu
+test_kcache_flush_gpu
+*/
+
+#pragma once
 
 #include <array>
 #include <tuple>
@@ -116,40 +126,38 @@
 #include "defs.hpp"
 #include "functional.hpp"
 #include "host_device.hpp"
-#include "implicit_cast.hpp"
-#include "utility.hpp"
-
-#define GT_TUPLE_UTIL_FORWARD_GETTER_TO_MEMBER(class_name, member_name)                                    \
-    struct class_name##_tuple_util_getter {                                                                \
-        template <::std::size_t I>                                                                         \
-        static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(class_name const &obj) {                        \
-            return ::gridtools::tuple_util::host_device::get<I>(obj.member_name);                          \
-        }                                                                                                  \
-        template <::std::size_t I>                                                                         \
-        static GT_FUNCTION decltype(auto) get(class_name &obj) {                                           \
-            return ::gridtools::tuple_util::host_device::get<I>(obj.member_name);                          \
-        }                                                                                                  \
-        template <::std::size_t I>                                                                         \
-        static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(class_name &&obj) {                             \
-            return ::gridtools::tuple_util::host_device::get<I>(::gridtools::wstd::move(obj).member_name); \
-        }                                                                                                  \
-    };                                                                                                     \
-    friend class_name##_tuple_util_getter tuple_getter(class_name const &) { return {}; }                  \
+
+#define GT_TUPLE_UTIL_FORWARD_GETTER_TO_MEMBER(class_name, member_name)                   \
+    struct class_name##_tuple_util_getter {                                               \
+        template <::std::size_t I>                                                        \
+        static GT_FORCE_INLINE constexpr decltype(auto) get(class_name const &obj) {      \
+            return ::gridtools::tuple_util::get<I>(obj.member_name);                      \
+        }                                                                                 \
+        template <::std::size_t I>                                                        \
+        static GT_FORCE_INLINE constexpr decltype(auto) get(class_name &obj) {            \
+            return ::gridtools::tuple_util::get<I>(obj.member_name);                      \
+        }                                                                                 \
+        template <::std::size_t I>                                                        \
+        static GT_FORCE_INLINE constexpr decltype(auto) get(class_name &&obj) {           \
+            return ::gridtools::tuple_util::get<I>(::std::move(obj).member_name);         \
+        }                                                                                 \
+    };                                                                                    \
+    friend class_name##_tuple_util_getter tuple_getter(class_name const &) { return {}; } \
     static_assert(1, "")
 
 #define GT_STRUCT_TUPLE_IMPL_DECL_(r, data, elem) BOOST_PP_TUPLE_ELEM(0, elem) BOOST_PP_TUPLE_ELEM(1, elem);
 #define GT_STRUCT_TUPLE_IMPL_TYPE_(s, data, elem) BOOST_PP_TUPLE_ELEM(0, elem)
 #define GT_STRUCT_TUPLE_IMPL_GETS_(s, name, i, elem)                                                        \
     template <::std::size_t I, ::std::enable_if_t<I == i, int> = 0, class T = BOOST_PP_TUPLE_ELEM(0, elem)> \
-    static GT_CONSTEXPR GT_FUNCTION T const &get(name const &obj) {                                         \
+    static GT_FORCE_INLINE constexpr T const &get(name const &obj) {                                        \
         return obj.BOOST_PP_TUPLE_ELEM(1, elem);                                                            \
     }                                                                                                       \
     template <::std::size_t I, ::std::enable_if_t<I == i, int> = 0, class T = BOOST_PP_TUPLE_ELEM(0, elem)> \
-    static GT_FUNCTION T &get(name &obj) {                                                                  \
+    static GT_FORCE_INLINE constexpr T &get(name &obj) {                                                    \
         return obj.BOOST_PP_TUPLE_ELEM(1, elem);                                                            \
     }                                                                                                       \
     template <::std::size_t I, ::std::enable_if_t<I == i, int> = 0, class T = BOOST_PP_TUPLE_ELEM(0, elem)> \
-    static GT_CONSTEXPR GT_FUNCTION T &&get(name &&obj) {                                                   \
+    static GT_FORCE_INLINE constexpr T &&get(name &&obj) {                                                  \
         return static_cast<T &&>(obj.BOOST_PP_TUPLE_ELEM(1, elem));                                         \
     }
 #define GT_STRUCT_TUPLE_IMPL_(name, members)                                                                          \
@@ -191,12 +199,29 @@
  */
 #define GT_STRUCT_TUPLE(name, ...) GT_STRUCT_TUPLE_IMPL_(name, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))
 
+#ifdef GT_CUDACC
+#define DEFINE_FUNCTOR_INSTANCE(name, functor)                      \
+    template <class... Args>                                        \
+    GT_FORCE_INLINE constexpr decltype(auto) name(Args &&...args) { \
+        return functor()(std::forward<Args>(args)...);              \
+    }                                                               \
+    static_assert(1, "")
+#ifdef __NVCC__
+#define DEFINE_TEMPLATED_FUNCTOR_INSTANCE(name, functor) GT_DEVICE constexpr functor name = {}
+#else
+#define DEFINE_TEMPLATED_FUNCTOR_INSTANCE(name, functor) constexpr functor name = {}
+#endif
+#else
+#define DEFINE_FUNCTOR_INSTANCE(name, functor) constexpr functor name = {}
+#define DEFINE_TEMPLATED_FUNCTOR_INSTANCE(name, functor) constexpr functor name = {}
+#endif
+
 namespace gridtools {
     namespace tuple_util {
 
         /// @cond
         namespace traits {
-            namespace _impl {
+            namespace impl_ {
 
                 template <class... Ts>
                 struct deduce_array_type : std::common_type<Ts...> {};
@@ -218,10 +243,10 @@ namespace gridtools {
                 struct std_getter {
                     template <size_t I, class T>
                     GT_FORCE_INLINE static constexpr decltype(auto) get(T &&obj) noexcept {
-                        return std::get<I>(wstd::forward<T>(obj));
+                        return std::get<I>(std::forward<T>(obj));
                     }
                 };
-            } // namespace _impl
+            } // namespace impl_
 
             // start of builtin adaptations
 
@@ -248,17 +273,17 @@ namespace gridtools {
 
             // arrays specialization.
             template <class T, size_t N>
-            _impl::array_from_types tuple_from_types(std::array<T, N>);
+            impl_::array_from_types tuple_from_types(std::array<T, N>);
 
             // getter
 
             // all `std` "tuple_like"s use `std::get`
             template <class... Ts>
-            _impl::std_getter tuple_getter(std::tuple<Ts...>);
+            impl_::std_getter tuple_getter(std::tuple<Ts...>);
             template <class T, class U>
-            _impl::std_getter tuple_getter(std::pair<T, U>);
+            impl_::std_getter tuple_getter(std::pair<T, U>);
             template <class T, size_t N>
-            _impl::std_getter tuple_getter(std::array<T, N>);
+            impl_::std_getter tuple_getter(std::array<T, N>);
 
             // end of builtin adaptations
 
@@ -304,9 +329,7 @@ namespace gridtools {
         template <class Tup>
         struct is_empty_or_tuple_of_empties<Tup, std::enable_if_t<is_tuple_of_empties<Tup>::value>> : std::true_type {};
 
-        // Here goes the stuff that is common for all targets (meta functions)
-        namespace _impl {
-
+        namespace impl_ {
             template <class T>
             using to_types = meta::rename<meta::list, traits::to_types<std::decay_t<T>>>;
 
@@ -445,1205 +468,1119 @@ namespace gridtools {
                       // check that the getters produce expected types for all indices
                       meta::all_of<meta::curry<is_getter_valid, T, Getter, Types>::template apply,
                           meta::make_indices_for<Types>>::value> {};
-        } // namespace _impl
+        } // namespace impl_
 
         template <class, class = void>
         struct is_tuple_like : std::false_type {};
 
         template <class T>
-        struct is_tuple_like<T, std::enable_if_t<_impl::is_tuple_like<T>::value>> : std::true_type {};
-    } // namespace tuple_util
-
-    using tuple_util::is_tuple_like;
-
-#ifdef __cpp_concepts
-    namespace concepts {
-        template <class T>
-        concept tuple_like = is_tuple_like<T>::value;
-
-        template <class T, class... Ts>
-        concept tuple_like_of = tuple_like<T> &&
-            std::is_same_v<meta::rename<meta::list, tuple_util::traits::to_types<T>>, meta::list<Ts...>>;
-    } // namespace concepts
-#endif
-
-} // namespace gridtools
-
-// Now it's time to generate host/device/host_device stuff
-#define GT_FILENAME <gridtools/common/tuple_util.hpp>
-#include GT_ITERATE_ON_TARGETS()
-#undef GT_FILENAME
-
-#endif // GT_COMMON_TUPLE_UTIL_HPP_
-#else  // GT_TARGET_ITERATING
-
-#ifdef GT_TARGET_HAS_DEVICE
-
-#define DEFINE_FUNCTOR_INSTANCE(name, functor)                                          \
-    template <class... Args>                                                            \
-    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) name(Args &&...args) { \
-        return functor()(wstd::forward<Args>(args)...);                                 \
-    }                                                                                   \
-    static_assert(1, "")
-
-#ifdef __NVCC__
-#define DEFINE_TEMPLATED_FUNCTOR_INSTANCE(name, functor) GT_DEVICE constexpr functor name = {}
-#else
-#define DEFINE_TEMPLATED_FUNCTOR_INSTANCE(name, functor) constexpr functor name = {}
-#endif
-
-#else
-
-#define DEFINE_FUNCTOR_INSTANCE(name, functor) constexpr functor name = {}
-
-#define DEFINE_TEMPLATED_FUNCTOR_INSTANCE(name, functor) constexpr functor name = {}
-
-#endif
+        struct is_tuple_like<T, std::enable_if_t<impl_::is_tuple_like<T>::value>> : std::true_type {};
+
+        /**
+         * @brief Tuple element accessor like std::get.
+         *
+         * @tparam I Element index.
+         * @tparam T Tuple-like type.
+         * @param obj Tuple-like object.
+         */
+        template <size_t I, class T, class Getter = traits::getter<std::decay_t<T>>>
+        GT_FORCE_INLINE constexpr decltype(auto) get(T &&obj) noexcept {
+            return Getter::template get<I>(std::forward<T>(obj));
+        }
 
-namespace gridtools {
-    namespace tuple_util {
-        GT_TARGET_NAMESPACE {
-            /**
-             * @brief Tuple element accessor like std::get.
-             *
-             * @tparam I Element index.
-             * @tparam T Tuple-like type.
-             * @param obj Tuple-like object.
-             */
-            template <size_t I, class T, class Getter = traits::getter<std::decay_t<T>>>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) get(T && obj) noexcept {
-                return Getter::template get<I>(wstd::forward<T>(obj));
+        template <size_t I>
+        struct get_nth_f {
+            template <class T, class Getter = traits::getter<std::decay_t<T>>>
+            GT_FORCE_INLINE constexpr decltype(auto) operator()(T &&obj) const noexcept {
+                return Getter::template get<I>(std::forward<T>(obj));
             }
+        };
 
+        namespace impl_ {
             template <size_t I>
-            struct get_nth_f {
-                template <class T, class Getter = traits::getter<std::decay_t<T>>>
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) operator()(T &&obj) const noexcept {
-                    return Getter::template get<I>(wstd::forward<T>(obj));
+            struct transform_elem_index_f {
+                template <class Fun, class... Tups>
+                GT_FORCE_INLINE constexpr decltype(auto) operator()(Fun &&fun, Tups &&...tups) const {
+                    return std::forward<Fun>(fun).template operator()<I>(get<I>(std::forward<Tups>(tups))...);
                 }
             };
 
-            // Let us use `detail` for internal namespace of the target dependent namespace.
-            // This way we can refer `_impl::foo` for the entities that are independent on the target and
-            // `detail::bar` for the target dependent ones.
-            namespace detail {
-                using _impl::from_types;
-                using _impl::get_accessors;
-                using _impl::get_fun_result;
-                using _impl::to_types;
-
-                template <size_t I>
-                struct transform_elem_index_f {
-                    template <class Fun, class... Tups>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) operator()(
-                        Fun &&fun, Tups &&...tups) const {
-                        return wstd::forward<Fun>(fun).template operator()<I>(
-                            GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tups>(tups))...);
-                    }
-                };
+            template <class I>
+            using get_transform_index_generator = transform_elem_index_f<I::value>;
 
-                template <class I>
-                using get_transform_index_generator = transform_elem_index_f<I::value>;
-
-                template <class GeneratorList, class Res>
-                struct generate_f;
-                template <template <class...> class L, class... Generators, class Res>
-                struct generate_f<L<Generators...>, Res> {
-                    template <class... Args>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Args &&...args) const {
-                        return Res{Generators{}(wstd::forward<Args>(args)...)...};
-                    }
-                };
+            template <class GeneratorList, class Res>
+            struct generate_f;
+            template <template <class...> class L, class... Generators, class Res>
+            struct generate_f<L<Generators...>, Res> {
+                template <class... Args>
+                GT_FORCE_INLINE constexpr Res operator()(Args &&...args) const {
+                    return Res{Generators{}(std::forward<Args>(args)...)...};
+                }
+            };
 
-                template <class Fun>
-                struct transform_index_f {
-                    template <class... Args>
-                    using get_results_t = meta::transform<_impl::get_fun_result_index<Fun>::template apply, Args...>;
-
-                    Fun m_fun;
-
-                    template <class Tup, class... Tups>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto operator()(Tup &&tup, Tups &&...tups) const {
-                        using indices_t = meta::make_indices<size<std::decay_t<Tup>>>;
-                        using res_t =
-                            from_types<Tup, get_results_t<indices_t, get_accessors<Tup>, get_accessors<Tups>...>>;
-                        using generators_t = meta::transform<get_transform_index_generator, indices_t>;
-                        return generate_f<generators_t, res_t>()(
-                            m_fun, wstd::forward<Tup>(tup), wstd::forward<Tups>(tups)...);
-                    }
-                };
+            template <class Fun>
+            struct transform_index_f {
+                template <class... Args>
+                using get_results_t = meta::transform<get_fun_result_index<Fun>::template apply, Args...>;
+
+                Fun m_fun;
+
+                template <class Tup, class... Tups>
+                GT_FORCE_INLINE constexpr auto operator()(Tup &&tup, Tups &&...tups) const {
+                    using indices_t = meta::make_indices<size<std::decay_t<Tup>>>;
+                    using res_t = from_types<Tup, get_results_t<indices_t, get_accessors<Tup>, get_accessors<Tups>...>>;
+                    using generators_t = meta::transform<get_transform_index_generator, indices_t>;
+                    return generate_f<generators_t, res_t>()(
+                        m_fun, std::forward<Tup>(tup), std::forward<Tups>(tups)...);
+                }
+            };
 
-                template <class Fun>
-                struct add_index_arg_f {
-                    Fun m_fun;
+            template <class Fun>
+            struct add_index_arg_f {
+                Fun m_fun;
 
-                    template <size_t I, class... Args>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto operator()(Args &&...args) const
-                        -> decltype(m_fun(wstd::forward<Args>(args)...)) {
-                        return m_fun(wstd::forward<Args>(args)...);
-                    }
-                };
+                template <size_t I, class... Args>
+                GT_FORCE_INLINE constexpr auto operator()(Args &&...args) const
+                    -> decltype(m_fun(std::forward<Args>(args)...)) {
+                    return m_fun(std::forward<Args>(args)...);
+                }
+            };
 
-                template <class Fun>
-                using transform_f = transform_index_f<add_index_arg_f<Fun>>;
-
-                template <class Fun>
-                struct for_each_adaptor_f {
-                    Fun m_fun;
-                    template <size_t I, class... Args>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR meta::lazy::id<void> operator()(
-                        Args &&...args) const {
-                        m_fun(wstd::forward<Args>(args)...);
-                        return {};
-                    }
-                };
+            template <class Fun>
+            using transform_f = transform_index_f<add_index_arg_f<Fun>>;
 
-                template <class Fun>
-                struct for_each_index_adaptor_f {
-                    Fun m_fun;
-                    template <size_t I, class... Args>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR meta::lazy::id<void> operator()(
-                        Args &&...args) const {
-                        m_fun.template operator()<I>(wstd::forward<Args>(args)...);
-                        return {};
-                    }
-                };
+            template <class Fun>
+            struct for_each_adaptor_f {
+                Fun m_fun;
+                template <size_t I, class... Args>
+                GT_FORCE_INLINE constexpr meta::lazy::id<void> operator()(Args &&...args) const {
+                    m_fun(std::forward<Args>(args)...);
+                    return {};
+                }
+            };
 
-                template <class Indices>
-                struct apply_to_elements_f;
+            template <class Fun>
+            struct for_each_index_adaptor_f {
+                Fun m_fun;
+                template <size_t I, class... Args>
+                GT_FORCE_INLINE constexpr meta::lazy::id<void> operator()(Args &&...args) const {
+                    m_fun.template operator()<I>(std::forward<Args>(args)...);
+                    return {};
+                }
+            };
 
-                template <template <class...> class L, class... Is>
-                struct apply_to_elements_f<L<Is...>> {
-                    template <class Fun, class... Tups>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) operator()(
-                        Fun &&fun, Tups &&...tups) const {
-                        return wstd::forward<Fun>(fun)(
-                            GT_TARGET_NAMESPACE_NAME::get<Is::value>(wstd::forward<Tups>(tups))...);
-                    }
-                };
+            template <class Indices>
+            struct apply_to_elements_f;
 
-                template <class>
-                struct for_each_in_cartesian_product_impl_f;
-
-                template <template <class...> class Outer, class... Inners>
-                struct for_each_in_cartesian_product_impl_f<Outer<Inners...>> {
-                    template <class Fun, class... Tups>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void operator()(Fun &&fun, Tups &&...tups) const {
-                        using loop_t = int[sizeof...(Inners)];
-                        void(loop_t{
-                            (apply_to_elements_f<Inners>{}(wstd::forward<Fun>(fun), wstd::forward<Tups>(tups)...),
-                                0)...});
-                    }
-                };
+            template <template <class...> class L, class... Is>
+            struct apply_to_elements_f<L<Is...>> {
+                template <class Fun, class... Tups>
+                GT_FORCE_INLINE constexpr decltype(auto) operator()(Fun &&fun, Tups &&...tups) const {
+                    return std::forward<Fun>(fun)(get<Is::value>(std::forward<Tups>(tups))...);
+                }
+            };
 
-                template <class Fun>
-                struct for_each_in_cartesian_product_f {
-                    Fun m_fun;
-                    template <class... Tups>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void operator()(Tups &&...tups) const {
-                        for_each_in_cartesian_product_impl_f<
-                            meta::cartesian_product<meta::make_indices_c<size<std::decay_t<Tups>>::value>...>>{}(
-                            m_fun, wstd::forward<Tups>(tups)...);
-                    }
-                };
+            template <class>
+            struct for_each_in_cartesian_product_impl_f;
+
+            template <template <class...> class Outer, class... Inners>
+            struct for_each_in_cartesian_product_impl_f<Outer<Inners...>> {
+                template <class Fun, class... Tups>
+                GT_FORCE_INLINE constexpr void operator()(Fun &&fun, Tups &&...tups) const {
+                    using loop_t = int[sizeof...(Inners)];
+                    void(loop_t{
+                        (apply_to_elements_f<Inners>{}(std::forward<Fun>(fun), std::forward<Tups>(tups)...), 0)...});
+                }
+            };
 
-                struct skip_me {
-                    template <class T>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR skip_me(T &&) {}
-                };
+            template <class Fun>
+            struct for_each_in_cartesian_product_f {
+                Fun m_fun;
+                template <class... Tups>
+                GT_FORCE_INLINE constexpr void operator()(Tups &&...tups) const {
+                    for_each_in_cartesian_product_impl_f<
+                        meta::cartesian_product<meta::make_indices_c<size<std::decay_t<Tups>>::value>...>>{}(
+                        m_fun, std::forward<Tups>(tups)...);
+                }
+            };
 
-                template <size_t>
-                using skip_me_type = skip_me;
+            struct skip_me {
+                template <class T>
+                GT_FORCE_INLINE constexpr skip_me(T &&) {}
+            };
 
-                template <class IndicesToSkip>
-                struct select_arg_f;
+            template <size_t>
+            using skip_me_type = skip_me;
 
-                template <size_t... IndicesToSkip>
-                struct select_arg_f<std::index_sequence<IndicesToSkip...>> {
-                    template <class T, class... Ts>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR T &&operator()(
-                        skip_me_type<IndicesToSkip> &&..., T &&obj, Ts &&...) const {
-                        return wstd::forward<T>(obj);
-                    }
-                };
+            template <class IndicesToSkip>
+            struct select_arg_f;
 
-                template <class ResultMaker>
-                struct concat_f {
-                    template <class OuterI, class InnerI>
-                    struct generator_f {
-                        template <class... Tups>
-                        GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) operator()(Tups &&...tups) const {
-                            return GT_TARGET_NAMESPACE_NAME::get<InnerI::value>(
-                                select_arg_f<std::make_index_sequence<OuterI::value>>{}(wstd::forward<Tups>(tups)...));
-                        }
-                    };
-
-                    template <class OuterI, class InnerTup>
-                    using get_inner_generators = meta::transform<meta::curry<generator_f, OuterI>::template apply,
-                        meta::make_indices_for<InnerTup>>;
+            template <size_t... IndicesToSkip>
+            struct select_arg_f<std::index_sequence<IndicesToSkip...>> {
+                template <class T, class... Ts>
+                GT_FORCE_INLINE constexpr T &&operator()(skip_me_type<IndicesToSkip> &&..., T &&obj, Ts &&...) const {
+                    return std::forward<T>(obj);
+                }
+            };
 
+            template <class ResultMaker>
+            struct concat_f {
+                template <class OuterI, class InnerI>
+                struct generator_f {
                     template <class... Tups>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto operator()(Tups &&...tups) const {
-                        using accessors_t = meta::transform<get_accessors, meta::list<Tups...>>;
-                        using res_t =
-                            typename ResultMaker::template apply<meta::flatten<accessors_t>, meta::list<Tups...>>;
-                        using generators_t = meta::flatten<
-                            meta::transform<get_inner_generators, meta::make_indices_for<accessors_t>, accessors_t>>;
-                        return generate_f<generators_t, res_t>{}(wstd::forward<Tups>(tups)...);
+                    GT_FORCE_INLINE constexpr decltype(auto) operator()(Tups &&...tups) const {
+                        return get<InnerI::value>(
+                            select_arg_f<std::make_index_sequence<OuterI::value>>{}(std::forward<Tups>(tups)...));
                     }
                 };
 
-                template <class ResultMaker>
-                struct flatten_f {
-                    template <class OuterI, class InnerI>
-                    struct generator_f {
-                        template <class Tup>
-                        GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) operator()(Tup &&tup) const {
-                            return GT_TARGET_NAMESPACE_NAME::get<InnerI::value>(
-                                GT_TARGET_NAMESPACE_NAME::get<OuterI::value>(wstd::forward<Tup>(tup)));
-                        }
-                    };
-
-                    template <class OuterI, class InnerTup>
-                    using get_inner_generators = meta::transform<meta::curry<generator_f, OuterI>::template apply,
-                        meta::make_indices_for<InnerTup>>;
+                template <class OuterI, class InnerTup>
+                using get_inner_generators =
+                    meta::transform<meta::curry<generator_f, OuterI>::template apply, meta::make_indices_for<InnerTup>>;
+
+                template <class... Tups>
+                GT_FORCE_INLINE constexpr auto operator()(Tups &&...tups) const {
+                    using accessors_t = meta::transform<get_accessors, meta::list<Tups...>>;
+                    using res_t = typename ResultMaker::template apply<meta::flatten<accessors_t>, meta::list<Tups...>>;
+                    using generators_t = meta::flatten<
+                        meta::transform<get_inner_generators, meta::make_indices_for<accessors_t>, accessors_t>>;
+                    return generate_f<generators_t, res_t>{}(std::forward<Tups>(tups)...);
+                }
+            };
 
+            template <class ResultMaker>
+            struct flatten_f {
+                template <class OuterI, class InnerI>
+                struct generator_f {
                     template <class Tup>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto operator()(Tup &&tup) const {
-                        static_assert(size<Tup>::value != 0, "can not flatten empty tuple");
-                        using accessors_t = meta::transform<get_accessors, get_accessors<Tup>>;
-                        using res_t = typename ResultMaker::template apply<meta::flatten<accessors_t>, to_types<Tup>>;
-                        using generators_t = meta::flatten<
-                            meta::transform<get_inner_generators, meta::make_indices_for<accessors_t>, accessors_t>>;
-                        return generate_f<generators_t, res_t>{}(wstd::forward<Tup>(tup));
+                    GT_FORCE_INLINE constexpr decltype(auto) operator()(Tup &&tup) const {
+                        return get<InnerI::value>(get<OuterI::value>(std::forward<Tup>(tup)));
                     }
                 };
 
-                template <size_t N>
-                struct drop_front_f {
-                    template <class I>
-                    using get_drop_front_generator = get_nth_f<N + I::value>;
-
-                    template <class Tup,
-                        class Accessors = get_accessors<Tup>,
-                        class Res = from_types<Tup, meta::drop_front_c<N, Accessors>>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        using generators =
-                            meta::transform<get_drop_front_generator, meta::make_indices_c<size<Accessors>::value - N>>;
-                        return generate_f<generators, Res>{}(wstd::forward<Tup>(tup));
-                    }
-                };
+                template <class OuterI, class InnerTup>
+                using get_inner_generators =
+                    meta::transform<meta::curry<generator_f, OuterI>::template apply, meta::make_indices_for<InnerTup>>;
+
+                template <class Tup>
+                GT_FORCE_INLINE constexpr auto operator()(Tup &&tup) const {
+                    static_assert(size<Tup>::value != 0, "can not flatten empty tuple");
+                    using accessors_t = meta::transform<get_accessors, get_accessors<Tup>>;
+                    using res_t = typename ResultMaker::template apply<meta::flatten<accessors_t>, to_types<Tup>>;
+                    using generators_t = meta::flatten<
+                        meta::transform<get_inner_generators, meta::make_indices_for<accessors_t>, accessors_t>>;
+                    return generate_f<generators_t, res_t>{}(std::forward<Tup>(tup));
+                }
+            };
 
-                template <class, class>
-                struct push_back_impl_f;
+            template <size_t N>
+            struct drop_front_f {
+                template <class I>
+                using get_drop_front_generator = get_nth_f<N + I::value>;
+
+                template <class Tup,
+                    class Accessors = get_accessors<Tup>,
+                    class Res = from_types<Tup, meta::drop_front_c<N, Accessors>>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    using generators =
+                        meta::transform<get_drop_front_generator, meta::make_indices_c<size<Accessors>::value - N>>;
+                    return generate_f<generators, Res>{}(std::forward<Tup>(tup));
+                }
+            };
 
-                template <template <class T, T...> class L, class Int, Int... Is, class Res>
-                struct push_back_impl_f<L<Int, Is...>, Res> {
-                    template <class Tup, class... Args>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup, Args &&...args) const {
-                        return Res{GT_TARGET_NAMESPACE_NAME::get<Is>(wstd::forward<Tup>(tup))...,
-                            wstd::forward<Args>(args)...};
-                    }
-                };
+            template <class, class>
+            struct push_back_impl_f;
 
-                struct push_back_f {
-                    template <class Tup,
-                        class... Args,
-                        class Accessors = get_accessors<Tup>,
-                        class Res = from_types<Tup, meta::push_back<Accessors, Args &&...>>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup, Args &&...args) const {
-                        return push_back_impl_f<std::make_index_sequence<size<Accessors>::value>, Res>{}(
-                            wstd::forward<Tup>(tup), wstd::forward<Args>(args)...);
-                    }
-                };
+            template <template <class T, T...> class L, class Int, Int... Is, class Res>
+            struct push_back_impl_f<L<Int, Is...>, Res> {
+                template <class Tup, class... Args>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup, Args &&...args) const {
+                    return Res{get<Is>(std::forward<Tup>(tup))..., std::forward<Args>(args)...};
+                }
+            };
 
-                template <class, class>
-                struct push_front_impl_f;
+            struct push_back_f {
+                template <class Tup,
+                    class... Args,
+                    class Accessors = get_accessors<Tup>,
+                    class Res = from_types<Tup, meta::push_back<Accessors, Args &&...>>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup, Args &&...args) const {
+                    return push_back_impl_f<std::make_index_sequence<size<Accessors>::value>, Res>{}(
+                        std::forward<Tup>(tup), std::forward<Args>(args)...);
+                }
+            };
 
-                template <template <class T, T...> class L, class Int, Int... Is, class Res>
-                struct push_front_impl_f<L<Int, Is...>, Res> {
-                    template <class Tup, class... Args>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup, Args &&...args) const {
-                        return Res{wstd::forward<Args>(args)...,
-                            GT_TARGET_NAMESPACE_NAME::get<Is>(wstd::forward<Tup>(tup))...};
-                    }
-                };
+            template <class, class>
+            struct push_front_impl_f;
 
-                struct push_front_f {
-                    template <class Tup,
-                        class... Args,
-                        class Accessors = get_accessors<Tup>,
-                        class Res = from_types<Tup, meta::push_front<Accessors, Args &&...>>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup, Args &&...args) const {
-                        return push_front_impl_f<std::make_index_sequence<size<Accessors>::value>, Res>{}(
-                            wstd::forward<Tup>(tup), wstd::forward<Args>(args)...);
-                    }
-                };
+            template <template <class T, T...> class L, class Int, Int... Is, class Res>
+            struct push_front_impl_f<L<Int, Is...>, Res> {
+                template <class Tup, class... Args>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup, Args &&...args) const {
+                    return Res{std::forward<Args>(args)..., get<Is>(std::forward<Tup>(tup))...};
+                }
+            };
 
-                template <class, class>
-                struct pop_back_impl_f;
+            struct push_front_f {
+                template <class Tup,
+                    class... Args,
+                    class Accessors = get_accessors<Tup>,
+                    class Res = from_types<Tup, meta::push_front<Accessors, Args &&...>>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup, Args &&...args) const {
+                    return push_front_impl_f<std::make_index_sequence<size<Accessors>::value>, Res>{}(
+                        std::forward<Tup>(tup), std::forward<Args>(args)...);
+                }
+            };
 
-                template <template <class T, T...> class L, class Int, Int... Is, class Res>
-                struct pop_back_impl_f<L<Int, Is...>, Res> {
-                    template <class Tup>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        return Res{GT_TARGET_NAMESPACE_NAME::get<Is>(wstd::forward<Tup>(tup))...};
-                    }
-                };
+            template <class, class>
+            struct pop_back_impl_f;
 
-                struct pop_back_f {
-                    template <class Tup,
-                        class Accessors = get_accessors<Tup>,
-                        class Res = from_types<Tup, meta::pop_front<Accessors>>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        return pop_back_impl_f<std::make_index_sequence<size<Accessors>::value - 1>, Res>()(
-                            wstd::forward<Tup>(tup));
-                    }
-                };
+            template <template <class T, T...> class L, class Int, Int... Is, class Res>
+            struct pop_back_impl_f<L<Int, Is...>, Res> {
+                template <class Tup>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    return Res{get<Is>(std::forward<Tup>(tup))...};
+                }
+            };
 
-                template <class, class>
-                struct pop_front_impl_f;
+            struct pop_back_f {
+                template <class Tup,
+                    class Accessors = get_accessors<Tup>,
+                    class Res = from_types<Tup, meta::pop_front<Accessors>>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    return pop_back_impl_f<std::make_index_sequence<size<Accessors>::value - 1>, Res>()(
+                        std::forward<Tup>(tup));
+                }
+            };
 
-                template <template <class T, T...> class L, class Int, Int... Is, class Res>
-                struct pop_front_impl_f<L<Int, Is...>, Res> {
-                    template <class Tup>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        return Res{GT_TARGET_NAMESPACE_NAME::get<Is + 1>(wstd::forward<Tup>(tup))...};
-                    }
-                };
+            template <class, class>
+            struct pop_front_impl_f;
 
-                struct pop_front_f {
-                    template <class Tup,
-                        class Accessors = get_accessors<Tup>,
-                        class Res = from_types<Tup, meta::pop_front<Accessors>>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        return pop_front_impl_f<std::make_index_sequence<size<Accessors>::value - 1>, Res>()(
-                            wstd::forward<Tup>(tup));
-                    }
-                };
+            template <template <class T, T...> class L, class Int, Int... Is, class Res>
+            struct pop_front_impl_f<L<Int, Is...>, Res> {
+                template <class Tup>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    return Res{get<Is + 1>(std::forward<Tup>(tup))...};
+                }
+            };
 
-                template <class Fun>
-                struct fold_f {
-                    template <class S, class T>
-                    using meta_fun = typename get_fun_result<Fun>::template apply<S, T>;
-                    Fun m_fun;
+            struct pop_front_f {
+                template <class Tup,
+                    class Accessors = get_accessors<Tup>,
+                    class Res = from_types<Tup, meta::pop_front<Accessors>>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    return pop_front_impl_f<std::make_index_sequence<size<Accessors>::value - 1>, Res>()(
+                        std::forward<Tup>(tup));
+                }
+            };
 
-                    template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR State impl(State &&state, Tup &&) const {
-                        return state;
-                    }
+            template <class Fun>
+            struct fold_f {
+                template <class S, class T>
+                using meta_fun = typename get_fun_result<Fun>::template apply<S, T>;
+                Fun m_fun;
+
+                template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I == N, int> = 0>
+                GT_FORCE_INLINE constexpr State impl(State &&state, Tup &&) const {
+                    return state;
+                }
 
-                    template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I + 1 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) impl(State &&state, Tup &&tup) const {
-                        return m_fun(
-                            wstd::forward<State>(state), GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tup>(tup)));
-                    }
+                template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I + 1 == N, int> = 0>
+                GT_FORCE_INLINE constexpr decltype(auto) impl(State &&state, Tup &&tup) const {
+                    return m_fun(std::forward<State>(state), get<I>(std::forward<Tup>(tup)));
+                }
 
-                    template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I + 2 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) impl(State &&state, Tup &&tup) const {
-                        return m_fun(m_fun(wstd::forward<State>(state),
-                                         GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tup>(tup))),
-                            GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tup>(tup)));
-                    }
+                template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I + 2 == N, int> = 0>
+                GT_FORCE_INLINE constexpr decltype(auto) impl(State &&state, Tup &&tup) const {
+                    return m_fun(m_fun(std::forward<State>(state), get<I>(std::forward<Tup>(tup))),
+                        get<I + 1>(std::forward<Tup>(tup)));
+                }
 
-                    template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I + 3 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) impl(State &&state, Tup &&tup) const {
-                        return m_fun(m_fun(m_fun(wstd::forward<State>(state),
-                                               GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tup>(tup))),
-                                         GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tup>(tup))),
-                            GT_TARGET_NAMESPACE_NAME::get<I + 2>(wstd::forward<Tup>(tup)));
-                    }
+                template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I + 3 == N, int> = 0>
+                GT_FORCE_INLINE constexpr decltype(auto) impl(State &&state, Tup &&tup) const {
+                    return m_fun(m_fun(m_fun(std::forward<State>(state), get<I>(std::forward<Tup>(tup))),
+                                     get<I + 1>(std::forward<Tup>(tup))),
+                        get<I + 2>(std::forward<Tup>(tup)));
+                }
 
-                    template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I + 4 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) impl(State &&state, Tup &&tup) const {
-                        return m_fun(m_fun(m_fun(m_fun(wstd::forward<State>(state),
-                                                     GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tup>(tup))),
-                                               GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tup>(tup))),
-                                         GT_TARGET_NAMESPACE_NAME::get<I + 2>(wstd::forward<Tup>(tup))),
-                            GT_TARGET_NAMESPACE_NAME::get<I + 3>(wstd::forward<Tup>(tup)));
-                    }
+                template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I + 4 == N, int> = 0>
+                GT_FORCE_INLINE constexpr decltype(auto) impl(State &&state, Tup &&tup) const {
+                    return m_fun(m_fun(m_fun(m_fun(std::forward<State>(state), get<I>(std::forward<Tup>(tup))),
+                                           get<I + 1>(std::forward<Tup>(tup))),
+                                     get<I + 2>(std::forward<Tup>(tup))),
+                        get<I + 3>(std::forward<Tup>(tup)));
+                }
 
-                    template <size_t I,
-                        size_t N,
-                        class State,
-                        class Tup,
-                        class AllAccessors = get_accessors<Tup>,
-                        class Accessors = meta::drop_front_c<I, AllAccessors>,
-                        class Res = meta::foldl<meta_fun, State, Accessors>,
-                        std::enable_if_t<(I + 4 < N), int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res impl(State &&state, Tup &&tup) const {
-                        return impl<I + 5, N>(
-                            m_fun(m_fun(m_fun(m_fun(m_fun(wstd::forward<State>(state),
-                                                        GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tup>(tup))),
-                                                  GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tup>(tup))),
-                                            GT_TARGET_NAMESPACE_NAME::get<I + 2>(wstd::forward<Tup>(tup))),
-                                      GT_TARGET_NAMESPACE_NAME::get<I + 3>(wstd::forward<Tup>(tup))),
-                                GT_TARGET_NAMESPACE_NAME::get<I + 4>(wstd::forward<Tup>(tup))),
-                            wstd::forward<Tup>(tup));
-                    }
+                template <size_t I,
+                    size_t N,
+                    class State,
+                    class Tup,
+                    class AllAccessors = get_accessors<Tup>,
+                    class Accessors = meta::drop_front_c<I, AllAccessors>,
+                    class Res = meta::foldl<meta_fun, State, Accessors>,
+                    std::enable_if_t<(I + 4 < N), int> = 0>
+                GT_FORCE_INLINE constexpr Res impl(State &&state, Tup &&tup) const {
+                    return impl<I + 5, N>(
+                        m_fun(m_fun(m_fun(m_fun(m_fun(std::forward<State>(state), get<I>(std::forward<Tup>(tup))),
+                                              get<I + 1>(std::forward<Tup>(tup))),
+                                        get<I + 2>(std::forward<Tup>(tup))),
+                                  get<I + 3>(std::forward<Tup>(tup))),
+                            get<I + 4>(std::forward<Tup>(tup))),
+                        std::forward<Tup>(tup));
+                }
 
-                    template <class State,
-                        class Tup,
-                        class Accessors = get_accessors<Tup>,
-                        class Res = meta::foldl<meta_fun, State, Accessors>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(State &&state, Tup &&tup) const {
-                        return impl<0, size<std::decay_t<Tup>>::value>(
-                            wstd::forward<State>(state), wstd::forward<Tup>(tup));
-                    }
+                template <class State,
+                    class Tup,
+                    class Accessors = get_accessors<Tup>,
+                    class Res = meta::foldl<meta_fun, State, Accessors>>
+                GT_FORCE_INLINE constexpr Res operator()(State &&state, Tup &&tup) const {
+                    return impl<0, size<std::decay_t<Tup>>::value>(std::forward<State>(state), std::forward<Tup>(tup));
+                }
 
-                    template <class Tup,
-                        class AllAccessors = get_accessors<Tup>,
-                        class StateAccessor = meta::first<AllAccessors>,
-                        class Accessors = meta::drop_front_c<1, AllAccessors>,
-                        class Res = meta::foldl<meta_fun, StateAccessor, Accessors>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        return impl<1, size<std::decay_t<Tup>>::value>(
-                            GT_TARGET_NAMESPACE_NAME::get<0>(wstd::forward<Tup>(tup)), wstd::forward<Tup>(tup));
-                    }
-                };
+                template <class Tup,
+                    class AllAccessors = get_accessors<Tup>,
+                    class StateAccessor = meta::first<AllAccessors>,
+                    class Accessors = meta::drop_front_c<1, AllAccessors>,
+                    class Res = meta::foldl<meta_fun, StateAccessor, Accessors>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    return impl<1, size<std::decay_t<Tup>>::value>(
+                        get<0>(std::forward<Tup>(tup)), std::forward<Tup>(tup));
+                }
+            };
 
-                template <class Fun>
-                struct all_of_f {
-                    Fun m_fun;
+            template <class Fun>
+            struct all_of_f {
+                Fun m_fun;
 
-                    template <size_t I, size_t N, class... Tups, std::enable_if_t<I == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&...) const {
-                        return true;
-                    }
+                template <size_t I, size_t N, class... Tups, std::enable_if_t<I == N, int> = 0>
+                GT_FORCE_INLINE constexpr bool impl(Tups &&...) const {
+                    return true;
+                }
 
-                    template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 1 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&...tups) const {
-                        return m_fun(GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tups>(tups))...);
-                    }
+                template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 1 == N, int> = 0>
+                GT_FORCE_INLINE constexpr bool impl(Tups &&...tups) const {
+                    return m_fun(get<I>(std::forward<Tups>(tups))...);
+                }
 
-                    template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 2 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&...tups) const {
-                        return m_fun(GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tups>(tups))...) &&
-                               m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tups>(tups))...);
-                    }
+                template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 2 == N, int> = 0>
+                GT_FORCE_INLINE constexpr bool impl(Tups &&...tups) const {
+                    return m_fun(get<I>(std::forward<Tups>(tups))...) && m_fun(get<I + 1>(std::forward<Tups>(tups))...);
+                }
 
-                    template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 3 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&...tups) const {
-                        return m_fun(GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tups>(tups))...) &&
-                               m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tups>(tups))...) &&
-                               m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 2>(wstd::forward<Tups>(tups))...);
-                    }
+                template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 3 == N, int> = 0>
+                GT_FORCE_INLINE constexpr bool impl(Tups &&...tups) const {
+                    return m_fun(get<I>(std::forward<Tups>(tups))...) &&
+                           m_fun(get<I + 1>(std::forward<Tups>(tups))...) &&
+                           m_fun(get<I + 2>(std::forward<Tups>(tups))...);
+                }
 
-                    template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 4 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&...tups) const {
-                        return m_fun(GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tups>(tups))...) &&
-                               m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tups>(tups))...) &&
-                               m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 2>(wstd::forward<Tups>(tups))...) &&
-                               m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 3>(wstd::forward<Tups>(tups))...);
-                    }
+                template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 4 == N, int> = 0>
+                GT_FORCE_INLINE constexpr bool impl(Tups &&...tups) const {
+                    return m_fun(get<I>(std::forward<Tups>(tups))...) &&
+                           m_fun(get<I + 1>(std::forward<Tups>(tups))...) &&
+                           m_fun(get<I + 2>(std::forward<Tups>(tups))...) &&
+                           m_fun(get<I + 3>(std::forward<Tups>(tups))...);
+                }
 
-                    template <size_t I, size_t N, class... Tups, std::enable_if_t<(I + 4 < N), int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&...tups) const {
-                        return m_fun(GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tups>(tups))...) &&
-                               m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tups>(tups))...) &&
-                               m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 2>(wstd::forward<Tups>(tups))...) &&
-                               m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 3>(wstd::forward<Tups>(tups))...) &&
-                               impl<I + 4, N>(wstd::forward<Tups>(tups)...);
-                    }
+                template <size_t I, size_t N, class... Tups, std::enable_if_t<(I + 4 < N), int> = 0>
+                GT_FORCE_INLINE constexpr bool impl(Tups &&...tups) const {
+                    return m_fun(get<I>(std::forward<Tups>(tups))...) &&
+                           m_fun(get<I + 1>(std::forward<Tups>(tups))...) &&
+                           m_fun(get<I + 2>(std::forward<Tups>(tups))...) &&
+                           m_fun(get<I + 3>(std::forward<Tups>(tups))...) &&
+                           impl<I + 4, N>(std::forward<Tups>(tups)...);
+                }
 
-                    template <class Tup, class... Tups>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool operator()(Tup &&tup, Tups &&...tups) const {
-                        return impl<0, size<std::decay_t<Tup>>::value>(
-                            wstd::forward<Tup>(tup), wstd::forward<Tups>(tups)...);
-                    }
-                };
+                template <class Tup, class... Tups>
+                GT_FORCE_INLINE constexpr bool operator()(Tup &&tup, Tups &&...tups) const {
+                    return impl<0, size<std::decay_t<Tup>>::value>(std::forward<Tup>(tup), std::forward<Tups>(tups)...);
+                }
+            };
 
-                template <class To, class Index>
-                struct implicit_convert_to_f {
-                    using type = implicit_convert_to_f;
-                    template <class Tup>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR To operator()(Tup &&tup) const {
-                        return GT_TARGET_NAMESPACE_NAME::get<Index::value>(wstd::forward<Tup>(tup));
-                    }
-                };
+            template <class To, class Index>
+            struct implicit_convert_to_f {
+                using type = implicit_convert_to_f;
+                template <class Tup>
+                GT_FORCE_INLINE constexpr To operator()(Tup &&tup) const {
+                    return get<Index::value>(std::forward<Tup>(tup));
+                }
+            };
 
-                template <class DstFromTypesMetaClass>
-                struct convert_to_f {
-                    template <class Tup,
-                        class ToTypes = get_accessors<Tup>,
-                        class Res = meta::rename<DstFromTypesMetaClass::template apply, ToTypes>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        using generators_t =
-                            meta::transform<implicit_convert_to_f, to_types<Res>, meta::make_indices_for<ToTypes>>;
-                        return generate_f<generators_t, Res>{}(wstd::forward<Tup>(tup));
-                    }
+            template <class DstFromTypesMetaClass>
+            struct convert_to_f {
+                template <class Tup,
+                    class ToTypes = get_accessors<Tup>,
+                    class Res = meta::rename<DstFromTypesMetaClass::template apply, ToTypes>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    using generators_t =
+                        meta::transform<implicit_convert_to_f, to_types<Res>, meta::make_indices_for<ToTypes>>;
+                    return generate_f<generators_t, Res>{}(std::forward<Tup>(tup));
+                }
+            };
+
+            struct transpose_f {
+                template <class Tup>
+                struct get_inner_tuple_f {
+                    template <class Types>
+                    using apply = from_types<Tup, Types>;
                 };
 
-                struct transpose_f {
-                    template <class Tup>
-                    struct get_inner_tuple_f {
-                        template <class Types>
-                        using apply = from_types<Tup, Types>;
-                    };
+                template <class I>
+                using get_generator = transform_f<get_nth_f<I::value>>;
 
-                    template <class I>
-                    using get_generator = transform_f<get_nth_f<I::value>>;
+                template <class Tup>
+                GT_FORCE_INLINE constexpr std::enable_if_t<tuple_util::size<std::decay_t<Tup>>::value == 0> operator()(
+                    Tup &&) const {
+                    static_assert(
+                        tuple_util::size<std::decay_t<Tup>>::value, "tuple_util::transpose input should not be empty");
+                }
 
-                    template <class Tup>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR
-                        std::enable_if_t<tuple_util::size<std::decay_t<Tup>>::value == 0>
-                        operator()(Tup &&) const {
-                        static_assert(tuple_util::size<std::decay_t<Tup>>::value,
-                            "tuple_util::transpose input should not be empty");
-                    }
+                template <class Tup,
+                    class First = meta::first<to_types<Tup>>,
+                    class Accessors = meta::transform<get_accessors, get_accessors<Tup>>,
+                    class Types = meta::transpose<Accessors>,
+                    class InnerTuples = meta::transform<get_inner_tuple_f<Tup>::template apply, Types>,
+                    class Res = from_types<First, InnerTuples>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    using inner_indices_t = meta::make_indices_for<to_types<First>>;
+                    using generators_t = meta::transform<get_generator, inner_indices_t>;
+                    return generate_f<generators_t, Res>{}(std::forward<Tup>(tup));
+                }
+            };
 
-                    template <class Tup,
-                        class First = meta::first<to_types<Tup>>,
-                        class Accessors = meta::transform<get_accessors, get_accessors<Tup>>,
-                        class Types = meta::transpose<Accessors>,
-                        class InnerTuples = meta::transform<get_inner_tuple_f<Tup>::template apply, Types>,
-                        class Res = from_types<First, InnerTuples>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        using inner_indices_t = meta::make_indices_for<to_types<First>>;
-                        using generators_t = meta::transform<get_generator, inner_indices_t>;
-                        return generate_f<generators_t, Res>{}(wstd::forward<Tup>(tup));
-                    }
+            struct reverse_f {
+                template <class N>
+                struct generator_f {
+                    template <class I>
+                    using apply = get_nth_f<N::value - 1 - I::value>;
                 };
 
-                struct reverse_f {
-                    template <class N>
-                    struct generator_f {
-                        template <class I>
-                        using apply = get_nth_f<N::value - 1 - I::value>;
-                    };
-
-                    template <class Tup,
-                        class Accessors = get_accessors<Tup>,
-                        class Res = from_types<Tup, meta::reverse<Accessors>>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        using n_t = size<std::decay_t<Tup>>;
-                        using generators_t = meta::transform<generator_f<n_t>::template apply, meta::make_indices<n_t>>;
-                        return generate_f<generators_t, Res>{}(wstd::forward<Tup>(tup));
-                    }
-                };
+                template <class Tup,
+                    class Accessors = get_accessors<Tup>,
+                    class Res = from_types<Tup, meta::reverse<Accessors>>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    using n_t = size<std::decay_t<Tup>>;
+                    using generators_t = meta::transform<generator_f<n_t>::template apply, meta::make_indices<n_t>>;
+                    return generate_f<generators_t, Res>{}(std::forward<Tup>(tup));
+                }
+            };
 
-                template <size_t I>
-                struct insert_tup_generator_f {
-                    using type = insert_tup_generator_f;
+            template <size_t I>
+            struct insert_tup_generator_f {
+                using type = insert_tup_generator_f;
 
-                    template <class Tup, class Val>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) operator()(Tup &&tup, Val &&) const {
-                        return GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tup>(tup));
-                    }
-                };
+                template <class Tup, class Val>
+                GT_FORCE_INLINE constexpr decltype(auto) operator()(Tup &&tup, Val &&) const {
+                    return get<I>(std::forward<Tup>(tup));
+                }
+            };
 
-                struct insert_val_generator_f {
-                    using type = insert_val_generator_f;
-                    template <class Tup, class Val>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Val operator()(Tup &&, Val &&val) const {
-                        return wstd::forward<Val>(val);
-                    }
-                };
+            struct insert_val_generator_f {
+                using type = insert_val_generator_f;
+                template <class Tup, class Val>
+                GT_FORCE_INLINE constexpr Val operator()(Tup &&, Val &&val) const {
+                    return std::forward<Val>(val);
+                }
+            };
 
-                template <size_t N, class Val>
-                struct insert_f {
-                    Val m_val;
+            template <size_t N, class Val>
+            struct insert_f {
+                Val m_val;
 
-                    template <class I>
-                    using get_generator =
-                        meta::if_c <
-                        I::value<N,
-                            insert_tup_generator_f<I::value>,
-                            meta::if_c<I::value == N, insert_val_generator_f, insert_tup_generator_f<I::value - 1>>>;
-
-                    template <class Tup,
-                        class Accessors = get_accessors<Tup>,
-                        class Types = meta::insert_c<N, Accessors, Val>,
-                        class Res = from_types<Tup, Types>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        using generators_t = meta::transform<get_generator, meta::make_indices_for<Types>>;
-                        return generate_f<generators_t, Res>{}(wstd::forward<Tup>(tup), m_val);
-                    }
-                };
-            } // namespace detail
-
-            /**
-             * @brief Transforms each tuple element by a function.
-             *
-             * Transformations with functions with more than one argument are supported by passing multiple tuples of
-             * the same size.
-             *
-             * @tparam Fun Functor type.
-             * @tparam Tup Optional tuple-like type.
-             * @tparam Tups Optional Tuple-like types.
-             *
-             * @param fun Function that should be applied to all elements of the given tuple(s).
-             * @param tup First tuple-like object, serves as first arguments to `fun` if given.
-             * @param tups Further tuple-like objects, serve as additional arguments to `fun` if given.
-             *
-             * Example code:
-             * @code
-             * #include <functional>
-             * using namespace std::placeholders;
-             *
-             * struct add {
-             *     template < class A, class B >
-             *     auto operator()(A a, B b) -> decltype(a + b) {
-             *         return a + b;
-             *     }
-             * };
-             *
-             * // Unary function, like boost::fusion::transform
-             * auto tup = std::tuple(1, 2, 3.5);
-             * auto fun = std::bind(add{}, 2, _1);
-             * auto res = transform(fun, tup);
-             * // res == {3, 4, 5.5}
-             *
-             * // Binary function
-             * auto tup2 = std::tuple(1.5, 3, 4.1);
-             * auto res2 = transform(add{}, tup, tup2);
-             * // res2 == {2.5, 5, 7.6}
-             * @endcode
-             */
-            template <class Fun, class Tup, class... Tups>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto transform(Fun && fun, Tup && tup, Tups && ...tups) {
-                return detail::transform_f<Fun>{{wstd::forward<Fun>(fun)}}(
-                    wstd::forward<Tup>(tup), wstd::forward<Tups>(tups)...);
-            }
+                template <class I>
+                using get_generator =
+                    meta::if_c <
+                    I::value<N,
+                        insert_tup_generator_f<I::value>,
+                        meta::if_c<I::value == N, insert_val_generator_f, insert_tup_generator_f<I::value - 1>>>;
+
+                template <class Tup,
+                    class Accessors = get_accessors<Tup>,
+                    class Types = meta::insert_c<N, Accessors, Val>,
+                    class Res = from_types<Tup, Types>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    using generators_t = meta::transform<get_generator, meta::make_indices_for<Types>>;
+                    return generate_f<generators_t, Res>{}(std::forward<Tup>(tup), m_val);
+                }
+            };
 
-            /**
-             * @brief Returns a functor that transforms each tuple element by a function.
-             *
-             * Composable version of `transform` that returns a functor which can be invoked with (one or multiple)
-             * tuples.
-             *
-             * @tparam Fun Functor type.
-             *
-             * @param fun Function that should be applied to all elements of the given tuple(s).
-             *
-             * Example code:
-             * @code
-             * struct add {
-             *     template < class A, class B >
-             *     auto operator()(A a, B b) -> decltype(a + b) {
-             *         return a + b;
-             *     }
-             * };
-             *
-             * // Composable usage with only a function argument
-             * auto addtuples = transform(add{});
-             * // addtuples takes now two tuples as arguments
-             * auto tup1 = std::tuple(1, 2, 3.5);
-             * auto tup2 = std::tuple(1.5, 3, 4.1);
-             * auto res = addtuples(tup1, tup2)
-             * // res == {2.5, 5, 7.6}
-             * @endcode
-             */
-            template <class Fun>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR detail::transform_f<Fun> transform(Fun fun) {
-                return {wstd::move(fun)};
+            template <class Fun, class Tup, std::size_t... Is>
+            GT_FORCE_INLINE constexpr decltype(auto) apply_impl(Fun &&f, Tup &&tup, std::index_sequence<Is...>) {
+                return std::forward<Fun>(f)(get<Is>(std::forward<Tup>(tup))...);
             }
+        } // namespace impl_
+
+        /**
+         * @brief Transforms each tuple element by a function.
+         *
+         * Transformations with functions with more than one argument are supported by passing multiple tuples of
+         * the same size.
+         *
+         * @tparam Fun Functor type.
+         * @tparam Tup Optional tuple-like type.
+         * @tparam Tups Optional Tuple-like types.
+         *
+         * @param fun Function that should be applied to all elements of the given tuple(s).
+         * @param tup First tuple-like object, serves as first arguments to `fun` if given.
+         * @param tups Further tuple-like objects, serve as additional arguments to `fun` if given.
+         *
+         * Example code:
+         * @code
+         * #include <functional>
+         * using namespace std::placeholders;
+         *
+         * struct add {
+         *     template < class A, class B >
+         *     auto operator()(A a, B b) -> decltype(a + b) {
+         *         return a + b;
+         *     }
+         * };
+         *
+         * // Unary function, like boost::fusion::transform
+         * auto tup = std::tuple(1, 2, 3.5);
+         * auto fun = std::bind(add{}, 2, _1);
+         * auto res = transform(fun, tup);
+         * // res == {3, 4, 5.5}
+         *
+         * // Binary function
+         * auto tup2 = std::tuple(1.5, 3, 4.1);
+         * auto res2 = transform(add{}, tup, tup2);
+         * // res2 == {2.5, 5, 7.6}
+         * @endcode
+         */
+        template <class Fun, class Tup, class... Tups>
+        GT_FORCE_INLINE constexpr auto transform(Fun &&fun, Tup &&tup, Tups &&...tups) {
+            return impl_::transform_f<Fun>{{std::forward<Fun>(fun)}}(
+                std::forward<Tup>(tup), std::forward<Tups>(tups)...);
+        }
 
-            template <class Fun, class Tup, class... Tups>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto transform_index(
-                Fun && fun, Tup && tup, Tups && ...tups) {
-                return detail::transform_index_f<Fun>{wstd::forward<Fun>(fun)}(
-                    wstd::forward<Tup>(tup), wstd::forward<Tups>(tups)...);
-            }
+        /**
+         * @brief Returns a functor that transforms each tuple element by a function.
+         *
+         * Composable version of `transform` that returns a functor which can be invoked with (one or multiple)
+         * tuples.
+         *
+         * @tparam Fun Functor type.
+         *
+         * @param fun Function that should be applied to all elements of the given tuple(s).
+         *
+         * Example code:
+         * @code
+         * struct add {
+         *     template < class A, class B >
+         *     auto operator()(A a, B b) -> decltype(a + b) {
+         *         return a + b;
+         *     }
+         * };
+         *
+         * // Composable usage with only a function argument
+         * auto addtuples = transform(add{});
+         * // addtuples takes now two tuples as arguments
+         * auto tup1 = std::tuple(1, 2, 3.5);
+         * auto tup2 = std::tuple(1.5, 3, 4.1);
+         * auto res = addtuples(tup1, tup2)
+         * // res == {2.5, 5, 7.6}
+         * @endcode
+         */
+        template <class Fun>
+        GT_FORCE_INLINE constexpr impl_::transform_f<Fun> transform(Fun fun) {
+            return {std::move(fun)};
+        }
 
-            template <class Fun>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR detail::transform_index_f<Fun> transform_index(Fun fun) {
-                return {wstd::move(fun)};
-            }
+        template <class Fun, class Tup, class... Tups>
+        GT_FORCE_INLINE constexpr auto transform_index(Fun &&fun, Tup &&tup, Tups &&...tups) {
+            return impl_::transform_index_f<Fun>{std::forward<Fun>(fun)}(
+                std::forward<Tup>(tup), std::forward<Tups>(tups)...);
+        }
 
-            /**
-             * @brief Calls a function for each element in a tuple.
-             *
-             * Functions with more than one argument are supported by passing multiple tuples of the same size. If only
-             * a function but no tuples are passed, a composable functor is returned.
-             *
-             * @tparam Fun Functor type.
-             * @tparam Tup Optional tuple-like type.
-             * @tparam Tups Optional Tuple-like types.
-             *
-             * @param fun Function that should be called for each element of the given tuple(s).
-             * @param tup First tuple-like object, serves as first arguments to `fun` if given.
-             * @param tups Further tuple-like objects, serve as additional arguments to `fun` if given.
-             *
-             * Example code:
-             * @code
-             * struct sum {
-             *     double& value;
-             *     template < class A >
-             *     void operator()(A a, bool mask = true) const {
-             *         if (mask)
-             *             value += a;
-             *     }
-             * };
-             *
-             * // Unary function, like boost::fusion::for_each
-             * auto tup = std::tuple(1, 2, 3.5);
-             * double sum_value = 0.0;
-             * for_each(sum{sum_value}, tup);
-             * // sum_value == 6.5
-             *
-             * // Binary function
-             * auto tup2 = std::tuple(false, true, true);
-             * sum_value = 0.0;
-             * for_each(sum{sum_value}, tup, tup2);
-             * // sum_value == 5.5
-             * @endcode
-             */
-            template <class Fun, class Tup, class... Tups>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void for_each(Fun && fun, Tup && tup, Tups && ...tups) {
-                transform_index(detail::for_each_adaptor_f<Fun>{wstd::forward<Fun>(fun)},
-                    wstd::forward<Tup>(tup),
-                    wstd::forward<Tups>(tups)...);
-            }
+        template <class Fun>
+        GT_FORCE_INLINE constexpr impl_::transform_index_f<Fun> transform_index(Fun fun) {
+            return {std::move(fun)};
+        }
 
-            /**
-             * @brief Returns a functor that calls a function for each element in a tuple.
-             *
-             * Composable version of `for_each` that returns a functor which can be invoked with (one or multiple)
-             * tuples.
-             *
-             * @tparam Fun Functor type.
-             *
-             * @param fun Function that should be called for each element of the given tuple(s).
-             *
-             * Example code:
-             * @code
-             * struct sum {
-             *     double& value;
-             *     template < class A >
-             *     void operator()(A a, bool mask = true) const {
-             *         if (mask)
-             *             value += a;
-             *     }
-             * };
-             *
-             * // Composable usage with only a function argument
-             * sum_value = 0.0;
-             * auto sumtuples = for_each(sum{sum_value});
-             * // sumtuples takes now two tuples as arguments
-             * auto tup1 = std::tuple(1, 2, 3.5);
-             * auto tup2 = std::tuple(false, true, true);
-             * auto res = sumtuples(tup1, tup2)
-             * // sum_value == 5.5
-             * @endcode
-             */
-            template <class Fun>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR detail::transform_index_f<detail::for_each_adaptor_f<Fun>>
-            for_each(Fun fun) {
-                return {{wstd::move(fun)}};
-            }
+        /**
+         * @brief Calls a function for each element in a tuple.
+         *
+         * Functions with more than one argument are supported by passing multiple tuples of the same size. If only
+         * a function but no tuples are passed, a composable functor is returned.
+         *
+         * @tparam Fun Functor type.
+         * @tparam Tup Optional tuple-like type.
+         * @tparam Tups Optional Tuple-like types.
+         *
+         * @param fun Function that should be called for each element of the given tuple(s).
+         * @param tup First tuple-like object, serves as first arguments to `fun` if given.
+         * @param tups Further tuple-like objects, serve as additional arguments to `fun` if given.
+         *
+         * Example code:
+         * @code
+         * struct sum {
+         *     double& value;
+         *     template < class A >
+         *     void operator()(A a, bool mask = true) const {
+         *         if (mask)
+         *             value += a;
+         *     }
+         * };
+         *
+         * // Unary function, like boost::fusion::for_each
+         * auto tup = std::tuple(1, 2, 3.5);
+         * double sum_value = 0.0;
+         * for_each(sum{sum_value}, tup);
+         * // sum_value == 6.5
+         *
+         * // Binary function
+         * auto tup2 = std::tuple(false, true, true);
+         * sum_value = 0.0;
+         * for_each(sum{sum_value}, tup, tup2);
+         * // sum_value == 5.5
+         * @endcode
+         */
+        template <class Fun, class Tup, class... Tups>
+        GT_FORCE_INLINE constexpr void for_each(Fun &&fun, Tup &&tup, Tups &&...tups) {
+            transform_index(impl_::for_each_adaptor_f<Fun>{std::forward<Fun>(fun)},
+                std::forward<Tup>(tup),
+                std::forward<Tups>(tups)...);
+        }
 
-            template <class Fun, class Tup, class... Tups>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void for_each_index(Fun && fun, Tup && tup, Tups && ...tups) {
-                transform_index(detail::for_each_index_adaptor_f<Fun>{wstd::forward<Fun>(fun)},
-                    wstd::forward<Tup>(tup),
-                    wstd::forward<Tups>(tups)...);
-            }
+        /**
+         * @brief Returns a functor that calls a function for each element in a tuple.
+         *
+         * Composable version of `for_each` that returns a functor which can be invoked with (one or multiple)
+         * tuples.
+         *
+         * @tparam Fun Functor type.
+         *
+         * @param fun Function that should be called for each element of the given tuple(s).
+         *
+         * Example code:
+         * @code
+         * struct sum {
+         *     double& value;
+         *     template < class A >
+         *     void operator()(A a, bool mask = true) const {
+         *         if (mask)
+         *             value += a;
+         *     }
+         * };
+         *
+         * // Composable usage with only a function argument
+         * sum_value = 0.0;
+         * auto sumtuples = for_each(sum{sum_value});
+         * // sumtuples takes now two tuples as arguments
+         * auto tup1 = std::tuple(1, 2, 3.5);
+         * auto tup2 = std::tuple(false, true, true);
+         * auto res = sumtuples(tup1, tup2)
+         * // sum_value == 5.5
+         * @endcode
+         */
+        template <class Fun>
+        GT_FORCE_INLINE constexpr impl_::transform_index_f<impl_::for_each_adaptor_f<Fun>> for_each(Fun fun) {
+            return {{std::move(fun)}};
+        }
 
-            template <class Fun>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR
-                detail::transform_index_f<detail::for_each_index_adaptor_f<Fun>>
-                for_each_index(Fun fun) {
-                return {{wstd::move(fun)}};
-            }
+        template <class Fun, class Tup, class... Tups>
+        GT_FORCE_INLINE constexpr void for_each_index(Fun &&fun, Tup &&tup, Tups &&...tups) {
+            transform_index(impl_::for_each_index_adaptor_f<Fun>{std::forward<Fun>(fun)},
+                std::forward<Tup>(tup),
+                std::forward<Tups>(tups)...);
+        }
 
-            /**
-             * @brief Calls a function for each element in a cartesian product of the given tuples.
-             *
-             * If only a function but no tuples are passed, a composable functor is returned.
-             *
-             * @tparam Fun Functor type.
-             * @tparam Tup Optional tuple-like type.
-             * @tparam Tups Optional Tuple-like types.
-             *
-             * @param fun Function that should be called for each element in a cartesian product of the given tuples.
-             * @param tup First tuple-like object, serves as first arguments to `fun` if given.
-             * @param tups Further tuple-like objects, serve as additional arguments to `fun` if given.
-             *
-             * Example code:
-             * @code
-             * struct sum {
-             *     double& value;
-             *     template < class A, class B >
-             *     void operator()(A a, B b) const {
-             *         value += a * b;
-             *     }
-             * };
-             *
-             * // Binary function
-             * sum_value = 0.;
-             * for_each_in_cartesian_product(sum{sum_value}, std::tuple(1, 2, 3), std::tuple(1, 10));
-             * // sum_value == 66.
-             * @endcode
-             */
-            template <class Fun, class Tup, class... Tups>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void for_each_in_cartesian_product(
-                Fun && fun, Tup && tup, Tups && ...tups) {
-                detail::for_each_in_cartesian_product_f<Fun>{wstd::forward<Fun>(fun)}(
-                    wstd::forward<Tup>(tup), wstd::forward<Tups>(tups)...);
-            }
+        template <class Fun>
+        GT_FORCE_INLINE constexpr impl_::transform_index_f<impl_::for_each_index_adaptor_f<Fun>> for_each_index(
+            Fun fun) {
+            return {{std::move(fun)}};
+        }
 
-            template <class Fun>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR detail::for_each_in_cartesian_product_f<Fun>
-            for_each_in_cartesian_product(Fun fun) {
-                return {wstd::move(fun)};
-            }
+        /**
+         * @brief Calls a function for each element in a cartesian product of the given tuples.
+         *
+         * If only a function but no tuples are passed, a composable functor is returned.
+         *
+         * @tparam Fun Functor type.
+         * @tparam Tup Optional tuple-like type.
+         * @tparam Tups Optional Tuple-like types.
+         *
+         * @param fun Function that should be called for each element in a cartesian product of the given tuples.
+         * @param tup First tuple-like object, serves as first arguments to `fun` if given.
+         * @param tups Further tuple-like objects, serve as additional arguments to `fun` if given.
+         *
+         * Example code:
+         * @code
+         * struct sum {
+         *     double& value;
+         *     template < class A, class B >
+         *     void operator()(A a, B b) const {
+         *         value += a * b;
+         *     }
+         * };
+         *
+         * // Binary function
+         * sum_value = 0.;
+         * for_each_in_cartesian_product(sum{sum_value}, std::tuple(1, 2, 3), std::tuple(1, 10));
+         * // sum_value == 66.
+         * @endcode
+         */
+        template <class Fun, class Tup, class... Tups>
+        GT_FORCE_INLINE constexpr void for_each_in_cartesian_product(Fun &&fun, Tup &&tup, Tups &&...tups) {
+            impl_::for_each_in_cartesian_product_f<Fun>{std::forward<Fun>(fun)}(
+                std::forward<Tup>(tup), std::forward<Tups>(tups)...);
+        }
 
-            /*
-             *  Concatenate several tuple-likes into one.
-             *  The type of result is deduced from the first argument
-             */
-            DEFINE_FUNCTOR_INSTANCE(concat, detail::concat_f<_impl::default_concat_result_maker_f>);
-
-            /*
-             * Variation of concat that allows to specify the resulting type.
-             *
-             * ResultMaker is a meta class with the following signature:
-             *   struct ResultMaker {
-             *     template <class FlattenTypesList,  ArgumentsOfConcatList>
-             *     using apply = ...;
-             *   }
-             */
-            template <class ResultMaker>
-            DEFINE_TEMPLATED_FUNCTOR_INSTANCE(concat_ex, detail::concat_f<ResultMaker>);
-
-            /**
-             * @brief Non-recursively flattens a tuple of tuples into a single tuple.
-             *
-             * Flattens only the first two levels of nested tuples into a single level. Does not flatten further levels
-             * of nesting.
-             *
-             * @tparam Tup Tuple-like type.
-             * @param tup Tuple-like object.
-             *
-             * Example:
-             * @code
-             * auto tup1 = std::tuple(1, 2);
-             * auto tup2 = std::tuple(3, 4, 5);
-             * auto flat = flatten(tup1, tup2);
-             * // flat == {1, 2, 3, 4, 5}
-             * @endcode
-             */
-            DEFINE_FUNCTOR_INSTANCE(flatten, detail::flatten_f<_impl::default_concat_result_maker_f>);
-
-            /*
-             * Extended variation of flatten. See concat_ex comments
-             */
-            template <class ResultMaker>
-            DEFINE_TEMPLATED_FUNCTOR_INSTANCE(flatten_ex, detail::flatten_f<ResultMaker>);
-
-            /**
-             * @brief Constructs an object from generator functors.
-             *
-             * `Generators` is a typelist of generator functors. Instances of those types are first default constructed,
-             * then invoked with `args` as arguments. The results of those calls are then passed to the constructor of
-             * `Res`.
-             *
-             * @tparam Generators A typelist of functors. All functor types must be default-constructible and callable
-             * with arguments of type `Args`.
-             * @tparam Res The type that should be constructed.
-             * @tparam Args Argument types for the generator functors.
-             *
-             * @param args Arguments that will be passed to the generator functors.
-             *
-             * Example:
-             * @code
-             * // Generators that extract some information from the given arguments (a single std::string in this
-             * example) struct ptr_extractor { const char* operator()(std::string const& s) const { return s.data();
-             *     }
-             * };
-             *
-             * struct size_extractor {
-             *     std::size_t operator()(std::string const& s) const {
-             *         return s.size();
-             *     }
-             * };
-             *
-             * // We want to generate a pair of a pointer and size,
-             * // that represents this string in a simple C-style manner
-             * std::string s = "Hello World!";
-             * // Target-type to construct
-             * using ptr_size_pair = std::pair< const char*, std::size_t >;
-             *
-             * // Typelist of generators
-             * using generators = std::tuple< ptr_extractor, size_extractor>;
-             *
-             * // Generate pair
-             * auto p = generate< generators, ptr_size_pair >(s);
-             * // p.first is now a pointer to the first character of s, p.second is the size of s
-             * @endcode
-             */
-            template <class Generators, class Res, class... Args>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res generate(Args && ...args) {
-                return detail::generate_f<Generators, Res>{}(wstd::forward<Args>(args)...);
-            }
+        template <class Fun>
+        GT_FORCE_INLINE constexpr impl_::for_each_in_cartesian_product_f<Fun> for_each_in_cartesian_product(Fun fun) {
+            return {std::move(fun)};
+        }
 
-            /**
-             * @brief Removes the first `N` elements from a tuple.
-             *
-             * @tparam N Number of elements to remove.
-             * @tparam Tup Tuple-like type.
-             *
-             * @param tup Tuple to remove first `N` elements from.
-             *
-             * Example:
-             * @code
-             * auto tup = std::tuple(1, 2, 3, 4);
-             * auto res = drop_front<2>(tup);
-             * // res == {3, 4}
-             * @endcode
-             */
-            template <size_t N>
-            DEFINE_TEMPLATED_FUNCTOR_INSTANCE(drop_front, detail::drop_front_f<N>);
-
-            /**
-             * @brief Appends elements to a tuple.
-             *
-             * @tparam Tup Tuple-like type.
-             * @tparam Args Argument types to append.
-             *
-             * @param tup Tuple-like object.
-             * @param args Arguments to append.
-             *
-             * Example:
-             * @code
-             * auto tup = std::tuple(1, 2);
-             * auto res = push_back(tup, 3, 4);
-             * // res = {1, 2, 3, 4}
-             * @endcode
-             */
-            DEFINE_FUNCTOR_INSTANCE(push_back, detail::push_back_f);
-
-            /**
-             * @brief Appends elements to a tuple from the front.
-             */
-            DEFINE_FUNCTOR_INSTANCE(push_front, detail::push_front_f);
-
-            /**
-             * @brief Removes elements to a tuple from the front.
-             */
-            DEFINE_FUNCTOR_INSTANCE(pop_front, detail::pop_front_f);
-
-            /**
-             * @brief Removes elements to a tuple from the back.
-             */
-            DEFINE_FUNCTOR_INSTANCE(pop_back, detail::pop_back_f);
-
-            /**
-             * @brief Left fold on tuple-like objects.
-             *
-             * This function accepts either two or three arguments. If three arguments are given, the second is the
-             * initial state and the third a tuple-like object to fold. If only two arguments are given, the second is a
-             * tuple-like object where the first element acts as the initial state.
-             *
-             * @tparam Fun Binary function type.
-             * @tparam Arg Either the initial state if three arguments are given or the tuple to fold if two arguments
-             * are given.
-             * @tparam Args The tuple type to fold (if three arguments are given).
-             *
-             * @param fun Binary function object.
-             * @param arg Either the initial state if three arguments are given or the tuple to fold if two arguments
-             * are given.
-             * @param args The tuple to fold (if three arguments are given).
-             *
-             * Example:
-             * @code
-             * auto tup = std::tuple(1, 2, 3);
-             *
-             * // Three arguments
-             * auto res = fold(std::plus<int>{}, 0, tup);
-             * // res == 6
-             *
-             * // Two arguments
-             * auto res2 = fold(std::plus<int>{}, tup);
-             * // res2 == 6
-             * @endcode
-             */
-            template <class Fun, class Arg, class... Args>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) fold(Fun && fun, Arg && arg, Args && ...args) {
-                return detail::fold_f<Fun>{wstd::forward<Fun>(fun)}(
-                    wstd::forward<Arg>(arg), wstd::forward<Args>(args)...);
-            }
+        /*
+         *  Concatenate several tuple-likes into one.
+         *  The type of result is deduced from the first argument
+         */
+        DEFINE_FUNCTOR_INSTANCE(concat, impl_::concat_f<impl_::default_concat_result_maker_f>);
+
+        /*
+         * Variation of concat that allows to specify the resulting type.
+         *
+         * ResultMaker is a meta class with the following signature:
+         *   struct ResultMaker {
+         *     template <class FlattenTypesList,  ArgumentsOfConcatList>
+         *     using apply = ...;
+         *   }
+         */
+        template <class ResultMaker>
+        DEFINE_TEMPLATED_FUNCTOR_INSTANCE(concat_ex, impl_::concat_f<ResultMaker>);
+
+        /**
+         * @brief Non-recursively flattens a tuple of tuples into a single tuple.
+         *
+         * Flattens only the first two levels of nested tuples into a single level. Does not flatten further levels
+         * of nesting.
+         *
+         * @tparam Tup Tuple-like type.
+         * @param tup Tuple-like object.
+         *
+         * Example:
+         * @code
+         * auto tup1 = std::tuple(1, 2);
+         * auto tup2 = std::tuple(3, 4, 5);
+         * auto flat = flatten(tup1, tup2);
+         * // flat == {1, 2, 3, 4, 5}
+         * @endcode
+         */
+        DEFINE_FUNCTOR_INSTANCE(flatten, impl_::flatten_f<impl_::default_concat_result_maker_f>);
+
+        /*
+         * Extended variation of flatten. See concat_ex comments
+         */
+        template <class ResultMaker>
+        DEFINE_TEMPLATED_FUNCTOR_INSTANCE(flatten_ex, impl_::flatten_f<ResultMaker>);
+
+        /**
+         * @brief Constructs an object from generator functors.
+         *
+         * `Generators` is a typelist of generator functors. Instances of those types are first default constructed,
+         * then invoked with `args` as arguments. The results of those calls are then passed to the constructor of
+         * `Res`.
+         *
+         * @tparam Generators A typelist of functors. All functor types must be default-constructible and callable
+         * with arguments of type `Args`.
+         * @tparam Res The type that should be constructed.
+         * @tparam Args Argument types for the generator functors.
+         *
+         * @param args Arguments that will be passed to the generator functors.
+         *
+         * Example:
+         * @code
+         * // Generators that extract some information from the given arguments (a single std::string in this
+         * example) struct ptr_extractor { const char* operator()(std::string const& s) const { return s.data();
+         *     }
+         * };
+         *
+         * struct size_extractor {
+         *     std::size_t operator()(std::string const& s) const {
+         *         return s.size();
+         *     }
+         * };
+         *
+         * // We want to generate a pair of a pointer and size,
+         * // that represents this string in a simple C-style manner
+         * std::string s = "Hello World!";
+         * // Target-type to construct
+         * using ptr_size_pair = std::pair< const char*, std::size_t >;
+         *
+         * // Typelist of generators
+         * using generators = std::tuple< ptr_extractor, size_extractor>;
+         *
+         * // Generate pair
+         * auto p = generate< generators, ptr_size_pair >(s);
+         * // p.first is now a pointer to the first character of s, p.second is the size of s
+         * @endcode
+         */
+        template <class Generators, class Res, class... Args>
+        GT_FORCE_INLINE constexpr Res generate(Args &&...args) {
+            return impl_::generate_f<Generators, Res>{}(std::forward<Args>(args)...);
+        }
 
-            /**
-             * @brief Returns a functor that performs a left fold on tuple-like objects.
-             *
-             * The returned functor accepts either one or two arguments. If two arguments are given, the first is the
-             * initial state and the second a tuple-like object to fold. If only one argument is given, the argument
-             * must be a tuple-like object where the first element acts as the initial state.
-             *
-             * @tparam Fun Binary function type.
-             * @param fun Binary function object.
-             *
-             * Example:
-             * @code
-             * auto tup = std::tuple(1, 2, 3);
-             * auto folder = fold(std::plus<int>{});
-             *
-             * // Three arguments
-             * auto res = folder(0, tup);
-             * // res == 6
-             *
-             * // Two arguments
-             * auto res2 = folder(tup);
-             * // res2 == 6
-             * @endcode
-             */
-            template <class Fun>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR detail::fold_f<Fun> fold(Fun fun) {
-                return {wstd::move(fun)};
-            }
+        /**
+         * @brief Removes the first `N` elements from a tuple.
+         *
+         * @tparam N Number of elements to remove.
+         * @tparam Tup Tuple-like type.
+         *
+         * @param tup Tuple to remove first `N` elements from.
+         *
+         * Example:
+         * @code
+         * auto tup = std::tuple(1, 2, 3, 4);
+         * auto res = drop_front<2>(tup);
+         * // res == {3, 4}
+         * @endcode
+         */
+        template <size_t N>
+        DEFINE_TEMPLATED_FUNCTOR_INSTANCE(drop_front, impl_::drop_front_f<N>);
+
+        /**
+         * @brief Appends elements to a tuple.
+         *
+         * @tparam Tup Tuple-like type.
+         * @tparam Args Argument types to append.
+         *
+         * @param tup Tuple-like object.
+         * @param args Arguments to append.
+         *
+         * Example:
+         * @code
+         * auto tup = std::tuple(1, 2);
+         * auto res = push_back(tup, 3, 4);
+         * // res = {1, 2, 3, 4}
+         * @endcode
+         */
+        DEFINE_FUNCTOR_INSTANCE(push_back, impl_::push_back_f);
+
+        /**
+         * @brief Appends elements to a tuple from the front.
+         */
+        DEFINE_FUNCTOR_INSTANCE(push_front, impl_::push_front_f);
+
+        /**
+         * @brief Removes elements to a tuple from the front.
+         */
+        DEFINE_FUNCTOR_INSTANCE(pop_front, impl_::pop_front_f);
+
+        /**
+         * @brief Removes elements to a tuple from the back.
+         */
+        DEFINE_FUNCTOR_INSTANCE(pop_back, impl_::pop_back_f);
+
+        /**
+         * @brief Left fold on tuple-like objects.
+         *
+         * This function accepts either two or three arguments. If three arguments are given, the second is the
+         * initial state and the third a tuple-like object to fold. If only two arguments are given, the second is a
+         * tuple-like object where the first element acts as the initial state.
+         *
+         * @tparam Fun Binary function type.
+         * @tparam Arg Either the initial state if three arguments are given or the tuple to fold if two arguments
+         * are given.
+         * @tparam Args The tuple type to fold (if three arguments are given).
+         *
+         * @param fun Binary function object.
+         * @param arg Either the initial state if three arguments are given or the tuple to fold if two arguments
+         * are given.
+         * @param args The tuple to fold (if three arguments are given).
+         *
+         * Example:
+         * @code
+         * auto tup = std::tuple(1, 2, 3);
+         *
+         * // Three arguments
+         * auto res = fold(std::plus<int>{}, 0, tup);
+         * // res == 6
+         *
+         * // Two arguments
+         * auto res2 = fold(std::plus<int>{}, tup);
+         * // res2 == 6
+         * @endcode
+         */
+        template <class Fun, class Arg, class... Args>
+        GT_FORCE_INLINE constexpr decltype(auto) fold(Fun &&fun, Arg &&arg, Args &&...args) {
+            return impl_::fold_f<Fun>{std::forward<Fun>(fun)}(std::forward<Arg>(arg), std::forward<Args>(args)...);
+        }
 
-            template <class Pred, class... Tups>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool all_of(Pred && pred, Tups && ...tups) {
-                return detail::all_of_f<Pred>{wstd::forward<Pred>(pred)}(wstd::forward<Tups>(tups)...);
-            }
+        /**
+         * @brief Returns a functor that performs a left fold on tuple-like objects.
+         *
+         * The returned functor accepts either one or two arguments. If two arguments are given, the first is the
+         * initial state and the second a tuple-like object to fold. If only one argument is given, the argument
+         * must be a tuple-like object where the first element acts as the initial state.
+         *
+         * @tparam Fun Binary function type.
+         * @param fun Binary function object.
+         *
+         * Example:
+         * @code
+         * auto tup = std::tuple(1, 2, 3);
+         * auto folder = fold(std::plus<int>{});
+         *
+         * // Three arguments
+         * auto res = folder(0, tup);
+         * // res == 6
+         *
+         * // Two arguments
+         * auto res2 = folder(tup);
+         * // res2 == 6
+         * @endcode
+         */
+        template <class Fun>
+        GT_FORCE_INLINE constexpr impl_::fold_f<Fun> fold(Fun fun) {
+            return {std::move(fun)};
+        }
 
-            template <class Pred>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR detail::all_of_f<Pred> all_of(Pred pred) {
-                return {wstd::move(pred)};
-            }
+        template <class Pred, class... Tups>
+        GT_FORCE_INLINE constexpr bool all_of(Pred &&pred, Tups &&...tups) {
+            return impl_::all_of_f<Pred>{std::forward<Pred>(pred)}(std::forward<Tups>(tups)...);
+        }
 
-            /**
-             * transposes a `tuple like` of `tuple like`.
-             *
-             * Ex.
-             *   transpose(array{array{1, 2, 3}, array{10, 20, 30}}) returns the same as
-             *   array{array{1, 10}, array{2, 20}, array{3, 30}};
-             */
-            DEFINE_FUNCTOR_INSTANCE(transpose, detail::transpose_f);
-
-            /**
-             * @brief Replaces reference types by value types in a tuple.
-             *
-             * @tparam Tup Tuple-like type.
-             * @param tup Tuple-like object, possibly containing references.
-             *
-             * Example:
-             * @code
-             * int foo = 3;
-             * std::tuple<int&> tup(foo);
-             * auto tupcopy = deep_copy(tup);
-             * ++foo;
-             * // tup == {4}, tupcopy == {3}
-             * @endcode
-             */
-            DEFINE_FUNCTOR_INSTANCE(deep_copy, detail::transform_f<gridtools::GT_TARGET_NAMESPACE_NAME::clone>);
-
-            namespace detail {
-                // in impl as it is not as powerful as std::invoke (does not support invoking member functions)
-                template <class Fun, class... Args>
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) invoke_impl(Fun &&f, Args &&...args) {
-                    return wstd::forward<Fun>(f)(wstd::forward<Args>(args)...);
-                }
+        template <class Pred>
+        GT_FORCE_INLINE constexpr impl_::all_of_f<Pred> all_of(Pred pred) {
+            return {std::move(pred)};
+        }
 
-                template <class Fun, class Tup, std::size_t... Is>
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) apply_impl(
-                    Fun &&f, Tup &&tup, std::index_sequence<Is...>) {
-                    return invoke_impl(wstd::forward<Fun>(f), get<Is>(wstd::forward<Tup>(tup))...);
-                }
-            } // namespace detail
-
-            /**
-             * @brief Invoke callable f with tuple of arguments.
-             *
-             * @tparam Fun Functor type.
-             * @tparam Tup Tuple-like type.
-             * @param tup Tuple-like object containing arguments
-             * @param fun Function that should be called with the arguments in tup
-             *
-             * See std::apply (c++17), with the limitation that it only works for FunctionObjects (not for any Callable)
-             */
-            template <class Fun, class Tup>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) apply(Fun && fun, Tup && tup) {
-                return detail::apply_impl(wstd::forward<Fun>(fun),
-                    wstd::forward<Tup>(tup),
-                    std::make_index_sequence<size<std::decay_t<Tup>>::value>{});
-            }
+        /**
+         * transposes a `tuple like` of `tuple like`.
+         *
+         * Ex.
+         *   transpose(array{array{1, 2, 3}, array{10, 20, 30}}) returns the same as
+         *   array{array{1, 10}, array{2, 20}, array{3, 30}};
+         */
+        DEFINE_FUNCTOR_INSTANCE(transpose, impl_::transpose_f);
+
+        /**
+         * @brief Replaces reference types by value types in a tuple.
+         *
+         * @tparam Tup Tuple-like type.
+         * @param tup Tuple-like object, possibly containing references.
+         *
+         * Example:
+         * @code
+         * int foo = 3;
+         * std::tuple<int&> tup(foo);
+         * auto tupcopy = deep_copy(tup);
+         * ++foo;
+         * // tup == {4}, tupcopy == {3}
+         * @endcode
+         */
+        DEFINE_FUNCTOR_INSTANCE(deep_copy, impl_::transform_f<clone>);
+
+        /**
+         * @brief Invoke callable f with tuple of arguments.
+         *
+         * @tparam Fun Functor type.
+         * @tparam Tup Tuple-like type.
+         * @param tup Tuple-like object containing arguments
+         * @param fun Function that should be called with the arguments in tup
+         *
+         * See std::apply (c++17), with the limitation that it only works for FunctionObjects (not for any Callable)
+         */
+        template <class Fun, class Tup>
+        GT_FORCE_INLINE constexpr decltype(auto) apply(Fun &&fun, Tup &&tup) {
+            return impl_::apply_impl(std::forward<Fun>(fun),
+                std::forward<Tup>(tup),
+                std::make_index_sequence<size<std::decay_t<Tup>>::value>{});
+        }
 
-            /// Generalization of `std::tie`
-            //
-            template <template <class...> class L, class... Ts>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR L<Ts &...> tie(Ts & ...elems) {
-                return L<Ts &...>{elems...};
-            }
+        /// Generalization of `std::tie`
+        //
+        template <template <class...> class L, class... Ts>
+        GT_FORCE_INLINE constexpr L<Ts &...> tie(Ts &...elems) {
+            return L<Ts &...>{elems...};
+        }
 
-            /**
-             *   The family of `convert_to` functions.
-             *
-             *   First template parameter could be either some tuple [`std::tuple`, `std::pair` or gridtools clones]
-             *   or some array [`std::array` or gridtools clone]
-             *   Array vaiants can take additional parameter -- the desired type of array. If it is not provided,
-             *   the type is deduced
-             *   Runtime parameter is any "tuple like" or none. Variants without runtime parameter return functors as
-             *   usual.
-             *
-             *   Examples of valid appllcations:
-             *
-             *   convert_to<std::tuple>(some_tuple_like);
-             *   convert_to<std::pair>()(some_tuple_like_with_two_elements);
-             *   convert_to<std::array>(some_tuple_like);
-             *   convert_to<gridtools::array, int>(some_tuple_like);
-             */
-            template <template <class...> class L
+        /**
+         *   The family of `convert_to` functions.
+         *
+         *   First template parameter could be either some tuple [`std::tuple`, `std::pair` or gridtools clones]
+         *   or some array [`std::array` or gridtools clone]
+         *   Array vaiants can take additional parameter -- the desired type of array. If it is not provided,
+         *   the type is deduced
+         *   Runtime parameter is any "tuple like" or none. Variants without runtime parameter return functors as
+         *   usual.
+         *
+         *   Examples of valid appllcations:
+         *
+         *   convert_to<std::tuple>(some_tuple_like);
+         *   convert_to<std::pair>()(some_tuple_like_with_two_elements);
+         *   convert_to<std::array>(some_tuple_like);
+         *   convert_to<gridtools::array, int>(some_tuple_like);
+         */
+        template <template <class...> class L
 #if defined(__NVCC__) && defined(__CUDACC_VER_MAJOR__) && \
     (__CUDACC_VER_MAJOR__ < 11 || __CUDACC_VER_MAJOR__ == 11 && __CUDACC_VER_MINOR__ <= 5)
-                // workaround against nvcc bug: https://godbolt.org/z/orrev1xnM
-                ,
-                int = 0,
-                class = std::void_t<L<int, int>>
+            // workaround against nvcc bug: https://godbolt.org/z/orrev1xnM
+            ,
+            int = 0,
+            class = std::void_t<L<int, int>>
 #endif
-                >
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR detail::convert_to_f<_impl::to_tuple_converter_helper<L>>
-            convert_to() {
-                return {};
-            }
+            >
+        GT_FORCE_INLINE constexpr impl_::convert_to_f<impl_::to_tuple_converter_helper<L>> convert_to() {
+            return {};
+        }
 
-            template <template <class...> class L
+        template <template <class...> class L
 #if defined(__NVCC__) && defined(__CUDACC_VER_MAJOR__) && \
     (__CUDACC_VER_MAJOR__ < 11 || __CUDACC_VER_MAJOR__ == 11 && __CUDACC_VER_MINOR__ <= 5)
 
-                // workaround against nvcc bug: https://godbolt.org/z/orrev1xnM
-                ,
-                int = 0,
-                class = std::void_t<L<int, int>>
+            // workaround against nvcc bug: https://godbolt.org/z/orrev1xnM
+            ,
+            int = 0,
+            class = std::void_t<L<int, int>>
 #endif
-                ,
-                class Tup>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto convert_to(Tup && tup) {
-                return detail::convert_to_f<_impl::to_tuple_converter_helper<L>>{}(wstd::forward<Tup>(tup));
-            }
+            ,
+            class Tup>
+        GT_FORCE_INLINE constexpr auto convert_to(Tup &&tup) {
+            return impl_::convert_to_f<impl_::to_tuple_converter_helper<L>>{}(std::forward<Tup>(tup));
+        }
 
-            template <template <class, size_t> class Arr, class D = void>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR detail::convert_to_f<_impl::to_array_converter_helper<Arr, D>>
-            convert_to() {
-                return {};
-            }
+        template <template <class, size_t> class Arr, class D = void>
+        GT_FORCE_INLINE constexpr impl_::convert_to_f<impl_::to_array_converter_helper<Arr, D>> convert_to() {
+            return {};
+        }
 
-            template <template <class, size_t> class Arr, class D = void, class Tup>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto convert_to(Tup && tup) {
-                return (detail::convert_to_f<_impl::to_array_converter_helper<Arr, D>>{}(wstd::forward<Tup>(tup)));
-            }
+        template <template <class, size_t> class Arr, class D = void, class Tup>
+        GT_FORCE_INLINE constexpr auto convert_to(Tup &&tup) {
+            return (impl_::convert_to_f<impl_::to_array_converter_helper<Arr, D>>{}(std::forward<Tup>(tup)));
+        }
 
-            DEFINE_FUNCTOR_INSTANCE(reverse, detail::reverse_f);
+        DEFINE_FUNCTOR_INSTANCE(reverse, impl_::reverse_f);
 
-            template <size_t I, class Val>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR detail::insert_f<I, Val> insert(Val && val) {
-                return {wstd::forward<Val>(val)};
-            }
+        template <size_t I, class Val>
+        GT_FORCE_INLINE constexpr impl_::insert_f<I, Val> insert(Val &&val) {
+            return {std::forward<Val>(val)};
+        }
 
-            template <size_t I, class Val, class Tup>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto insert(Val && val, Tup && tup) {
-                return insert<I>(wstd::forward<Val>(val))(wstd::forward<Tup>(tup));
-            }
+        template <size_t I, class Val, class Tup>
+        GT_FORCE_INLINE constexpr auto insert(Val &&val, Tup &&tup) {
+            return insert<I>(std::forward<Val>(val))(std::forward<Tup>(tup));
         }
     } // namespace tuple_util
+
+    using tuple_util::is_tuple_like;
+
+#ifdef __cpp_concepts
+    namespace concepts {
+        template <class T>
+        concept tuple_like = is_tuple_like<T>::value;
+
+        template <class T, class... Ts>
+        concept tuple_like_of = tuple_like<T> &&
+            std::is_same_v<meta::rename<meta::list, tuple_util::traits::to_types<T>>, meta::list<Ts...>>;
+    } // namespace concepts
+#endif
+
 } // namespace gridtools
 
 #undef DEFINE_TEMPLATED_FUNCTOR_INSTANCE
 #undef DEFINE_FUNCTOR_INSTANCE
 
-#endif // GT_TARGET_ITERATING
-
 /** @} */
 /** @} */
diff --git a/include/gridtools/fn/backend/naive/fencil.hpp b/include/gridtools/fn/backend/naive/fencil.hpp
index d4fd4a23ef..dd7a144191 100644
--- a/include/gridtools/fn/backend/naive/fencil.hpp
+++ b/include/gridtools/fn/backend/naive/fencil.hpp
@@ -58,7 +58,7 @@ namespace gridtools::fn {
                 using tree_t = ast::popup_tmps<raw_tree_t>;
                 using specs_t = ast::flatten_tmps_tree<tree_t, input_types_t>;
                 using stages_t = meta::transform<make_stage_from_spec, specs_t>;
-                auto alloc = sid::make_allocator(&std::make_unique<char[]>);
+                auto alloc = sid::allocator(&std::make_unique<char[]>);
                 auto tmps = make_tmps<meta::pop_back<specs_t>>(alloc, domain);
                 fn_fencil(naive(), stages_t(), domain, tuple_util::push_back(tuple_util::concat(inputs, tmps), output));
             } else {
diff --git a/include/gridtools/fn/scan.hpp b/include/gridtools/fn/scan.hpp
index c0f5bbe368..507763e90d 100644
--- a/include/gridtools/fn/scan.hpp
+++ b/include/gridtools/fn/scan.hpp
@@ -11,6 +11,7 @@
 
 #include <cassert>
 #include <type_traits>
+#include <utility>
 
 #include "../common/functional.hpp"
 #include "../common/integral_constant.hpp"
@@ -20,7 +21,7 @@
 
 namespace gridtools::fn {
     namespace scan_impl_ {
-        template <class F, class Projector = host_device::identity>
+        template <class F, class Projector = gridtools::identity>
         struct scan_pass {
             F m_f;
             Projector m_p;
@@ -53,25 +54,25 @@ namespace gridtools::fn {
                     if constexpr (is_scan_pass<decltype(pass)>()) {
                         // scan
                         auto res =
-                            pass.m_f(wstd::move(acc), MakeIterator()()(integral_constant<int, Ins>(), ptr, strides)...);
-                        *host_device::at_key<integral_constant<int, Out>>(ptr) = pass.m_p(res);
+                            pass.m_f(std::move(acc), MakeIterator()()(integral_constant<int, Ins>(), ptr, strides)...);
+                        *at_key<integral_constant<int, Out>>(ptr) = pass.m_p(res);
                         inc();
                         return res;
                     } else {
                         // fold
                         auto res =
-                            pass(wstd::move(acc), MakeIterator()()(integral_constant<int, Ins>(), ptr, strides)...);
+                            pass(std::move(acc), MakeIterator()()(integral_constant<int, Ins>(), ptr, strides)...);
                         inc();
                         return res;
                     }
                 };
                 if constexpr (ScanOrFold::value)
                     sid::shift(ptr, v_stride, size - 1);
-                auto acc = tuple_util::host_device::fold(next, wstd::move(seed), ScanOrFold::prologue());
+                auto acc = tuple_util::fold(next, std::move(seed), ScanOrFold::prologue());
                 std::size_t n = size - prologue_size - epilogue_size;
                 for (std::size_t i = 0; i < n; ++i)
-                    acc = next(wstd::move(acc), ScanOrFold::body());
-                return tuple_util::host_device::fold(next, wstd::move(acc), ScanOrFold::epilogue());
+                    acc = next(std::move(acc), ScanOrFold::body());
+                return tuple_util::fold(next, std::move(acc), ScanOrFold::epilogue());
             }
         };
 
@@ -79,9 +80,8 @@ namespace gridtools::fn {
         struct merged_column_stage {
             template <class Seed, class Ptr, class Strides>
             GT_FUNCTION auto operator()(Seed seed, std::size_t size, Ptr ptr, Strides const &strides) const {
-                return tuple_util::host_device::fold(
-                    [&](auto acc, auto stage) { return stage(wstd::move(acc), size, ptr, strides); },
-                    wstd::move(seed),
+                return tuple_util::fold([&](auto acc, auto stage) { return stage(std::move(acc), size, ptr, strides); },
+                    std::move(seed),
                     tuple(ColumnStages()...));
             }
         };
diff --git a/include/gridtools/layout_transformation/gpu.hpp b/include/gridtools/layout_transformation/gpu.hpp
index 95b3df0b35..c647d7fb5f 100644
--- a/include/gridtools/layout_transformation/gpu.hpp
+++ b/include/gridtools/layout_transformation/gpu.hpp
@@ -38,7 +38,7 @@ namespace gridtools {
                 for (auto &&i = m_hyper_cube.begin(); i != e; ++i) {
                     T *d = dst;
                     T const *__restrict__ s = src;
-                    tuple_util::device::for_each(
+                    tuple_util::for_each(
                         [&](auto i, auto d_stride, auto s_stride) {
                             d += i * d_stride;
                             s += i * s_stride;
@@ -77,19 +77,19 @@ namespace gridtools {
             OuterLoop outer_loop) {
 
             uint_t i = blockIdx.x * block_size_1d_t::value + threadIdx.x;
-            if (i >= tuple_util::device::get<0>(dims))
+            if (i >= tuple_util::get<0>(dims))
                 return;
             uint_t j = blockIdx.y * block_size_1d_t::value + threadIdx.y;
-            if (j >= tuple_util::device::get<1>(dims))
+            if (j >= tuple_util::get<1>(dims))
                 return;
             uint_t k = blockIdx.z * block_size_1d_t::value + threadIdx.z;
-            if (k >= tuple_util::device::get<2>(dims))
+            if (k >= tuple_util::get<2>(dims))
                 return;
 
-            outer_loop(dst + i * tuple_util::device::get<0>(dst_strides) + j * tuple_util::device::get<1>(dst_strides) +
-                           k * tuple_util::device::get<2>(dst_strides),
-                src + i * tuple_util::device::get<0>(src_strides) + j * tuple_util::device::get<1>(src_strides) +
-                    k * tuple_util::device::get<2>(src_strides));
+            outer_loop(dst + i * tuple_util::get<0>(dst_strides) + j * tuple_util::get<1>(dst_strides) +
+                           k * tuple_util::get<2>(dst_strides),
+                src + i * tuple_util::get<0>(src_strides) + j * tuple_util::get<1>(src_strides) +
+                    k * tuple_util::get<2>(src_strides));
         }
 
         template <class T, class Dims, class DstStrides, class SrcSrides>
diff --git a/include/gridtools/reduction/frontend.hpp b/include/gridtools/reduction/frontend.hpp
index e9037971fc..6aeda287ba 100644
--- a/include/gridtools/reduction/frontend.hpp
+++ b/include/gridtools/reduction/frontend.hpp
@@ -58,7 +58,7 @@ namespace gridtools {
 
             template <class Backend, class StorageTraits, class Id = void, class T, class... Dims>
             auto make_reducible(T const &neutral_value, Dims... dims) {
-                auto alloc = sid::host_device::make_cached_allocator(
+                auto alloc = sid::cached_allocator(
                     [](size_t size) { return storage::traits::allocate<StorageTraits, char>(size); });
                 auto lengths = tuple(dims...);
                 auto info = storage::traits::make_info<StorageTraits, T>(lengths);
diff --git a/include/gridtools/sid/allocator.hpp b/include/gridtools/sid/allocator.hpp
index e20bb63ec2..f8f8803c2f 100644
--- a/include/gridtools/sid/allocator.hpp
+++ b/include/gridtools/sid/allocator.hpp
@@ -7,10 +7,7 @@
  * Please, refer to the LICENSE file in the root directory.
  * SPDX-License-Identifier: BSD-3-Clause
  */
-#ifndef GT_TARGET_ITERATING
-// DON'T USE #pragma once HERE!!!
-#ifndef GT_SID_ALLOCATOR_HPP_
-#define GT_SID_ALLOCATOR_HPP_
+#pragma once
 
 #include <map>
 #include <memory>
@@ -47,15 +44,13 @@
  *
  *  Both are templated with the functor that takes the size in bytes and returns `std::unique_ptr`
  *
- *  There are also correspondent generators: `make_allocator` and `make_cached_allocator`.
- *
  *  Semantics:
  *    - `allocator` keeps the resources that are allocated and releases them in dtor.
  *    - `cached_allocator` keeps resources during its lifetime. On dtor it stashes the resources in the internal static
  *      storage. The newly created instances of `cached_allocator` will attempt to reuse the stashed resources.
  *
  *  To make the simplest possible allocator one can do:
- *    `auto alloc = make_allocator(&std::make_unique<char[]>);`
+ *    `auto alloc = allocator(&std::make_unique<char[]>);`
  *
  */
 
@@ -96,57 +91,35 @@ namespace gridtools {
                 }
             };
         } // namespace allocator_impl_
-    }     // namespace sid
-} // namespace gridtools
 
-#define GT_FILENAME <gridtools/sid/allocator.hpp>
-#include GT_ITERATE_ON_TARGETS()
-#undef GT_FILENAME
+        template <class Impl, class Ptr = decltype(std::declval<Impl const>()(size_t{}))>
+        class allocator;
 
-#endif
-#else
+        template <class Impl, class T, class Deleter>
+        class allocator<Impl, std::unique_ptr<T, Deleter>> {
+            Impl m_impl;
+            std::vector<std::unique_ptr<T, Deleter>> m_buffers;
 
-namespace gridtools {
-    namespace sid {
-        GT_TARGET_NAMESPACE {
-            template <class Impl, class Ptr = decltype(std::declval<Impl const>()(size_t{}))>
-            class allocator;
+          public:
+            allocator() = default;
+            allocator(Impl impl) : m_impl(std::move(impl)) {}
 
-            template <class Impl, class T, class Deleter>
-            class allocator<Impl, std::unique_ptr<T, Deleter>> {
-                Impl m_impl;
-                std::vector<std::unique_ptr<T, Deleter>> m_buffers;
-
-              public:
-                allocator() = default;
-                allocator(Impl impl) : m_impl(std::move(impl)) {}
-
-                template <class LazyT>
-                friend auto allocate(allocator &self, LazyT, size_t size) {
-                    using type = typename LazyT::type;
-                    auto ptr = self.m_impl(sizeof(type) * size);
-                    self.m_buffers.push_back(self.m_impl(sizeof(type) * size));
-                    return make_simple_ptr_holder(reinterpret_cast<type *>(self.m_buffers.back().get()));
-                }
-            };
-
-            template <class Impl>
-            struct cached_allocator : allocator<allocator_impl_::cached_proxy_f<Impl>> {
-                cached_allocator() = default;
-                cached_allocator(Impl impl) : cached_allocator::allocator({std::move(impl)}) {}
-            };
-
-            template <class Impl>
-            allocator<Impl> make_allocator(Impl impl) {
-                return {std::move(impl)};
+            template <class LazyT>
+            friend auto allocate(allocator &self, LazyT, size_t size) {
+                using type = typename LazyT::type;
+                auto ptr = self.m_impl(sizeof(type) * size);
+                self.m_buffers.push_back(self.m_impl(sizeof(type) * size));
+                return simple_ptr_holder(reinterpret_cast<type *>(self.m_buffers.back().get()));
             }
+        };
 
-            template <class Impl>
-            cached_allocator<Impl> make_cached_allocator(Impl impl) {
-                return {std::move(impl)};
-            }
-        }
+        template <class Impl>
+        allocator(Impl) -> allocator<Impl>;
+
+        template <class Impl>
+        struct cached_allocator : allocator<allocator_impl_::cached_proxy_f<Impl>> {
+            cached_allocator() = default;
+            cached_allocator(Impl impl) : cached_allocator::allocator({std::move(impl)}) {}
+        };
     } // namespace sid
 } // namespace gridtools
-
-#endif
diff --git a/include/gridtools/sid/block.hpp b/include/gridtools/sid/block.hpp
index a60f8e55a4..517fa9d247 100644
--- a/include/gridtools/sid/block.hpp
+++ b/include/gridtools/sid/block.hpp
@@ -34,8 +34,7 @@ namespace gridtools {
             template <class Ptr, class Stride, class BlockSize, class Offset>
             GT_FUNCTION decltype(auto) sid_shift(
                 Ptr &ptr, blocked_stride<Stride, BlockSize> const &stride, Offset const &offset) {
-                return shift(
-                    ptr, tuple_util::host_device::get<0>(stride), tuple_util::host_device::get<1>(stride) * offset);
+                return shift(ptr, tuple_util::get<0>(stride), tuple_util::get<1>(stride) * offset);
             }
 
             template <class Stride, class BlockSize, std::enable_if_t<!std::is_integral<Stride>::value, int> = 0>
diff --git a/include/gridtools/sid/composite.hpp b/include/gridtools/sid/composite.hpp
index da95d961b7..9d10c5a868 100644
--- a/include/gridtools/sid/composite.hpp
+++ b/include/gridtools/sid/composite.hpp
@@ -10,9 +10,11 @@
 #pragma once
 
 #include <cassert>
+#include <functional>
 #include <type_traits>
 #include <utility>
 
+#include "../common/compose.hpp"
 #include "../common/defs.hpp"
 #include "../common/enable_maker.hpp"
 #include "../common/for_each.hpp"
@@ -111,8 +113,9 @@ namespace gridtools {
                 };
 
                 template <class ObjTup, class StrideTup, class Offset>
-                GT_FUNCTION void composite_shift_impl(ObjTup &obj_tup, StrideTup &&stride_tup, Offset offset) {
-                    tuple_util::host_device::for_each(
+                GT_FORCE_INLINE constexpr void composite_shift_impl(
+                    ObjTup &obj_tup, StrideTup &&stride_tup, Offset offset) {
+                    tuple_util::for_each(
                         [offset](auto &obj, auto &&stride)
                             GT_FORCE_INLINE_LAMBDA { shift(obj, wstd::forward<decltype(stride)>(stride), offset); },
                         obj_tup,
@@ -137,13 +140,6 @@ namespace gridtools {
                 };
 
                 struct ctor_tag {};
-
-                struct sum {
-                    template <class Lhs, class Rhs>
-                    GT_FUNCTION GT_CONSTEXPR auto operator()(Lhs &&lhs, Rhs &&rhs) const {
-                        return wstd::forward<Lhs>(lhs) + wstd::forward<Rhs>(rhs);
-                    }
-                };
             } // namespace impl_
 
             /**
@@ -192,12 +188,13 @@ namespace gridtools {
 
                 template <class... Args,
                     std::enable_if_t<std::conjunction_v<std::is_constructible<Ptrs, Args>...>, int> = 0>
-                constexpr GT_FUNCTION composite_ptr(Args &&...args) noexcept : m_vals{wstd::forward<Args>(args)...} {}
+                GT_FORCE_INLINE constexpr composite_ptr(Args &&...args) noexcept
+                    : m_vals{wstd::forward<Args>(args)...} {}
 
-                constexpr GT_FUNCTION composite_ptr(Ptrs const &...args) noexcept : m_vals(args...) {}
+                GT_FORCE_INLINE constexpr composite_ptr(Ptrs const &...args) noexcept : m_vals(args...) {}
 
-                constexpr GT_FUNCTION composite_ptr(tuple<Ptrs...> &&args) noexcept : m_vals(wstd::move(args)) {}
-                constexpr GT_FUNCTION composite_ptr(tuple<Ptrs...> const &args) noexcept : m_vals(args) {}
+                GT_FORCE_INLINE constexpr composite_ptr(tuple<Ptrs...> &&args) noexcept : m_vals(wstd::move(args)) {}
+                GT_FORCE_INLINE constexpr composite_ptr(tuple<Ptrs...> const &args) noexcept : m_vals(args) {}
 
                 composite_ptr() = default;
                 composite_ptr(composite_ptr const &) = default;
@@ -207,14 +204,14 @@ namespace gridtools {
 
                 GT_TUPLE_UTIL_FORWARD_GETTER_TO_MEMBER(composite_ptr, m_vals);
 
-                GT_CONSTEXPR GT_FUNCTION decltype(auto) operator*() const {
-                    return tuple_util::host_device::convert_to<hymap::keys<Keys...>::template values>(
-                        tuple_util::host_device::transform([](auto const &ptr)
+                GT_FORCE_INLINE constexpr decltype(auto) operator*() const {
+                    return tuple_util::convert_to<hymap::keys<Keys...>::template values>(
+                        tuple_util::transform([](auto const &ptr)
 // Workaround for GCC 9 bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90333
 // The failure is observed with 9.3 as well even though they say it was already fixed there.
 // gcc 10.1, 10.2 fails here as well. Disabling for all gcc 9 and 10 versions...
 #if defined(__clang__) || !defined(__GNUC__) || (__GNUC__ != 9 && __GNUC__ != 10)
-                                                               GT_FORCE_INLINE_LAMBDA
+                                                  GT_FORCE_INLINE_LAMBDA
 #endif
                             -> decltype(auto) { return *ptr; },
                             m_vals));
@@ -223,6 +220,11 @@ namespace gridtools {
                 friend keys hymap_get_keys(composite_ptr const &) { return {}; }
             };
 
+            template <class Fun, class Tup, std::size_t... Is>
+            GT_FORCE_INLINE constexpr decltype(auto) my_apply_impl(Fun &&f, Tup &&tup, std::index_sequence<Is...>) {
+                return std::forward<Fun>(f)(get<Is>(std::forward<Tup>(tup))...);
+            }
+
             template <class... Keys>
             template <class... PtrHolders>
             struct keys<Keys...>::composite_ptr_holder {
@@ -232,14 +234,15 @@ namespace gridtools {
 
                 template <class... Args,
                     std::enable_if_t<std::conjunction_v<std::is_constructible<PtrHolders, Args>...>, int> = 0>
-                constexpr GT_FUNCTION composite_ptr_holder(Args &&...args) noexcept
-                    : m_vals{wstd::forward<Args>(args)...} {}
+                GT_FORCE_INLINE constexpr composite_ptr_holder(Args &&...args) noexcept
+                    : m_vals{std::forward<Args>(args)...} {}
 
-                constexpr GT_FUNCTION composite_ptr_holder(PtrHolders const &...args) noexcept : m_vals(args...) {}
+                GT_FORCE_INLINE constexpr composite_ptr_holder(PtrHolders const &...args) noexcept : m_vals(args...) {}
 
-                constexpr GT_FUNCTION composite_ptr_holder(tuple<PtrHolders...> &&args) noexcept
-                    : m_vals(wstd::move(args)) {}
-                constexpr GT_FUNCTION composite_ptr_holder(tuple<PtrHolders...> const &args) noexcept : m_vals(args) {}
+                GT_FORCE_INLINE constexpr composite_ptr_holder(tuple<PtrHolders...> &&args) noexcept
+                    : m_vals(std::move(args)) {}
+                GT_FORCE_INLINE constexpr composite_ptr_holder(tuple<PtrHolders...> const &args) noexcept
+                    : m_vals(args) {}
 
                 composite_ptr_holder() = default;
                 composite_ptr_holder(composite_ptr_holder const &) = default;
@@ -249,9 +252,12 @@ namespace gridtools {
 
                 GT_TUPLE_UTIL_FORWARD_GETTER_TO_MEMBER(composite_ptr_holder, m_vals);
 
-                GT_CONSTEXPR GT_FUNCTION auto operator()() const {
-                    return tuple_util::host_device::convert_to<composite_ptr>(tuple_util::host_device::transform(
-                        [](auto const &obj) GT_FORCE_INLINE_LAMBDA { return obj(); }, m_vals));
+                GT_FUNCTION constexpr auto operator()() const {
+                    return tuple_util::apply(
+                        [](auto const &...holders) {
+                            return composite_ptr<std::decay_t<decltype(holders())>...>(holders()...);
+                        },
+                        m_vals);
                 }
 
                 friend keys hymap_get_keys(composite_ptr_holder const &) { return {}; }
@@ -292,8 +298,8 @@ namespace gridtools {
                     class T,
                     class Item = meta::mp_find<Map, std::integral_constant<size_t, I>>,
                     class Pos = meta::second<Item>>
-                static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(T &&obj) {
-                    return tuple_util::host_device::get<Pos::value>(wstd::forward<T>(obj).m_vals);
+                static GT_FORCE_INLINE constexpr decltype(auto) get(T &&obj) {
+                    return tuple_util::get<Pos::value>(wstd::forward<T>(obj).m_vals);
                 }
 
                 template <class... Ts>
@@ -308,7 +314,7 @@ namespace gridtools {
                     vals_t m_vals;
 
                     template <template <class...> class L, class... Args>
-                    composite_entity(impl_::ctor_tag, L<Args...> &&tup) noexcept
+                    GT_FORCE_INLINE constexpr composite_entity(impl_::ctor_tag, L<Args...> &&tup) noexcept
                         : m_vals{tuple_util::generate<generators_t, vals_t>(std::move(tup))} {
                         static_assert(sizeof...(Args) == sizeof...(Keys), GT_INTERNAL_ERROR);
                     }
@@ -322,25 +328,25 @@ namespace gridtools {
                     friend compressed tuple_getter(composite_entity const &) { return {}; }
 
                     template <class... Ptrs>
-                    friend GT_CONSTEXPR GT_FUNCTION composite_ptr<Ptrs...> operator+(
+                    friend GT_FORCE_INLINE constexpr composite_ptr<Ptrs...> operator+(
                         composite_ptr<Ptrs...> const &lhs, composite_entity const &rhs) {
-                        return tuple_util::host_device::transform(impl_::sum(), lhs, rhs);
+                        return tuple_util::transform(std::plus<>(), lhs, rhs);
                     }
 
                     template <class... PtrHolders>
-                    friend composite_ptr_holder<PtrHolders...> operator+(
+                    friend GT_FORCE_INLINE constexpr composite_ptr_holder<PtrHolders...> operator+(
                         composite_ptr_holder<PtrHolders...> const &lhs, composite_entity const &rhs) {
-                        return tuple_util::transform(impl_::sum(), lhs, rhs);
+                        return tuple_util::transform(std::plus<>(), lhs, rhs);
                     }
 
                     template <class... Ptrs, class Offset>
-                    friend GT_FUNCTION void sid_shift(
+                    friend GT_FORCE_INLINE constexpr void sid_shift(
                         composite_ptr<Ptrs...> &ptr, composite_entity const &stride, Offset offset) {
                         impl_::composite_shift_impl(ptr.m_vals, stride, offset);
                     }
 
                     template <class... Ptrs, class Offset>
-                    friend GT_FUNCTION void sid_shift(
+                    friend GT_FORCE_INLINE constexpr void sid_shift(
                         composite_ptr<Ptrs...> &ptr, composite_entity &&stride, Offset offset) {
                         impl_::composite_shift_impl(ptr.m_vals, wstd::move(stride), offset);
                     }
@@ -349,21 +355,22 @@ namespace gridtools {
                 };
 
                 template <class... PtrDiffs, class... Strides, class Offset>
-                friend GT_FUNCTION void sid_shift(composite_entity<PtrDiffs...> &ptr_diff,
+                friend GT_FORCE_INLINE constexpr void sid_shift(composite_entity<PtrDiffs...> &ptr_diff,
                     composite_entity<Strides...> const &stride,
                     Offset offset) {
                     impl_::composite_shift_impl(ptr_diff.m_vals, stride.m_vals, offset);
                 }
 
                 template <class... PtrDiffs, class... Strides, class Offset>
-                friend GT_FUNCTION void sid_shift(
+                friend GT_FORCE_INLINE constexpr void sid_shift(
                     composite_entity<PtrDiffs...> &ptr_diff, composite_entity<Strides...> &&stride, Offset offset) {
                     impl_::composite_shift_impl(ptr_diff.m_vals, wstd::move(stride.m_vals), offset);
                 }
 
                 struct convert_f {
                     template <template <class...> class L, class... Ts>
-                    composite_entity<std::remove_reference_t<Ts>...> operator()(L<Ts...> &&tup) const {
+                    GT_FORCE_INLINE constexpr composite_entity<std::remove_reference_t<Ts>...> operator()(
+                        L<Ts...> &&tup) const {
                         return {impl_::ctor_tag(), std::move(tup)};
                     }
                 };
@@ -474,9 +481,9 @@ namespace gridtools {
             template <>
             template <>
             struct keys<>::values<> {
-                constexpr GT_FUNCTION values operator()() const { return {}; }
-                constexpr GT_FUNCTION values operator*() const { return {}; }
-                friend constexpr GT_FUNCTION values operator+(values, values) { return {}; }
+                constexpr values operator()() const { return {}; }
+                constexpr values operator*() const { return {}; }
+                friend constexpr values operator+(values, values) { return {}; }
                 friend values sid_get_origin(values) { return {}; }
                 friend values sid_get_ptr_diff(values) { return {}; }
                 friend values tuple_getter(values) { return {}; }
diff --git a/include/gridtools/sid/concept.hpp b/include/gridtools/sid/concept.hpp
index c5cb1a9906..5bde37444c 100644
--- a/include/gridtools/sid/concept.hpp
+++ b/include/gridtools/sid/concept.hpp
@@ -11,6 +11,7 @@
 
 #include <limits>
 #include <type_traits>
+#include <utility>
 
 #include "../common/defs.hpp"
 #include "../common/host_device.hpp"
@@ -215,7 +216,7 @@ namespace gridtools {
              *  C-array specialization
              */
             template <class T, class Res = std::add_pointer_t<std::remove_all_extents_t<T>>>
-            std::enable_if_t<std::is_array<T>::value, host_device::simple_ptr_holder<Res>> get_origin(T &obj) {
+            std::enable_if_t<std::is_array<T>::value, simple_ptr_holder<Res>> get_origin(T &obj) {
                 return {(Res)obj};
             }
 
@@ -449,8 +450,8 @@ namespace gridtools {
              *  noop `shift` overload
              */
             template <class T, class Stride, class Offset>
-            GT_FUNCTION std::enable_if_t<!(std::is_lvalue_reference<T>::value &&
-                                           need_shift<std::remove_reference_t<T>, std::decay_t<Stride>, Offset>::value)>
+            constexpr std::enable_if_t<!(std::is_lvalue_reference<T>::value &&
+                                         need_shift<std::remove_reference_t<T>, std::decay_t<Stride>, Offset>::value)>
             shift(T &&, Stride &&, Offset) {}
 
             /**
@@ -464,8 +465,8 @@ namespace gridtools {
                 std::enable_if_t<need_shift<T, std::decay_t<Stride>, Offset>::value &&
                                      !is_default_shiftable<T, std::decay_t<Stride>>::value,
                     int> = 0>
-            GT_FUNCTION decltype(auto) shift(T &obj, Stride &&stride, Offset offset) {
-                return sid_shift(obj, wstd::forward<Stride>(stride), offset);
+            constexpr decltype(auto) shift(T &obj, Stride &&stride, Offset offset) {
+                return sid_shift(obj, std::forward<Stride>(stride), offset);
             }
 
             /**
@@ -475,10 +476,10 @@ namespace gridtools {
                 class Stride,
                 class Offset,
                 int_t PtrOffset = get_static_const_value<Stride>::value *Offset::value>
-            GT_FUNCTION
-                std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
-                                 !(has_inc<T>::value && PtrOffset == 1) && !(has_dec<T>::value && PtrOffset == -1)>
-                shift(T &obj, Stride, Offset) {
+            constexpr std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
+                                       !(has_inc<T>::value && PtrOffset == 1) &&
+                                       !(has_dec<T>::value && PtrOffset == -1)>
+            shift(T &obj, Stride, Offset) {
                 obj += integral_constant<int_t, PtrOffset>{};
             }
 
@@ -489,8 +490,8 @@ namespace gridtools {
                 class Stride,
                 class Offset,
                 int_t PtrOffset = get_static_const_value<Stride>::value *Offset::value>
-            GT_FUNCTION std::enable_if_t<need_shift<T, Stride, Offset>::value &&
-                                         is_default_shiftable<T, Stride>::value && has_inc<T>::value && PtrOffset == 1>
+            constexpr std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
+                                       has_inc<T>::value && PtrOffset == 1>
             shift(T &obj, Stride, Offset) {
                 ++obj;
             }
@@ -502,8 +503,8 @@ namespace gridtools {
                 class Stride,
                 class Offset,
                 int_t PtrOffset = get_static_const_value<Stride>::value *Offset::value>
-            GT_FUNCTION std::enable_if_t<need_shift<T, Stride, Offset>::value &&
-                                         is_default_shiftable<T, Stride>::value && has_dec<T>::value && PtrOffset == -1>
+            constexpr std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
+                                       has_dec<T>::value && PtrOffset == -1>
             shift(T &obj, Stride, Offset) {
                 --obj;
             }
@@ -512,10 +513,10 @@ namespace gridtools {
              *  `shift` overload where the offset is 1
              */
             template <class T, class Stride, class Offset>
-            GT_FUNCTION
-                std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
-                                 !is_integral_constant<Stride>::value && is_integral_constant_of<Offset, 1>::value>
-                shift(T &obj, Stride const &stride, Offset) {
+            constexpr std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
+                                       !is_integral_constant<Stride>::value &&
+                                       is_integral_constant_of<Offset, 1>::value>
+            shift(T &obj, Stride const &stride, Offset) {
                 obj += stride;
             }
 
@@ -523,11 +524,11 @@ namespace gridtools {
              *  `shift` overload where the offset is -1
              */
             template <class T, class Stride, class Offset>
-            GT_FUNCTION
-                std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
-                                 !is_integral_constant<Stride>::value && is_integral_constant_of<Offset, -1>::value &&
-                                 has_dec_assignment<T, Stride>::value>
-                shift(T &obj, Stride const &stride, Offset) {
+            constexpr std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
+                                       !is_integral_constant<Stride>::value &&
+                                       is_integral_constant_of<Offset, -1>::value &&
+                                       has_dec_assignment<T, Stride>::value>
+            shift(T &obj, Stride const &stride, Offset) {
                 obj -= stride;
             }
 
@@ -535,10 +536,10 @@ namespace gridtools {
              *  `shift` overload where the stride is 1
              */
             template <class T, class Stride, class Offset>
-            GT_FUNCTION
-                std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
-                                 is_integral_constant_of<Stride, 1>::value && !is_integral_constant<Offset>::value>
-                shift(T &obj, Stride, Offset offset) {
+            constexpr std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
+                                       is_integral_constant_of<Stride, 1>::value &&
+                                       !is_integral_constant<Offset>::value>
+            shift(T &obj, Stride, Offset offset) {
                 obj += offset;
             }
 
@@ -546,11 +547,10 @@ namespace gridtools {
              *  `shift` overload where the stride is -1
              */
             template <class T, class Stride, class Offset>
-            GT_FUNCTION
-                std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
-                                 is_integral_constant_of<Stride, -1>::value && !is_integral_constant<Offset>::value &&
-                                 has_dec_assignment<T, Stride>::value>
-                shift(T &obj, Stride, Offset offset) {
+            constexpr std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
+                                       is_integral_constant_of<Stride, -1>::value &&
+                                       !is_integral_constant<Offset>::value && has_dec_assignment<T, Stride>::value>
+            shift(T &obj, Stride, Offset offset) {
                 obj -= offset;
             }
 
@@ -558,14 +558,14 @@ namespace gridtools {
              *  `shift` overload, default version
              */
             template <class T, class Stride, class Offset, class Decayed = std::decay_t<Stride>>
-            GT_FUNCTION std::enable_if_t<
+            constexpr std::enable_if_t<
                 need_shift<T, Decayed, Offset>::value && is_default_shiftable<T, Decayed>::value &&
                 !(is_integral_constant<Decayed>::value && is_integral_constant<Offset>::value) &&
                 !(is_integral_constant_of<Decayed, 1>::value || is_integral_constant_of<Offset, 1>::value) &&
                 !(has_dec_assignment<T, Decayed>::value &&
                     (is_integral_constant_of<Decayed, -1>::value || is_integral_constant_of<Offset, -1>::value))>
             shift(T &obj, Stride &&stride, Offset offset) {
-                obj += wstd::forward<Stride>(stride) * offset;
+                obj += std::forward<Stride>(stride) * offset;
             }
 
             // END `shift` PART
@@ -611,7 +611,8 @@ namespace gridtools {
                 class UpperBoundsType = upper_bounds_type<Sid>>
             using is_sid = std::conjunction<
 
-                // `is_trivially_copy_constructible` check is applied to the types that are will be passed from host to device
+                // `is_trivially_copy_constructible` check is applied to the types that are will be passed from host to
+                // device
                 std::is_trivially_copy_constructible<PtrHolder>,
                 std::is_trivially_copy_constructible<StridesType>,
 
@@ -692,8 +693,8 @@ namespace gridtools {
          *  Which allows to silently ignore the offsets in non existing dimensions.
          */
         template <class Key, class Strides>
-        GT_CONSTEXPR GT_FUNCTION decltype(auto) get_stride(Strides &&strides) {
-            return gridtools::host_device::at_key_with_default<Key, default_stride>(wstd::forward<Strides>(strides));
+        constexpr decltype(auto) get_stride(Strides &&strides) {
+            return at_key_with_default<Key, default_stride>(std::forward<Strides>(strides));
         }
 
         /**
@@ -704,16 +705,15 @@ namespace gridtools {
             class Dim,
             class Strides,
             std::enable_if_t<has_key<std::decay_t<Strides>, Dim>::value, int> = 0>
-        GT_CONSTEXPR GT_FUNCTION decltype(auto) get_stride_element(Strides &&strides) {
-            return gridtools::host_device::at_key<Key>(
-                gridtools::host_device::at_key<Dim>(wstd::forward<Strides>(strides)));
+        constexpr decltype(auto) get_stride_element(Strides &&strides) {
+            return at_key<Key>(at_key<Dim>(std::forward<Strides>(strides)));
         }
 
         template <class Key,
             class Dim,
             class Strides,
             std::enable_if_t<!has_key<std::decay_t<Strides>, Dim>::value, int> = 0>
-        GT_CONSTEXPR GT_FUNCTION integral_constant<int_t, 0> get_stride_element(Strides &&) {
+        constexpr integral_constant<int_t, 0> get_stride_element(Strides &&) {
             return {};
         }
 
@@ -724,17 +724,17 @@ namespace gridtools {
          */
         template <class Key, class Bounds>
         decltype(auto) get_lower_bound(Bounds &&bounds) {
-            return gridtools::host_device::at_key_with_default<Key,
-                integral_constant<int_t, std::numeric_limits<int_t>::min()>>(wstd::forward<Bounds>(bounds));
+            return at_key_with_default<Key, integral_constant<int_t, std::numeric_limits<int_t>::min()>>(
+                std::forward<Bounds>(bounds));
         }
         template <class Key, class Bounds>
         decltype(auto) get_upper_bound(Bounds &&bounds) {
-            return gridtools::host_device::at_key_with_default<Key,
-                integral_constant<int_t, std::numeric_limits<int_t>::max()>>(wstd::forward<Bounds>(bounds));
+            return at_key_with_default<Key, integral_constant<int_t, std::numeric_limits<int_t>::max()>>(
+                std::forward<Bounds>(bounds));
         }
 
         template <class T, class Stride, class Offset>
-        GT_FUNCTION T shifted(T obj, Stride const &stride, Offset offset) {
+        constexpr T shifted(T obj, Stride const &stride, Offset offset) {
             shift(obj, stride, offset);
             return obj;
         }
diff --git a/include/gridtools/sid/loop.hpp b/include/gridtools/sid/loop.hpp
index 49e1fc35f6..a7c93c6909 100644
--- a/include/gridtools/sid/loop.hpp
+++ b/include/gridtools/sid/loop.hpp
@@ -48,13 +48,13 @@ namespace gridtools {
                             m_fun(ptr, strides);
                             shift(ptr, stride, m_step);
                         }
-                        shift(wstd::forward<Ptr>(ptr), stride, -m_step * m_num_steps);
+                        shift(std::forward<Ptr>(ptr), stride, -m_step * m_num_steps);
                     }
                 };
 
                 template <class Fun>
                 GT_CONSTEXPR GT_FUNCTION loop_f<Fun> operator()(Fun &&fun) const {
-                    return {wstd::forward<Fun>(fun), m_num_steps, m_step};
+                    return {std::forward<Fun>(fun), m_num_steps, m_step};
                 }
 
                 template <class Outer>
@@ -72,9 +72,9 @@ namespace gridtools {
                         if (++m_pos == m_num_steps) {
                             shift(ptr, get_stride<Key>(strides), m_step * (1 - m_num_steps));
                             m_pos = 0;
-                            m_outer.next(wstd::forward<Ptr>(ptr), strides);
+                            m_outer.next(std::forward<Ptr>(ptr), strides);
                         } else {
-                            shift(wstd::forward<Ptr>(ptr), get_stride<Key>(strides), m_step);
+                            shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), m_step);
                         }
                     }
 
@@ -83,7 +83,7 @@ namespace gridtools {
 
                 template <class Outer>
                 GT_CONSTEXPR GT_FUNCTION cursor_f<Outer> make_cursor(Outer &&outer) const {
-                    return {wstd::forward<Outer>(outer), m_num_steps, m_step, 0};
+                    return {std::forward<Outer>(outer), m_num_steps, m_step, 0};
                 }
 
                 struct outer_most_cursor_f {
@@ -93,7 +93,7 @@ namespace gridtools {
                     template <class Ptr, class Strides>
                     void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
                         --m_pos;
-                        shift(wstd::forward<Ptr>(ptr), get_stride<Key>(strides), m_step);
+                        shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), m_step);
                     }
 
                     GT_FUNCTION bool done() const { return m_pos > 0; }
@@ -124,13 +124,13 @@ namespace gridtools {
                             shift(ptr, stride, integral_constant<T, Step>{});
                         }
                         static constexpr T minus_step = -Step;
-                        shift(wstd::forward<Ptr>(ptr), stride, minus_step * m_num_steps);
+                        shift(std::forward<Ptr>(ptr), stride, minus_step * m_num_steps);
                     }
                 };
 
                 template <class Fun>
                 GT_FUNCTION loop_f<Fun> operator()(Fun &&fun) const {
-                    return {wstd::forward<Fun>(fun), m_num_steps};
+                    return {std::forward<Fun>(fun), m_num_steps};
                 }
 
                 template <class Outer>
@@ -147,9 +147,9 @@ namespace gridtools {
                         if (++m_pos == m_num_steps) {
                             shift(ptr, get_stride<Key>(strides), Step * (1 - m_num_steps));
                             m_pos = 0;
-                            m_outer.next(wstd::forward<Ptr>(ptr), strides);
+                            m_outer.next(std::forward<Ptr>(ptr), strides);
                         } else {
-                            shift(wstd::forward<Ptr>(ptr), get_stride<Key>(strides), integral_constant<T, Step>{});
+                            shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), integral_constant<T, Step>{});
                         }
                     }
 
@@ -158,7 +158,7 @@ namespace gridtools {
 
                 template <class Outer>
                 GT_CONSTEXPR GT_FUNCTION cursor_f<Outer> make_cursor(Outer &&outer) const {
-                    return {wstd::forward<Outer>(outer), m_num_steps, 0};
+                    return {std::forward<Outer>(outer), m_num_steps, 0};
                 }
 
                 struct outer_most_cursor_f {
@@ -167,7 +167,7 @@ namespace gridtools {
                     template <class Ptr, class Strides>
                     void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
                         --m_pos;
-                        shift(wstd::forward<Ptr>(ptr), get_stride<Key>(strides), integral_constant<T, Step>{});
+                        shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), integral_constant<T, Step>{});
                     }
 
                     GT_FUNCTION bool done() const { return m_pos > 0; }
@@ -191,13 +191,13 @@ namespace gridtools {
                     void GT_FUNCTION operator()(Ptr &&ptr, const Strides &strides) const {
                         assert(m_num_steps >= 0);
                         for (T i = 0; i < m_num_steps; ++i)
-                            m_fun(wstd::forward<Ptr>(ptr), strides);
+                            m_fun(std::forward<Ptr>(ptr), strides);
                     }
                 };
 
                 template <class Fun>
                 GT_CONSTEXPR GT_FUNCTION loop_f<Fun> operator()(Fun &&fun) const {
-                    return {wstd::forward<Fun>(fun), m_num_steps};
+                    return {std::forward<Fun>(fun), m_num_steps};
                 }
 
                 template <class Outer>
@@ -213,7 +213,7 @@ namespace gridtools {
                             return;
                         if (++m_pos == m_num_steps) {
                             m_pos = 0;
-                            m_outer.next(wstd::forward<Ptr>(ptr), strides);
+                            m_outer.next(std::forward<Ptr>(ptr), strides);
                         }
                     }
 
@@ -222,7 +222,7 @@ namespace gridtools {
 
                 template <class Outer>
                 GT_CONSTEXPR GT_FUNCTION cursor_f<Outer> make_cursor(Outer &&outer) const {
-                    return {wstd::forward<Outer>(outer), m_num_steps, 0};
+                    return {std::forward<Outer>(outer), m_num_steps, 0};
                 }
 
                 struct outer_most_cursor_f {
@@ -259,13 +259,13 @@ namespace gridtools {
                             shift(ptr, stride, m_step);
                         }
                         static constexpr T minus_num_steps = -NumSteps;
-                        shift(wstd::forward<Ptr>(ptr), stride, m_step * minus_num_steps);
+                        shift(std::forward<Ptr>(ptr), stride, m_step * minus_num_steps);
                     }
                 };
 
                 template <class Fun>
                 GT_CONSTEXPR GT_FUNCTION loop_f<Fun> operator()(Fun &&fun) const {
-                    return {wstd::forward<Fun>(fun), m_step};
+                    return {std::forward<Fun>(fun), m_step};
                 }
 
                 template <class Outer>
@@ -280,9 +280,9 @@ namespace gridtools {
                             constexpr T num_steps_back = 1 - NumSteps;
                             shift(ptr, get_stride<Key>(strides), m_step * num_steps_back);
                             m_pos = 0;
-                            m_outer.next(wstd::forward<Ptr>(ptr), strides);
+                            m_outer.next(std::forward<Ptr>(ptr), strides);
                         } else {
-                            shift(wstd::forward<Ptr>(ptr), get_stride<Key>(strides), m_step);
+                            shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), m_step);
                         }
                     }
 
@@ -291,7 +291,7 @@ namespace gridtools {
 
                 template <class Outer>
                 GT_CONSTEXPR GT_FUNCTION cursor_f<Outer> make_cursor(Outer &&outer) const {
-                    return {wstd::forward<Outer>(outer), m_step, 0};
+                    return {std::forward<Outer>(outer), m_step, 0};
                 }
 
                 struct outer_most_cursor_f {
@@ -301,7 +301,7 @@ namespace gridtools {
                     template <class Ptr, class Strides>
                     void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
                         --m_pos;
-                        shift(wstd::forward<Ptr>(ptr), get_stride<Key>(strides), m_step);
+                        shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), m_step);
                     }
 
                     GT_FUNCTION bool done() const { return m_pos > 0; }
@@ -325,13 +325,13 @@ namespace gridtools {
                             m_fun(ptr, strides);
                             shift(ptr, stride, integral_constant<T, Step>{});
                         }
-                        shift(wstd::forward<Ptr>(ptr), stride, integral_constant<T, -Step * NumSteps>{});
+                        shift(std::forward<Ptr>(ptr), stride, integral_constant<T, -Step * NumSteps>{});
                     }
                 };
 
                 template <class Fun>
                 GT_CONSTEXPR GT_FUNCTION loop_f<Fun> operator()(Fun &&fun) const {
-                    return {wstd::forward<Fun>(fun)};
+                    return {std::forward<Fun>(fun)};
                 }
 
                 template <class Outer>
@@ -345,9 +345,9 @@ namespace gridtools {
                             constexpr T offset_back = Step * (1 - NumSteps);
                             shift(ptr, get_stride<Key>(strides), offset_back);
                             m_pos = 0;
-                            m_outer.next(wstd::forward<Ptr>(ptr), strides);
+                            m_outer.next(std::forward<Ptr>(ptr), strides);
                         } else {
-                            shift(wstd::forward<Ptr>(ptr), get_stride<Key>(strides), Step);
+                            shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), Step);
                         }
                     }
 
@@ -356,7 +356,7 @@ namespace gridtools {
 
                 template <class Outer>
                 GT_CONSTEXPR GT_FUNCTION cursor_f<Outer> make_cursor(Outer &&outer) const {
-                    return {wstd::forward<Outer>(outer), 0};
+                    return {std::forward<Outer>(outer), 0};
                 }
 
                 struct outer_most_cursor_f {
@@ -365,7 +365,7 @@ namespace gridtools {
                     template <class Ptr, class Strides>
                     void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
                         --m_pos;
-                        shift(wstd::forward<Ptr>(ptr), get_stride<Key>(strides), Step);
+                        shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), Step);
                     }
 
                     GT_FUNCTION bool done() const { return m_pos > 0; }
@@ -391,7 +391,7 @@ namespace gridtools {
 
                 template <class Fun>
                 GT_CONSTEXPR GT_FUNCTION loop_f<Fun> operator()(Fun &&fun) const {
-                    return {wstd::forward<Fun>(fun)};
+                    return {std::forward<Fun>(fun)};
                 }
 
                 template <class Outer>
@@ -403,7 +403,7 @@ namespace gridtools {
                     void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
                         if (++m_pos == NumSteps) {
                             m_pos = 0;
-                            m_outer.next(wstd::forward<Ptr>(ptr), strides);
+                            m_outer.next(std::forward<Ptr>(ptr), strides);
                         }
                     }
 
@@ -412,7 +412,7 @@ namespace gridtools {
 
                 template <class Outer>
                 GT_CONSTEXPR GT_FUNCTION cursor_f<Outer> make_cursor(Outer &&outer) const {
-                    return {wstd::forward<Outer>(outer), 0};
+                    return {std::forward<Outer>(outer), 0};
                 }
 
                 struct outer_most_cursor_f {
@@ -440,7 +440,7 @@ namespace gridtools {
 
                 template <class Outer>
                 GT_CONSTEXPR GT_FUNCTION Outer make_cursor(Outer &&outer) const {
-                    return wstd::forward<Outer>(outer);
+                    return std::forward<Outer>(outer);
                 }
 
                 struct outer_most_cursor_f {
@@ -462,7 +462,7 @@ namespace gridtools {
                 static_assert(std::is_signed<T>::value, GT_INTERNAL_ERROR);
 
                 template <class Fun>
-                GT_CONSTEXPR GT_FUNCTION gridtools::host_device::noop operator()(Fun &&) const {
+                GT_CONSTEXPR GT_FUNCTION noop operator()(Fun &&) const {
                     return {};
                 }
 
@@ -482,20 +482,20 @@ namespace gridtools {
             struct make_cursor_f {
                 template <class Cursor, class Loop>
                 GT_CONSTEXPR GT_FUNCTION auto operator()(Cursor &&cursor, Loop const &loop) const {
-                    return loop.make_cursor(wstd::forward<Cursor>(cursor));
+                    return loop.make_cursor(std::forward<Cursor>(cursor));
                 }
             };
 
             template <class Loops>
             GT_CONSTEXPR GT_FUNCTION auto make_cursor_r(Loops &&loops) {
-                return tuple_util::host_device::fold(make_cursor_f{},
-                    tuple_util::host_device::get<0>(wstd::forward<Loops>(loops)).make_cursor(),
-                    tuple_util::host_device::drop_front<1>(wstd::forward<Loops>(loops)));
+                return tuple_util::fold(make_cursor_f{},
+                    tuple_util::get<0>(std::forward<Loops>(loops)).make_cursor(),
+                    tuple_util::drop_front<1>(std::forward<Loops>(loops)));
             }
 
             template <class Loops>
             GT_CONSTEXPR GT_FUNCTION auto make_cursor(Loops &&loops) {
-                return make_cursor_r(tuple_util::host_device::reverse(wstd::forward<Loops>(loops)));
+                return make_cursor_r(tuple_util::reverse(std::forward<Loops>(loops)));
             }
 
             template <class Ptr, class Strides, class Cursor>
@@ -518,7 +518,7 @@ namespace gridtools {
             template <class Ptr, class Strides, class Cursor>
             GT_CONSTEXPR GT_FUNCTION range<Ptr, Strides const &, Cursor> make_range(
                 Ptr ptr, Strides const &strides, Cursor &&cursor) {
-                return {wstd::move(ptr), strides, wstd::forward<Cursor>(cursor)};
+                return {std::move(ptr), strides, std::forward<Cursor>(cursor)};
             }
         } // namespace loop_impl_
 
@@ -654,10 +654,10 @@ namespace gridtools {
         template <class Ptr, class Strides, class OuterMostLoop, class... Loops>
         GT_CONSTEXPR GT_FUNCTION auto make_range(
             Ptr ptr, Strides const &strides, OuterMostLoop &&outer_most_loop, Loops &&... loops) {
-            return loop_impl_::make_range(wstd::move(ptr),
+            return loop_impl_::make_range(std::move(ptr),
                 strides,
                 loop_impl_::make_cursor(tuple<OuterMostLoop, Loops...>{
-                    wstd::forward<OuterMostLoop>(outer_most_loop), wstd::forward<Loops>(loops)...}));
+                    std::forward<OuterMostLoop>(outer_most_loop), std::forward<Loops>(loops)...}));
         }
 
     } // namespace sid
diff --git a/include/gridtools/sid/multi_shift.hpp b/include/gridtools/sid/multi_shift.hpp
index d1db2a192d..af8585a13a 100644
--- a/include/gridtools/sid/multi_shift.hpp
+++ b/include/gridtools/sid/multi_shift.hpp
@@ -10,6 +10,7 @@
 #pragma once
 
 #include <type_traits>
+#include <utility>
 
 #include "../common/defs.hpp"
 #include "../common/host_device.hpp"
@@ -27,8 +28,7 @@ namespace gridtools {
                 template <class Ptr, class Strides, class Offsets>
                 GT_FUNCTION for_each_dim(Ptr &ptr, Strides const &strides, Offsets offsets) {
                     using array_t = int[sizeof...(Dims)];
-                    (void)array_t{
-                        (shift(ptr, get_stride<Dims>(strides), gridtools::host_device::at_key<Dims>(offsets)), 0)...};
+                    (void)array_t{(shift(ptr, get_stride<Dims>(strides), at_key<Dims>(offsets)), 0)...};
                 }
             };
 
@@ -45,19 +45,9 @@ namespace gridtools {
             struct for_each_dim_a<Arg, L<Dims...>> {
                 template <class Ptr, class Strides, class Offsets>
                 GT_FUNCTION for_each_dim_a(Ptr &ptr, Strides const &strides, Offsets offsets) {
-                    using array_t = int[sizeof...(Dims)];
-                    (void)array_t{(
-                        shift(
-                            ptr, get_stride_element<Arg, Dims>(strides), gridtools::host_device::at_key<Dims>(offsets)),
-                        0)...};
+                    (..., shift(ptr, get_stride_element<Arg, Dims>(strides), at_key<Dims>(offsets)));
                 }
             };
-
-            template <class Arg, template <class...> class L>
-            struct for_each_dim_a<Arg, L<>> {
-                template <class Ptr, class Strides, class Offsets>
-                GT_FUNCTION for_each_dim_a(Ptr &ptr, Strides const &strides, Offsets offsets) {}
-            };
         } // namespace multi_shift_impl_
 
         /**
@@ -66,12 +56,12 @@ namespace gridtools {
          */
         template <class Ptr, class Strides, class Offsets>
         GT_FUNCTION void multi_shift(Ptr &ptr, Strides const &strides, Offsets offsets) {
-            multi_shift_impl_::for_each_dim<get_keys<Offsets>>(ptr, strides, wstd::move(offsets));
+            multi_shift_impl_::for_each_dim<get_keys<Offsets>>(ptr, strides, std::move(offsets));
         }
 
         template <class Ptr, class Strides, class Offsets>
         GT_FUNCTION Ptr multi_shifted(Ptr ptr, Strides const &strides, Offsets offsets) {
-            multi_shift(ptr, strides, wstd::move(offsets));
+            multi_shift(ptr, strides, std::move(offsets));
             return ptr;
         }
 
@@ -80,12 +70,12 @@ namespace gridtools {
          */
         template <class Arg, class Ptr, class Strides, class Offsets>
         GT_FUNCTION void multi_shift(Ptr &ptr, Strides const &strides, Offsets offsets) {
-            multi_shift_impl_::for_each_dim_a<Arg, get_keys<Offsets>>(ptr, strides, wstd::move(offsets));
+            multi_shift_impl_::for_each_dim_a<Arg, get_keys<Offsets>>(ptr, strides, std::move(offsets));
         }
 
         template <class Arg, class Ptr, class Strides, class Offsets>
         GT_FUNCTION Ptr multi_shifted(Ptr ptr, Strides const &strides, Offsets offsets) {
-            multi_shift<Arg>(ptr, strides, wstd::move(offsets));
+            multi_shift<Arg>(ptr, strides, std::move(offsets));
             return ptr;
         }
     } // namespace sid
diff --git a/include/gridtools/sid/simple_ptr_holder.hpp b/include/gridtools/sid/simple_ptr_holder.hpp
index b07dabd7b7..db95f00996 100644
--- a/include/gridtools/sid/simple_ptr_holder.hpp
+++ b/include/gridtools/sid/simple_ptr_holder.hpp
@@ -7,48 +7,32 @@
  * Please, refer to the LICENSE file in the root directory.
  * SPDX-License-Identifier: BSD-3-Clause
  */
-#ifndef GT_TARGET_ITERATING
-// DON'T USE #pragma once HERE!!!
-#ifndef GT_SID_SIMPLE_PTR_HOLDER_HPP_
-#define GT_SID_SIMPLE_PTR_HOLDER_HPP_
+#pragma once
 
 #include <utility>
 
-#include "../common/defs.hpp"
 #include "../common/host_device.hpp"
 
-#define GT_FILENAME <gridtools/sid/simple_ptr_holder.hpp>
-#include GT_ITERATE_ON_TARGETS()
-#undef GT_FILENAME
-
-#endif
-#else
-
 namespace gridtools {
     namespace sid {
-        GT_TARGET_NAMESPACE {
-            template <class T>
-            struct simple_ptr_holder {
-                T m_val;
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR T const &operator()() const { return m_val; }
-            };
+        template <class T>
+        struct simple_ptr_holder {
+            T m_val;
+            simple_ptr_holder() = default;
 
-            template <class T>
-            constexpr simple_ptr_holder<T> make_simple_ptr_holder(T const &ptr) {
-                return {ptr};
-            }
+            GT_FORCE_INLINE constexpr simple_ptr_holder(T const& val) : m_val(val) {}
 
-            template <class T, class Arg>
-            constexpr auto operator+(simple_ptr_holder<T> const &obj, Arg &&arg) {
-                return make_simple_ptr_holder(obj.m_val + std::forward<Arg>(arg));
-            }
+            GT_FORCE_INLINE constexpr T const &operator()() const { return m_val; }
+        };
 
-            template <class T, class Arg>
-            constexpr auto operator+(simple_ptr_holder<T> &&obj, Arg &&arg) {
-                return make_simple_ptr_holder(std::move(obj).m_val + std::forward<Arg>(arg));
-            }
+        template <class T, class Arg>
+        constexpr auto operator+(simple_ptr_holder<T> const &obj, Arg &&arg) {
+            return simple_ptr_holder(obj.m_val + std::forward<Arg>(arg));
+        }
+
+        template <class T, class Arg>
+        constexpr auto operator+(simple_ptr_holder<T> &&obj, Arg &&arg) {
+            return simple_ptr_holder(std::move(obj.m_val) + std::forward<Arg>(arg));
         }
     } // namespace sid
 } // namespace gridtools
-
-#endif
diff --git a/include/gridtools/stencil/be_api.hpp b/include/gridtools/stencil/be_api.hpp
index 2f90f9d64a..2a48a1d2f0 100644
--- a/include/gridtools/stencil/be_api.hpp
+++ b/include/gridtools/stencil/be_api.hpp
@@ -192,7 +192,7 @@ namespace gridtools {
 
                 template <class Deref = void, class Ptr, class Strides>
                 GT_FUNCTION void operator()(Ptr const &ptr, Strides const &strides) const {
-                    host_device::for_each<Funs>(run_f<Deref, Ptr, Strides>{ptr, strides});
+                    for_each<Funs>(run_f<Deref, Ptr, Strides>{ptr, strides});
                 }
 
                 template <class Ptr, class Strides>
diff --git a/include/gridtools/stencil/cpu_kfirst.hpp b/include/gridtools/stencil/cpu_kfirst.hpp
index 0a743a5542..0f1d9e4658 100644
--- a/include/gridtools/stencil/cpu_kfirst.hpp
+++ b/include/gridtools/stencil/cpu_kfirst.hpp
@@ -97,7 +97,7 @@ namespace gridtools {
                 DataStores external_data_stores) {
                 using stages_t = be_api::make_split_view<Spec>;
 
-                auto alloc = sid::make_cached_allocator(&std::make_unique<char[]>);
+                auto alloc = sid::cached_allocator(&std::make_unique<char[]>);
 
                 using tmp_plh_map_t = be_api::remove_caches_from_plh_map<typename stages_t::tmp_plh_map_t>;
                 auto temporaries = be_api::make_data_stores(tmp_plh_map_t(), [&grid, &alloc](auto info) {
diff --git a/include/gridtools/stencil/frontend/cartesian/stage.hpp b/include/gridtools/stencil/frontend/cartesian/stage.hpp
index 84a84581f5..0ea463f6ba 100644
--- a/include/gridtools/stencil/frontend/cartesian/stage.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/stage.hpp
@@ -57,8 +57,8 @@ namespace gridtools {
                     template <class Accessor>
                     GT_FUNCTION decltype(auto) operator()(Accessor acc) const {
                         using key_t = meta::at_c<Keys, Accessor::index_t::value>;
-                        return apply_intent<Accessor::intent_v>(Deref()(key_t(),
-                            sid::multi_shifted<key_t>(host_device::at_key<key_t>(m_ptr), m_strides, wstd::move(acc))));
+                        return apply_intent<Accessor::intent_v>(Deref()(
+                            key_t(), sid::multi_shifted<key_t>(at_key<key_t>(m_ptr), m_strides, wstd::move(acc))));
                     }
 
                     template <class Op, class... Ts>
diff --git a/include/gridtools/stencil/frontend/cartesian/stencil_functions.hpp b/include/gridtools/stencil/frontend/cartesian/stencil_functions.hpp
index 7ea2bcb74f..6e774dd79a 100644
--- a/include/gridtools/stencil/frontend/cartesian/stencil_functions.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/stencil_functions.hpp
@@ -43,16 +43,15 @@ namespace gridtools {
 
                     template <class Lhs, class Rhs>
                     GT_FUNCTION auto operator()(Lhs &&lhs, Rhs &&rhs) const {
-                        return host_device::at_key_with_default<Key, default_t>(wstd::forward<Lhs>(lhs)) +
-                               host_device::at_key_with_default<Key, default_t>(wstd::forward<Rhs>(rhs));
+                        return at_key_with_default<Key, default_t>(wstd::forward<Lhs>(lhs)) +
+                               at_key_with_default<Key, default_t>(wstd::forward<Rhs>(rhs));
                     }
                 };
 
                 template <class Res, class Lhs, class Rhs>
                 GT_FUNCTION Res sum_offsets(Lhs &&lhs, Rhs rhs) {
                     using generators_t = meta::transform<sum_offset_generator_f, get_keys<Res>>;
-                    return tuple_util::host_device::generate<generators_t, Res>(
-                        wstd::forward<Lhs>(lhs), wstd::move(rhs));
+                    return tuple_util::generate<generators_t, Res>(wstd::forward<Lhs>(lhs), wstd::move(rhs));
                 }
 
                 template <int_t I, int_t J, int_t K, class Accessor>
@@ -84,8 +83,7 @@ namespace gridtools {
                             int> = 0>
                     GT_FUNCTION decltype(auto) operator()(Accessor acc) const {
                         return m_eval(sum_offsets<Arg>(
-                            get_offsets<I, J, K>(tuple_util::host_device::get<Accessor::index_t::value>(m_args)),
-                            std::move(acc)));
+                            get_offsets<I, J, K>(tuple_util::get<Accessor::index_t::value>(m_args)), std::move(acc)));
                     }
 
                     template <class Accessor,
@@ -96,7 +94,7 @@ namespace gridtools {
                                                  std::is_const<std::remove_reference_t<Arg>>::value),
                             int> = 0>
                     GT_FUNCTION decltype(auto) operator()(Accessor) const {
-                        return tuple_util::host_device::get<Accessor::index_t::value>(m_args);
+                        return tuple_util::get<Accessor::index_t::value>(m_args);
                     }
 
                     template <class Op, class... Ts>
@@ -189,11 +187,10 @@ namespace gridtools {
                     class Res =
                         typename call_interfaces_impl_::get_result_type<Eval, ReturnType, std::decay_t<Args>...>::type,
                     std::enable_if_t<sizeof...(Args) + 1 == meta::length<params_t>::value, int> = 0>
-                GT_FUNCTION static Res with(Eval &eval, Args &&... args) {
+                GT_FUNCTION static Res with(Eval &eval, Args &&...args) {
                     Res res;
                     call_interfaces_impl_::evaluate_bound_functor<Functor, Region, OffI, OffJ, OffK>(eval,
-                        tuple_util::host_device::insert<out_param_index>(
-                            res, tuple<Args &&...>{wstd::forward<Args>(args)...}));
+                        tuple_util::insert<out_param_index>(res, tuple<Args &&...>{wstd::forward<Args>(args)...}));
                     return res;
                 }
             };
@@ -235,7 +232,7 @@ namespace gridtools {
                 template <class Eval, class... Args>
                 GT_FUNCTION static std::enable_if_t<sizeof...(Args) ==
                                                     meta::length<typename Functor::param_list>::value>
-                with(Eval &eval, Args &&... args) {
+                with(Eval &eval, Args &&...args) {
                     call_interfaces_impl_::evaluate_bound_functor<Functor, Region, OffI, OffJ, OffK>(
                         eval, tuple<Args &&...>{wstd::forward<Args>(args)...});
                 }
diff --git a/include/gridtools/stencil/frontend/icosahedral/stage.hpp b/include/gridtools/stencil/frontend/icosahedral/stage.hpp
index 172b88a834..7d1ec81fde 100644
--- a/include/gridtools/stencil/frontend/icosahedral/stage.hpp
+++ b/include/gridtools/stencil/frontend/icosahedral/stage.hpp
@@ -73,8 +73,8 @@ namespace gridtools {
 
                     template <class Key, class Offset>
                     GT_FUNCTION decltype(auto) get_ref(Offset offset) const {
-                        return Deref()(Key(),
-                            sid::multi_shifted<Key>(host_device::at_key<Key>(m_ptr), m_strides, wstd::move(offset)));
+                        return Deref()(
+                            Key(), sid::multi_shifted<Key>(at_key<Key>(m_ptr), m_strides, wstd::move(offset)));
                     }
 
                     template <class Accessor>
@@ -97,7 +97,7 @@ namespace gridtools {
                             std::conjunction<
                                 std::is_same<typename Accessor::location_t, typename Accessors::location_t>...>::value,
                             "All accessors should be of the same location");
-                        host_device::for_each<neighbor_offsets<LocationType, typename Accessor::location_t, Color>>(
+                        for_each<neighbor_offsets<LocationType, typename Accessor::location_t, Color>>(
                             [&](auto offset) { fun(neighbor(Accessor(), offset), neighbor(Accessors(), offset)...); });
                     }
                 };
@@ -109,7 +109,7 @@ namespace gridtools {
                     template <class Deref = void, class Ptr, class Strides>
                     GT_FUNCTION void operator()(Ptr const &ptr, Strides const &strides) const {
                         using deref_t = meta::if_<std::is_void<Deref>, default_deref_f, Deref>;
-                        host_device::for_each<meta::make_indices<location_t>>([&](auto color) {
+                        for_each<meta::make_indices<location_t>>([&](auto color) {
                             using eval_t = evaluator<Ptr, Strides, PlhMap, deref_t, location_t, decltype(color)::value>;
                             Functor::apply(eval_t{ptr, strides});
                         });
diff --git a/include/gridtools/stencil/gpu/entry_point.hpp b/include/gridtools/stencil/gpu/entry_point.hpp
index 67fcf4c8d8..bd38185f38 100644
--- a/include/gridtools/stencil/gpu/entry_point.hpp
+++ b/include/gridtools/stencil/gpu/entry_point.hpp
@@ -53,7 +53,7 @@ namespace gridtools {
 
                 template <class Validator>
                 GT_FUNCTION_DEVICE void operator()(int_t i_block, int_t j_block, Validator const &validator) const {
-                    (void)(int[]){(tuple_util::device::get<Is>(m_funs)(i_block, j_block, validator), 0)...};
+                    (void)(int[]){(tuple_util::get<Is>(m_funs)(i_block, j_block, validator), 0)...};
                 }
             };
 
@@ -243,7 +243,7 @@ namespace gridtools {
 
                 template <class Msses, class Grid, class DataStores>
                 static void entry_point(Grid const &grid, DataStores external_data_stores) {
-                    auto cuda_alloc = sid::device::make_cached_allocator(&cuda_util::cuda_malloc<char[]>);
+                    auto cuda_alloc = sid::cached_allocator(&cuda_util::cuda_malloc<char[]>);
                     auto data_stores = hymap::concat(
                         block(std::move(external_data_stores)), make_temporaries<Msses>(grid, cuda_alloc));
                     using const_keys_t =
diff --git a/include/gridtools/stencil/gpu/fill_flush.hpp b/include/gridtools/stencil/gpu/fill_flush.hpp
index d138f7a893..21c28ffe16 100644
--- a/include/gridtools/stencil/gpu/fill_flush.hpp
+++ b/include/gridtools/stencil/gpu/fill_flush.hpp
@@ -65,7 +65,7 @@ namespace gridtools {
 
                     template <class Ptrs>
                     GT_FUNCTION int_t get_k_pos(Ptrs const &ptrs) {
-                        return *host_device::at_key<meta::list<k_pos_key>>(ptrs);
+                        return *at_key<meta::list<k_pos_key>>(ptrs);
                     }
 
                     template <class PlhInfo, class Ptr, class Strides, class Offset>
@@ -81,12 +81,12 @@ namespace gridtools {
 
                     template <class PlhInfo, class Ptrs>
                     GT_FUNCTION auto get_orig(Ptrs const &ptrs) {
-                        return host_device::at_key<meta::list<typename PlhInfo::plh_t>>(ptrs);
+                        return at_key<meta::list<typename PlhInfo::plh_t>>(ptrs);
                     }
 
                     template <class PlhInfo, class Ptrs>
                     GT_FUNCTION auto get_cached(Ptrs const &ptrs) {
-                        return host_device::at_key<typename PlhInfo::key_t>(ptrs);
+                        return at_key<typename PlhInfo::key_t>(ptrs);
                     }
 
                     template <class PlhInfo,
@@ -130,7 +130,7 @@ namespace gridtools {
                             using namespace literals;
                             auto orig = get_orig<PlhInfo>(ptrs);
                             auto cached = get_cached<PlhInfo>(ptrs);
-                            auto lim = *host_device::at_key<bound_key_t>(ptrs);
+                            auto lim = *at_key<bound_key_t>(ptrs);
 
                             using from_t = meta::if_c<Range == range::plus,
                                 typename PlhInfo::extent_t::kplus,
@@ -138,7 +138,7 @@ namespace gridtools {
 
                             shift_orig<PlhInfo>(orig, strides, from_t());
                             shift_cached<PlhInfo>(cached, strides, from_t());
-                            int_t k = *host_device::at_key<pos_key_t>(ptrs) + from_t::value;
+                            int_t k = *at_key<pos_key_t>(ptrs) + from_t::value;
 
                             static constexpr int_t size = Range == range::all ? PlhInfo::extent_t::kplus::value -
                                                                                     PlhInfo::extent_t::kminus::value + 1
@@ -258,14 +258,15 @@ namespace gridtools {
                             !sync_all || std::is_same<meta::first<CurInterval>, meta::second<CurInterval>>::value,
                             "offset_limit too small");
 
-                        static constexpr range range_v =
-                            minus == plus ? range::minus
-                                          : sync_all ? range::all : is_forward == is_fill ? range::plus : range::minus;
+                        static constexpr range range_v = minus == plus           ? range::minus
+                                                         : sync_all              ? range::all
+                                                         : is_forward == is_fill ? range::plus
+                                                                                 : range::minus;
 
-                        static constexpr check check_v =
-                            minus == plus || PlhInfo::is_tmp_t::value
-                                ? check::none
-                                : close_to_first ? check::lo : close_to_last ? check::hi : check::none;
+                        static constexpr check check_v = minus == plus || PlhInfo::is_tmp_t::value ? check::none
+                                                         : close_to_first                          ? check::lo
+                                                         : close_to_last                           ? check::hi
+                                                                                                   : check::none;
 
                         using type = sync_fun<PlhInfo, range_v, check_v>;
                     };
diff --git a/include/gridtools/stencil/gpu/k_cache.hpp b/include/gridtools/stencil/gpu/k_cache.hpp
index 664906204d..a30c91fe05 100644
--- a/include/gridtools/stencil/gpu/k_cache.hpp
+++ b/include/gridtools/stencil/gpu/k_cache.hpp
@@ -62,13 +62,13 @@ namespace gridtools {
 
                   public:
                     GT_FUNCTION_DEVICE auto ptr() {
-                        return tuple_util::device::transform(
+                        return tuple_util::transform(
                             [](auto &storage) GT_FORCE_INLINE_LAMBDA { return storage.ptr(); }, m_storages);
                     }
 
                     template <class Step>
                     GT_FUNCTION_DEVICE void slide(Step step) {
-                        tuple_util::device::for_each(
+                        tuple_util::for_each(
                             [step](auto &storage) GT_FORCE_INLINE_LAMBDA { storage.slide(step); }, m_storages);
                     }
                 };
diff --git a/include/gridtools/stencil/gpu/make_kernel_fun.hpp b/include/gridtools/stencil/gpu/make_kernel_fun.hpp
index 1dc21a2dd0..e879b38070 100644
--- a/include/gridtools/stencil/gpu/make_kernel_fun.hpp
+++ b/include/gridtools/stencil/gpu/make_kernel_fun.hpp
@@ -33,7 +33,7 @@ namespace gridtools {
                 template <class Deref, class Info, class Ptr, class Strides, class Validator>
                 GT_FUNCTION_DEVICE void exec_cells(
                     Info, Ptr const &ptr, Strides const &strides, Validator const &validator) {
-                    device::for_each<typename Info::cells_t>([&](auto cell) GT_FORCE_INLINE_LAMBDA {
+                    for_each<typename Info::cells_t>([&](auto cell) {
                         syncthreads(cell.need_sync());
                         if (validator(cell.extent()))
                             cell.template operator()<Deref>(ptr, strides);
@@ -54,8 +54,8 @@ namespace gridtools {
                     template <class Ptr, class Strides, class Validator>
                     GT_FUNCTION_DEVICE void operator()(Ptr ptr, Strides const &strides, Validator validator) const {
                         k_caches_type<Mss> k_caches;
-                        auto mixed_ptr = hymap::device::merge(k_caches.ptr(), wstd::move(ptr));
-                        tuple_util::device::for_each(
+                        auto mixed_ptr = hymap::merge(k_caches.ptr(), wstd::move(ptr));
+                        tuple_util::for_each(
                             [&](const int_t size, auto info) GT_FORCE_INLINE_LAMBDA {
 #ifdef __HIPCC__
 // unroll factor estimate based on GT perftests on AMD Mi50
@@ -80,7 +80,7 @@ namespace gridtools {
 
                     template <class Ptr, class Strides, class Validator>
                     GT_FUNCTION_DEVICE void operator()(Ptr ptr, Strides const &strides, Validator validator) const {
-                        tuple_util::device::for_each(
+                        tuple_util::for_each(
                             [&](const int_t size, auto info) GT_FORCE_INLINE_LAMBDA {
 #ifdef __HIPCC__
 // unroll factor estimate based on GT perftests on AMD Mi50
@@ -106,7 +106,7 @@ namespace gridtools {
                     GT_FUNCTION_DEVICE void operator()(Ptr ptr, Strides const &strides, Validator validator) const {
                         int_t cur = -(int_t)blockIdx.z * BlockSize;
                         sid::shift(ptr, sid::get_stride<dim::k>(strides), -cur);
-                        tuple_util::device::for_each(
+                        tuple_util::for_each(
                             [&](int_t size, auto info) GT_FORCE_INLINE_LAMBDA {
                                 if (cur >= BlockSize)
                                     return;
diff --git a/include/gridtools/stencil/gpu_horizontal/entry_point.hpp b/include/gridtools/stencil/gpu_horizontal/entry_point.hpp
index e5bb3a0502..3020966637 100644
--- a/include/gridtools/stencil/gpu_horizontal/entry_point.hpp
+++ b/include/gridtools/stencil/gpu_horizontal/entry_point.hpp
@@ -71,7 +71,7 @@ namespace gridtools {
 
                     using j_caches_t = j_caches_type<Info>;
                     j_caches_t j_caches;
-                    auto mixed_ptr = hymap::device::merge(j_caches.ptr(), wstd::move(ptr));
+                    auto mixed_ptr = hymap::merge(j_caches.ptr(), wstd::move(ptr));
 
                     auto shift_mixed_ptr = [&](auto dim, auto offset) {
                         sid::shift(mixed_ptr.secondary(), sid::get_stride<decltype(dim)>(strides), offset);
@@ -80,7 +80,7 @@ namespace gridtools {
 
 #pragma unroll
                     for (int_t j = decltype(j_start)::value; j < JBlockSize; ++j) {
-                        device::for_each<typename Info::cells_t>([&](auto cell) GT_FORCE_INLINE_LAMBDA {
+                        for_each<typename Info::cells_t>([&](auto cell) {
                             using cell_t = decltype(cell);
                             using extent_t = typename cell_t::extent_t;
                             constexpr auto j_offset = typename extent_t::jplus();
@@ -109,7 +109,7 @@ namespace gridtools {
                 GT_FUNCTION_DEVICE void operator()(Ptr ptr, Strides const &strides, Validator validator) const {
                     int_t cur = -(int_t)blockIdx.z * KBlockSize;
                     sid::shift(ptr, sid::get_stride<dim::k>(strides), -cur);
-                    tuple_util::device::for_each(
+                    tuple_util::for_each(
                         [&](int_t size, auto info) GT_FORCE_INLINE_LAMBDA {
                             if (cur >= KBlockSize)
                                 return;
@@ -140,7 +140,7 @@ namespace gridtools {
                     sid::shift(ptr, sid::get_stride<sid::blocked_dim<dim::i>>(m_strides), blockIdx.x);
                     sid::shift(ptr, sid::get_stride<sid::blocked_dim<dim::j>>(m_strides), blockIdx.y);
                     sid::shift(ptr, sid::get_stride<dim::i>(m_strides), i_block);
-                    k_loop(wstd::move(ptr), m_strides, wstd::move(validator));
+                    k_loop(std::move(ptr), m_strides, std::move(validator));
                 }
             };
 
diff --git a/include/gridtools/stencil/gpu_horizontal/j_cache.hpp b/include/gridtools/stencil/gpu_horizontal/j_cache.hpp
index d29e0de221..1a4b90067c 100644
--- a/include/gridtools/stencil/gpu_horizontal/j_cache.hpp
+++ b/include/gridtools/stencil/gpu_horizontal/j_cache.hpp
@@ -90,20 +90,19 @@ namespace gridtools {
 
                   public:
                     GT_FUNCTION_DEVICE auto ptr() {
-                        return tuple_util::device::transform(
+                        return tuple_util::transform(
                             [](auto &storage) GT_FORCE_INLINE_LAMBDA { return storage.ptr(); }, m_storages);
                     }
 
                     GT_FUNCTION_DEVICE void slide() {
-                        tuple_util::device::for_each(
-                            [](auto &storage) GT_FORCE_INLINE_LAMBDA { storage.slide(); }, m_storages);
+                        tuple_util::for_each([](auto &storage) GT_FORCE_INLINE_LAMBDA { storage.slide(); }, m_storages);
                     }
 
                     template <class Ptr, class Dim, class Offset>
                     static GT_FUNCTION_DEVICE void shift(Dim, Ptr &ptr, Offset offset) {
                         using strides_t =
                             meta::rename<tuple, meta::transform<get_stride_f<Dim>::template apply, Storages>>;
-                        tuple_util::device::for_each(
+                        tuple_util::for_each(
                             [offset](auto &ptr, auto stride) { sid::shift(ptr, stride, offset); }, ptr, strides_t());
                     }
                 };
diff --git a/include/gridtools/stencil/naive.hpp b/include/gridtools/stencil/naive.hpp
index c114070113..958a52d8f5 100644
--- a/include/gridtools/stencil/naive.hpp
+++ b/include/gridtools/stencil/naive.hpp
@@ -32,7 +32,7 @@ namespace gridtools {
         struct naive {
             template <class Spec, class Grid, class DataStores>
             friend void gridtools_backend_entry_point(naive, Spec, Grid const &grid, DataStores external_data_stores) {
-                auto alloc = sid::host_device::make_allocator(&std::make_unique<char[]>);
+                auto alloc = sid::allocator(&std::make_unique<char[]>);
                 using stages_t = be_api::make_split_view<Spec>;
                 using tmp_plh_map_t = be_api::remove_caches_from_plh_map<typename stages_t::tmp_plh_map_t>;
                 auto temporaries = be_api::make_data_stores(tmp_plh_map_t(), [&](auto info) {
diff --git a/include/gridtools/stencil/positional.hpp b/include/gridtools/stencil/positional.hpp
index fa033dedc1..188154fc06 100644
--- a/include/gridtools/stencil/positional.hpp
+++ b/include/gridtools/stencil/positional.hpp
@@ -23,14 +23,14 @@ namespace gridtools {
         struct positional {
             int_t m_val;
 
-            GT_FUNCTION positional(int_t val = 0) : m_val{val} {}
+            GT_FORCE_INLINE constexpr positional(int_t val = 0) : m_val{val} {}
 
-            GT_FUNCTION int operator*() const { return m_val; }
-            GT_FUNCTION positional const &operator()() const { return *this; }
+            GT_FORCE_INLINE constexpr int operator*() const { return m_val; }
+            GT_FORCE_INLINE constexpr positional const &operator()() const { return *this; }
         };
 
         template <class Dim>
-        GT_FUNCTION positional<Dim> operator+(positional<Dim> lhs, positional<Dim> rhs) {
+        GT_FORCE_INLINE constexpr positional<Dim> operator+(positional<Dim> lhs, positional<Dim> rhs) {
             return {lhs.m_val + rhs.m_val};
         }
 
@@ -40,7 +40,7 @@ namespace gridtools {
         }
 
         template <class Dim>
-        GT_FUNCTION void sid_shift(positional<Dim> &p, positional_stride, int_t offset) {
+        GT_FORCE_INLINE constexpr void sid_shift(positional<Dim> &p, positional_stride, int_t offset) {
             p.m_val += offset;
         }
 
diff --git a/include/gridtools/storage/info.hpp b/include/gridtools/storage/info.hpp
index 19417a5c80..de66df1187 100644
--- a/include/gridtools/storage/info.hpp
+++ b/include/gridtools/storage/info.hpp
@@ -13,6 +13,7 @@
 #include <cassert>
 #include <cstddef>
 #include <type_traits>
+#include <utility>
 
 #include "../common/array.hpp"
 #include "../common/defs.hpp"
@@ -98,20 +99,20 @@ namespace gridtools {
                 info(Lengths lengths, Strides strides)
                     : tuple<Lengths, Strides>{std::move(lengths), std::move(strides)} {}
 
-                GT_FUNCTION auto const &native_lengths() const { return tuple_util::host_device::get<0>(base()); }
-                GT_FUNCTION auto const &native_strides() const { return tuple_util::host_device::get<1>(base()); }
+                GT_FUNCTION auto const &native_lengths() const { return tuple_util::get<0>(base()); }
+                GT_FUNCTION auto const &native_strides() const { return tuple_util::get<1>(base()); }
                 GT_FUNCTION int length() const {
-                    using tuple_util::host_device::get;
+                    using tuple_util::get;
                     bool is_empty = false;
                     for (auto empty_dim : {(get<Dims>(native_lengths()) == 0)...})
                         is_empty = is_empty || empty_dim;
                     return is_empty ? 0 : index((get<Dims>(native_lengths()) - integral_constant<int_t, 1>())...) + 1;
                 }
                 GT_FUNCTION array<uint_t, ndims> lengths() const {
-                    return {(uint_t)tuple_util::host_device::get<Dims>(native_lengths())...};
+                    return {(uint_t)tuple_util::get<Dims>(native_lengths())...};
                 }
                 GT_FUNCTION array<uint_t, ndims> strides() const {
-                    return {(uint_t)tuple_util::host_device::get<Dims>(native_strides())...};
+                    return {(uint_t)tuple_util::get<Dims>(native_strides())...};
                 }
 
                 template <class... Is,
@@ -124,9 +125,9 @@ namespace gridtools {
 
                 template <class Indices>
                 GT_FUNCTION auto index_from_tuple(Indices &&indices) const {
-                    using namespace tuple_util::host_device;
+                    using namespace tuple_util;
 #ifndef NDEBUG
-                    tuple_util::host_device::for_each(
+                    tuple_util::for_each(
                         [](int index, int length) {
                             assert(index >= 0);
                             assert(index < length);
@@ -136,7 +137,7 @@ namespace gridtools {
 #endif
                     return fold([](auto l, auto r) { return l + r; },
                         transform(
-                            [](auto i, auto s) { return i * s; }, wstd::forward<Indices>(indices), native_strides()));
+                            [](auto i, auto s) { return i * s; }, std::forward<Indices>(indices), native_strides()));
                 }
             };
 
diff --git a/tests/unit_tests/common/test_for_each.cpp b/tests/unit_tests/common/test_for_each.cpp
index 6eeb755f30..73bc9525c1 100644
--- a/tests/unit_tests/common/test_for_each.cpp
+++ b/tests/unit_tests/common/test_for_each.cpp
@@ -15,15 +15,13 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-#include <gridtools/common/host_device.hpp>
-
 namespace gridtools {
 
     struct f {
         int *&dst;
 
         template <class T>
-        GT_FUNCTION_WARNING void operator()(T) const {
+        void operator()(T) const {
             *(dst++) = T::value;
         }
     };
@@ -64,11 +62,4 @@ namespace gridtools {
         }
         static_assert(foo() == 2, "");
     } // namespace test_constexpr
-
-    TEST(for_each, targets) {
-        int *ptr = nullptr;
-        for_each<lst<>>(f{ptr});
-        host::for_each<lst<>>(f{ptr});
-        host_device::for_each<lst<>>(f{ptr});
-    }
 } // namespace gridtools
diff --git a/tests/unit_tests/common/test_tuple.cpp b/tests/unit_tests/common/test_tuple.cpp
index 0cf3c4ceda..73b3befb91 100644
--- a/tests/unit_tests/common/test_tuple.cpp
+++ b/tests/unit_tests/common/test_tuple.cpp
@@ -55,7 +55,7 @@ namespace gridtools {
         static_assert(std::is_same<tuple_util::element<1, tuple<int, char, double, char>>, char>(), "");
         static_assert(std::is_same<tuple_util::element<0, tuple<int>>, int>(), "");
 
-        using tuple_util::host_device::get;
+        using tuple_util::get;
 
         TEST(tuple, get) {
             tuple<int, double, an_empty<59>> testee;
diff --git a/tests/unit_tests/common/test_tuple.cu b/tests/unit_tests/common/test_tuple.cu
index 97a9ce011d..9968c4c930 100644
--- a/tests/unit_tests/common/test_tuple.cu
+++ b/tests/unit_tests/common/test_tuple.cu
@@ -21,16 +21,16 @@
 namespace gridtools {
     TEST(tuple, get) {
         tuple<int, double> src{42, 2.5};
-        EXPECT_EQ(42, on_device::exec(tuple_util::host_device::get_nth_f<0>{}, src));
-        EXPECT_EQ(2.5, on_device::exec(tuple_util::host_device::get_nth_f<1>{}, src));
+        EXPECT_EQ(42, on_device::exec(tuple_util::get_nth_f<0>{}, src));
+        EXPECT_EQ(2.5, on_device::exec(tuple_util::get_nth_f<1>{}, src));
     }
 
     __device__ tuple<int, double> element_wise_ctor(int x, double y) { return {x, y}; }
 
     TEST(tuple, element_wise_ctor) {
         tuple<int, double> testee = on_device::exec(GT_MAKE_INTEGRAL_CONSTANT_FROM_VALUE(&element_wise_ctor), 42, 2.5);
-        EXPECT_EQ(42, tuple_util::host::get<0>(testee));
-        EXPECT_EQ(2.5, tuple_util::host::get<1>(testee));
+        EXPECT_EQ(42, tuple_util::get<0>(testee));
+        EXPECT_EQ(2.5, tuple_util::get<1>(testee));
     }
 
 #if defined(__clang__) && (__clang_major__ == 11 && __clang_minor__ == 0 && __clang_patchlevel__ == 0)
@@ -41,8 +41,8 @@ namespace gridtools {
     TEST(tuple, element_wise_conversion_ctor) {
         tuple<int, double> testee =
             on_device::exec(GT_MAKE_INTEGRAL_CONSTANT_FROM_VALUE(&element_wise_conversion_ctor), 'a', 'b');
-        EXPECT_EQ('a', tuple_util::host::get<0>(testee));
-        EXPECT_EQ('b', tuple_util::host::get<1>(testee));
+        EXPECT_EQ('a', tuple_util::get<0>(testee));
+        EXPECT_EQ('b', tuple_util::get<1>(testee));
     }
 
     __device__ tuple<int, double> tuple_conversion_ctor(tuple<char, char> const &src) { return src; }
@@ -50,8 +50,8 @@ namespace gridtools {
     TEST(tuple, tuple_conversion_ctor) {
         tuple<int, double> testee =
             on_device::exec(GT_MAKE_INTEGRAL_CONSTANT_FROM_VALUE(&tuple_conversion_ctor), tuple<char, char>{'a', 'b'});
-        EXPECT_EQ('a', tuple_util::host::get<0>(testee));
-        EXPECT_EQ('b', tuple_util::host::get<1>(testee));
+        EXPECT_EQ('a', tuple_util::get<0>(testee));
+        EXPECT_EQ('b', tuple_util::get<1>(testee));
     }
 #endif
 } // namespace gridtools
diff --git a/tests/unit_tests/common/test_tuple_util.cpp b/tests/unit_tests/common/test_tuple_util.cpp
index e7de8a1e52..5563c84e34 100644
--- a/tests/unit_tests/common/test_tuple_util.cpp
+++ b/tests/unit_tests/common/test_tuple_util.cpp
@@ -113,7 +113,7 @@ namespace gridtools {
 
         TEST(transform, gt_array) {
             auto src = gridtools::array{42, 5};
-            auto res = host_device::transform(add_2_f{}, src);
+            auto res = transform(add_2_f{}, src);
             static_assert(std::is_same<decltype(res), decltype(src)>{}, "");
             EXPECT_THAT(res, testing::ElementsAre(44, 7));
         }
diff --git a/tests/unit_tests/fn/test_fn_scan.cpp b/tests/unit_tests/fn/test_fn_scan.cpp
index 9a2abc5fa0..8c2161b94d 100644
--- a/tests/unit_tests/fn/test_fn_scan.cpp
+++ b/tests/unit_tests/fn/test_fn_scan.cpp
@@ -56,10 +56,10 @@ namespace gridtools::fn {
             column_t b = {1, 2, 3, 4, 5};
             auto composite = sid::composite::keys<integral_constant<int, 0>, integral_constant<int, 1>>::make_values(
                 sid::synthetic()
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&a[0]))
+                    .set<property::origin>(sid::simple_ptr_holder(&a[0]))
                     .set<property::strides>(tuple(1_c)),
                 sid::synthetic()
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&b[0]))
+                    .set<property::origin>(sid::simple_ptr_holder(&b[0]))
                     .set<property::strides>(tuple(1_c)));
             auto ptr = sid::get_origin(composite)();
             auto strides = sid::get_strides(composite);
diff --git a/tests/unit_tests/fn/test_fn_scan.cu b/tests/unit_tests/fn/test_fn_scan.cu
index 76315043b6..fd9a9bcc3e 100644
--- a/tests/unit_tests/fn/test_fn_scan.cu
+++ b/tests/unit_tests/fn/test_fn_scan.cu
@@ -31,9 +31,7 @@ namespace gridtools::fn {
         };
         struct make_iterator_mock {
             GT_FUNCTION auto operator()() const {
-                return [](auto tag, auto const &ptr, auto const &strides) {
-                    return host_device::at_key<decltype(tag)>(ptr);
-                };
+                return [](auto tag, auto const &ptr, auto const &strides) { return at_key<decltype(tag)>(ptr); };
             }
         };
 
@@ -52,10 +50,10 @@ namespace gridtools::fn {
             cudaMemcpy(b.get(), bh, 5 * sizeof(int), cudaMemcpyHostToDevice);
             auto composite = sid::composite::keys<integral_constant<int, 0>, integral_constant<int, 1>>::make_values(
                 sid::synthetic()
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(a.get()))
+                    .set<property::origin>(sid::simple_ptr_holder(a.get()))
                     .set<property::strides>(tuple(1_c)),
                 sid::synthetic()
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(b.get()))
+                    .set<property::origin>(sid::simple_ptr_holder(b.get()))
                     .set<property::strides>(tuple(1_c)));
             auto ptr = sid::get_origin(composite)();
             auto strides = sid::get_strides(composite);
diff --git a/tests/unit_tests/sid/test_sid_as_const.cpp b/tests/unit_tests/sid/test_sid_as_const.cpp
index a32c90b8ed..93e4cf8d56 100644
--- a/tests/unit_tests/sid/test_sid_as_const.cpp
+++ b/tests/unit_tests/sid/test_sid_as_const.cpp
@@ -24,7 +24,7 @@ namespace gridtools {
 
         TEST(as_const, smoke) {
             double data = 42;
-            auto src = sid::synthetic().set<property::origin>(sid::host_device::make_simple_ptr_holder(&data));
+            auto src = sid::synthetic().set<property::origin>(sid::simple_ptr_holder(&data));
             auto testee = sid::as_const(src);
             using testee_t = decltype(testee);
 
diff --git a/tests/unit_tests/sid/test_sid_composite.cpp b/tests/unit_tests/sid/test_sid_composite.cpp
index 7e491649d0..6bf1fd6a2f 100644
--- a/tests/unit_tests/sid/test_sid_composite.cpp
+++ b/tests/unit_tests/sid/test_sid_composite.cpp
@@ -50,9 +50,8 @@ namespace gridtools {
 #endif
             double const src = 42;
             double dst = 0;
-            sid::composite::keys<a, b>::values(
-                sid::synthetic().set<property::origin>(sid::host_device::make_simple_ptr_holder(&src)),
-                sid::synthetic().set<property::origin>(sid::host_device::make_simple_ptr_holder(&dst)));
+            sid::composite::keys<a, b>::values(sid::synthetic().set<property::origin>(sid::simple_ptr_holder(&src)),
+                sid::synthetic().set<property::origin>(sid::simple_ptr_holder(&dst)));
         }
 #endif
 
@@ -61,8 +60,8 @@ namespace gridtools {
             double dst = 0;
 
             auto testee = sid::composite::keys<a, b>::make_values(
-                sid::synthetic().set<property::origin>(sid::host_device::make_simple_ptr_holder(&src)),
-                sid::synthetic().set<property::origin>(sid::host_device::make_simple_ptr_holder(&dst)));
+                sid::synthetic().set<property::origin>(sid::simple_ptr_holder(&src)),
+                sid::synthetic().set<property::origin>(sid::simple_ptr_holder(&dst)));
             static_assert(is_sid<decltype(testee)>(), "");
 
             auto ptrs = sid::get_origin(testee)();
@@ -88,23 +87,23 @@ namespace gridtools {
 
             auto my_strides = array{1, 5, 15};
 
-            auto testee = sid::composite::keys<a, b, c, d>::make_values(                              //
-                sid::synthetic()                                                                      //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&one[0]))         //
-                    .set<property::strides>(tuple(1_c))                                               //
-                ,                                                                                     //
-                sid::synthetic()                                                                      //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&two))            //
-                ,                                                                                     //
-                sid::synthetic()                                                                      //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&three[0][0][0])) //
-                    .set<property::strides>(my_strides)                                               //
-                    .set<property::strides_kind, my_strides_kind>()                                   //
-                ,                                                                                     //
-                sid::synthetic()                                                                      //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&four[0][0][0]))  //
-                    .set<property::strides>(my_strides)                                               //
-                    .set<property::strides_kind, my_strides_kind>()                                   //
+            auto testee = sid::composite::keys<a, b, c, d>::make_values(            //
+                sid::synthetic()                                                    //
+                    .set<property::origin>(sid::simple_ptr_holder(&one[0]))         //
+                    .set<property::strides>(tuple(1_c))                             //
+                ,                                                                   //
+                sid::synthetic()                                                    //
+                    .set<property::origin>(sid::simple_ptr_holder(&two))            //
+                ,                                                                   //
+                sid::synthetic()                                                    //
+                    .set<property::origin>(sid::simple_ptr_holder(&three[0][0][0])) //
+                    .set<property::strides>(my_strides)                             //
+                    .set<property::strides_kind, my_strides_kind>()                 //
+                ,                                                                   //
+                sid::synthetic()                                                    //
+                    .set<property::origin>(sid::simple_ptr_holder(&four[0][0][0]))  //
+                    .set<property::strides>(my_strides)                             //
+                    .set<property::strides_kind, my_strides_kind>()                 //
             );
             static_assert(is_sid<decltype(testee)>(), "");
 
@@ -178,21 +177,21 @@ namespace gridtools {
             char four[6][4][5] = {};
             auto strides_four = hymap::keys<dim_y, dim_z, dim_x>::make_values(1_c, 5_c, 20_c);
 
-            auto testee = sid::composite::keys<a, b, c, d>::make_values(                              //
-                sid::synthetic()                                                                      //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&one[0]))         //
-                    .set<property::strides>(strides_one)                                              //
-                ,                                                                                     //
-                sid::synthetic()                                                                      //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&two))            //
-                ,                                                                                     //
-                sid::synthetic()                                                                      //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&three[0][0][0])) //
-                    .set<property::strides>(strides_three)                                            //
-                ,                                                                                     //
-                sid::synthetic()                                                                      //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&four[0][0][0]))  //
-                    .set<property::strides>(strides_four)                                             //
+            auto testee = sid::composite::keys<a, b, c, d>::make_values(            //
+                sid::synthetic()                                                    //
+                    .set<property::origin>(sid::simple_ptr_holder(&one[0]))         //
+                    .set<property::strides>(strides_one)                            //
+                ,                                                                   //
+                sid::synthetic()                                                    //
+                    .set<property::origin>(sid::simple_ptr_holder(&two))            //
+                ,                                                                   //
+                sid::synthetic()                                                    //
+                    .set<property::origin>(sid::simple_ptr_holder(&three[0][0][0])) //
+                    .set<property::strides>(strides_three)                          //
+                ,                                                                   //
+                sid::synthetic()                                                    //
+                    .set<property::origin>(sid::simple_ptr_holder(&four[0][0][0]))  //
+                    .set<property::strides>(strides_four)                           //
             );
 
             auto &&strides = sid::get_strides(testee);
@@ -216,14 +215,14 @@ namespace gridtools {
             int one[1] = {};
             int two[1][1] = {};
 
-            auto testee = sid::composite::keys<a, b>::make_values(                               //
-                sid::synthetic()                                                                 //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&one[0]))    //
-                    .set<property::strides>(tuple(1))                                            //
-                    .set<property::strides_kind, sid::unknown_kind>(),                           //
-                sid::synthetic()                                                                 //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&two[0][0])) //
-                    .set<property::strides>(tuple(1, 1))                                         //
+            auto testee = sid::composite::keys<a, b>::make_values(             //
+                sid::synthetic()                                               //
+                    .set<property::origin>(sid::simple_ptr_holder(&one[0]))    //
+                    .set<property::strides>(tuple(1))                          //
+                    .set<property::strides_kind, sid::unknown_kind>(),         //
+                sid::synthetic()                                               //
+                    .set<property::origin>(sid::simple_ptr_holder(&two[0][0])) //
+                    .set<property::strides>(tuple(1, 1))                       //
                     .set<property::strides_kind, sid::unknown_kind>());
 
             auto &&strides = sid::get_strides(testee);
diff --git a/tests/unit_tests/sid/test_sid_concept.cpp b/tests/unit_tests/sid/test_sid_concept.cpp
index 62397a9c27..e69b6f8a24 100644
--- a/tests/unit_tests/sid/test_sid_concept.cpp
+++ b/tests/unit_tests/sid/test_sid_concept.cpp
@@ -54,7 +54,7 @@ namespace gridtools {
             struct bounds_validator_kind;
 
             struct testee {
-                friend sid::host_device::simple_ptr_holder<ptr> sid_get_origin(testee &) { return {}; }
+                friend sid::simple_ptr_holder<ptr> sid_get_origin(testee &) { return {}; }
                 friend strides sid_get_strides(testee const &) { return {}; }
 
                 friend ptr_diff sid_get_ptr_diff(testee);
@@ -86,7 +86,7 @@ namespace gridtools {
         namespace fallbacks {
 
             struct testee {
-                friend sid::host_device::simple_ptr_holder<testee *> sid_get_origin(testee &obj) { return {&obj}; }
+                friend sid::simple_ptr_holder<testee *> sid_get_origin(testee &obj) { return {&obj}; }
             };
 
             static_assert(is_sid<testee>(), "");
@@ -149,7 +149,7 @@ namespace gridtools {
 
             struct testee {};
 
-            sid::host_device::simple_ptr_holder<testee *> sid_get_origin(testee &obj) { return {&obj}; }
+            sid::simple_ptr_holder<testee *> sid_get_origin(testee &obj) { return {&obj}; }
             tuple<stride> sid_get_strides(testee const &) { return {}; }
             GT_FUNCTION int operator*(stride, int) { return 100; }
             integral_constant<int, 42> sid_get_strides_kind(testee const &);
diff --git a/tests/unit_tests/sid/test_sid_contiguous.cpp b/tests/unit_tests/sid/test_sid_contiguous.cpp
index 1092e438bb..4c5c6d6cd3 100644
--- a/tests/unit_tests/sid/test_sid_contiguous.cpp
+++ b/tests/unit_tests/sid/test_sid_contiguous.cpp
@@ -34,7 +34,7 @@ namespace gridtools {
         using sid::property;
 
         TEST(contiguous, smoke) {
-            auto alloc = sid::make_allocator(&std::make_unique<char[]>);
+            auto alloc = sid::allocator(&std::make_unique<char[]>);
             hymap::keys<a, b, c>::values<integral_constant<int_t, 2>, int, int> sizes = {2_c, 3, 4};
             auto testee = sid::make_contiguous<int>(alloc, sizes);
 
@@ -43,9 +43,9 @@ namespace gridtools {
             using strides_t = sid::strides_type<testee_t>;
             using strides_kind_t = sid::strides_kind<testee_t>;
 
-            static_assert(is_sid<testee_t>(), "");
-            static_assert(std::is_same<ptrdiff_t, ptr_diff_t>(), "");
-            static_assert(std::is_same<strides_kind_t, strides_t>(), "");
+            static_assert(is_sid<testee_t>());
+            static_assert(std::is_same<ptrdiff_t, ptr_diff_t>());
+            static_assert(std::is_same<strides_kind_t, strides_t>());
 
             auto lower_bounds = sid::get_lower_bounds(testee);
             EXPECT_EQ(0, at_key<a>(lower_bounds));
diff --git a/tests/unit_tests/sid/test_sid_delegate.cpp b/tests/unit_tests/sid/test_sid_delegate.cpp
index 4a20ae115f..57d5ad49fa 100644
--- a/tests/unit_tests/sid/test_sid_delegate.cpp
+++ b/tests/unit_tests/sid/test_sid_delegate.cpp
@@ -46,7 +46,7 @@ namespace gridtools {
         TEST(delegate, smoke) {
             double data[3][5];
             auto src = sid::synthetic()
-                           .set<property::origin>(sid::host_device::make_simple_ptr_holder(&data[0][0]))
+                           .set<property::origin>(sid::simple_ptr_holder(&data[0][0]))
                            .set<property::strides>(tuple(5_c, 1_c));
             EXPECT_EQ(&data[0][0], sid::get_origin(src)());
 
@@ -77,11 +77,10 @@ namespace gridtools {
         TEST(delegate, do_nothing) {
             double data[3][5];
             auto src = sid::synthetic()
-                           .set<property::origin>(sid::host_device::make_simple_ptr_holder(&data[0][0]))
+                           .set<property::origin>(sid::simple_ptr_holder(&data[0][0]))
                            .set<property::strides>(tuple(5_c, 1_c));
             auto testee = just_delegate(src);
-            static_assert(is_sid<decltype(testee)>(), "");
+            static_assert(is_sid<decltype(testee)>());
         }
-
     } // namespace
 } // namespace gridtools
diff --git a/tests/unit_tests/sid/test_sid_loop.cpp b/tests/unit_tests/sid/test_sid_loop.cpp
index d9b4336580..0ae8ac363d 100644
--- a/tests/unit_tests/sid/test_sid_loop.cpp
+++ b/tests/unit_tests/sid/test_sid_loop.cpp
@@ -63,7 +63,7 @@ namespace gridtools {
             double *ptr = &data[0][0];
             auto strides = tuple(10_c, 1_c);
 
-            auto testee = host_device::compose(sid::make_loop<i_t>(10_c), sid::make_loop<j_t>(10_c));
+            auto testee = compose(sid::make_loop<i_t>(10_c), sid::make_loop<j_t>(10_c));
 
             testee(assignment_f{42})(ptr, strides);
 
diff --git a/tests/unit_tests/sid/test_sid_rename_dimensions.cpp b/tests/unit_tests/sid/test_sid_rename_dimensions.cpp
index b9ec877c8a..777ef5b1de 100644
--- a/tests/unit_tests/sid/test_sid_rename_dimensions.cpp
+++ b/tests/unit_tests/sid/test_sid_rename_dimensions.cpp
@@ -34,7 +34,7 @@ namespace gridtools {
             double data[3][5][7];
 
             auto src = sid::synthetic()
-                           .set<property::origin>(sid::make_simple_ptr_holder(&data[0][0][0]))
+                           .set<property::origin>(sid::simple_ptr_holder(&data[0][0][0]))
                            .set<property::strides>(hymap::keys<a, b, c>::make_values(5_c * 7_c, 7_c, 1_c))
                            .set<property::upper_bounds>(hymap::keys<a, b>::make_values(3, 5));
 
@@ -77,13 +77,13 @@ namespace gridtools {
         TEST(rename_dimensions, rename_twice_and_make_composite) {
             double data[3][5][7];
             auto src = sid::synthetic()
-                           .set<property::origin>(sid::host_device::make_simple_ptr_holder(&data[0][0][0]))
+                           .set<property::origin>(sid::simple_ptr_holder(&data[0][0][0]))
                            .set<property::strides>(hymap::keys<a, b, c>::make_values(5_c * 7_c, 7_c, 1_c))
                            .set<property::upper_bounds>(hymap::keys<a, b>::make_values(3, 5));
             auto testee = sid::rename_dimensions<a, c, b, d>(src);
-            static_assert(sid::is_sid<decltype(testee)>::value, "");
+            static_assert(sid::is_sid<decltype(testee)>::value);
             auto composite = sid::composite::keys<void>::make_values(testee);
-            static_assert(sid::is_sid<decltype(composite)>::value, "");
+            static_assert(sid::is_sid<decltype(composite)>::value);
             sid::get_origin(composite);
         }
 
diff --git a/tests/unit_tests/sid/test_sid_shift_sid_origin.cpp b/tests/unit_tests/sid/test_sid_shift_sid_origin.cpp
index 248a0fef8e..285ec56bc3 100644
--- a/tests/unit_tests/sid/test_sid_shift_sid_origin.cpp
+++ b/tests/unit_tests/sid/test_sid_shift_sid_origin.cpp
@@ -28,14 +28,14 @@ namespace gridtools {
             double data[3][5][7];
 
             auto src = sid::synthetic()
-                           .set<property::origin>(sid::make_simple_ptr_holder(&data[0][0][0]))
+                           .set<property::origin>(sid::simple_ptr_holder(&data[0][0][0]))
                            .set<property::strides>(tuple(5_c * 7_c, 7_c, 1_c))
                            .set<property::upper_bounds>(tuple(3));
 
             auto offset = tuple(1_c, 2);
             auto testee = sid::shift_sid_origin(src, offset);
 
-            static_assert(is_sid<decltype(testee)>(), "");
+            static_assert(is_sid<decltype(testee)>());
 
             EXPECT_EQ(&data[0][0][0], sid::get_origin(src)());
             EXPECT_EQ(&data[1][2][0], sid::get_origin(testee)());
diff --git a/tests/unit_tests/sid/test_sid_synthetic.cpp b/tests/unit_tests/sid/test_sid_synthetic.cpp
index 18ddec3ce0..90acdf30f2 100644
--- a/tests/unit_tests/sid/test_sid_synthetic.cpp
+++ b/tests/unit_tests/sid/test_sid_synthetic.cpp
@@ -24,7 +24,7 @@ namespace gridtools {
 
         TEST(sid_synthetic, smoke) {
             double a = 100;
-            auto testee = sid::synthetic().set<property::origin>(sid::host_device::make_simple_ptr_holder(&a));
+            auto testee = sid::synthetic().set<property::origin>(sid::simple_ptr_holder(&a));
             static_assert(is_sid<decltype(testee)>::value, "");
 
             EXPECT_EQ(a, *sid::get_origin(testee)());
@@ -55,7 +55,7 @@ namespace gridtools {
                 strides the_strides = {stride{3}, stride{4}};
 
                 auto the_testee = sid::synthetic()
-                                      .set<property::origin>(sid::host_device::make_simple_ptr_holder(the_origin))
+                                      .set<property::origin>(sid::simple_ptr_holder(the_origin))
                                       .set<property::strides>(the_strides)
                                       .set<property::ptr_diff, ptr_diff>()
                                       .set<property::strides_kind, strides_kind>();
diff --git a/tests/unit_tests/stencil/gpu/test_simple_device_memory_allocator.cu b/tests/unit_tests/stencil/gpu/test_simple_device_memory_allocator.cu
index d11868b2ef..e33425cc4b 100644
--- a/tests/unit_tests/stencil/gpu/test_simple_device_memory_allocator.cu
+++ b/tests/unit_tests/stencil/gpu/test_simple_device_memory_allocator.cu
@@ -31,7 +31,7 @@ namespace gridtools {
         __global__ void test_allocated(PtrHolder testee, bool *result) {}
 
         TEST(simple_device_memory_allocator, test) {
-            sid::device::allocator<GT_INTEGRAL_CONSTANT_FROM_VALUE(&cuda_util::cuda_malloc<char[]>)> alloc;
+            sid::allocator<GT_INTEGRAL_CONSTANT_FROM_VALUE(&cuda_util::cuda_malloc<char[]>)> alloc;
             auto ptr_holder = allocate(alloc, meta::lazy::id<double>{}, 1);
 
             auto result = gridtools::on_device::exec(
diff --git a/tests/unit_tests/stencil/gpu/test_tmp_storage_sid.cpp b/tests/unit_tests/stencil/gpu/test_tmp_storage_sid.cpp
index 215ba87625..15e9a285cf 100644
--- a/tests/unit_tests/stencil/gpu/test_tmp_storage_sid.cpp
+++ b/tests/unit_tests/stencil/gpu/test_tmp_storage_sid.cpp
@@ -36,7 +36,7 @@ namespace gridtools {
                 TEST(tmp_cuda_storage_sid, write_in_blocks) {
                     using index_info = multiplet<5>;
 
-                    auto alloc = sid::make_allocator(&std::make_unique<char[]>);
+                    auto alloc = sid::allocator(&std::make_unique<char[]>);
 
                     auto testee = make_tmp_storage<index_info>(
                         1_c, blocksize_i, blocksize_j, extent_t{}, n_blocks_i, n_blocks_j, k_size, alloc);
@@ -51,11 +51,11 @@ namespace gridtools {
                                 for (int bj = 0; bj < n_blocks_j; ++bj)
                                     for (int k = 0; k < k_size; ++k) {
                                         auto ptr = origin();
-                                        sid::shift(ptr, host::at_key<dim::i>(strides), i);
-                                        sid::shift(ptr, host::at_key<dim::j>(strides), j);
-                                        sid::shift(ptr, host::at_key<sid::blocked_dim<dim::i>>(strides), bi);
-                                        sid::shift(ptr, host::at_key<sid::blocked_dim<dim::j>>(strides), bj);
-                                        sid::shift(ptr, host::at_key<dim::k>(strides), k);
+                                        sid::shift(ptr, at_key<dim::i>(strides), i);
+                                        sid::shift(ptr, at_key<dim::j>(strides), j);
+                                        sid::shift(ptr, at_key<sid::blocked_dim<dim::i>>(strides), bi);
+                                        sid::shift(ptr, at_key<sid::blocked_dim<dim::j>>(strides), bj);
+                                        sid::shift(ptr, at_key<dim::k>(strides), k);
                                         *ptr = {i, j, bi, bj, k};
                                     }
                     // validate that block id is correct, i.e. there were no overlapping memory accesses in the write
@@ -65,11 +65,11 @@ namespace gridtools {
                                 for (int bj = 0; bj < n_blocks_j; ++bj)
                                     for (int k = 0; k < k_size; ++k) {
                                         auto ptr = origin();
-                                        sid::shift(ptr, host::at_key<dim::i>(strides), i);
-                                        sid::shift(ptr, host::at_key<dim::j>(strides), j);
-                                        sid::shift(ptr, host::at_key<sid::blocked_dim<dim::i>>(strides), bi);
-                                        sid::shift(ptr, host::at_key<sid::blocked_dim<dim::j>>(strides), bj);
-                                        sid::shift(ptr, host::at_key<dim::k>(strides), k);
+                                        sid::shift(ptr, at_key<dim::i>(strides), i);
+                                        sid::shift(ptr, at_key<dim::j>(strides), j);
+                                        sid::shift(ptr, at_key<sid::blocked_dim<dim::i>>(strides), bi);
+                                        sid::shift(ptr, at_key<sid::blocked_dim<dim::j>>(strides), bj);
+                                        sid::shift(ptr, at_key<dim::k>(strides), k);
                                         EXPECT_EQ((index_info{i, j, bi, bj, k}), *ptr);
                                     }
                 }
@@ -78,7 +78,7 @@ namespace gridtools {
                 TEST(tmp_cuda_storage_sid_block, write_in_blocks) {
                     using index_info = multiplet<6>;
 
-                    auto alloc = sid::make_allocator(&std::make_unique<char[]>);
+                    auto alloc = sid::allocator(&std::make_unique<char[]>);
 
                     auto testee = make_tmp_storage<index_info>(
                         2_c, blocksize_i, blocksize_j, extent_t{}, n_blocks_i, n_blocks_j, k_size, alloc);
@@ -94,12 +94,12 @@ namespace gridtools {
                                     for (int bj = 0; bj < n_blocks_j; ++bj)
                                         for (int k = 0; k < k_size; ++k) {
                                             auto ptr = origin();
-                                            sid::shift(ptr, host::at_key<dim::i>(strides), i);
-                                            sid::shift(ptr, host::at_key<dim::j>(strides), j);
-                                            sid::shift(ptr, host::at_key<dim::c>(strides), c);
-                                            sid::shift(ptr, host::at_key<sid::blocked_dim<dim::i>>(strides), bi);
-                                            sid::shift(ptr, host::at_key<sid::blocked_dim<dim::j>>(strides), bj);
-                                            sid::shift(ptr, host::at_key<dim::k>(strides), k);
+                                            sid::shift(ptr, at_key<dim::i>(strides), i);
+                                            sid::shift(ptr, at_key<dim::j>(strides), j);
+                                            sid::shift(ptr, at_key<dim::c>(strides), c);
+                                            sid::shift(ptr, at_key<sid::blocked_dim<dim::i>>(strides), bi);
+                                            sid::shift(ptr, at_key<sid::blocked_dim<dim::j>>(strides), bj);
+                                            sid::shift(ptr, at_key<dim::k>(strides), k);
                                             *ptr = {i, j, c, bi, bj, k};
                                         }
 
@@ -111,12 +111,12 @@ namespace gridtools {
                                     for (int bj = 0; bj < n_blocks_j; ++bj)
                                         for (int k = 0; k < k_size; ++k) {
                                             auto ptr = origin();
-                                            sid::shift(ptr, host::at_key<dim::i>(strides), i);
-                                            sid::shift(ptr, host::at_key<dim::j>(strides), j);
-                                            sid::shift(ptr, host::at_key<dim::c>(strides), c);
-                                            sid::shift(ptr, host::at_key<sid::blocked_dim<dim::i>>(strides), bi);
-                                            sid::shift(ptr, host::at_key<sid::blocked_dim<dim::j>>(strides), bj);
-                                            sid::shift(ptr, host::at_key<dim::k>(strides), k);
+                                            sid::shift(ptr, at_key<dim::i>(strides), i);
+                                            sid::shift(ptr, at_key<dim::j>(strides), j);
+                                            sid::shift(ptr, at_key<dim::c>(strides), c);
+                                            sid::shift(ptr, at_key<sid::blocked_dim<dim::i>>(strides), bi);
+                                            sid::shift(ptr, at_key<sid::blocked_dim<dim::j>>(strides), bj);
+                                            sid::shift(ptr, at_key<dim::k>(strides), k);
                                             EXPECT_EQ((index_info{i, j, c, bi, bj, k}), *ptr);
                                         }
                 }
diff --git a/tests/unit_tests/stencil/gpu/test_tmp_storage_sid.cu b/tests/unit_tests/stencil/gpu/test_tmp_storage_sid.cu
index e517901f30..61b3ad720a 100644
--- a/tests/unit_tests/stencil/gpu/test_tmp_storage_sid.cu
+++ b/tests/unit_tests/stencil/gpu/test_tmp_storage_sid.cu
@@ -39,7 +39,7 @@ namespace gridtools {
             };
 
             TEST(tmp_cuda_storage, maker_with_device_allocator) {
-                sid::device::allocator<GT_INTEGRAL_CONSTANT_FROM_VALUE(&cuda_util::cuda_malloc<char[]>)> alloc;
+                sid::allocator<GT_INTEGRAL_CONSTANT_FROM_VALUE(&cuda_util::cuda_malloc<char[]>)> alloc;
                 auto testee = gpu_backend::make_tmp_storage<int>(1_c, 2_c, 2_c, extent<>{}, 1, 1, 2, alloc);
                 EXPECT_TRUE(on_device::exec(smoke_f{}, sid::get_origin(testee), sid::get_strides(testee)));
             }

From 210fa36423f224382ef2af05df29dbd211f788d4 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Thu, 23 Dec 2021 16:38:35 +0100
Subject: [PATCH 15/19] cleanup

---
 examples/boundaries/boundaries.cpp            |   6 +-
 examples/stencil/tridiagonal_solver.cpp       |   3 +-
 .../interpolate_stencil.cpp                   |   2 +-
 include/gridtools/boundaries/apply_gpu.hpp    |  31 +-
 include/gridtools/common/atomic_host.hpp      |  19 +-
 include/gridtools/common/defs.hpp             |   2 -
 include/gridtools/common/enable_maker.hpp     |   2 +-
 include/gridtools/common/gt_math.hpp          |  44 +--
 include/gridtools/common/halo_descriptor.hpp  |  36 +-
 include/gridtools/common/host_device.hpp      |  66 ----
 .../gridtools/common/hypercube_iterator.hpp   |  22 +-
 include/gridtools/common/int_vector.hpp       |  41 ++-
 .../gridtools/common/integral_constant.hpp    |  40 +--
 .../common/iterate_on_host_device.hpp         |  90 -----
 include/gridtools/common/pair.hpp             | 201 -----------
 include/gridtools/common/tuple_util.hpp       |  89 +----
 include/gridtools/common/utility.hpp          |  54 ---
 include/gridtools/fn/extents.hpp              |  14 +-
 include/gridtools/fn/scan.hpp                 |   8 +-
 .../gcl/high_level/wrap_argument.hpp          |   6 +-
 .../gridtools/gcl/low_level/proc_grids_3D.hpp |   6 +-
 include/gridtools/meta/debug.hpp              |   5 +-
 include/gridtools/reduction/cpu.hpp           |   8 +-
 include/gridtools/reduction/functions.hpp     |  14 +-
 include/gridtools/sid/as_const.hpp            |   4 +-
 include/gridtools/sid/block.hpp               |   2 +-
 include/gridtools/sid/composite.hpp           |  22 +-
 include/gridtools/sid/loop.hpp                | 177 +++++-----
 include/gridtools/sid/multi_shift.hpp         |  14 +-
 include/gridtools/stencil/be_api.hpp          |  86 ++---
 include/gridtools/stencil/common/extent.hpp   |  14 +-
 include/gridtools/stencil/common/intent.hpp   |   2 +-
 .../stencil/core/functor_metafunctions.hpp    |   4 +-
 .../stencil/frontend/cartesian/accessor.hpp   |  47 ++-
 .../stencil/frontend/cartesian/dimension.hpp  |   6 +-
 .../cartesian/expressions/expr_base.hpp       |  18 +-
 .../cartesian/expressions/expr_divide.hpp     |   4 +-
 .../cartesian/expressions/expr_minus.hpp      |   8 +-
 .../cartesian/expressions/expr_plus.hpp       |   8 +-
 .../cartesian/expressions/expr_pow.hpp        |   4 +-
 .../cartesian/expressions/expr_times.hpp      |   4 +-
 .../stencil/frontend/cartesian/stage.hpp      |  11 +-
 .../frontend/cartesian/stencil_functions.hpp  |  39 +-
 .../stencil/frontend/cartesian/tmp_arg.hpp    |   4 +-
 .../stencil/frontend/icosahedral/stage.hpp    |  17 +-
 .../stencil/frontend/icosahedral/tmp_arg.hpp  |   4 +-
 include/gridtools/stencil/frontend/run.hpp    |   6 +-
 .../gridtools/stencil/global_parameter.hpp    |  10 +-
 include/gridtools/stencil/gpu/entry_point.hpp |   4 +-
 include/gridtools/stencil/gpu/fill_flush.hpp  |  22 +-
 include/gridtools/stencil/gpu/k_cache.hpp     |   4 +-
 .../gridtools/stencil/gpu/make_kernel_fun.hpp |   5 +-
 .../stencil/gpu/shared_allocator.hpp          |   2 +-
 .../stencil/gpu_horizontal/entry_point.hpp    |   7 +-
 .../stencil/gpu_horizontal/j_cache.hpp        |   4 +-
 .../storage/adapter/fortran_array_adapter.hpp |   2 +-
 include/gridtools/storage/builder.hpp         |   4 +-
 include/gridtools/storage/gpu.hpp             |   5 +-
 include/gridtools/storage/info.hpp            |  16 +-
 include/gridtools/storage/sid.hpp             |   4 +-
 tests/include/cuda_test_helper.hpp            |   6 +-
 tests/include/verifier.hpp                    |   6 +-
 tests/regression/c_array_copy.cpp             |   2 +-
 tests/regression/extended_4D.cpp              |   4 +-
 .../horizontal_diffusion_functions.cpp        |   2 +-
 .../regression/py_bindings/implementation.cpp |  12 +-
 .../regression/vertical_advection_dycore.cpp  |   2 +-
 .../boundaries/test_bindbc_utilities.cpp      |  14 +-
 tests/unit_tests/common/CMakeLists.txt        |   1 -
 tests/unit_tests/common/test_array.cpp        |   4 +-
 .../common/test_cuda_type_traits.cu           |   8 +-
 tests/unit_tests/common/test_for_each.cpp     |   2 +-
 tests/unit_tests/common/test_gt_math.cpp      |  20 +-
 tests/unit_tests/common/test_hymap.cpp        |  42 ++-
 .../common/test_hypercube_iterator.cpp        |  19 +-
 .../common/test_hypercube_iterator.cu         |   2 +-
 tests/unit_tests/common/test_int_vector.cu    |   8 +-
 .../common/test_integral_constant.cpp         |  24 +-
 tests/unit_tests/common/test_layout_map.cpp   |  54 +--
 tests/unit_tests/common/test_pair.cpp         |  78 ----
 tests/unit_tests/common/test_stride_util.cpp  |  15 +-
 tests/unit_tests/common/test_tuple.cpp        |  48 +--
 tests/unit_tests/common/test_tuple.cu         |   4 +-
 tests/unit_tests/common/test_tuple_util.cpp   |  43 +--
 tests/unit_tests/fn/test_fn_scan.cpp          |  12 +-
 tests/unit_tests/fn/test_fn_scan.cu           |   8 +-
 .../test_layout_transformation.cpp            |   4 +-
 tests/unit_tests/sid/test_sid_as_const.cpp    |   4 +-
 tests/unit_tests/sid/test_sid_block.cpp       |  14 +-
 tests/unit_tests/sid/test_sid_composite.cpp   |  12 +-
 tests/unit_tests/sid/test_sid_concept.cpp     |  85 +++--
 tests/unit_tests/sid/test_sid_contiguous.cpp  |   4 +-
 tests/unit_tests/sid/test_sid_delegate.cpp    |   4 +-
 .../sid/test_sid_rename_dimensions.cpp        |   2 +-
 .../sid/test_sid_shift_sid_origin.cpp         |   2 +-
 tests/unit_tests/sid/test_sid_synthetic.cpp   |  18 +-
 .../stencil/core/test_esf_metafunctions.cpp   |  27 +-
 .../core/test_functor_metafunctions.cpp       |  22 +-
 .../unit_tests/stencil/core/test_interval.cpp |  11 +-
 tests/unit_tests/stencil/core/test_level.cpp  |  52 +--
 .../cpu_ifirst/test_tmp_storage_sid.cpp       |   8 +-
 .../frontend/cartesian/test_accessor.cpp      |  16 +-
 .../cartesian/test_arg_extent_intent.cpp      |  56 +--
 .../cartesian/test_call_proc_stress_types.cpp |  14 +-
 .../cartesian/test_call_stress_types.cpp      |  52 +--
 .../frontend/cartesian/test_expressions.cpp   |  10 +-
 .../test_expressions_integration.cpp          |   4 +-
 .../cartesian/test_stage_with_extents.cpp     |  10 +-
 .../icosahedral/test_from_to_mapping.cpp      |  54 +--
 .../unit_tests/stencil/frontend/test_axis.cpp |  10 +-
 tests/unit_tests/stencil/gpu/test_ij_cache.cu |   8 +-
 .../stencil/gpu/test_shared_allocator.cu      |   6 +-
 .../stencil/test_global_parameter.cpp         |  18 +-
 tests/unit_tests/stencil/test_positional.cpp  |   2 +-
 .../storage/test_storage_facility.cpp         | 244 ++++++-------
 tests/unit_tests/storage/test_storage_sid.cpp |  40 +--
 tests/unit_tests/test_meta.cpp                | 332 ++++++++----------
 117 files changed, 1187 insertions(+), 1801 deletions(-)
 delete mode 100644 include/gridtools/common/iterate_on_host_device.hpp
 delete mode 100644 include/gridtools/common/pair.hpp
 delete mode 100644 include/gridtools/common/utility.hpp
 delete mode 100644 tests/unit_tests/common/test_pair.cpp

diff --git a/examples/boundaries/boundaries.cpp b/examples/boundaries/boundaries.cpp
index 89185a4344..9d29e54cc9 100644
--- a/examples/boundaries/boundaries.cpp
+++ b/examples/boundaries/boundaries.cpp
@@ -64,11 +64,9 @@ template <typename T>
 struct direction_bc_input {
     T value;
 
-    GT_FUNCTION
-    direction_bc_input() : value(1) {}
+    constexpr direction_bc_input() : value(1) {}
 
-    GT_FUNCTION
-    direction_bc_input(T v) : value(v) {}
+    constexpr direction_bc_input(T v) : value(v) {}
 
     // This is the primary template and it will be picked when all the other specializations below fail to be selected.
     // It is important for debugging to note that, if a needed specialization i missing, this version will be selected.
diff --git a/examples/stencil/tridiagonal_solver.cpp b/examples/stencil/tridiagonal_solver.cpp
index 5556c4bfc9..a6d36712db 100644
--- a/examples/stencil/tridiagonal_solver.cpp
+++ b/examples/stencil/tridiagonal_solver.cpp
@@ -114,8 +114,7 @@ int main() {
 
     // Here we make the computation, specifying the backend, the grid (iteration space), binding of the spec arguments
     // to the fields
-    st::run(
-        spec, stencil_backend_t(), grid, st::make_global_parameter(-1), st::make_global_parameter(3), sup, rhs, out);
+    st::run(spec, stencil_backend_t(), grid, st::global_parameter(-1), st::global_parameter(3), sup, rhs, out);
 
     // In this simple example the solution is known and we can easily check it.
     auto view = out->const_host_view();
diff --git a/examples/stencil_type_erasure/interpolate_stencil.cpp b/examples/stencil_type_erasure/interpolate_stencil.cpp
index b984a32353..89107a4c05 100644
--- a/examples/stencil_type_erasure/interpolate_stencil.cpp
+++ b/examples/stencil_type_erasure/interpolate_stencil.cpp
@@ -48,6 +48,6 @@ namespace {
 std::function<void(inputs, outputs)> make_interpolate_stencil(grid_t grid, double weight) {
     return [grid = std::move(grid), weight](inputs in, outputs out) {
         run_single_stage(
-            interpolate_stage(), stencil_backend_t(), grid, in.in1, in.in2, make_global_parameter(weight), out.out);
+            interpolate_stage(), stencil_backend_t(), grid, in.in1, in.in2, global_parameter(weight), out.out);
     };
 }
diff --git a/include/gridtools/boundaries/apply_gpu.hpp b/include/gridtools/boundaries/apply_gpu.hpp
index 0bd33d8aee..cd3541492a 100644
--- a/include/gridtools/boundaries/apply_gpu.hpp
+++ b/include/gridtools/boundaries/apply_gpu.hpp
@@ -69,7 +69,7 @@ namespace gridtools {
               private:
                 /** Computation of the bit-index in `m_predicate_values` of the given direction. */
                 template <sign I, sign J, sign K>
-                GT_FUNCTION static constexpr uint_t direction_index(direction<I, J, K>) {
+                static constexpr uint_t direction_index(direction<I, J, K>) {
                     // computation of the bit-index of the given direction
                     constexpr int_t stride_i = 9;
                     constexpr int_t stride_j = 3;
@@ -133,23 +133,12 @@ namespace gridtools {
                         }
                     }
 
-                    GT_FUNCTION
-                    uint_t max() const { return m_sorted[0]; }
-
-                    GT_FUNCTION
-                    uint_t min() const { return m_sorted[2]; }
-
-                    GT_FUNCTION
-                    uint_t median() const { return m_sorted[1]; }
-
-                    GT_FUNCTION
-                    uint_t size(uint_t i) const { return m_size[i]; }
-
-                    GT_FUNCTION
-                    uint_t perm(uint_t i) const { return m_perm[i]; }
-
-                    GT_FUNCTION
-                    uint_t start(uint_t i) const { return m_start[i]; }
+                    constexpr uint_t max() const { return m_sorted[0]; }
+                    constexpr uint_t min() const { return m_sorted[2]; }
+                    constexpr uint_t median() const { return m_sorted[1]; }
+                    constexpr uint_t size(uint_t i) const { return m_size[i]; }
+                    constexpr uint_t perm(uint_t i) const { return m_perm[i]; }
+                    constexpr uint_t start(uint_t i) const { return m_start[i]; }
                 };
 
                 array<array<array<shape_type, 3>, 3>, 3> sizes;
@@ -219,12 +208,12 @@ namespace gridtools {
                 };
 
                 template <sign I, sign J, sign K>
-                GT_FUNCTION shape_type const &shape(direction<I, J, K>) const {
+                constexpr shape_type const &shape(direction<I, J, K>) const {
                     return sizes[I + 1][J + 1][K + 1];
                 }
             };
 
-            GT_FUNCTION int thread_along_axis(int i, int j, int k, int axis) {
+            constexpr int thread_along_axis(int i, int j, int k, int axis) {
                 assert(axis >= 0 && axis < 3);
                 return axis == 0 ? i : axis == 1 ? j : k;
             }
@@ -299,7 +288,7 @@ namespace gridtools {
             (DataField0, Datafield1, DataField2, ...)
             */
             template <typename... DataFieldViews>
-            void apply(DataFieldViews const &... data_field_views) const {
+            void apply(DataFieldViews const &...data_field_views) const {
                 apply_gpu_impl_::loop_kernel<<<m_conf.kernel_grid_size(), m_conf.kernel_thread_block_size()>>>(
                     m_boundary_function, m_predicate, m_conf, data_field_views...);
                 GT_CUDA_CHECK(cudaGetLastError());
diff --git a/include/gridtools/common/atomic_host.hpp b/include/gridtools/common/atomic_host.hpp
index 1d5a30c395..576e58d385 100644
--- a/include/gridtools/common/atomic_host.hpp
+++ b/include/gridtools/common/atomic_host.hpp
@@ -8,7 +8,11 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 #pragma once
+
 #include <algorithm>
+
+#include "host_device.hpp"
+
 namespace gridtools {
 
     /** \ingroup common
@@ -27,8 +31,7 @@ namespace gridtools {
          * @param val value added to var
          * @return the old value contained in var
          */
-        GT_FUNCTION
-        static T atomic_add(T &var, const T val) {
+        static GT_FORCE_INLINE constexpr T atomic_add(T &var, const T val) {
 #if _OPENMP > 201106
             T old;
 #pragma omp atomic capture
@@ -54,8 +57,7 @@ namespace gridtools {
          * @param val value added to var
          * @return the old value contained in var
          */
-        GT_FUNCTION
-        static T atomic_sub(T &var, const T val) {
+        static GT_FORCE_INLINE constexpr T atomic_sub(T &var, const T val) {
 #if _OPENMP > 201106
             T old;
 #pragma omp atomic capture
@@ -81,8 +83,7 @@ namespace gridtools {
          * @param val value inserted in variable var
          * @return the old value contained in var
          */
-        GT_FUNCTION
-        static T atomic_exch(T &var, const T val) {
+        static GT_FORCE_INLINE constexpr T atomic_exch(T &var, const T val) {
 #if _OPENMP > 201106
             T old;
 #pragma omp atomic capture
@@ -108,8 +109,7 @@ namespace gridtools {
          * @param val value used in the min comparison
          * @return the old value contained in var
          */
-        GT_FUNCTION
-        static T atomic_min(T &var, const T val) {
+        static GT_FORCE_INLINE constexpr T atomic_min(T &var, const T val) {
             T old;
 #pragma omp critical(min)
             {
@@ -125,8 +125,7 @@ namespace gridtools {
          * @param val value used in the min comparison
          * @return the old value contained in var
          */
-        GT_FUNCTION
-        static T atomic_max(T &var, const T val) {
+        static GT_FORCE_INLINE constexpr T atomic_max(T &var, const T val) {
             T old;
 #pragma omp critical(max)
             {
diff --git a/include/gridtools/common/defs.hpp b/include/gridtools/common/defs.hpp
index d96f34806b..957f9b1465 100644
--- a/include/gridtools/common/defs.hpp
+++ b/include/gridtools/common/defs.hpp
@@ -26,8 +26,6 @@ namespace gridtools {
 #endif
 #endif
 
-#define GT_CONSTEXPR constexpr
-
 #ifdef __cpp_consteval
 #define GT_CONSTEVAL consteval
 #else
diff --git a/include/gridtools/common/enable_maker.hpp b/include/gridtools/common/enable_maker.hpp
index f3d030b56e..50908b6800 100644
--- a/include/gridtools/common/enable_maker.hpp
+++ b/include/gridtools/common/enable_maker.hpp
@@ -21,7 +21,7 @@ namespace gridtools {
         template <template <class...> class L>
         struct maker {
             template <class... Args>
-            constexpr GT_FUNCTION L<Args...> operator()(Args const &...args) const {
+            GT_FORCE_INLINE constexpr L<Args...> operator()(Args const &...args) const {
                 return {args...};
             }
         };
diff --git a/include/gridtools/common/gt_math.hpp b/include/gridtools/common/gt_math.hpp
index a4439553c7..e57e3a5cbc 100644
--- a/include/gridtools/common/gt_math.hpp
+++ b/include/gridtools/common/gt_math.hpp
@@ -25,20 +25,20 @@ namespace gridtools {
     */
 
     /**@brief Class in substitution of std::pow, not available in CUDA*/
-    template <uint_t Number>
+    template <size_t N>
     struct gt_pow {
-        template <typename Value>
-        GT_FUNCTION static Value constexpr apply(Value const &v) {
-            return v * gt_pow<Number - 1>::apply(v);
+        template <class T>
+        static constexpr T apply(T const &v) {
+            return v * gt_pow<N - 1>::apply(v);
         }
     };
 
     /**@brief Class in substitution of std::pow, not available in CUDA*/
     template <>
     struct gt_pow<0> {
-        template <typename Value>
-        GT_FUNCTION static Value constexpr apply(Value const &) {
-            return 1.;
+        template <class T>
+        static constexpr T apply(T const &) {
+            return 1;
         }
     };
 
@@ -47,42 +47,44 @@ namespace gridtools {
      * @param num value to ceil
      * @return ceiled value
      */
-    GT_FUNCTION GT_CONSTEXPR static int gt_ceil(float num) {
-        return (static_cast<float>(static_cast<int>(num)) == num) ? static_cast<int>(num)
-                                                                  : static_cast<int>(num) + ((num > 0) ? 1 : 0);
+    GT_FORCE_INLINE constexpr int gt_ceil(float num) {
+        int n = static_cast<int>(num);
+        return static_cast<float>(n) == num ? n : n + num > 0 ? 1 : 0;
     }
 
     namespace math {
-        template <typename Value>
-        GT_FUNCTION GT_CONSTEXPR Value const &max(Value const &val0) {
+        template <class Value>
+        GT_FORCE_INLINE constexpr Value const &max(Value const &val0) {
             return val0;
         }
 
-        template <typename Value>
-        GT_FUNCTION GT_CONSTEXPR Value const &max(Value const &val0, Value const &val1) {
+        template <class Value>
+        GT_FORCE_INLINE constexpr Value const &max(Value const &val0, Value const &val1) {
             return val0 > val1 ? val0 : val1;
         }
 
-        template <typename Value, typename... OtherValues>
-        GT_FUNCTION GT_CONSTEXPR Value const &max(Value const &val0, Value const &val1, OtherValues const &... vals) {
+        template <class Value, class... Values>
+        GT_FORCE_INLINE constexpr Value const &max(Value const &val0, Value const &val1, Values const &...vals) {
             return val0 > max(val1, vals...) ? val0 : max(val1, vals...);
         }
 
-        template <typename Value>
-        GT_FUNCTION GT_CONSTEXPR Value const &min(Value const &val0) {
+        template <class Value>
+        GT_FORCE_INLINE constexpr Value const &min(Value const &val0) {
             return val0;
         }
 
         template <typename Value>
-        GT_FUNCTION GT_CONSTEXPR Value const &min(Value const &val0, Value const &val1) {
+        GT_FORCE_INLINE constexpr Value const &min(Value const &val0, Value const &val1) {
             return val0 > val1 ? val1 : val0;
         }
 
-        template <typename Value, typename... OtherValues>
-        GT_FUNCTION GT_CONSTEXPR Value const &min(Value const &val0, Value const &val1, OtherValues const &... vals) {
+        template <typename Value, typename... Values>
+        GT_FORCE_INLINE constexpr Value const &min(Value const &val0, Value const &val1, Values const &...vals) {
             return val0 > min(val1, vals...) ? min(val1, vals...) : val0;
         }
 
+// Note that as for C++20, std functions in <cmath>  are not constexpr. 
+
 #if defined(GT_CUDACC) && defined(__NVCC__)
         // providing the same overload pattern as the std library
         // auto return type to ensure that we do not accidentally cast
diff --git a/include/gridtools/common/halo_descriptor.hpp b/include/gridtools/common/halo_descriptor.hpp
index 24bce7425f..c761030308 100644
--- a/include/gridtools/common/halo_descriptor.hpp
+++ b/include/gridtools/common/halo_descriptor.hpp
@@ -54,12 +54,12 @@ namespace gridtools {
          * initialized values that are subsequently copy constructed (since this is a POD structure it can be copied
          * without an explicit copy constructor.
          */
-        GT_FUNCTION halo_descriptor() : halo_descriptor(0, 0, 0, 0, 1) {}
+        GT_FORCE_INLINE constexpr halo_descriptor() : halo_descriptor(0, 0, 0, 0, 1) {}
 
         /**
          * @brief simple ctor without halos and padding
          */
-        GT_FUNCTION halo_descriptor(uint_t size) : halo_descriptor(0, 0, 0, size - 1, size) {}
+        GT_FORCE_INLINE constexpr halo_descriptor(uint_t size) : halo_descriptor(0, 0, 0, size - 1, size) {}
 
         /** Main constructors where the five integers are passed.
           \code
@@ -75,7 +75,7 @@ namespace gridtools {
           \param[in] e The end parameter (inclusive)
           \param[in] l The total_length parameter
          */
-        GT_FUNCTION halo_descriptor(uint_t m, uint_t p, uint_t b, uint_t e, uint_t l)
+        GT_FORCE_INLINE constexpr halo_descriptor(uint_t m, uint_t p, uint_t b, uint_t e, uint_t l)
             : m_minus(m), m_plus(p), m_begin(b), m_end(e), m_total_length(l) {
             assert(m_minus + m_plus + (m_end - m_begin + 1) <= m_total_length);
             assert(m_begin <= m_end);
@@ -87,7 +87,7 @@ namespace gridtools {
            Begin index for the loop on the outside region.
            \param[in] I relative coordinate of the neighbor (the \f$eta\f$ parameter in \link MULTI_DIM_ACCESS \endlink)
         */
-        GT_FUNCTION int_t loop_low_bound_outside(
+        GT_FORCE_INLINE constexpr int_t loop_low_bound_outside(
             int_t I) const { // inside is the fact that the halos are ones outside the begin-end region
             switch (I) {
             case 0:
@@ -106,7 +106,7 @@ namespace gridtools {
            End index for the loop on the outside region.
            \param[in] I relative coordinate of the neighbor (the \f$eta\f$ parameter in \link MULTI_DIM_ACCESS \endlink)
          */
-        GT_FUNCTION int_t loop_high_bound_outside(
+        GT_FORCE_INLINE constexpr int_t loop_high_bound_outside(
             int_t I) const { // inside is the fact that the halos are ones outside the begin-end region
             switch (I) {
             case 0:
@@ -125,7 +125,7 @@ namespace gridtools {
            Begin index for the loop on the inside region.
            \param[in] I relative coordinate of the neighbor (the \f$eta\f$ parameter in \link MULTI_DIM_ACCESS \endlink)
          */
-        GT_FUNCTION int_t loop_low_bound_inside(
+        GT_FORCE_INLINE constexpr int_t loop_low_bound_inside(
             int_t I) const { // inside is the fact that the halos are ones outside the begin-end region
 
             switch (I) {
@@ -145,7 +145,7 @@ namespace gridtools {
            End index for the loop on the inside region.
            \param[in] I relative coordinate of the neighbor (the \f$eta\f$ parameter in \link MULTI_DIM_ACCESS \endlink)
          */
-        GT_FUNCTION int_t loop_high_bound_inside(
+        GT_FORCE_INLINE constexpr int_t loop_high_bound_inside(
             int_t I) const { // inside is the fact that the halos are ones outside the begin-end region
             switch (I) {
             case 0:
@@ -166,7 +166,7 @@ namespace gridtools {
            \param[in] I relative coordinate of the neighbor (the \f$eta\f$ parameter in \link MULTI_DIM_ACCESS
            \endlink)
         */
-        GT_FUNCTION uint_t r_length(int_t I) const {
+        GT_FORCE_INLINE constexpr uint_t r_length(int_t I) const {
             switch (I) {
             case 0:
                 return (m_end - m_begin + 1);
@@ -186,7 +186,7 @@ namespace gridtools {
            \param[in] I relative coordinate of the neighbor (the \f$eta\f$ parameter in \link MULTI_DIM_ACCESS
            \endlink)
         */
-        GT_FUNCTION uint_t s_length(int_t I) const {
+        GT_FORCE_INLINE constexpr uint_t s_length(int_t I) const {
             switch (I) {
             case 0:
                 return (m_end - m_begin + 1);
@@ -200,30 +200,30 @@ namespace gridtools {
             }
         }
 
-        GT_FUNCTION uint_t minus() const { return m_minus; }
-        GT_FUNCTION uint_t plus() const { return m_plus; }
-        GT_FUNCTION uint_t begin() const { return m_begin; }
-        GT_FUNCTION uint_t end() const { return m_end; }
-        GT_FUNCTION uint_t total_length() const { return m_total_length; }
+        GT_FORCE_INLINE constexpr uint_t minus() const { return m_minus; }
+        GT_FORCE_INLINE constexpr uint_t plus() const { return m_plus; }
+        GT_FORCE_INLINE constexpr uint_t begin() const { return m_begin; }
+        GT_FORCE_INLINE constexpr uint_t end() const { return m_end; }
+        GT_FORCE_INLINE constexpr uint_t total_length() const { return m_total_length; }
 
         /**
          * @brief sets minus halo to zero.
          * This operation is needed in the communication module.
          * Unlike a general setter this operation will always result in a valid halo_descriptor.
          */
-        GT_FUNCTION void reset_minus() { m_minus = 0; }
+        GT_FORCE_INLINE constexpr void reset_minus() { m_minus = 0; }
         /**
          * @brief sets plus halo to zero.
          * This operation, unlike a general setter, will always result in a valid halo_descriptor.
          */
-        GT_FUNCTION void reset_plus() { m_plus = 0; }
+        GT_FORCE_INLINE constexpr void reset_plus() { m_plus = 0; }
 
-        GT_FUNCTION bool operator==(const halo_descriptor &rhs) const {
+        GT_FORCE_INLINE constexpr bool operator==(const halo_descriptor &rhs) const {
             return (m_minus == rhs.m_minus) && (m_plus == rhs.m_plus) && (m_begin == rhs.m_begin) &&
                    (m_end == rhs.m_end) && (m_total_length == rhs.m_total_length);
         }
 
-        GT_FUNCTION bool operator!=(const halo_descriptor &rhs) const { return !(*this == rhs); }
+        GT_FORCE_INLINE constexpr bool operator!=(const halo_descriptor &rhs) const { return !(*this == rhs); }
     };
 
     /** @} */
diff --git a/include/gridtools/common/host_device.hpp b/include/gridtools/common/host_device.hpp
index 11859cdc00..b96194b54f 100644
--- a/include/gridtools/common/host_device.hpp
+++ b/include/gridtools/common/host_device.hpp
@@ -74,71 +74,5 @@
 #define GT_FUNCTION_DEVICE GT_DEVICE GT_FORCE_INLINE
 #endif
 
-/**
- *   A helper to implement a family of functions which are different from each other only by target specifies.
- *
- *   It uses the same design pattern as `BOOST_PP_ITERATE` does.
- *   For example if one wants to define a function with any possible combination of `__host__` and `__device__`
- *   specifiers he needs to write the following code:
- *
- *   foo.hpp:
- *
- *   \code
- *   // here we query if this file is used in the context of iteration
- *   #ifndef GT_TARGET_ITERATING
- *
- *   // note that you can't use `#pragma once` here and have to use classic header guards instead
- *   #ifndef FOO_HPP_
- *   #define FOO_HPP_
- *
- *   #include <path/to/this/file/host_device.hpp>
- *
- *   // we need to provide GT_ITERATE_ON_TARGETS() with the name of the current file to include it back during
- *   // iteration process. GT_FILENAME is a hardcoded name that GT_ITERATE_ON_TARGETS() will use.
- *   #define GT_FILENAME <path/to/the/user/file/foo.hpp>
- *
- *   // iteration takes place here
- *   #include GT_ITERATE_ON_TARGETS()
- *
- *   // cleanup
- *   #undef GT_FILENAME
- *
- *   #endif
- *   #else
- *
- *   // here is the code that will be included several times during the iteration process
- *
- *   namespace my {
- *     // GT_TARGET_NAMESPACE will be defined by GT_ITERATE_ON_TARGETS() for you.
- *     // It could be either `namespace host` or `namespace device` or `namespace host_device`.
- *     // one of those namespaces would be defined as `inline`
- *     GT_TARGET_NAMESPACE {
- *        // GT_TARGET will be defined by GT_ITERATE_ON_TARGETS() for you.
- *        // It will contain target specifier that is needed it the given context.
- *        GT_TARGET void foo() {}
- *     }
- *   }
- *
- *   #endif
- *   \endcode
- *
- *   By including "file.hpp" file the following symbols would be available:
- *   - `my::foo`
- *   - `my::host::foo`
- *   - `my::device::foo`
- *   - `my::host_device::foo`
- *
- *   where:
- *
- *   - `my::host::foo` has no specifiers.
- *   - `my::foo` is resolved to `my::host::foo`
- *
- *   If compiling with CUDA, `my::device::foo` has `__device__` specifier, `my::host_device::foo` has
- *   `__host__ __device__` specifier.
- *
- *   Otherwise `my::device::foo` and `my::host_device::foo` are resolved to `my::host::foo`.
- */
-#define GT_ITERATE_ON_TARGETS() <gridtools/common/iterate_on_host_device.hpp>
-
 /** @} */
 /** @} */
diff --git a/include/gridtools/common/hypercube_iterator.hpp b/include/gridtools/common/hypercube_iterator.hpp
index e05d5413e1..69661469ff 100644
--- a/include/gridtools/common/hypercube_iterator.hpp
+++ b/include/gridtools/common/hypercube_iterator.hpp
@@ -30,7 +30,7 @@ namespace gridtools {
                 const point_t &m_begin;
                 const point_t &m_end;
 
-                GT_FUNCTION grid_iterator &operator++() {
+                GT_FORCE_INLINE constexpr grid_iterator &operator++() {
                     // The CUDA compiler is very sensitive in properly unrolling the following loop, please change with
                     // care. The kernel in test_layout_transformation_cuda should use 0 stack frame (and about 14
                     // registers) if this loop is properly unrolled.
@@ -52,23 +52,23 @@ namespace gridtools {
                     return *this;
                 }
 
-                GT_FUNCTION grid_iterator operator++(int) {
+                GT_FORCE_INLINE constexpr grid_iterator operator++(int) {
                     grid_iterator tmp(*this);
                     operator++();
                     return tmp;
                 }
 
-                GT_FUNCTION point_t const &operator*() const { return m_pos; }
+                GT_FORCE_INLINE constexpr point_t const &operator*() const { return m_pos; }
 
-                GT_FUNCTION bool operator!=(const grid_iterator &other) const { return m_pos != other.m_pos; }
+                GT_FORCE_INLINE constexpr bool operator!=(const grid_iterator &other) const { return m_pos != other.m_pos; }
             };
 
           public:
-            GT_FUNCTION hypercube_view(const point_t &begin, const point_t &end) : m_begin(begin), m_end(end) {}
-            GT_FUNCTION hypercube_view(const point_t &end) : m_end(end) {}
+            GT_FORCE_INLINE constexpr hypercube_view(const point_t &begin, const point_t &end) : m_begin(begin), m_end(end) {}
+            GT_FORCE_INLINE constexpr hypercube_view(const point_t &end) : m_end(end) {}
 
-            GT_FUNCTION grid_iterator begin() const { return grid_iterator{m_begin, m_begin, m_end}; }
-            GT_FUNCTION grid_iterator end() const { return grid_iterator{m_end, m_begin, m_end}; }
+            GT_FORCE_INLINE constexpr grid_iterator begin() const { return grid_iterator{m_begin, m_begin, m_end}; }
+            GT_FORCE_INLINE constexpr grid_iterator end() const { return grid_iterator{m_end, m_begin, m_end}; }
 
           private:
             point_t m_begin = {};
@@ -94,7 +94,7 @@ namespace gridtools {
         size_t OuterD = tuple_util::size<Decayed>::value,
         std::enable_if_t<OuterD != 0 && meta::all_of<impl_::is_pair_like, tuple_util::traits::to_types<Decayed>>::value,
             int> = 0>
-    GT_FUNCTION impl_::hypercube_view<OuterD> make_hypercube_view(Container &&cube) {
+    GT_FORCE_INLINE constexpr impl_::hypercube_view<OuterD> make_hypercube_view(Container &&cube) {
         auto &&transposed = tuple_util::transpose(std::forward<Container>(cube));
         return {tuple_util::convert_to<array, size_t>(tuple_util::get<0>(transposed)),
             tuple_util::convert_to<array, size_t>(tuple_util::get<1>(transposed))};
@@ -106,7 +106,7 @@ namespace gridtools {
     template <typename Container,
         size_t D = tuple_util::size<std::decay_t<Container>>::value,
         std::enable_if_t<D == 0, int> = 0>
-    GT_FUNCTION array<array<size_t, 0>, 1> make_hypercube_view(Container &&) {
+    GT_FORCE_INLINE constexpr array<array<size_t, 0>, 1> make_hypercube_view(Container &&) {
         return {{}};
     }
 
@@ -119,7 +119,7 @@ namespace gridtools {
         size_t D = tuple_util::size<Decayed>::value,
         std::enable_if_t<D != 0 && meta::all_of<impl_::is_size_t_like, tuple_util::traits::to_types<Decayed>>::value,
             int> = 0>
-    GT_FUNCTION impl_::hypercube_view<D> make_hypercube_view(Container &&sizes) {
+    GT_FORCE_INLINE constexpr impl_::hypercube_view<D> make_hypercube_view(Container &&sizes) {
         return {tuple_util::convert_to<array, size_t>(std::forward<Container>(sizes))};
     }
 } // namespace gridtools
diff --git a/include/gridtools/common/int_vector.hpp b/include/gridtools/common/int_vector.hpp
index 78bc65e5ef..9927276add 100644
--- a/include/gridtools/common/int_vector.hpp
+++ b/include/gridtools/common/int_vector.hpp
@@ -22,14 +22,13 @@
 #pragma once
 
 #include <type_traits>
+#include <utility>
 
 #include "../meta.hpp"
-#include "defs.hpp"
 #include "host_device.hpp"
 #include "hymap.hpp"
 #include "integral_constant.hpp"
 #include "tuple_util.hpp"
-#include "utility.hpp"
 
 namespace gridtools {
 
@@ -48,7 +47,7 @@ namespace gridtools {
         template <class Key>
         struct add_f {
             template <class... Ts>
-            GT_FUNCTION GT_CONSTEXPR decltype(auto) operator()(Ts const &...args) const {
+            GT_FORCE_INLINE constexpr decltype(auto) operator()(Ts const &...args) const {
                 return (at_key_with_default<Key, integral_constant<int, 0>>(args) + ...);
             }
         };
@@ -59,7 +58,7 @@ namespace gridtools {
         template <class Key>
         struct at_key_f {
             template <class T>
-            GT_FUNCTION GT_CONSTEXPR decltype(auto) operator()(T const &arg) const {
+            GT_FORCE_INLINE constexpr decltype(auto) operator()(T const &arg) const {
                 return at_key<Key>(arg);
             }
         };
@@ -99,31 +98,31 @@ namespace gridtools {
          * The keys of the resulting `int_vector` are the union of the keys of the operands.
          */
         template <class... Vecs>
-        GT_FUNCTION GT_CONSTEXPR auto plus(Vecs && ...vecs) {
+        GT_FORCE_INLINE constexpr auto plus(Vecs && ...vecs) {
             using merged_meta_map_t = meta::mp_make<impl_::merger_t, meta::concat<hymap::to_meta_map<Vecs>...>>;
             using keys_t = meta::transform<meta::first, merged_meta_map_t>;
             using generators = meta::transform<impl_::add_f, keys_t>;
             return tuple_util::generate<generators, hymap::from_meta_map<merged_meta_map_t>>(
-                wstd::forward<Vecs>(vecs)...);
+                std::forward<Vecs>(vecs)...);
         }
 
         /**
          * @brief Returns `int_vector` with elements multiplied by an integral scalar
          */
         template <class Vec, class Scalar>
-        GT_FUNCTION GT_CONSTEXPR auto multiply(Vec && vec, Scalar scalar) {
-            return tuple_util::transform([scalar](auto v) { return v * scalar; }, wstd::forward<Vec>(vec));
+        GT_FORCE_INLINE constexpr auto multiply(Vec && vec, Scalar scalar) {
+            return tuple_util::transform([scalar](auto v) { return v * scalar; }, std::forward<Vec>(vec));
         }
 
         /**
          * @brief Returns `int_vector` with elements removed that are `integral_constant<T, 0>`
          */
         template <class Vec>
-        GT_FUNCTION GT_CONSTEXPR auto prune_zeros(Vec && vec) {
+        GT_FORCE_INLINE constexpr auto prune_zeros(Vec && vec) {
             using filtered_map_t = meta::filter<meta::not_<impl_::is_constant_zero>::apply, hymap::to_meta_map<Vec>>;
             using keys_t = meta::transform<meta::first, filtered_map_t>;
             using generators = meta::transform<impl_::at_key_f, keys_t>;
-            return tuple_util::generate<generators, hymap::from_meta_map<filtered_map_t>>(wstd::forward<Vec>(vec));
+            return tuple_util::generate<generators, hymap::from_meta_map<filtered_map_t>>(std::forward<Vec>(vec));
         }
 
         namespace arithmetic {
@@ -132,8 +131,8 @@ namespace gridtools {
                 std::enable_if_t<is_int_vector_v<std::decay_t<Vec>> &&
                                      impl_::is_integral_or_gr_integral_constant<Scalar>::value,
                     bool> = true>
-            GT_FUNCTION GT_CONSTEXPR auto operator*(Vec &&vec, Scalar scalar) {
-                return multiply(wstd::forward<Vec>(vec), scalar);
+            GT_FORCE_INLINE constexpr auto operator*(Vec &&vec, Scalar scalar) {
+                return multiply(std::forward<Vec>(vec), scalar);
             }
 
             template <class Vec,
@@ -141,34 +140,34 @@ namespace gridtools {
                 std::enable_if_t<is_int_vector_v<std::decay_t<Vec>> &&
                                      impl_::is_integral_or_gr_integral_constant<Scalar>::value,
                     bool> = true>
-            GT_FUNCTION GT_CONSTEXPR auto operator*(Scalar scalar, Vec &&vec) {
-                return multiply(wstd::forward<Vec>(vec), scalar);
+            GT_FORCE_INLINE constexpr auto operator*(Scalar scalar, Vec &&vec) {
+                return multiply(std::forward<Vec>(vec), scalar);
             }
 
             template <class First,
                 class Second,
                 std::enable_if_t<is_int_vector_v<std::decay_t<First>> && is_int_vector_v<std::decay_t<Second>>, bool> =
                     true>
-            GT_FUNCTION GT_CONSTEXPR auto operator+(First &&first, Second &&second) {
-                return plus(wstd::forward<First>(first), wstd::forward<Second>(second));
+            GT_FORCE_INLINE constexpr auto operator+(First &&first, Second &&second) {
+                return plus(std::forward<First>(first), std::forward<Second>(second));
             }
 
             template <class Vec, std::enable_if_t<is_int_vector_v<std::decay_t<Vec>>, bool> = true>
-            GT_FUNCTION GT_CONSTEXPR auto operator+(Vec &&vec) {
+            GT_FORCE_INLINE constexpr auto operator+(Vec &&vec) {
                 return vec;
             }
 
             template <class Vec, std::enable_if_t<is_int_vector_v<std::decay_t<Vec>>, bool> = true>
-            GT_FUNCTION GT_CONSTEXPR auto operator-(Vec &&vec) {
-                return multiply(wstd::forward<Vec>(vec), integral_constant<int, -1>{});
+            GT_FORCE_INLINE constexpr auto operator-(Vec &&vec) {
+                return multiply(std::forward<Vec>(vec), integral_constant<int, -1>{});
             }
 
             template <class First,
                 class Second,
                 std::enable_if_t<is_int_vector_v<std::decay_t<First>> && is_int_vector_v<std::decay_t<Second>>, bool> =
                     true>
-            GT_FUNCTION GT_CONSTEXPR auto operator-(First &&first, Second &&second) {
-                return plus(wstd::forward<First>(first), -wstd::forward<Second>(second));
+            GT_FORCE_INLINE constexpr auto operator-(First &&first, Second &&second) {
+                return plus(std::forward<First>(first), -std::forward<Second>(second));
             }
 
         } // namespace arithmetic
diff --git a/include/gridtools/common/integral_constant.hpp b/include/gridtools/common/integral_constant.hpp
index adf5b4d8a2..ccf3a9aec5 100644
--- a/include/gridtools/common/integral_constant.hpp
+++ b/include/gridtools/common/integral_constant.hpp
@@ -37,8 +37,6 @@ namespace gridtools {
     template <class T, T V>
     struct integral_constant : std::integral_constant<T, V> {
         using type = integral_constant;
-
-        constexpr GT_FUNCTION operator T() const noexcept { return V; }
     };
 
     // This predicate checks if the the class has `gridtools::integral_constant` as a public base, which has arithmetic
@@ -51,12 +49,13 @@ namespace gridtools {
         std::enable_if_t<std::is_base_of<integral_constant<typename T::value_type, T::value>, T>::value>>
         : std::true_type {};
 
-#define GT_INTEGRAL_CONSTANT_DEFINE_UNARY_OPERATOR(op, type)                                                           \
-    template <class T, T V>                                                                                            \
-    constexpr GT_FUNCTION integral_constant<decltype(op V), (op V)> operator op(integral_constant<T, V> &&) noexcept { \
-        return {};                                                                                                     \
-    }                                                                                                                  \
-    static_assert(1, "")
+#define GT_INTEGRAL_CONSTANT_DEFINE_UNARY_OPERATOR(op, type)                         \
+    template <class T, T V>                                                          \
+    GT_FORCE_INLINE constexpr integral_constant<decltype(op V), (op V)> operator op( \
+        integral_constant<T, V> &&) noexcept {                                       \
+        return {};                                                                   \
+    }                                                                                \
+    static_assert(1)
 
     GT_INTEGRAL_CONSTANT_DEFINE_UNARY_OPERATOR(+, T);
     GT_INTEGRAL_CONSTANT_DEFINE_UNARY_OPERATOR(-, T);
@@ -65,13 +64,13 @@ namespace gridtools {
 
 #undef GT_INTEGRAL_CONSTANT_DEFINE_UNARY_OPERATOR
 
-#define GT_INTEGRAL_CONSTANT_DEFINE_BINARY_OPERATOR(op, type)                            \
-    template <class T, T TV, class U, U UV>                                              \
-    constexpr GT_FUNCTION integral_constant<decltype(TV op UV), (TV op UV)> operator op( \
-        integral_constant<T, TV>, integral_constant<U, UV>) noexcept {                   \
-        return {};                                                                       \
-    }                                                                                    \
-    static_assert(1, "")
+#define GT_INTEGRAL_CONSTANT_DEFINE_BINARY_OPERATOR(op, type)                                \
+    template <class T, T TV, class U, U UV>                                                  \
+    GT_FORCE_INLINE constexpr integral_constant<decltype(TV op UV), (TV op UV)> operator op( \
+        integral_constant<T, TV>, integral_constant<U, UV>) noexcept {                       \
+        return {};                                                                           \
+    }                                                                                        \
+    static_assert(1)
 
     GT_INTEGRAL_CONSTANT_DEFINE_BINARY_OPERATOR(+, (std::common_type_t<T, U>));
     GT_INTEGRAL_CONSTANT_DEFINE_BINARY_OPERATOR(-, (std::common_type_t<T, U>));
@@ -115,10 +114,10 @@ namespace gridtools {
             }
             template <>
             constexpr literal_int_t to_int<16>(char c) {
-                return c >= 'A' && c <= 'F'
-                           ? c - 'A' + 10
-                           : c >= 'a' && c <= 'f' ? c - 'a' + 10
-                                                  : c >= '0' && c <= '9' ? c - '0' : throw "invalid hex _c literal";
+                return c >= 'A' && c <= 'F'   ? c - 'A' + 10
+                       : c >= 'a' && c <= 'f' ? c - 'a' + 10
+                       : c >= '0' && c <= '9' ? c - '0'
+                                              : throw "invalid hex _c literal";
             }
 
             template <literal_int_t Base>
@@ -150,7 +149,8 @@ namespace gridtools {
         } // namespace literals_impl_
 
         template <char... Chars>
-        constexpr GT_FUNCTION integral_constant<literals_impl_::literal_int_t, literals_impl_::parser<Chars...>::value>
+        GT_FORCE_INLINE constexpr integral_constant<literals_impl_::literal_int_t,
+            literals_impl_::parser<Chars...>::value>
         operator"" _c() {
             return {};
         }
diff --git a/include/gridtools/common/iterate_on_host_device.hpp b/include/gridtools/common/iterate_on_host_device.hpp
deleted file mode 100644
index cb735feb2c..0000000000
--- a/include/gridtools/common/iterate_on_host_device.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * GridTools
- *
- * Copyright (c) 2014-2021, ETH Zurich
- * All rights reserved.
- *
- * Please, refer to the LICENSE file in the root directory.
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-// DON'T USE #pragma once HERE!!!
-
-#if !defined(GT_FILENAME)
-#error GT_FILENAME is not defined
-#endif
-
-#if defined(GT_TARGET_ITERATING)
-#error nesting target iterating is not supported
-#endif
-
-#if defined(GT_TARGET)
-#error GT_TARGET should not be defined outside of this file
-#endif
-
-#if defined(GT_TARGET_NAMESPACE)
-#error GT_TARGET_NAMESPACE should not be defined outside of this file
-#endif
-
-#if defined(GT_TARGET_CONSTEXPR)
-#error GT_TARGET_NAMESPACE should not be defined outside of this file
-#endif
-
-#define GT_TARGET_ITERATING
-
-#ifdef GT_CUDACC
-
-#define GT_TARGET_NAMESPACE_NAME host
-#define GT_TARGET_NAMESPACE inline namespace host
-#define GT_TARGET GT_HOST
-#define GT_TARGET_CONSTEXPR constexpr
-
-#include GT_FILENAME
-#undef GT_TARGET
-#undef GT_TARGET_NAMESPACE
-#undef GT_TARGET_NAMESPACE_NAME
-#undef GT_TARGET_CONSTEXPR
-
-#define GT_TARGET_NAMESPACE_NAME host_device
-#define GT_TARGET_NAMESPACE namespace host_device
-#define GT_TARGET GT_HOST_DEVICE
-#define GT_TARGET_CONSTEXPR constexpr
-#define GT_TARGET_HAS_DEVICE
-#include GT_FILENAME
-#undef GT_TARGET_HAS_DEVICE
-#undef GT_TARGET
-#undef GT_TARGET_NAMESPACE
-#undef GT_TARGET_NAMESPACE_NAME
-#undef GT_TARGET_CONSTEXPR
-
-#define GT_TARGET_NAMESPACE_NAME device
-#define GT_TARGET_NAMESPACE namespace device
-#define GT_TARGET GT_DEVICE
-#define GT_TARGET_HAS_DEVICE
-#define GT_TARGET_CONSTEXPR constexpr
-#include GT_FILENAME
-#undef GT_TARGET_HAS_DEVICE
-#undef GT_TARGET
-#undef GT_TARGET_NAMESPACE
-#undef GT_TARGET_NAMESPACE_NAME
-#undef GT_TARGET_CONSTEXPR 
-
-#else
-
-#define GT_TARGET_NAMESPACE_NAME host
-#define GT_TARGET_NAMESPACE   \
-    inline namespace host {}  \
-    namespace host_device {   \
-        using namespace host; \
-    }                         \
-    inline namespace host
-#define GT_TARGET GT_HOST
-#define GT_TARGET_CONSTEXPR constexpr
-#include GT_FILENAME
-#undef GT_TARGET
-#undef GT_TARGET_NAMESPACE
-#undef GT_TARGET_NAMESPACE_NAME
-#undef GT_TARGET_CONSTEXPR
-#endif
-
-#undef GT_TARGET_ITERATING
diff --git a/include/gridtools/common/pair.hpp b/include/gridtools/common/pair.hpp
deleted file mode 100644
index 7505a86b76..0000000000
--- a/include/gridtools/common/pair.hpp
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
- * GridTools
- *
- * Copyright (c) 2014-2021, ETH Zurich
- * All rights reserved.
- *
- * Please, refer to the LICENSE file in the root directory.
- * SPDX-License-Identifier: BSD-3-Clause
- */
-#pragma once
-#include <utility>
-
-namespace gridtools{
-    using std::pair;
-}
-
-#if 0
-#include <cstddef>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-#include "defs.hpp"
-#include "host_device.hpp"
-#include "utility.hpp"
-
-namespace gridtools {
-    /** \ingroup common
-        @{
-        \defgroup pair Simple Pair
-        @{
-    */
-
-    /**
-       @brief simple pair with constexpr constructor
-
-       NOTE: can be replaced by std::pair
-     */
-    template <typename T1, typename T2>
-    struct pair {
-        pair() = default;
-
-        template <class U1, class U2>
-        GT_CONSTEXPR GT_FUNCTION pair(const std::pair<U1, U2> &p) : pair(p.first, p.second) {}
-
-        template <class U1, class U2>
-        GT_CONSTEXPR GT_FUNCTION pair(std::pair<U1, U2> &&p) : pair(wstd::move(p.first), wstd::move(p.second)) {}
-
-        GT_CONSTEXPR GT_FUNCTION pair(T1 const &t1_, T2 const &t2_) : first(t1_), second(t2_) {}
-
-        template <class U1, class U2>
-        GT_CONSTEXPR GT_FUNCTION pair(U1 &&t1_, U2 &&t2_)
-            : first(wstd::forward<U1>(t1_)), second(wstd::forward<U2>(t2_)) {}
-
-        template <class U1, class U2, std::enable_if_t<!std::is_same<pair<U1, U2>, pair>::value, int> = 0>
-        GT_CONSTEXPR GT_FUNCTION pair(pair<U1, U2> const &p) : first(p.first), second(p.second) {}
-
-        template <class U1, class U2, std::enable_if_t<!std::is_same<pair<U1, U2>, pair>::value, int> = 0>
-        GT_CONSTEXPR GT_FUNCTION pair(pair<U1, U2> &&p) : first(wstd::move(p.first)), second(wstd::move(p.second)) {}
-
-        template <typename U1, typename U2, std::enable_if_t<!std::is_same<pair<U1, U2>, pair>::value, int> = 0>
-        GT_FUNCTION pair &operator=(const pair<U1, U2> &other) {
-            first = other.first;
-            second = other.second;
-            return *this;
-        }
-
-        template <typename U1, typename U2, std::enable_if_t<!std::is_same<pair<U1, U2>, pair>::value, int> = 0>
-        GT_FUNCTION pair &operator=(pair<U1, U2> &&other) noexcept {
-            first = wstd::move(other.first);
-            second = wstd::move(other.second);
-            return *this;
-        }
-
-        T1 first;
-        T2 second;
-    };
-
-    template <typename T1, typename T2>
-    GT_CONSTEXPR GT_FUNCTION bool operator==(const pair<T1, T2> &lhs, const pair<T1, T2> &rhs) {
-        return lhs.first == rhs.first && lhs.second == rhs.second;
-    }
-
-    template <typename T1, typename T2>
-    GT_CONSTEXPR GT_FUNCTION bool operator!=(const pair<T1, T2> &lhs, const pair<T1, T2> &rhs) {
-        return !(lhs == rhs);
-    }
-
-    template <typename T1, typename T2>
-    GT_CONSTEXPR GT_FUNCTION bool operator<(const pair<T1, T2> &lhs, const pair<T1, T2> &rhs) {
-        return lhs.first < rhs.first || (!(rhs.first < lhs.first) && lhs.second < rhs.second);
-    }
-
-    template <typename T1, typename T2>
-    GT_CONSTEXPR GT_FUNCTION bool operator>(const pair<T1, T2> &lhs, const pair<T1, T2> &rhs) {
-        return rhs < lhs;
-    }
-
-    template <typename T1, typename T2>
-    GT_CONSTEXPR GT_FUNCTION bool operator<=(const pair<T1, T2> &lhs, const pair<T1, T2> &rhs) {
-        return !(rhs < lhs);
-    }
-
-    template <typename T1, typename T2>
-    GT_CONSTEXPR GT_FUNCTION bool operator>=(const pair<T1, T2> &lhs, const pair<T1, T2> &rhs) {
-        return !(lhs < rhs);
-    }
-
-    template <typename T1, typename T2>
-    GT_CONSTEXPR GT_FUNCTION pair<T1, T2> make_pair(T1 const &t1_, T2 const &t2_) {
-        return pair<T1, T2>(t1_, t2_);
-    }
-    /** @} */
-    /** @} */
-
-    namespace pair_impl_ {
-        template <std::size_t I>
-        struct pair_get;
-
-        template <>
-        struct pair_get<0> {
-            template <typename T1, typename T2>
-            static GT_CONSTEXPR GT_FUNCTION const T1 &const_get(const pair<T1, T2> &p) noexcept {
-                return p.first;
-            }
-            template <typename T1, typename T2>
-            static GT_FUNCTION T1 &get(pair<T1, T2> &p) noexcept {
-                return p.first;
-            }
-            template <typename T1, typename T2>
-            static GT_CONSTEXPR GT_FUNCTION T1 &&move_get(pair<T1, T2> &&p) noexcept {
-                return wstd::move(p.first);
-            }
-        };
-        template <>
-        struct pair_get<1> {
-            template <typename T1, typename T2>
-            static GT_CONSTEXPR GT_FUNCTION const T2 &const_get(const pair<T1, T2> &p) noexcept {
-                return p.second;
-            }
-            template <typename T1, typename T2>
-            static GT_FUNCTION T2 &get(pair<T1, T2> &p) noexcept {
-                return p.second;
-            }
-            template <typename T1, typename T2>
-            static GT_CONSTEXPR GT_FUNCTION T2 &&move_get(pair<T1, T2> &&p) noexcept {
-                return wstd::move(p.second);
-            }
-        };
-
-        struct getter {
-            template <std::size_t I, class T1, class T2>
-            static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(pair<T1, T2> &p) noexcept {
-                return pair_get<I>::get(p);
-            }
-
-            template <std::size_t I, class T1, class T2>
-            static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(const pair<T1, T2> &p) noexcept {
-                return pair_get<I>::const_get(p);
-            }
-
-            template <std::size_t I, class T1, class T2>
-            static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(pair<T1, T2> &&p) noexcept {
-                return pair_get<I>::move_get(wstd::move(p));
-            }
-        };
-    } // namespace pair_impl_
-
-    template <std::size_t I, class T1, class T2>
-    GT_FUNCTION decltype(auto) get(pair<T1, T2> &p) noexcept {
-        return pair_impl_::pair_get<I>::get(p);
-    }
-
-    template <std::size_t I, class T1, class T2>
-    GT_CONSTEXPR GT_FUNCTION decltype(auto) get(const pair<T1, T2> &p) noexcept {
-        return pair_impl_::pair_get<I>::const_get(p);
-    }
-
-    template <std::size_t I, class T1, class T2>
-    GT_CONSTEXPR GT_FUNCTION decltype(auto) get(pair<T1, T2> &&p) noexcept {
-        return pair_impl_::pair_get<I>::move_get(wstd::move(p));
-    }
-
-    template <class T1, class T2>
-    pair_impl_::getter tuple_getter(pair<T1, T2> const &);
-} // namespace gridtools
-
-namespace std {
-    template <class T1, class T2>
-    struct tuple_size<::gridtools::pair<T1, T2>> : integral_constant<size_t, 2> {};
-
-    template <class T1, class T2>
-    struct tuple_element<0, ::gridtools::pair<T1, T2>> {
-        using type = T1;
-    };
-    template <class T1, class T2>
-    struct tuple_element<1, ::gridtools::pair<T1, T2>> {
-        using type = T2;
-    };
-} // namespace std
-#endif
\ No newline at end of file
diff --git a/include/gridtools/common/tuple_util.hpp b/include/gridtools/common/tuple_util.hpp
index 95b2fc7ad1..178c3efd3c 100644
--- a/include/gridtools/common/tuple_util.hpp
+++ b/include/gridtools/common/tuple_util.hpp
@@ -143,7 +143,7 @@ test_kcache_flush_gpu
         }                                                                                 \
     };                                                                                    \
     friend class_name##_tuple_util_getter tuple_getter(class_name const &) { return {}; } \
-    static_assert(1, "")
+    static_assert(1)
 
 #define GT_STRUCT_TUPLE_IMPL_DECL_(r, data, elem) BOOST_PP_TUPLE_ELEM(0, elem) BOOST_PP_TUPLE_ELEM(1, elem);
 #define GT_STRUCT_TUPLE_IMPL_TYPE_(s, data, elem) BOOST_PP_TUPLE_ELEM(0, elem)
@@ -205,7 +205,7 @@ test_kcache_flush_gpu
     GT_FORCE_INLINE constexpr decltype(auto) name(Args &&...args) { \
         return functor()(std::forward<Args>(args)...);              \
     }                                                               \
-    static_assert(1, "")
+    static_assert(1)
 #ifdef __NVCC__
 #define DEFINE_TEMPLATED_FUNCTOR_INSTANCE(name, functor) GT_DEVICE constexpr functor name = {}
 #else
@@ -476,6 +476,14 @@ namespace gridtools {
         template <class T>
         struct is_tuple_like<T, std::enable_if_t<impl_::is_tuple_like<T>::value>> : std::true_type {};
 
+        template <size_t I>
+        struct get_f {
+            template <class T, class Getter = traits::getter<std::decay_t<T>>>
+            GT_FORCE_INLINE constexpr decltype(auto) operator()(T &&obj) const noexcept {
+                return Getter::template get<I>(std::forward<T>(obj));
+            }
+        };
+
         /**
          * @brief Tuple element accessor like std::get.
          *
@@ -483,18 +491,8 @@ namespace gridtools {
          * @tparam T Tuple-like type.
          * @param obj Tuple-like object.
          */
-        template <size_t I, class T, class Getter = traits::getter<std::decay_t<T>>>
-        GT_FORCE_INLINE constexpr decltype(auto) get(T &&obj) noexcept {
-            return Getter::template get<I>(std::forward<T>(obj));
-        }
-
         template <size_t I>
-        struct get_nth_f {
-            template <class T, class Getter = traits::getter<std::decay_t<T>>>
-            GT_FORCE_INLINE constexpr decltype(auto) operator()(T &&obj) const noexcept {
-                return Getter::template get<I>(std::forward<T>(obj));
-            }
-        };
+        DEFINE_TEMPLATED_FUNCTOR_INSTANCE(get, get_f<I>);
 
         namespace impl_ {
             template <size_t I>
@@ -676,7 +674,7 @@ namespace gridtools {
             template <size_t N>
             struct drop_front_f {
                 template <class I>
-                using get_drop_front_generator = get_nth_f<N + I::value>;
+                using get_drop_front_generator = get_f<N + I::value>;
 
                 template <class Tup,
                     class Accessors = get_accessors<Tup>,
@@ -848,55 +846,6 @@ namespace gridtools {
                 }
             };
 
-            template <class Fun>
-            struct all_of_f {
-                Fun m_fun;
-
-                template <size_t I, size_t N, class... Tups, std::enable_if_t<I == N, int> = 0>
-                GT_FORCE_INLINE constexpr bool impl(Tups &&...) const {
-                    return true;
-                }
-
-                template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 1 == N, int> = 0>
-                GT_FORCE_INLINE constexpr bool impl(Tups &&...tups) const {
-                    return m_fun(get<I>(std::forward<Tups>(tups))...);
-                }
-
-                template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 2 == N, int> = 0>
-                GT_FORCE_INLINE constexpr bool impl(Tups &&...tups) const {
-                    return m_fun(get<I>(std::forward<Tups>(tups))...) && m_fun(get<I + 1>(std::forward<Tups>(tups))...);
-                }
-
-                template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 3 == N, int> = 0>
-                GT_FORCE_INLINE constexpr bool impl(Tups &&...tups) const {
-                    return m_fun(get<I>(std::forward<Tups>(tups))...) &&
-                           m_fun(get<I + 1>(std::forward<Tups>(tups))...) &&
-                           m_fun(get<I + 2>(std::forward<Tups>(tups))...);
-                }
-
-                template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 4 == N, int> = 0>
-                GT_FORCE_INLINE constexpr bool impl(Tups &&...tups) const {
-                    return m_fun(get<I>(std::forward<Tups>(tups))...) &&
-                           m_fun(get<I + 1>(std::forward<Tups>(tups))...) &&
-                           m_fun(get<I + 2>(std::forward<Tups>(tups))...) &&
-                           m_fun(get<I + 3>(std::forward<Tups>(tups))...);
-                }
-
-                template <size_t I, size_t N, class... Tups, std::enable_if_t<(I + 4 < N), int> = 0>
-                GT_FORCE_INLINE constexpr bool impl(Tups &&...tups) const {
-                    return m_fun(get<I>(std::forward<Tups>(tups))...) &&
-                           m_fun(get<I + 1>(std::forward<Tups>(tups))...) &&
-                           m_fun(get<I + 2>(std::forward<Tups>(tups))...) &&
-                           m_fun(get<I + 3>(std::forward<Tups>(tups))...) &&
-                           impl<I + 4, N>(std::forward<Tups>(tups)...);
-                }
-
-                template <class Tup, class... Tups>
-                GT_FORCE_INLINE constexpr bool operator()(Tup &&tup, Tups &&...tups) const {
-                    return impl<0, size<std::decay_t<Tup>>::value>(std::forward<Tup>(tup), std::forward<Tups>(tups)...);
-                }
-            };
-
             template <class To, class Index>
             struct implicit_convert_to_f {
                 using type = implicit_convert_to_f;
@@ -926,7 +875,7 @@ namespace gridtools {
                 };
 
                 template <class I>
-                using get_generator = transform_f<get_nth_f<I::value>>;
+                using get_generator = transform_f<get_f<I::value>>;
 
                 template <class Tup>
                 GT_FORCE_INLINE constexpr std::enable_if_t<tuple_util::size<std::decay_t<Tup>>::value == 0> operator()(
@@ -952,7 +901,7 @@ namespace gridtools {
                 template <class N>
                 struct generator_f {
                     template <class I>
-                    using apply = get_nth_f<N::value - 1 - I::value>;
+                    using apply = get_f<N::value - 1 - I::value>;
                 };
 
                 template <class Tup,
@@ -1436,16 +1385,6 @@ namespace gridtools {
             return {std::move(fun)};
         }
 
-        template <class Pred, class... Tups>
-        GT_FORCE_INLINE constexpr bool all_of(Pred &&pred, Tups &&...tups) {
-            return impl_::all_of_f<Pred>{std::forward<Pred>(pred)}(std::forward<Tups>(tups)...);
-        }
-
-        template <class Pred>
-        GT_FORCE_INLINE constexpr impl_::all_of_f<Pred> all_of(Pred pred) {
-            return {std::move(pred)};
-        }
-
         /**
          * transposes a `tuple like` of `tuple like`.
          *
diff --git a/include/gridtools/common/utility.hpp b/include/gridtools/common/utility.hpp
deleted file mode 100644
index 5860569cb1..0000000000
--- a/include/gridtools/common/utility.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * GridTools
- *
- * Copyright (c) 2014-2021, ETH Zurich
- * All rights reserved.
- *
- * Please, refer to the LICENSE file in the root directory.
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#pragma once
-#include <utility>
-
-namespace gridtools {
-    namespace wstd {
-        using ::std::forward;
-        using ::std::move;
-    } // namespace wstd
-} // namespace gridtools
-
-#if 0
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-#include "defs.hpp"
-#include "host_device.hpp"
-
-namespace gridtools {
-    /**
-     *  `std::forward`/`std::move` versions that are guaranteed to be not constexpr. They are needed because
-     *  some compilers, especially nvcc have problems with functions that return references in constexpr functions,
-     *  if they are not used in constexpr context. As the `std` versions are constexpr, we must have separate
-     *  functions that are constexpr only if the compiler is known to not mess up with them.
-     */
-    namespace wstd {
-        template <class T>
-        GT_CONSTEXPR GT_HOST_DEVICE std::remove_reference_t<T> &&move(T &&obj) noexcept {
-            return static_cast<std::remove_reference_t<T> &&>(obj);
-        }
-        template <class T>
-        GT_CONSTEXPR GT_HOST_DEVICE T &&forward(std::remove_reference_t<T> &obj) noexcept {
-            return static_cast<T &&>(obj);
-        }
-        template <class T>
-        GT_CONSTEXPR GT_HOST_DEVICE T &&forward(std::remove_reference_t<T> &&obj) noexcept {
-            static_assert(
-                !std::is_lvalue_reference<T>::value, "Error: obj is instantiated with an lvalue reference type");
-            return static_cast<T &&>(obj);
-        }
-
-    } // namespace wstd
-} // namespace gridtools
-#endif
\ No newline at end of file
diff --git a/include/gridtools/fn/extents.hpp b/include/gridtools/fn/extents.hpp
index 1ec9359f0e..096a08b797 100644
--- a/include/gridtools/fn/extents.hpp
+++ b/include/gridtools/fn/extents.hpp
@@ -26,10 +26,10 @@
 #include <algorithm>
 #include <cstddef>
 #include <type_traits>
+#include <utility>
 
 #include "../common/int_vector.hpp"
 #include "../common/integral_constant.hpp"
-#include "../common/utility.hpp"
 #include "../meta.hpp"
 
 namespace gridtools {
@@ -61,12 +61,12 @@ namespace gridtools {
             static_assert(meta::is_set<meta::list<typename Ts::dim_t...>>::value);
             using keys_t = hymap::keys<typename Ts::dim_t...>;
 
-            static GT_CONSTEVAL GT_FUNCTION auto offsets() {
+            static GT_CONSTEVAL auto offsets() {
                 return int_vector::prune_zeros(typename keys_t::template values<typename Ts::lower_t...>());
             }
             using offsets_t = decltype(offsets());
 
-            static GT_CONSTEVAL GT_FUNCTION auto sizes() {
+            static GT_CONSTEVAL auto sizes() {
                 return int_vector::prune_zeros(typename keys_t::template values<typename Ts::size_t...>());
             }
             using sizes_t = decltype(sizes());
@@ -86,19 +86,19 @@ namespace gridtools {
 #endif
 
         template <class Extents, class Offsets>
-        decltype(auto) GT_FUNCTION GT_CONSTEXPR extend_offsets(Offsets &&src) {
+        GT_FORCE_INLINE constexpr decltype(auto) extend_offsets(Offsets &&src) {
             static_assert(is_extents<Extents>::value);
             static_assert(is_int_vector<std::decay_t<Offsets>>::value);
             using namespace int_vector::arithmetic;
-            return wstd::forward<Offsets>(src) + Extents::offsets();
+            return std::forward<Offsets>(src) + Extents::offsets();
         }
 
         template <class Extents, class Sizes>
-        decltype(auto) GT_FUNCTION GT_CONSTEXPR extend_sizes(Sizes &&sizes) {
+        GT_FORCE_INLINE constexpr decltype(auto) extend_sizes(Sizes &&sizes) {
             static_assert(is_extents<Extents>::value);
             static_assert(is_int_vector<std::decay_t<Sizes>>::value);
             using namespace int_vector::arithmetic;
-            return wstd::forward<Sizes>(sizes) + Extents::sizes();
+            return std::forward<Sizes>(sizes) + Extents::sizes();
         }
 
         namespace extent_impl_ {
diff --git a/include/gridtools/fn/scan.hpp b/include/gridtools/fn/scan.hpp
index 507763e90d..f5024a16c1 100644
--- a/include/gridtools/fn/scan.hpp
+++ b/include/gridtools/fn/scan.hpp
@@ -16,6 +16,7 @@
 #include "../common/functional.hpp"
 #include "../common/integral_constant.hpp"
 #include "../common/tuple.hpp"
+#include "../common/host_device.hpp"
 #include "../meta/is_instantiation_of.hpp"
 #include "../sid/concept.hpp"
 
@@ -33,8 +34,8 @@ namespace gridtools::fn {
 
         template <bool IsBackward>
         struct base : std::bool_constant<IsBackward> {
-            static GT_FUNCTION constexpr auto prologue() { return tuple<>(); }
-            static GT_FUNCTION constexpr auto epilogue() { return tuple<>(); }
+            static GT_FORCE_INLINE constexpr auto prologue() { return tuple<>(); }
+            static GT_FORCE_INLINE constexpr auto epilogue() { return tuple<>(); }
         };
 
         using fwd = base<false>;
@@ -46,7 +47,8 @@ namespace gridtools::fn {
             GT_FUNCTION auto operator()(Seed seed, std::size_t size, Ptr ptr, Strides const &strides) const {
                 constexpr std::size_t prologue_size = std::tuple_size_v<decltype(ScanOrFold::prologue())>;
                 constexpr std::size_t epilogue_size = std::tuple_size_v<decltype(ScanOrFold::epilogue())>;
-                assert(size >= prologue_size + epilogue_size);
+                if constexpr (prologue_size + epilogue_size)
+                    assert(size >= prologue_size + epilogue_size);
                 using step_t = integral_constant<int, ScanOrFold::value ? -1 : 1>;
                 auto const &v_stride = sid::get_stride<Vertical>(strides);
                 auto inc = [&] { sid::shift(ptr, v_stride, step_t()); };
diff --git a/include/gridtools/gcl/high_level/wrap_argument.hpp b/include/gridtools/gcl/high_level/wrap_argument.hpp
index 15bf598904..2fcef60864 100644
--- a/include/gridtools/gcl/high_level/wrap_argument.hpp
+++ b/include/gridtools/gcl/high_level/wrap_argument.hpp
@@ -12,12 +12,12 @@
 struct wrap_argument {
     int data[27];
 
-    GT_FUNCTION wrap_argument(int const *ptr) {
+    constexpr wrap_argument(int const *ptr) {
         for (int i = 0; i < 27; ++i)
             data[i] = ptr[i];
     }
 
-    GT_FUNCTION int &operator[](int i) { return data[i]; }
+    constexpr int &operator[](int i) { return data[i]; }
 
-    GT_FUNCTION int const &operator[](int i) const { return data[i]; }
+    constexpr int const &operator[](int i) const { return data[i]; }
 };
diff --git a/include/gridtools/gcl/low_level/proc_grids_3D.hpp b/include/gridtools/gcl/low_level/proc_grids_3D.hpp
index bb06fbb5c6..9f01ac32d0 100644
--- a/include/gridtools/gcl/low_level/proc_grids_3D.hpp
+++ b/include/gridtools/gcl/low_level/proc_grids_3D.hpp
@@ -210,11 +210,9 @@ namespace gridtools {
                 return res;
             }
 
-            GT_FUNCTION
-            array<int, ndims> const &coordinates() const { return m_coordinates; }
+            constexpr array<int, ndims> const &coordinates() const { return m_coordinates; }
 
-            GT_FUNCTION
-            array<int, ndims> const &dimensions() const { return m_dimensions; }
+            constexpr array<int, ndims> const &dimensions() const { return m_dimensions; }
 
             /** Returns the process ID of the process with absolute coordinates specified by the input array of
                coordinates
diff --git a/include/gridtools/meta/debug.hpp b/include/gridtools/meta/debug.hpp
index 16d19eb88b..a3eb313d08 100644
--- a/include/gridtools/meta/debug.hpp
+++ b/include/gridtools/meta/debug.hpp
@@ -18,7 +18,7 @@
  *  Works also with parameter packs. I.e you can both `GT_META_PRINT_TYPE(SomeType)` and
  * `GT_META_PRINT_TYPE(SomeTypes...)`
  */
-#define GT_META_PRINT_TYPE(x) static_assert(::gridtools::meta::debug::type<BOOST_PP_REMOVE_PARENS(x)>::_, "")
+#define GT_META_PRINT_TYPE(x) static_assert(::gridtools::meta::debug::type<BOOST_PP_REMOVE_PARENS(x)>::_)
 
 /**
  *  This macro expands to the code snippet that generates a compiler error that refers to the compile time value(s) of
@@ -30,8 +30,7 @@
 #define GT_META_PRINT_VALUE(x)                                                                                \
     static_assert(                                                                                            \
         ::gridtools::meta::debug::value<decltype(::gridtools::meta::debug::first(BOOST_PP_REMOVE_PARENS(x))), \
-            BOOST_PP_REMOVE_PARENS(x)>::_,                                                                    \
-        "")
+            BOOST_PP_REMOVE_PARENS(x)>::_)
 
 namespace gridtools {
     namespace meta {
diff --git a/include/gridtools/reduction/cpu.hpp b/include/gridtools/reduction/cpu.hpp
index 05a1bb0275..b27c318d46 100644
--- a/include/gridtools/reduction/cpu.hpp
+++ b/include/gridtools/reduction/cpu.hpp
@@ -53,7 +53,7 @@ namespace gridtools {
 
         template <class T, std::enable_if_t<std::is_integral<T>::value, int> = 0>
         T reduction_reduce(cpu, T res, bitwise_xor, T const *buff, size_t n) {
-#pragma omp parallel for reduction (^ : res)
+#pragma omp parallel for reduction(^ : res)
             for (size_t i = 0; i < n; i++)
                 res ^= buff[i];
             return res;
@@ -61,10 +61,10 @@ namespace gridtools {
 
         template <class F, class T>
         T reduction_reduce(cpu, T res, F, T const *buff, size_t n) {
-            static_assert(std::is_empty<F>(), "OpenMP reduction supports only stateless functors.");
+            static_assert(std::is_empty_v<F>, "OpenMP reduction supports only stateless functors.");
             static_assert(
-                std::is_default_constructible<F>(), "OpenMP reduction supports only default constructible functors.");
-#pragma omp declare reduction(gridtools_generic : T : omp_out = F()(omp_out, omp_in)) initializer(omp_priv = omp_orig)
+                std::is_default_constructible_v<F>, "OpenMP reduction supports only default constructible functors.");
+#pragma omp declare reduction(gridtools_generic:T : omp_out = F()(omp_out, omp_in)) initializer(omp_priv = omp_orig)
 #pragma omp parallel for reduction(gridtools_generic : res)
             for (size_t i = 0; i < n; i++)
                 res = F()(res, buff[i]);
diff --git a/include/gridtools/reduction/functions.hpp b/include/gridtools/reduction/functions.hpp
index a2c958949c..fd171e1d3f 100644
--- a/include/gridtools/reduction/functions.hpp
+++ b/include/gridtools/reduction/functions.hpp
@@ -15,43 +15,43 @@ namespace gridtools {
     namespace reduction {
         struct plus {
             template <class T>
-            GT_FUNCTION auto operator()(T const &x, T const &y) const {
+            GT_FORCE_INLINE constexpr auto operator()(T const &x, T const &y) const {
                 return x + y;
             }
         };
         struct mul {
             template <class T>
-            GT_FUNCTION auto operator()(T const &x, T const &y) const {
+            GT_FORCE_INLINE constexpr auto operator()(T const &x, T const &y) const {
                 return x * y;
             }
         };
         struct min {
             template <class T>
-            GT_FUNCTION auto operator()(T const &x, T const &y) const {
+            GT_FORCE_INLINE constexpr auto operator()(T const &x, T const &y) const {
                 return x < y ? x : y;
             }
         };
         struct max {
             template <class T>
-            GT_FUNCTION auto operator()(T const &x, T const &y) const {
+            GT_FORCE_INLINE constexpr auto operator()(T const &x, T const &y) const {
                 return x > y ? x : y;
             }
         };
         struct bitwise_and {
             template <class T>
-            GT_FUNCTION auto operator()(T const &x, T const &y) const {
+            GT_FORCE_INLINE constexpr auto operator()(T const &x, T const &y) const {
                 return x & y;
             }
         };
         struct bitwise_or {
             template <class T>
-            GT_FUNCTION auto operator()(T const &x, T const &y) const {
+            GT_FORCE_INLINE constexpr auto operator()(T const &x, T const &y) const {
                 return x | y;
             }
         };
         struct bitwise_xor {
             template <class T>
-            GT_FUNCTION auto operator()(T const &x, T const &y) const {
+            GT_FORCE_INLINE constexpr auto operator()(T const &x, T const &y) const {
                 return x ^ y;
             }
         };
diff --git a/include/gridtools/sid/as_const.hpp b/include/gridtools/sid/as_const.hpp
index 3a0a292127..9e1632e6f3 100644
--- a/include/gridtools/sid/as_const.hpp
+++ b/include/gridtools/sid/as_const.hpp
@@ -26,11 +26,11 @@ namespace gridtools {
                 struct const_ptr_holder {
                     ptr_holder_type<Sid> m_impl;
 
-                    GT_CONSTEXPR GT_FUNCTION std::add_const_t<sid::element_type<Sid>> *operator()() const {
+                    GT_FORCE_INLINE constexpr std::add_const_t<sid::element_type<Sid>> *operator()() const {
                         return m_impl();
                     }
 
-                    friend GT_CONSTEXPR GT_FUNCTION const_ptr_holder operator+(
+                    friend GT_FORCE_INLINE constexpr const_ptr_holder operator+(
                         const_ptr_holder const &obj, ptr_diff_type<Sid> offset) {
                         return {obj.m_impl + offset};
                     }
diff --git a/include/gridtools/sid/block.hpp b/include/gridtools/sid/block.hpp
index 517fa9d247..c61e90e1a7 100644
--- a/include/gridtools/sid/block.hpp
+++ b/include/gridtools/sid/block.hpp
@@ -32,7 +32,7 @@ namespace gridtools {
             };
 
             template <class Ptr, class Stride, class BlockSize, class Offset>
-            GT_FUNCTION decltype(auto) sid_shift(
+            GT_FORCE_INLINE constexpr decltype(auto) sid_shift(
                 Ptr &ptr, blocked_stride<Stride, BlockSize> const &stride, Offset const &offset) {
                 return shift(ptr, tuple_util::get<0>(stride), tuple_util::get<1>(stride) * offset);
             }
diff --git a/include/gridtools/sid/composite.hpp b/include/gridtools/sid/composite.hpp
index 9d10c5a868..b87969a4c3 100644
--- a/include/gridtools/sid/composite.hpp
+++ b/include/gridtools/sid/composite.hpp
@@ -22,7 +22,6 @@
 #include "../common/hymap.hpp"
 #include "../common/tuple.hpp"
 #include "../common/tuple_util.hpp"
-#include "../common/utility.hpp"
 #include "../meta.hpp"
 #include "concept.hpp"
 #include "unknown_kind.hpp"
@@ -117,9 +116,9 @@ namespace gridtools {
                     ObjTup &obj_tup, StrideTup &&stride_tup, Offset offset) {
                     tuple_util::for_each(
                         [offset](auto &obj, auto &&stride)
-                            GT_FORCE_INLINE_LAMBDA { shift(obj, wstd::forward<decltype(stride)>(stride), offset); },
+                            GT_FORCE_INLINE_LAMBDA { shift(obj, std::forward<decltype(stride)>(stride), offset); },
                         obj_tup,
-                        wstd::forward<StrideTup>(stride_tup));
+                        std::forward<StrideTup>(stride_tup));
                 }
 
                 template <class Key, class Strides, class I = meta::st_position<get_keys<Strides>, Key>>
@@ -189,11 +188,11 @@ namespace gridtools {
                 template <class... Args,
                     std::enable_if_t<std::conjunction_v<std::is_constructible<Ptrs, Args>...>, int> = 0>
                 GT_FORCE_INLINE constexpr composite_ptr(Args &&...args) noexcept
-                    : m_vals{wstd::forward<Args>(args)...} {}
+                    : m_vals{std::forward<Args>(args)...} {}
 
                 GT_FORCE_INLINE constexpr composite_ptr(Ptrs const &...args) noexcept : m_vals(args...) {}
 
-                GT_FORCE_INLINE constexpr composite_ptr(tuple<Ptrs...> &&args) noexcept : m_vals(wstd::move(args)) {}
+                GT_FORCE_INLINE constexpr composite_ptr(tuple<Ptrs...> &&args) noexcept : m_vals(std::move(args)) {}
                 GT_FORCE_INLINE constexpr composite_ptr(tuple<Ptrs...> const &args) noexcept : m_vals(args) {}
 
                 composite_ptr() = default;
@@ -252,7 +251,7 @@ namespace gridtools {
 
                 GT_TUPLE_UTIL_FORWARD_GETTER_TO_MEMBER(composite_ptr_holder, m_vals);
 
-                GT_FUNCTION constexpr auto operator()() const {
+                GT_FORCE_INLINE constexpr auto operator()() const {
                     return tuple_util::apply(
                         [](auto const &...holders) {
                             return composite_ptr<std::decay_t<decltype(holders())>...>(holders()...);
@@ -299,7 +298,7 @@ namespace gridtools {
                     class Item = meta::mp_find<Map, std::integral_constant<size_t, I>>,
                     class Pos = meta::second<Item>>
                 static GT_FORCE_INLINE constexpr decltype(auto) get(T &&obj) {
-                    return tuple_util::get<Pos::value>(wstd::forward<T>(obj).m_vals);
+                    return tuple_util::get<Pos::value>(std::forward<T>(obj).m_vals);
                 }
 
                 template <class... Ts>
@@ -348,7 +347,7 @@ namespace gridtools {
                     template <class... Ptrs, class Offset>
                     friend GT_FORCE_INLINE constexpr void sid_shift(
                         composite_ptr<Ptrs...> &ptr, composite_entity &&stride, Offset offset) {
-                        impl_::composite_shift_impl(ptr.m_vals, wstd::move(stride), offset);
+                        impl_::composite_shift_impl(ptr.m_vals, std::move(stride), offset);
                     }
 
                     friend keys hymap_get_keys(composite_entity const &) { return {}; }
@@ -364,7 +363,7 @@ namespace gridtools {
                 template <class... PtrDiffs, class... Strides, class Offset>
                 friend GT_FORCE_INLINE constexpr void sid_shift(
                     composite_entity<PtrDiffs...> &ptr_diff, composite_entity<Strides...> &&stride, Offset offset) {
-                    impl_::composite_shift_impl(ptr_diff.m_vals, wstd::move(stride.m_vals), offset);
+                    impl_::composite_shift_impl(ptr_diff.m_vals, std::move(stride.m_vals), offset);
                 }
 
                 struct convert_f {
@@ -382,11 +381,10 @@ namespace gridtools {
                 static_assert(sizeof...(Keys) == sizeof...(Sids), GT_INTERNAL_ERROR);
 #if defined(__CUDACC_VER_MAJOR__) && __CUDACC_VER_MAJOR__ == 11 && __CUDACC_VER_MINOR__ < 1
 #else
-                static_assert(std::conjunction<is_sid<Sids>...>::value, GT_INTERNAL_ERROR);
+                static_assert(std::conjunction_v<is_sid<Sids>...>, GT_INTERNAL_ERROR);
 #endif
                 static_assert(meta::all<meta::mp_make<impl_::check_strides_of_the_same_kind,
-                                  meta::list<meta::list<strides_kind<Sids>, strides_type<Sids>>...>>>(),
-                    "");
+                        meta::list<meta::list<strides_kind<Sids>, strides_type<Sids>>...>>>());
 
                 tuple<Sids...> m_sids;
 
diff --git a/include/gridtools/sid/loop.hpp b/include/gridtools/sid/loop.hpp
index a7c93c6909..75a10c3585 100644
--- a/include/gridtools/sid/loop.hpp
+++ b/include/gridtools/sid/loop.hpp
@@ -27,7 +27,7 @@ namespace gridtools {
 
             template <class Key, class T>
             struct generic_loop {
-                static_assert(std::is_signed<T>::value, GT_INTERNAL_ERROR);
+                static_assert(std::is_signed_v<T>, GT_INTERNAL_ERROR);
 
                 T m_num_steps;
                 T m_step;
@@ -39,7 +39,7 @@ namespace gridtools {
                     T m_step;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION operator()(Ptr &&ptr, Strides const &strides) const {
+                    GT_FORCE_INLINE constexpr void operator()(Ptr &&ptr, Strides const &strides) const {
                         assert(m_num_steps >= 0);
                         if (m_num_steps <= 0)
                             return;
@@ -53,7 +53,7 @@ namespace gridtools {
                 };
 
                 template <class Fun>
-                GT_CONSTEXPR GT_FUNCTION loop_f<Fun> operator()(Fun &&fun) const {
+                GT_FORCE_INLINE constexpr loop_f<Fun> operator()(Fun &&fun) const {
                     return {std::forward<Fun>(fun), m_num_steps, m_step};
                 }
 
@@ -65,7 +65,7 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         assert(m_num_steps >= 0);
                         if (m_num_steps <= 0)
                             return;
@@ -78,11 +78,11 @@ namespace gridtools {
                         }
                     }
 
-                    GT_FUNCTION bool done() const { return m_num_steps <= 0 || m_outer.done(); }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_num_steps <= 0 || m_outer.done(); }
                 };
 
                 template <class Outer>
-                GT_CONSTEXPR GT_FUNCTION cursor_f<Outer> make_cursor(Outer &&outer) const {
+                GT_FORCE_INLINE constexpr cursor_f<Outer> make_cursor(Outer &&outer) const {
                     return {std::forward<Outer>(outer), m_num_steps, m_step, 0};
                 }
 
@@ -91,20 +91,20 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         --m_pos;
                         shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), m_step);
                     }
 
-                    GT_FUNCTION bool done() const { return m_pos > 0; }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_pos > 0; }
                 };
 
-                GT_CONSTEXPR GT_FUNCTION outer_most_cursor_f make_cursor() const { return {m_step, m_num_steps}; }
+                GT_FORCE_INLINE constexpr outer_most_cursor_f make_cursor() const { return {m_step, m_num_steps}; }
             };
 
             template <class Key, class T, ptrdiff_t Step>
             struct known_step_loop {
-                static_assert(std::is_signed<T>::value, GT_INTERNAL_ERROR);
+                static_assert(std::is_signed_v<T>, GT_INTERNAL_ERROR);
 
                 T m_num_steps;
 
@@ -114,7 +114,7 @@ namespace gridtools {
                     T m_num_steps;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION operator()(Ptr &&ptr, Strides const &strides) const {
+                    GT_FORCE_INLINE constexpr void operator()(Ptr &&ptr, Strides const &strides) const {
                         assert(m_num_steps >= 0);
                         if (m_num_steps <= 0)
                             return;
@@ -123,13 +123,12 @@ namespace gridtools {
                             m_fun(ptr, strides);
                             shift(ptr, stride, integral_constant<T, Step>{});
                         }
-                        static constexpr T minus_step = -Step;
-                        shift(std::forward<Ptr>(ptr), stride, minus_step * m_num_steps);
+                        shift(std::forward<Ptr>(ptr), stride, - Step * m_num_steps);
                     }
                 };
 
                 template <class Fun>
-                GT_FUNCTION loop_f<Fun> operator()(Fun &&fun) const {
+                GT_FORCE_INLINE constexpr loop_f<Fun> operator()(Fun &&fun) const {
                     return {std::forward<Fun>(fun), m_num_steps};
                 }
 
@@ -140,7 +139,7 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         assert(m_num_steps >= 0);
                         if (m_num_steps <= 0)
                             return;
@@ -153,11 +152,11 @@ namespace gridtools {
                         }
                     }
 
-                    GT_FUNCTION bool done() const { return m_num_steps <= 0 || m_outer.done(); }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_num_steps <= 0 || m_outer.done(); }
                 };
 
                 template <class Outer>
-                GT_CONSTEXPR GT_FUNCTION cursor_f<Outer> make_cursor(Outer &&outer) const {
+                GT_FORCE_INLINE constexpr cursor_f<Outer> make_cursor(Outer &&outer) const {
                     return {std::forward<Outer>(outer), m_num_steps, 0};
                 }
 
@@ -165,20 +164,20 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         --m_pos;
                         shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), integral_constant<T, Step>{});
                     }
 
-                    GT_FUNCTION bool done() const { return m_pos > 0; }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_pos > 0; }
                 };
 
-                GT_CONSTEXPR GT_FUNCTION outer_most_cursor_f make_cursor() const { return {m_num_steps}; }
+                GT_FORCE_INLINE constexpr outer_most_cursor_f make_cursor() const { return {m_num_steps}; }
             };
 
             template <class Key, class T>
             struct known_step_loop<Key, T, 0> {
-                static_assert(std::is_signed<T>::value, GT_INTERNAL_ERROR);
+                static_assert(std::is_signed_v<T>, GT_INTERNAL_ERROR);
 
                 T m_num_steps;
 
@@ -188,7 +187,7 @@ namespace gridtools {
                     T m_num_steps;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION operator()(Ptr &&ptr, const Strides &strides) const {
+                    GT_FORCE_INLINE constexpr void operator()(Ptr &&ptr, const Strides &strides) const {
                         assert(m_num_steps >= 0);
                         for (T i = 0; i < m_num_steps; ++i)
                             m_fun(std::forward<Ptr>(ptr), strides);
@@ -196,7 +195,7 @@ namespace gridtools {
                 };
 
                 template <class Fun>
-                GT_CONSTEXPR GT_FUNCTION loop_f<Fun> operator()(Fun &&fun) const {
+                GT_FORCE_INLINE constexpr loop_f<Fun> operator()(Fun &&fun) const {
                     return {std::forward<Fun>(fun), m_num_steps};
                 }
 
@@ -207,7 +206,7 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         assert(m_num_steps >= 0);
                         if (m_num_steps <= 0)
                             return;
@@ -217,11 +216,11 @@ namespace gridtools {
                         }
                     }
 
-                    GT_FUNCTION bool done() const { return m_num_steps <= 0 || m_outer.done(); }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_num_steps <= 0 || m_outer.done(); }
                 };
 
                 template <class Outer>
-                GT_CONSTEXPR GT_FUNCTION cursor_f<Outer> make_cursor(Outer &&outer) const {
+                GT_FORCE_INLINE constexpr cursor_f<Outer> make_cursor(Outer &&outer) const {
                     return {std::forward<Outer>(outer), m_num_steps, 0};
                 }
 
@@ -229,19 +228,19 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&, Strides const &) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&, Strides const &) {
                         --m_pos;
                     }
 
-                    GT_FUNCTION bool done() const { return m_pos > 0; }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_pos > 0; }
                 };
 
-                GT_CONSTEXPR GT_FUNCTION outer_most_cursor_f make_cursor() const { return {m_num_steps}; }
+                GT_FORCE_INLINE constexpr outer_most_cursor_f make_cursor() const { return {m_num_steps}; }
             };
 
             template <class Key, class T, T NumSteps>
             struct known_num_steps_loop {
-                static_assert(std::is_signed<T>::value, GT_INTERNAL_ERROR);
+                static_assert(std::is_signed_v<T>, GT_INTERNAL_ERROR);
 
                 T m_step;
 
@@ -251,20 +250,19 @@ namespace gridtools {
                     T m_step;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION operator()(Ptr &&ptr, const Strides &strides) const {
+                    GT_FORCE_INLINE constexpr void operator()(Ptr &&ptr, const Strides &strides) const {
                         auto &&stride = get_stride<Key>(strides);
                         // TODO(anstaf): to figure out if for_each<make_indices_c<NumSteps>>(...) produces better code.
                         for (T i = 0; i < NumSteps; ++i) {
                             m_fun(ptr, strides);
                             shift(ptr, stride, m_step);
                         }
-                        static constexpr T minus_num_steps = -NumSteps;
-                        shift(std::forward<Ptr>(ptr), stride, m_step * minus_num_steps);
+                        shift(std::forward<Ptr>(ptr), stride, - m_step * NumSteps);
                     }
                 };
 
                 template <class Fun>
-                GT_CONSTEXPR GT_FUNCTION loop_f<Fun> operator()(Fun &&fun) const {
+                GT_FORCE_INLINE constexpr loop_f<Fun> operator()(Fun &&fun) const {
                     return {std::forward<Fun>(fun), m_step};
                 }
 
@@ -275,10 +273,9 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         if (++m_pos == NumSteps) {
-                            constexpr T num_steps_back = 1 - NumSteps;
-                            shift(ptr, get_stride<Key>(strides), m_step * num_steps_back);
+                            shift(ptr, get_stride<Key>(strides), m_step * (1 - NumSteps));
                             m_pos = 0;
                             m_outer.next(std::forward<Ptr>(ptr), strides);
                         } else {
@@ -286,11 +283,11 @@ namespace gridtools {
                         }
                     }
 
-                    GT_FUNCTION bool done() const { return m_outer.done(); }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_outer.done(); }
                 };
 
                 template <class Outer>
-                GT_CONSTEXPR GT_FUNCTION cursor_f<Outer> make_cursor(Outer &&outer) const {
+                GT_FORCE_INLINE constexpr cursor_f<Outer> make_cursor(Outer &&outer) const {
                     return {std::forward<Outer>(outer), m_step, 0};
                 }
 
@@ -299,27 +296,27 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         --m_pos;
                         shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), m_step);
                     }
 
-                    GT_FUNCTION bool done() const { return m_pos > 0; }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_pos > 0; }
                 };
 
-                GT_CONSTEXPR GT_FUNCTION outer_most_cursor_f make_cursor() const { return {m_step, NumSteps}; }
+                GT_FORCE_INLINE constexpr outer_most_cursor_f make_cursor() const { return {m_step, NumSteps}; }
             };
 
             template <class Key, class T, ptrdiff_t NumSteps, ptrdiff_t Step>
             struct all_known_loop {
-                static_assert(std::is_signed<T>::value, GT_INTERNAL_ERROR);
+                static_assert(std::is_signed_v<T>, GT_INTERNAL_ERROR);
 
                 template <class Fun>
                 struct loop_f {
                     Fun m_fun;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION operator()(Ptr &&ptr, const Strides &strides) const {
+                    GT_FORCE_INLINE constexpr void operator()(Ptr &&ptr, const Strides &strides) const {
                         auto &&stride = get_stride<Key>(strides);
                         for (T i = 0; i < (T)NumSteps; ++i) {
                             m_fun(ptr, strides);
@@ -330,7 +327,7 @@ namespace gridtools {
                 };
 
                 template <class Fun>
-                GT_CONSTEXPR GT_FUNCTION loop_f<Fun> operator()(Fun &&fun) const {
+                GT_FORCE_INLINE constexpr loop_f<Fun> operator()(Fun &&fun) const {
                     return {std::forward<Fun>(fun)};
                 }
 
@@ -340,10 +337,9 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         if (++m_pos == NumSteps) {
-                            constexpr T offset_back = Step * (1 - NumSteps);
-                            shift(ptr, get_stride<Key>(strides), offset_back);
+                            shift(ptr, get_stride<Key>(strides), Step * (1 - NumSteps));
                             m_pos = 0;
                             m_outer.next(std::forward<Ptr>(ptr), strides);
                         } else {
@@ -351,11 +347,11 @@ namespace gridtools {
                         }
                     }
 
-                    GT_FUNCTION bool done() const { return m_outer.done(); }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_outer.done(); }
                 };
 
                 template <class Outer>
-                GT_CONSTEXPR GT_FUNCTION cursor_f<Outer> make_cursor(Outer &&outer) const {
+                GT_FORCE_INLINE constexpr cursor_f<Outer> make_cursor(Outer &&outer) const {
                     return {std::forward<Outer>(outer), 0};
                 }
 
@@ -363,34 +359,34 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         --m_pos;
                         shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), Step);
                     }
 
-                    GT_FUNCTION bool done() const { return m_pos > 0; }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_pos > 0; }
                 };
 
-                GT_CONSTEXPR GT_FUNCTION outer_most_cursor_f make_cursor() const { return {NumSteps}; }
+                GT_FORCE_INLINE constexpr outer_most_cursor_f make_cursor() const { return {NumSteps}; }
             };
 
             template <class Key, class T, ptrdiff_t NumSteps>
             struct all_known_loop<Key, T, NumSteps, 0> {
-                static_assert(std::is_signed<T>::value, GT_INTERNAL_ERROR);
+                static_assert(std::is_signed_v<T>, GT_INTERNAL_ERROR);
 
                 template <class Fun>
                 struct loop_f {
                     Fun m_fun;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION operator()(Ptr &&ptr, Strides const &strides) const {
+                    GT_FORCE_INLINE constexpr void operator()(Ptr &&ptr, Strides const &strides) const {
                         for (T i = 0; i < (T)NumSteps; ++i)
                             m_fun(ptr, strides);
                     }
                 };
 
                 template <class Fun>
-                GT_CONSTEXPR GT_FUNCTION loop_f<Fun> operator()(Fun &&fun) const {
+                GT_FORCE_INLINE constexpr loop_f<Fun> operator()(Fun &&fun) const {
                     return {std::forward<Fun>(fun)};
                 }
 
@@ -400,18 +396,18 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         if (++m_pos == NumSteps) {
                             m_pos = 0;
                             m_outer.next(std::forward<Ptr>(ptr), strides);
                         }
                     }
 
-                    GT_FUNCTION bool done() const { return m_outer.done(); }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_outer.done(); }
                 };
 
                 template <class Outer>
-                GT_CONSTEXPR GT_FUNCTION cursor_f<Outer> make_cursor(Outer &&outer) const {
+                GT_FORCE_INLINE constexpr cursor_f<Outer> make_cursor(Outer &&outer) const {
                     return {std::forward<Outer>(outer), 0};
                 }
 
@@ -419,27 +415,27 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&, Strides const &) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&, Strides const &) {
                         --m_pos;
                     }
 
-                    GT_FUNCTION bool done() const { return m_pos > 0; }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_pos > 0; }
                 };
 
-                GT_CONSTEXPR GT_FUNCTION outer_most_cursor_f make_cursor() const { return {NumSteps}; }
+                GT_FORCE_INLINE constexpr outer_most_cursor_f make_cursor() const { return {NumSteps}; }
             };
 
             template <class Key, class T>
             struct all_known_loop<Key, T, 1, 0> {
-                static_assert(std::is_signed<T>::value, GT_INTERNAL_ERROR);
+                static_assert(std::is_signed_v<T>, GT_INTERNAL_ERROR);
 
                 template <class Fun>
-                GT_CONSTEXPR GT_FUNCTION Fun operator()(Fun &&fun) const {
+                GT_FORCE_INLINE constexpr Fun operator()(Fun &&fun) const {
                     return fun;
                 }
 
                 template <class Outer>
-                GT_CONSTEXPR GT_FUNCTION Outer make_cursor(Outer &&outer) const {
+                GT_FORCE_INLINE constexpr Outer make_cursor(Outer &&outer) const {
                     return std::forward<Outer>(outer);
                 }
 
@@ -447,54 +443,54 @@ namespace gridtools {
                     bool m_done;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&, Strides const &) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&, Strides const &) {
                         m_done = true;
                     }
 
-                    GT_FUNCTION bool done() const { return m_done; }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_done; }
                 };
 
-                GT_CONSTEXPR GT_FUNCTION outer_most_cursor_f make_cursor() const { return {false}; }
+                GT_FORCE_INLINE constexpr outer_most_cursor_f make_cursor() const { return {false}; }
             };
 
             template <class Key, class T>
             struct all_known_loop<Key, T, 0, 0> {
-                static_assert(std::is_signed<T>::value, GT_INTERNAL_ERROR);
+                static_assert(std::is_signed_v<T>, GT_INTERNAL_ERROR);
 
                 template <class Fun>
-                GT_CONSTEXPR GT_FUNCTION noop operator()(Fun &&) const {
+                GT_FORCE_INLINE constexpr noop operator()(Fun &&) const {
                     return {};
                 }
 
                 struct cursor_f {
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&, Strides const &) {}
+                    GT_FORCE_INLINE constexpr void next(Ptr &&, Strides const &) {}
 
-                    GT_FUNCTION bool done() const { return true; }
+                    GT_FORCE_INLINE constexpr bool done() const { return true; }
                 };
 
                 template <class... Ts>
-                GT_CONSTEXPR GT_FUNCTION cursor_f make_cursor(Ts &&...) const {
+                GT_FORCE_INLINE constexpr cursor_f make_cursor(Ts &&...) const {
                     return {};
                 }
             };
 
             struct make_cursor_f {
                 template <class Cursor, class Loop>
-                GT_CONSTEXPR GT_FUNCTION auto operator()(Cursor &&cursor, Loop const &loop) const {
+                GT_FORCE_INLINE constexpr auto operator()(Cursor &&cursor, Loop const &loop) const {
                     return loop.make_cursor(std::forward<Cursor>(cursor));
                 }
             };
 
             template <class Loops>
-            GT_CONSTEXPR GT_FUNCTION auto make_cursor_r(Loops &&loops) {
+            GT_FORCE_INLINE constexpr auto make_cursor_r(Loops &&loops) {
                 return tuple_util::fold(make_cursor_f{},
                     tuple_util::get<0>(std::forward<Loops>(loops)).make_cursor(),
                     tuple_util::drop_front<1>(std::forward<Loops>(loops)));
             }
 
             template <class Loops>
-            GT_CONSTEXPR GT_FUNCTION auto make_cursor(Loops &&loops) {
+            GT_FORCE_INLINE constexpr auto make_cursor(Loops &&loops) {
                 return make_cursor_r(tuple_util::reverse(std::forward<Loops>(loops)));
             }
 
@@ -504,19 +500,19 @@ namespace gridtools {
                 Strides const &m_strides;
                 Cursor m_cursor;
 
-                GT_FUNCTION decltype(auto) operator*() const { return *m_ptr; }
-                GT_FUNCTION void operator++() { m_cursor.next(m_ptr, m_strides); }
+                GT_FORCE_INLINE constexpr decltype(auto) operator*() const { return *m_ptr; }
+                GT_FORCE_INLINE constexpr void operator++() { m_cursor.next(m_ptr, m_strides); }
                 template <class T>
-                GT_FUNCTION bool operator!=(T &&) const {
+                GT_FORCE_INLINE constexpr bool operator!=(T &&) const {
                     return m_cursor.done();
                 }
 
-                range begin() const { return *this; }
-                range end() const { return *this; }
+                GT_FORCE_INLINE constexpr range begin() const { return *this; }
+                GT_FORCE_INLINE constexpr range end() const { return *this; }
             };
 
             template <class Ptr, class Strides, class Cursor>
-            GT_CONSTEXPR GT_FUNCTION range<Ptr, Strides const &, Cursor> make_range(
+            GT_FORCE_INLINE constexpr range<Ptr, Strides const &, Cursor> make_range(
                 Ptr ptr, Strides const &strides, Cursor &&cursor) {
                 return {std::move(ptr), strides, std::forward<Cursor>(cursor)};
             }
@@ -587,7 +583,8 @@ namespace gridtools {
             class T2,
             class T = std::common_type_t<T1, T2>,
             std::enable_if_t<std::is_integral<T1>::value && std::is_integral<T2>::value, int> = 0>
-        GT_CONSTEXPR GT_FUNCTION loop_impl_::generic_loop<Key, std::make_signed_t<T>> make_loop(T1 num_steps, T2 step) {
+        GT_FORCE_INLINE constexpr loop_impl_::generic_loop<Key, std::make_signed_t<T>> make_loop(
+            T1 num_steps, T2 step) {
             return {std::make_signed_t<T>(num_steps), step};
         }
 
@@ -597,7 +594,7 @@ namespace gridtools {
             T2 Step = 1,
             class T = std::common_type_t<T1, T2>,
             std::enable_if_t<std::is_integral<T1>::value, int> = 0>
-        GT_CONSTEXPR GT_FUNCTION loop_impl_::known_step_loop<Key, std::make_signed_t<T>, Step> make_loop(
+        GT_FORCE_INLINE constexpr loop_impl_::known_step_loop<Key, std::make_signed_t<T>, Step> make_loop(
             T1 num_steps, std::integral_constant<T2, Step> = {}) {
             return {std::make_signed_t<T>(num_steps)};
         }
@@ -608,7 +605,7 @@ namespace gridtools {
             class T2,
             class T = std::common_type_t<T1, T2>,
             std::enable_if_t<std::is_integral<T1>::value && (NumStepsV > 1), int> = 0>
-        GT_CONSTEXPR GT_FUNCTION loop_impl_::known_num_steps_loop<Key, std::make_signed_t<T>, NumStepsV> make_loop(
+        GT_FORCE_INLINE constexpr loop_impl_::known_num_steps_loop<Key, std::make_signed_t<T>, NumStepsV> make_loop(
             std::integral_constant<T1, NumStepsV>, T2 step) {
             return {step};
         }
@@ -619,7 +616,7 @@ namespace gridtools {
             class T2,
             class T = std::common_type_t<T1, T2>,
             std::enable_if_t<std::is_integral<T1>::value && (NumStepsV == 0 || NumStepsV == 1), int> = 0>
-        GT_CONSTEXPR GT_FUNCTION loop_impl_::all_known_loop<Key, std::make_signed_t<T>, NumStepsV, 0> make_loop(
+        GT_FORCE_INLINE constexpr loop_impl_::all_known_loop<Key, std::make_signed_t<T>, NumStepsV, 0> make_loop(
             std::integral_constant<T1, NumStepsV>, T2) {
             return {};
         }
@@ -631,8 +628,8 @@ namespace gridtools {
             T2 StepV = 1,
             class T = std::common_type_t<T1, T2>,
             std::enable_if_t<(NumStepsV >= 0), int> = 0>
-        GT_CONSTEXPR
-            GT_FUNCTION loop_impl_::all_known_loop<Key, std::make_signed_t<T>, NumStepsV, (NumStepsV > 1) ? StepV : 0>
+        GT_FORCE_INLINE constexpr loop_impl_::
+            all_known_loop<Key, std::make_signed_t<T>, NumStepsV, (NumStepsV > 1) ? StepV : 0>
             make_loop(std::integral_constant<T1, NumStepsV>, std::integral_constant<T2, StepV> = {}) {
             return {};
         }
@@ -652,8 +649,8 @@ namespace gridtools {
          *   }
          */
         template <class Ptr, class Strides, class OuterMostLoop, class... Loops>
-        GT_CONSTEXPR GT_FUNCTION auto make_range(
-            Ptr ptr, Strides const &strides, OuterMostLoop &&outer_most_loop, Loops &&... loops) {
+        GT_FORCE_INLINE constexpr auto make_range(
+            Ptr ptr, Strides const &strides, OuterMostLoop &&outer_most_loop, Loops &&...loops) {
             return loop_impl_::make_range(std::move(ptr),
                 strides,
                 loop_impl_::make_cursor(tuple<OuterMostLoop, Loops...>{
diff --git a/include/gridtools/sid/multi_shift.hpp b/include/gridtools/sid/multi_shift.hpp
index af8585a13a..adeeb47157 100644
--- a/include/gridtools/sid/multi_shift.hpp
+++ b/include/gridtools/sid/multi_shift.hpp
@@ -26,7 +26,7 @@ namespace gridtools {
             template <template <class...> class L, class... Dims>
             struct for_each_dim<L<Dims...>> {
                 template <class Ptr, class Strides, class Offsets>
-                GT_FUNCTION for_each_dim(Ptr &ptr, Strides const &strides, Offsets offsets) {
+                GT_FORCE_INLINE constexpr for_each_dim(Ptr &ptr, Strides const &strides, Offsets offsets) {
                     using array_t = int[sizeof...(Dims)];
                     (void)array_t{(shift(ptr, get_stride<Dims>(strides), at_key<Dims>(offsets)), 0)...};
                 }
@@ -35,7 +35,7 @@ namespace gridtools {
             template <template <class...> class L>
             struct for_each_dim<L<>> {
                 template <class Ptr, class Strides, class Offsets>
-                GT_FUNCTION for_each_dim(Ptr &ptr, Strides const &strides, Offsets offsets) {}
+                GT_FORCE_INLINE constexpr for_each_dim(Ptr &ptr, Strides const &strides, Offsets offsets) {}
             };
 
             template <class Arg, class Dims>
@@ -44,7 +44,7 @@ namespace gridtools {
             template <class Arg, template <class...> class L, class... Dims>
             struct for_each_dim_a<Arg, L<Dims...>> {
                 template <class Ptr, class Strides, class Offsets>
-                GT_FUNCTION for_each_dim_a(Ptr &ptr, Strides const &strides, Offsets offsets) {
+                GT_FORCE_INLINE constexpr for_each_dim_a(Ptr &ptr, Strides const &strides, Offsets offsets) {
                     (..., shift(ptr, get_stride_element<Arg, Dims>(strides), at_key<Dims>(offsets)));
                 }
             };
@@ -55,12 +55,12 @@ namespace gridtools {
          *   `offsets` should be a hymap of individual offsets.
          */
         template <class Ptr, class Strides, class Offsets>
-        GT_FUNCTION void multi_shift(Ptr &ptr, Strides const &strides, Offsets offsets) {
+        GT_FORCE_INLINE constexpr void multi_shift(Ptr &ptr, Strides const &strides, Offsets offsets) {
             multi_shift_impl_::for_each_dim<get_keys<Offsets>>(ptr, strides, std::move(offsets));
         }
 
         template <class Ptr, class Strides, class Offsets>
-        GT_FUNCTION Ptr multi_shifted(Ptr ptr, Strides const &strides, Offsets offsets) {
+        GT_FORCE_INLINE constexpr Ptr multi_shifted(Ptr ptr, Strides const &strides, Offsets offsets) {
             multi_shift(ptr, strides, std::move(offsets));
             return ptr;
         }
@@ -69,12 +69,12 @@ namespace gridtools {
          *   Variation of multi_shift that works with the strides of composite sid.
          */
         template <class Arg, class Ptr, class Strides, class Offsets>
-        GT_FUNCTION void multi_shift(Ptr &ptr, Strides const &strides, Offsets offsets) {
+        GT_FORCE_INLINE constexpr void multi_shift(Ptr &ptr, Strides const &strides, Offsets offsets) {
             multi_shift_impl_::for_each_dim_a<Arg, get_keys<Offsets>>(ptr, strides, std::move(offsets));
         }
 
         template <class Arg, class Ptr, class Strides, class Offsets>
-        GT_FUNCTION Ptr multi_shifted(Ptr ptr, Strides const &strides, Offsets offsets) {
+        GT_FORCE_INLINE constexpr Ptr multi_shifted(Ptr ptr, Strides const &strides, Offsets offsets) {
             multi_shift<Arg>(ptr, strides, std::move(offsets));
             return ptr;
         }
diff --git a/include/gridtools/stencil/be_api.hpp b/include/gridtools/stencil/be_api.hpp
index 2a48a1d2f0..5201290b51 100644
--- a/include/gridtools/stencil/be_api.hpp
+++ b/include/gridtools/stencil/be_api.hpp
@@ -82,15 +82,15 @@ namespace gridtools {
                 using extent_t = Extent;
                 using cache_io_policies_t = meta::list<CacheIoPolicies...>;
 
-                static GT_FUNCTION key_t key() { return {}; }
-                static GT_FUNCTION plh_t plh() { return {}; }
-                static GT_FUNCTION caches_t caches() { return {}; }
-                static GT_FUNCTION is_tmp_t is_tmp() { return {}; }
+                static GT_FORCE_INLINE constexpr key_t key() { return {}; }
+                static GT_FORCE_INLINE constexpr plh_t plh() { return {}; }
+                static GT_FORCE_INLINE constexpr caches_t caches() { return {}; }
+                static GT_FORCE_INLINE constexpr is_tmp_t is_tmp() { return {}; }
                 static data_t data();
-                static GT_FUNCTION num_colors_t num_colors() { return {}; }
-                static GT_FUNCTION is_const_t is_const() { return {}; }
-                static GT_FUNCTION extent_t extent() { return {}; }
-                static GT_FUNCTION cache_io_policies_t cache_io_policies() { return {}; }
+                static GT_FORCE_INLINE constexpr num_colors_t num_colors() { return {}; }
+                static GT_FORCE_INLINE constexpr is_const_t is_const() { return {}; }
+                static GT_FORCE_INLINE constexpr extent_t extent() { return {}; }
+                static GT_FORCE_INLINE constexpr cache_io_policies_t cache_io_policies() { return {}; }
             };
 
             template <template <class...> class GetKey = get_plh, class PlhMap, class Fun>
@@ -180,15 +180,15 @@ namespace gridtools {
                 using plhs_t = meta::transform<get_plh, plh_map_t>;
                 using k_step_t = integral_constant<int_t, core::is_backward<Execution>::value ? -1 : 1>;
 
-                static GT_FUNCTION Funs funs() { return {}; }
-                static GT_FUNCTION Interval interval() { return {}; }
-                static GT_FUNCTION PlhMap plh_map() { return {}; }
-                static GT_FUNCTION Extent extent() { return {}; }
-                static GT_FUNCTION Execution execution() { return {}; }
-                static GT_FUNCTION NeedSync need_sync() { return {}; }
+                static GT_FORCE_INLINE constexpr Funs funs() { return {}; }
+                static GT_FORCE_INLINE constexpr Interval interval() { return {}; }
+                static GT_FORCE_INLINE constexpr PlhMap plh_map() { return {}; }
+                static GT_FORCE_INLINE constexpr Extent extent() { return {}; }
+                static GT_FORCE_INLINE constexpr Execution execution() { return {}; }
+                static GT_FORCE_INLINE constexpr NeedSync need_sync() { return {}; }
 
-                static GT_FUNCTION plhs_t plhs() { return {}; }
-                static GT_FUNCTION k_step_t k_step() { return {}; }
+                static GT_FORCE_INLINE constexpr plhs_t plhs() { return {}; }
+                static GT_FORCE_INLINE constexpr k_step_t k_step() { return {}; }
 
                 template <class Deref = void, class Ptr, class Strides>
                 GT_FUNCTION void operator()(Ptr const &ptr, Strides const &strides) const {
@@ -196,7 +196,7 @@ namespace gridtools {
                 }
 
                 template <class Ptr, class Strides>
-                static GT_FUNCTION void inc_k(Ptr &ptr, Strides const &strides) {
+                static GT_FORCE_INLINE constexpr void inc_k(Ptr &ptr, Strides const &strides) {
                     sid::shift(ptr, sid::get_stride<dim::k>(strides), k_step());
                 }
             };
@@ -308,16 +308,16 @@ namespace gridtools {
 
                 using cells_t = meta::rename<tuple, meta::filter<meta::not_<is_cell_empty>::apply, interval_info>>;
 
-                static GT_FUNCTION execution_t execution() { return {}; }
-                static GT_FUNCTION extent_t extent() { return {}; }
-                static GT_FUNCTION plh_map_t plh_map() { return {}; }
-                static GT_FUNCTION plhs_t plhs() { return {}; }
-                static GT_FUNCTION interval_t interval() { return {}; }
-                static GT_FUNCTION k_step_t k_step() { return {}; }
-                static GT_FUNCTION cells_t cells() { return {}; }
+                static GT_FORCE_INLINE constexpr execution_t execution() { return {}; }
+                static GT_FORCE_INLINE constexpr extent_t extent() { return {}; }
+                static GT_FORCE_INLINE constexpr plh_map_t plh_map() { return {}; }
+                static GT_FORCE_INLINE constexpr plhs_t plhs() { return {}; }
+                static GT_FORCE_INLINE constexpr interval_t interval() { return {}; }
+                static GT_FORCE_INLINE constexpr k_step_t k_step() { return {}; }
+                static GT_FORCE_INLINE constexpr cells_t cells() { return {}; }
 
                 template <class Ptr, class Strides>
-                static GT_FUNCTION void inc_k(Ptr &ptr, Strides const &strides) {
+                static GT_FORCE_INLINE constexpr void inc_k(Ptr &ptr, Strides const &strides) {
                     sid::shift(ptr, sid::get_stride<dim::k>(strides), k_step());
                 }
             };
@@ -325,8 +325,8 @@ namespace gridtools {
             template <class... IntervalInfos>
             class fused_view_item {
                 static_assert(sizeof...(IntervalInfos) > 0, GT_INTERNAL_ERROR);
-                static_assert(std::conjunction<meta::is_instantiation_of<interval_info, IntervalInfos>...>::value,
-                    GT_INTERNAL_ERROR);
+                static_assert(
+                    std::conjunction_v<meta::is_instantiation_of<interval_info, IntervalInfos>...>, GT_INTERNAL_ERROR);
                 static_assert(meta::are_same<typename meta::length<IntervalInfos>::type...>::value, GT_INTERNAL_ERROR);
 
                 using item_t = meta::first<meta::list<IntervalInfos...>>;
@@ -344,14 +344,14 @@ namespace gridtools {
                     meta::reverse<meta::rename<tuple, fused_view_item>>,
                     meta::rename<tuple, fused_view_item>>;
 
-                static GT_FUNCTION execution_t execution() { return {}; }
-                static GT_FUNCTION extent_t extent() { return {}; }
-                static GT_FUNCTION plh_map_t plh_map() { return {}; }
-                static GT_FUNCTION plhs_t plhs() { return {}; }
-                static GT_FUNCTION interval_t interval() { return {}; }
-                static GT_FUNCTION k_step_t k_step() { return {}; }
+                static GT_FORCE_INLINE constexpr execution_t execution() { return {}; }
+                static GT_FORCE_INLINE constexpr extent_t extent() { return {}; }
+                static GT_FORCE_INLINE constexpr plh_map_t plh_map() { return {}; }
+                static GT_FORCE_INLINE constexpr plhs_t plhs() { return {}; }
+                static GT_FORCE_INLINE constexpr interval_t interval() { return {}; }
+                static GT_FORCE_INLINE constexpr k_step_t k_step() { return {}; }
 
-                static GT_FUNCTION interval_infos_t interval_infos() { return {}; }
+                static GT_FORCE_INLINE constexpr interval_infos_t interval_infos() { return {}; }
             };
 
             template <class... Cells>
@@ -371,14 +371,14 @@ namespace gridtools {
                     meta::reverse<meta::rename<tuple, split_view_item>>,
                     meta::rename<tuple, split_view_item>>;
 
-                static GT_FUNCTION execution_t execution() { return {}; }
-                static GT_FUNCTION extent_t extent() { return {}; }
-                static GT_FUNCTION plh_map_t plh_map() { return {}; }
-                static GT_FUNCTION plhs_t plhs() { return {}; }
-                static GT_FUNCTION interval_t interval() { return {}; }
-                static GT_FUNCTION k_step_t k_step() { return {}; }
+                static GT_FORCE_INLINE constexpr execution_t execution() { return {}; }
+                static GT_FORCE_INLINE constexpr extent_t extent() { return {}; }
+                static GT_FORCE_INLINE constexpr plh_map_t plh_map() { return {}; }
+                static GT_FORCE_INLINE constexpr plhs_t plhs() { return {}; }
+                static GT_FORCE_INLINE constexpr interval_t interval() { return {}; }
+                static GT_FORCE_INLINE constexpr k_step_t k_step() { return {}; }
 
-                static GT_FUNCTION cells_t cells() { return {}; }
+                static GT_FORCE_INLINE constexpr cells_t cells() { return {}; }
             };
 
             template <class... Items>
@@ -392,8 +392,8 @@ namespace gridtools {
 
                 using interval_t = core::enclosing_interval<typename Items::interval_t...>;
 
-                static GT_FUNCTION tmp_plh_map_t tmp_plh_map() { return {}; }
-                static GT_FUNCTION interval_t interval() { return {}; }
+                static GT_FORCE_INLINE constexpr tmp_plh_map_t tmp_plh_map() { return {}; }
+                static GT_FORCE_INLINE constexpr interval_t interval() { return {}; }
             };
 
             template <class Matrix>
diff --git a/include/gridtools/stencil/common/extent.hpp b/include/gridtools/stencil/common/extent.hpp
index dd179c86ae..cf9f9cefe6 100644
--- a/include/gridtools/stencil/common/extent.hpp
+++ b/include/gridtools/stencil/common/extent.hpp
@@ -36,16 +36,16 @@ namespace gridtools {
             using kminus = integral_constant<int_t, KMinus>;
             using kplus = integral_constant<int_t, KPlus>;
 
-            static GT_FUNCTION iminus minus(dim::i) { return {}; }
-            static GT_FUNCTION jminus minus(dim::j) { return {}; }
-            static GT_FUNCTION kminus minus(dim::k) { return {}; }
+            static GT_FORCE_INLINE constexpr iminus minus(dim::i) { return {}; }
+            static GT_FORCE_INLINE constexpr jminus minus(dim::j) { return {}; }
+            static GT_FORCE_INLINE constexpr kminus minus(dim::k) { return {}; }
 
-            static GT_FUNCTION iplus plus(dim::i) { return {}; }
-            static GT_FUNCTION jplus plus(dim::j) { return {}; }
-            static GT_FUNCTION kplus plus(dim::k) { return {}; }
+            static GT_FORCE_INLINE constexpr iplus plus(dim::i) { return {}; }
+            static GT_FORCE_INLINE constexpr jplus plus(dim::j) { return {}; }
+            static GT_FORCE_INLINE constexpr kplus plus(dim::k) { return {}; }
 
             template <class Dim, class Size>
-            static GT_FUNCTION auto extend(Dim dim, Size size) {
+            static GT_FORCE_INLINE constexpr auto extend(Dim dim, Size size) {
                 return size - minus(dim) + plus(dim);
             }
         };
diff --git a/include/gridtools/stencil/common/intent.hpp b/include/gridtools/stencil/common/intent.hpp
index c1cb329ead..2a5ee5b0a7 100644
--- a/include/gridtools/stencil/common/intent.hpp
+++ b/include/gridtools/stencil/common/intent.hpp
@@ -43,7 +43,7 @@ namespace gridtools {
         using apply_intent_t = typename apply_intent_type<Intent, T>::type;
 
         template <intent Intent, class T, class Res = typename apply_intent_type<Intent, T>::type>
-        GT_FUNCTION Res apply_intent(T &&obj) {
+        GT_FORCE_INLINE constexpr Res apply_intent(T &&obj) {
             return static_cast<Res>(obj);
         }
     } // namespace stencil
diff --git a/include/gridtools/stencil/core/functor_metafunctions.hpp b/include/gridtools/stencil/core/functor_metafunctions.hpp
index 9452cd9cee..b64fa56966 100644
--- a/include/gridtools/stencil/core/functor_metafunctions.hpp
+++ b/include/gridtools/stencil/core/functor_metafunctions.hpp
@@ -10,9 +10,9 @@
 #pragma once
 
 #include <type_traits>
+#include <utility>
 
 #include "../../common/host_device.hpp"
-#include "../../common/utility.hpp"
 #include "../../meta.hpp"
 #include "interval.hpp"
 #include "level.hpp"
@@ -215,7 +215,7 @@ namespace gridtools {
                 struct bound_functor : Functor {
                     template <class Eval>
                     static GT_FUNCTION void apply(Eval &&eval) {
-                        Functor::apply(wstd::forward<Eval>(eval), Param());
+                        Functor::apply(std::forward<Eval>(eval), Param());
                     }
                 };
 
diff --git a/include/gridtools/stencil/frontend/cartesian/accessor.hpp b/include/gridtools/stencil/frontend/cartesian/accessor.hpp
index a3f50eba47..f40a2fd3a0 100644
--- a/include/gridtools/stencil/frontend/cartesian/accessor.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/accessor.hpp
@@ -45,17 +45,17 @@ namespace gridtools {
         namespace cartesian {
             namespace accessor_impl_ {
                 template <size_t I>
-                GT_FUNCTION GT_CONSTEXPR int_t pick_dimension() {
+                GT_FORCE_INLINE constexpr int_t pick_dimension() {
                     return 0;
                 }
 
                 template <size_t I, class... Ts>
-                GT_FUNCTION GT_CONSTEXPR int_t pick_dimension(dimension<I> src, Ts &&...) {
+                GT_FORCE_INLINE constexpr int_t pick_dimension(dimension<I> src, Ts &&...) {
                     return src.value;
                 }
 
                 template <size_t I, size_t J, class... Ts, std::enable_if_t<I != J, int> = 0>
-                GT_FUNCTION GT_CONSTEXPR int_t pick_dimension(dimension<J> src, Ts... srcs) {
+                GT_FORCE_INLINE constexpr int_t pick_dimension(dimension<J> src, Ts... srcs) {
                     return pick_dimension<I>(srcs...);
                 }
 
@@ -68,12 +68,12 @@ namespace gridtools {
                 using are_ints = std::conjunction<std::is_convertible<Ts, int_t>...>;
 
                 template <size_t Dim, size_t I, std::enable_if_t<(I > Dim), int> = 0>
-                GT_FUNCTION GT_CONSTEXPR int_t out_of_range_dim(dimension<I> obj) {
+                GT_FORCE_INLINE constexpr int_t out_of_range_dim(dimension<I> obj) {
                     return obj.value;
                 }
 
                 template <size_t Dim, size_t I, std::enable_if_t<(I <= Dim), int> = 0>
-                GT_FUNCTION GT_CONSTEXPR int_t out_of_range_dim(dimension<I>) {
+                GT_FORCE_INLINE constexpr int_t out_of_range_dim(dimension<I>) {
                     return 0;
                 }
 
@@ -95,26 +95,20 @@ namespace gridtools {
                 template <int_t IMinus, int_t IPlus, int_t JMinus, int_t JPlus, int_t KMinus, int_t KPlus>
                 struct minimal_requried_args<extent<IMinus, IPlus, JMinus, JPlus, KMinus, KPlus>>
                     : std::integral_constant<size_t,
-                          (KMinus > 0 || KPlus < 0 ? 3
-                                                   : JMinus > 0 || JPlus < 0 ? 2 : IMinus > 0 || IPlus < 0 ? 1 : 0)> {};
+                          (KMinus > 0 || KPlus < 0      ? 3
+                              : JMinus > 0 || JPlus < 0 ? 2
+                              : IMinus > 0 || IPlus < 0 ? 1
+                                                        : 0)> {};
 
 #ifndef NDEBUG
                 template <class Extent, size_t Dim>
-                GT_FUNCTION GT_CONSTEXPR bool check_offsets(array<int_t, Dim> const &offsets) {
+                constexpr bool check_offsets(array<int_t, Dim> const &offsets) {
                     int_t i = Dim > 0 ? offsets[0] : 0;
                     int_t j = Dim > 1 ? offsets[1] : 0;
                     int_t k = Dim > 2 ? offsets[2] : 0;
                     return i >= Extent::iminus::value && i <= Extent::iplus::value && j >= Extent::jminus::value &&
                            j <= Extent::jplus::value && k >= Extent::kminus::value && k <= Extent::kplus::value;
                 }
-
-                template <class... Ts>
-                GT_FUNCTION GT_CONSTEXPR bool all(Ts... args) {
-                    bool res = true;
-                    for (bool ok : (bool[]){args...})
-                        res = res && ok;
-                    return res;
-                }
 #endif
             } // namespace accessor_impl_
 
@@ -137,26 +131,26 @@ namespace gridtools {
                 template <class... Ts,
                     std::enable_if_t<sizeof...(Ts) < Dim && std::conjunction<std::is_convertible<Ts, int_t>...>::value,
                         int> = 0>
-                GT_FUNCTION GT_CONSTEXPR accessor(Ts... offsets) : base_t({offsets...}) {
+                GT_FORCE_INLINE constexpr accessor(Ts... offsets) : base_t({offsets...}) {
                     static_assert(sizeof...(Ts) >= accessor_impl_::minimal_requried_args<Extent>::value,
                         "zero offsets is out of the extents range");
                     assert(accessor_impl_::check_offsets<Extent>(*this));
                 }
 
                 template <class... Ts, std::enable_if_t<accessor_impl_::are_ints<Ts...>::value, int> = 0>
-                GT_FUNCTION GT_CONSTEXPR accessor(typename accessor_impl_::just_int<Is>::type... offsets, Ts... zeros)
+                GT_FORCE_INLINE constexpr accessor(typename accessor_impl_::just_int<Is>::type... offsets, Ts... zeros)
                     : base_t({offsets...}) {
-                    assert(accessor_impl_::all((zeros == 0)...));
+                    assert((true && ... && (zeros == 0)));
                     assert(accessor_impl_::check_offsets<Extent>(*this));
                 }
 
                 template <size_t J, size_t... Js>
-                GT_FUNCTION GT_CONSTEXPR accessor(dimension<J> src, dimension<Js>... srcs)
+                GT_FORCE_INLINE constexpr accessor(dimension<J> src, dimension<Js>... srcs)
                     : base_t({accessor_impl_::pick_dimension<Is + 1>(src, srcs...)...}) {
                     static_assert(meta::is_set_fast<meta::list<dimension<J>, dimension<Js>...>>::value,
                         "all dimensions should be of different indicies");
                     assert(accessor_impl_::out_of_range_dim<Dim>(src) == 0);
-                    assert(accessor_impl_::all((accessor_impl_::out_of_range_dim<Dim>(srcs) == 0)...));
+                    assert((true && ... && (accessor_impl_::out_of_range_dim<Dim>(srcs) == 0)));
                     assert(accessor_impl_::check_offsets<Extent>(*this));
                 }
             };
@@ -164,7 +158,7 @@ namespace gridtools {
             template <uint_t Id, class Extent, intent Intent>
             class accessor<Id, Intent, Extent, 0, std::index_sequence<>> : public tuple<> {
               public:
-                static_assert(std::is_same<Extent, extent<>>::value, GT_INTERNAL_ERROR);
+                static_assert(std::is_same_v<Extent, extent<>>, GT_INTERNAL_ERROR);
 
                 using index_t = integral_constant<uint_t, Id>;
                 static constexpr intent intent_v = Intent;
@@ -173,14 +167,13 @@ namespace gridtools {
                 accessor() = default;
 
                 template <class... Ts, std::enable_if_t<accessor_impl_::are_ints<Ts...>::value, int> = 0>
-                GT_FUNCTION GT_CONSTEXPR accessor(Ts... zeros) {
-                    assert(accessor_impl_::all((zeros == 0)...));
+                GT_FORCE_INLINE constexpr accessor(Ts... zeros) {
+                    assert((true && ... && (zeros == 0)));
                 }
 
                 template <size_t J, size_t... Js>
-                GT_FUNCTION GT_CONSTEXPR accessor(dimension<J> zero, dimension<Js>... zeros) {
-                    assert(zero.value == 0);
-                    assert(accessor_impl_::all((zeros.value == 0)...));
+                GT_FORCE_INLINE constexpr accessor(dimension<J> zero, dimension<Js>... zeros) {
+                    assert(((zero.value == 0) && ... && (zeros.value == 0)));
                 }
             };
 
diff --git a/include/gridtools/stencil/frontend/cartesian/dimension.hpp b/include/gridtools/stencil/frontend/cartesian/dimension.hpp
index f1a7caef95..ddb91beb05 100644
--- a/include/gridtools/stencil/frontend/cartesian/dimension.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/dimension.hpp
@@ -26,11 +26,11 @@ namespace gridtools {
             struct dimension {
                 static_assert(Coordinate != 0, "The coordinate values passed to the accessor start from 1");
 
-                GT_FUNCTION constexpr dimension(int_t value = 0) : value(value) {}
+                GT_FORCE_INLINE constexpr dimension(int_t value = 0) : value(value) {}
                 int_t value;
 
-                friend GT_FUNCTION GT_CONSTEXPR dimension operator+(dimension, int_t offset) { return {offset}; }
-                friend GT_FUNCTION GT_CONSTEXPR dimension operator-(dimension, int_t offset) { return {-offset}; }
+                friend GT_FORCE_INLINE constexpr dimension operator+(dimension, int_t offset) { return {offset}; }
+                friend GT_FORCE_INLINE constexpr dimension operator-(dimension, int_t offset) { return {-offset}; }
             };
         } // namespace cartesian
     }     // namespace stencil
diff --git a/include/gridtools/stencil/frontend/cartesian/expressions/expr_base.hpp b/include/gridtools/stencil/frontend/cartesian/expressions/expr_base.hpp
index b24ddd0183..6ab53c2302 100644
--- a/include/gridtools/stencil/frontend/cartesian/expressions/expr_base.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/expressions/expr_base.hpp
@@ -10,9 +10,9 @@
 #pragma once
 
 #include <type_traits>
+#include <utility>
 
 #include "../../../../common/host_device.hpp"
-#include "../../../../common/utility.hpp"
 #include "../../../../meta.hpp"
 #include "../accessor.hpp"
 
@@ -50,29 +50,29 @@ namespace gridtools {
                 template <class Op,
                     class... Args,
                     std::enable_if_t<std::disjunction<expr_or_accessor<Args>...>::value, int> = 0>
-                GT_FUNCTION GT_CONSTEXPR expr<Op, Args...> make_expr(Op, Args... args) {
+                GT_FORCE_INLINE constexpr expr<Op, Args...> make_expr(Op, Args... args) {
                     return {args...};
                 }
 
                 namespace evaluation {
                     template <class Eval, class Arg, std::enable_if_t<std::is_arithmetic<Arg>::value, int> = 0>
-                    GT_FUNCTION GT_CONSTEXPR Arg apply_eval(Eval &&, Arg arg) {
+                    GT_FORCE_INLINE constexpr Arg apply_eval(Eval &&, Arg arg) {
                         return arg;
                     }
 
                     template <class Eval, class Arg, std::enable_if_t<!std::is_arithmetic<Arg>::value, int> = 0>
-                    GT_FUNCTION GT_CONSTEXPR decltype(auto) apply_eval(Eval &&eval, Arg arg) {
-                        return wstd::forward<Eval>(eval)(wstd::move(arg));
+                    GT_FORCE_INLINE constexpr decltype(auto) apply_eval(Eval &&eval, Arg arg) {
+                        return std::forward<Eval>(eval)(std::move(arg));
                     }
 
                     template <class Eval, class Op, class Arg>
-                    GT_FUNCTION GT_CONSTEXPR auto value(Eval &&eval, expr<Op, Arg> arg) {
-                        return Op()(wstd::forward<Eval>(eval)(wstd::move(arg.m_arg)));
+                    GT_FORCE_INLINE constexpr auto value(Eval &&eval, expr<Op, Arg> arg) {
+                        return Op()(std::forward<Eval>(eval)(std::move(arg.m_arg)));
                     }
 
                     template <class Eval, class Op, class Lhs, class Rhs>
-                    GT_FUNCTION GT_CONSTEXPR auto value(Eval &&eval, expr<Op, Lhs, Rhs> arg) {
-                        return Op()(apply_eval(eval, wstd::move(arg.m_lhs)), apply_eval(eval, wstd::move(arg.m_rhs)));
+                    GT_FORCE_INLINE constexpr auto value(Eval &&eval, expr<Op, Lhs, Rhs> arg) {
+                        return Op()(apply_eval(eval, std::move(arg.m_lhs)), apply_eval(eval, std::move(arg.m_rhs)));
                     }
                 } // namespace evaluation
             }     // namespace expressions
diff --git a/include/gridtools/stencil/frontend/cartesian/expressions/expr_divide.hpp b/include/gridtools/stencil/frontend/cartesian/expressions/expr_divide.hpp
index 0ed5b43aa7..abde9f88ae 100644
--- a/include/gridtools/stencil/frontend/cartesian/expressions/expr_divide.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/expressions/expr_divide.hpp
@@ -19,13 +19,13 @@ namespace gridtools {
             namespace expressions {
                 struct divide_f {
                     template <class Lhs, class Rhs>
-                    GT_FUNCTION GT_CONSTEXPR auto operator()(Lhs const &lhs, Rhs const &rhs) const {
+                    GT_FORCE_INLINE constexpr auto operator()(Lhs const &lhs, Rhs const &rhs) const {
                         return lhs / rhs;
                     }
                 };
 
                 template <class Lhs, class Rhs>
-                GT_FUNCTION GT_CONSTEXPR auto operator/(Lhs lhs, Rhs rhs)
+                GT_FORCE_INLINE constexpr auto operator/(Lhs lhs, Rhs rhs)
                     -> decltype(make_expr(divide_f(), Lhs(), Rhs())) {
                     return make_expr(divide_f(), lhs, rhs);
                 }
diff --git a/include/gridtools/stencil/frontend/cartesian/expressions/expr_minus.hpp b/include/gridtools/stencil/frontend/cartesian/expressions/expr_minus.hpp
index 0f42d291db..d39dae49d8 100644
--- a/include/gridtools/stencil/frontend/cartesian/expressions/expr_minus.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/expressions/expr_minus.hpp
@@ -18,23 +18,23 @@ namespace gridtools {
             namespace expressions {
                 struct minus_f {
                     template <class Lhs, class Rhs>
-                    GT_FUNCTION GT_CONSTEXPR auto operator()(Lhs const &lhs, Rhs const &rhs) const {
+                    GT_FORCE_INLINE constexpr auto operator()(Lhs const &lhs, Rhs const &rhs) const {
                         return lhs - rhs;
                     }
                     template <class Arg>
-                    GT_FUNCTION GT_CONSTEXPR auto operator()(Arg const &arg) const {
+                    GT_FORCE_INLINE constexpr auto operator()(Arg const &arg) const {
                         return -arg;
                     }
                 };
 
                 template <class Lhs, class Rhs>
-                GT_FUNCTION GT_CONSTEXPR auto operator-(Lhs lhs, Rhs rhs)
+                GT_FORCE_INLINE constexpr auto operator-(Lhs lhs, Rhs rhs)
                     -> decltype(make_expr(minus_f(), Lhs(), Rhs())) {
                     return make_expr(minus_f(), lhs, rhs);
                 }
 
                 template <class Arg>
-                GT_FUNCTION GT_CONSTEXPR auto operator-(Arg arg) -> decltype(make_expr(minus_f(), Arg())) {
+                GT_FORCE_INLINE constexpr auto operator-(Arg arg) -> decltype(make_expr(minus_f(), Arg())) {
                     return make_expr(minus_f(), arg);
                 }
             } // namespace expressions
diff --git a/include/gridtools/stencil/frontend/cartesian/expressions/expr_plus.hpp b/include/gridtools/stencil/frontend/cartesian/expressions/expr_plus.hpp
index 240adccca2..e372cf9a97 100644
--- a/include/gridtools/stencil/frontend/cartesian/expressions/expr_plus.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/expressions/expr_plus.hpp
@@ -19,23 +19,23 @@ namespace gridtools {
             namespace expressions {
                 struct plus_f {
                     template <class Lhs, class Rhs>
-                    GT_FUNCTION GT_CONSTEXPR auto operator()(Lhs const &lhs, Rhs const &rhs) const {
+                    GT_FORCE_INLINE constexpr auto operator()(Lhs const &lhs, Rhs const &rhs) const {
                         return lhs + rhs;
                     }
                     template <class Arg>
-                    GT_FUNCTION GT_CONSTEXPR auto operator()(Arg const &arg) const {
+                    GT_FORCE_INLINE constexpr auto operator()(Arg const &arg) const {
                         return +arg;
                     }
                 };
 
                 template <class Lhs, class Rhs>
-                GT_FUNCTION GT_CONSTEXPR auto operator+(Lhs lhs, Rhs rhs)
+                GT_FORCE_INLINE constexpr auto operator+(Lhs lhs, Rhs rhs)
                     -> decltype(make_expr(plus_f(), Lhs(), Rhs())) {
                     return make_expr(plus_f(), lhs, rhs);
                 }
 
                 template <class Arg>
-                GT_FUNCTION GT_CONSTEXPR auto operator+(Arg arg) -> decltype(make_expr(plus_f(), Arg())) {
+                GT_FORCE_INLINE constexpr auto operator+(Arg arg) -> decltype(make_expr(plus_f(), Arg())) {
                     return make_expr(plus_f(), arg);
                 }
             } // namespace expressions
diff --git a/include/gridtools/stencil/frontend/cartesian/expressions/expr_pow.hpp b/include/gridtools/stencil/frontend/cartesian/expressions/expr_pow.hpp
index e98f481d8c..77c593410c 100644
--- a/include/gridtools/stencil/frontend/cartesian/expressions/expr_pow.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/expressions/expr_pow.hpp
@@ -20,13 +20,13 @@ namespace gridtools {
                 template <int I>
                 struct pow_f {
                     template <class Arg>
-                    GT_FUNCTION GT_CONSTEXPR auto operator()(Arg const &arg) const {
+                    GT_FORCE_INLINE constexpr auto operator()(Arg const &arg) const {
                         return gt_pow<I>::template apply(arg);
                     }
                 };
 
                 template <int I, class Arg>
-                GT_FUNCTION GT_CONSTEXPR auto pow(Arg arg) -> decltype(make_expr(pow_f<I>(), Arg())) {
+                GT_FORCE_INLINE constexpr auto pow(Arg arg) -> decltype(make_expr(pow_f<I>(), Arg())) {
                     return make_expr(pow_f<I>(), arg);
                 }
             } // namespace expressions
diff --git a/include/gridtools/stencil/frontend/cartesian/expressions/expr_times.hpp b/include/gridtools/stencil/frontend/cartesian/expressions/expr_times.hpp
index d5847c2b9c..9a43314b9d 100644
--- a/include/gridtools/stencil/frontend/cartesian/expressions/expr_times.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/expressions/expr_times.hpp
@@ -19,13 +19,13 @@ namespace gridtools {
             namespace expressions {
                 struct times_f {
                     template <class Lhs, class Rhs>
-                    GT_FUNCTION GT_CONSTEXPR auto operator()(Lhs const &lhs, Rhs const &rhs) const {
+                    GT_FORCE_INLINE constexpr auto operator()(Lhs const &lhs, Rhs const &rhs) const {
                         return lhs * rhs;
                     }
                 };
 
                 template <class Lhs, class Rhs>
-                GT_FUNCTION GT_CONSTEXPR auto operator*(Lhs lhs, Rhs rhs) -> decltype(make_expr(times_f(), lhs, rhs)) {
+                GT_FORCE_INLINE constexpr auto operator*(Lhs lhs, Rhs rhs) -> decltype(make_expr(times_f(), lhs, rhs)) {
                     return make_expr(times_f(), lhs, rhs);
                 }
             } // namespace expressions
diff --git a/include/gridtools/stencil/frontend/cartesian/stage.hpp b/include/gridtools/stencil/frontend/cartesian/stage.hpp
index 0ea463f6ba..c1d1d31712 100644
--- a/include/gridtools/stencil/frontend/cartesian/stage.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/stage.hpp
@@ -29,6 +29,7 @@
 #pragma once
 
 #include <type_traits>
+#include <utility>
 
 #include "../../../common/defs.hpp"
 #include "../../../common/host_device.hpp"
@@ -44,7 +45,7 @@ namespace gridtools {
             namespace stage_impl_ {
                 struct default_deref_f {
                     template <class Key, class T>
-                    GT_FUNCTION decltype(auto) operator()(Key, T ptr) const {
+                    GT_FORCE_INLINE constexpr decltype(auto) operator()(Key, T ptr) const {
                         return *ptr;
                     }
                 };
@@ -55,15 +56,15 @@ namespace gridtools {
                     Strides const &m_strides;
 
                     template <class Accessor>
-                    GT_FUNCTION decltype(auto) operator()(Accessor acc) const {
+                    GT_FORCE_INLINE constexpr decltype(auto) operator()(Accessor acc) const {
                         using key_t = meta::at_c<Keys, Accessor::index_t::value>;
                         return apply_intent<Accessor::intent_v>(Deref()(
-                            key_t(), sid::multi_shifted<key_t>(at_key<key_t>(m_ptr), m_strides, wstd::move(acc))));
+                            key_t(), sid::multi_shifted<key_t>(at_key<key_t>(m_ptr), m_strides, std::move(acc))));
                     }
 
                     template <class Op, class... Ts>
-                    GT_FUNCTION auto operator()(expr<Op, Ts...> arg) const {
-                        return expressions::evaluation::value(*this, wstd::move(arg));
+                    GT_FORCE_INLINE constexpr auto operator()(expr<Op, Ts...> arg) const {
+                        return expressions::evaluation::value(*this, std::move(arg));
                     }
                 };
 
diff --git a/include/gridtools/stencil/frontend/cartesian/stencil_functions.hpp b/include/gridtools/stencil/frontend/cartesian/stencil_functions.hpp
index 6e774dd79a..82ab95329f 100644
--- a/include/gridtools/stencil/frontend/cartesian/stencil_functions.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/stencil_functions.hpp
@@ -11,6 +11,7 @@
 #pragma once
 
 #include <type_traits>
+#include <utility>
 
 #include "../../../common/hymap.hpp"
 #include "../../../common/tuple.hpp"
@@ -39,23 +40,23 @@ namespace gridtools {
                 template <class Key>
                 struct sum_offset_generator_f {
 
-                    using default_t = integral_constant<int_t, 0>;
+                    using default_t = integral_constant<int, 0>;
 
                     template <class Lhs, class Rhs>
-                    GT_FUNCTION auto operator()(Lhs &&lhs, Rhs &&rhs) const {
-                        return at_key_with_default<Key, default_t>(wstd::forward<Lhs>(lhs)) +
-                               at_key_with_default<Key, default_t>(wstd::forward<Rhs>(rhs));
+                    GT_FORCE_INLINE constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const {
+                        return at_key_with_default<Key, default_t>(std::forward<Lhs>(lhs)) +
+                               at_key_with_default<Key, default_t>(std::forward<Rhs>(rhs));
                     }
                 };
 
                 template <class Res, class Lhs, class Rhs>
-                GT_FUNCTION Res sum_offsets(Lhs &&lhs, Rhs rhs) {
+                GT_FORCE_INLINE constexpr Res sum_offsets(Lhs &&lhs, Rhs rhs) {
                     using generators_t = meta::transform<sum_offset_generator_f, get_keys<Res>>;
-                    return tuple_util::generate<generators_t, Res>(wstd::forward<Lhs>(lhs), wstd::move(rhs));
+                    return tuple_util::generate<generators_t, Res>(std::forward<Lhs>(lhs), std::move(rhs));
                 }
 
                 template <int_t I, int_t J, int_t K, class Accessor>
-                GT_FUNCTION std::enable_if_t<I == 0 && J == 0 && K == 0, Accessor> get_offsets(Accessor acc) {
+                GT_FORCE_INLINE constexpr std::enable_if_t<I == 0 && J == 0 && K == 0, Accessor> get_offsets(Accessor acc) {
                     return acc;
                 }
 
@@ -64,10 +65,10 @@ namespace gridtools {
                     int_t K,
                     class Accessor,
                     class Res = array<int_t, tuple_util::size<Accessor>::value>>
-                GT_FUNCTION std::enable_if_t<I != 0 || J != 0 || K != 0, Res> get_offsets(Accessor acc) {
+                GT_FORCE_INLINE constexpr std::enable_if_t<I != 0 || J != 0 || K != 0, Res> get_offsets(Accessor acc) {
                     using offset_t = hymap::keys<dim::i, dim::j, dim::k>::
                         values<integral_constant<int_t, I>, integral_constant<int_t, J>, integral_constant<int_t, K>>;
-                    return sum_offsets<Res>(wstd::move(acc), offset_t());
+                    return sum_offsets<Res>(std::move(acc), offset_t());
                 }
 
                 template <int_t I, int_t J, int_t K, class Params, class Eval, class Args>
@@ -81,7 +82,7 @@ namespace gridtools {
                         std::enable_if_t<is_accessor<Accessor>::value && is_accessor<Arg>::value &&
                                              !(Param::intent_v == intent::inout && Arg::intent_v == intent::in),
                             int> = 0>
-                    GT_FUNCTION decltype(auto) operator()(Accessor acc) const {
+                    GT_FORCE_INLINE constexpr decltype(auto) operator()(Accessor acc) const {
                         return m_eval(sum_offsets<Arg>(
                             get_offsets<I, J, K>(tuple_util::get<Accessor::index_t::value>(m_args)), std::move(acc)));
                     }
@@ -93,25 +94,25 @@ namespace gridtools {
                                              !(Param::intent_v == intent::inout &&
                                                  std::is_const<std::remove_reference_t<Arg>>::value),
                             int> = 0>
-                    GT_FUNCTION decltype(auto) operator()(Accessor) const {
+                    GT_FORCE_INLINE constexpr decltype(auto) operator()(Accessor) const {
                         return tuple_util::get<Accessor::index_t::value>(m_args);
                     }
 
                     template <class Op, class... Ts>
-                    GT_FUNCTION auto operator()(expr<Op, Ts...> arg) const {
-                        return expressions::evaluation::value(*this, wstd::move(arg));
+                    GT_FORCE_INLINE constexpr auto operator()(expr<Op, Ts...> arg) const {
+                        return expressions::evaluation::value(*this, std::move(arg));
                     }
                 };
 
                 template <int_t I, int_t J, int_t K, class Params, class Eval, class Args>
-                GT_CONSTEXPR GT_FUNCTION evaluator<I, J, K, Params, Eval, Args> make_evaluator(Eval &eval, Args args) {
-                    return {eval, wstd::move(args)};
+                GT_FORCE_INLINE constexpr evaluator<I, J, K, Params, Eval, Args> make_evaluator(Eval &eval, Args args) {
+                    return {eval, std::move(args)};
                 }
 
                 template <class Functor, class Region, int_t I, int_t J, int_t K, class Eval, class Args>
                 GT_FUNCTION void evaluate_bound_functor(Eval &eval, Args args) {
                     call_functor<Functor, Region>(
-                        make_evaluator<I, J, K, typename Functor::param_list>(eval, wstd::move(args)));
+                        make_evaluator<I, J, K, typename Functor::param_list>(eval, std::move(args)));
                 }
 
                 template <class Eval, class Arg, bool = is_accessor<Arg>::value>
@@ -189,8 +190,8 @@ namespace gridtools {
                     std::enable_if_t<sizeof...(Args) + 1 == meta::length<params_t>::value, int> = 0>
                 GT_FUNCTION static Res with(Eval &eval, Args &&...args) {
                     Res res;
-                    call_interfaces_impl_::evaluate_bound_functor<Functor, Region, OffI, OffJ, OffK>(eval,
-                        tuple_util::insert<out_param_index>(res, tuple<Args &&...>{wstd::forward<Args>(args)...}));
+                    call_interfaces_impl_::evaluate_bound_functor<Functor, Region, OffI, OffJ, OffK>(
+                        eval, tuple_util::insert<out_param_index>(res, tuple<Args &&...>{std::forward<Args>(args)...}));
                     return res;
                 }
             };
@@ -234,7 +235,7 @@ namespace gridtools {
                                                     meta::length<typename Functor::param_list>::value>
                 with(Eval &eval, Args &&...args) {
                     call_interfaces_impl_::evaluate_bound_functor<Functor, Region, OffI, OffJ, OffK>(
-                        eval, tuple<Args &&...>{wstd::forward<Args>(args)...});
+                        eval, tuple<Args &&...>{std::forward<Args>(args)...});
                 }
             };
         } // namespace cartesian
diff --git a/include/gridtools/stencil/frontend/cartesian/tmp_arg.hpp b/include/gridtools/stencil/frontend/cartesian/tmp_arg.hpp
index 8c971aa410..1f95a2d384 100644
--- a/include/gridtools/stencil/frontend/cartesian/tmp_arg.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/tmp_arg.hpp
@@ -23,7 +23,7 @@
 
 #define GT_DECLARE_TMP(type, ...)                                                               \
     BOOST_PP_SEQ_FOR_EACH(GT_INTERNAL_DECLARE_TMP, type, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)) \
-    static_assert(1, "")
+    static_assert(1)
 
 #define GT_INTERNAL_DECLARE_EXPANDABLE_TMP(r, type, name)                                    \
     constexpr ::gridtools::stencil::expandable<                                              \
@@ -32,7 +32,7 @@
 
 #define GT_DECLARE_EXPANDABLE_TMP(type, ...)                                                               \
     BOOST_PP_SEQ_FOR_EACH(GT_INTERNAL_DECLARE_EXPANDABLE_TMP, type, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)) \
-    static_assert(1, "")
+    static_assert(1)
 
 namespace gridtools {
     namespace stencil {
diff --git a/include/gridtools/stencil/frontend/icosahedral/stage.hpp b/include/gridtools/stencil/frontend/icosahedral/stage.hpp
index 7d1ec81fde..66d172ba97 100644
--- a/include/gridtools/stencil/frontend/icosahedral/stage.hpp
+++ b/include/gridtools/stencil/frontend/icosahedral/stage.hpp
@@ -11,6 +11,7 @@
 #pragma once
 
 #include <type_traits>
+#include <utility>
 
 #include "../../../common/defs.hpp"
 #include "../../../common/for_each.hpp"
@@ -61,7 +62,7 @@ namespace gridtools {
             namespace stage_impl_ {
                 struct default_deref_f {
                     template <class Key, class T>
-                    GT_FUNCTION decltype(auto) operator()(Key, T ptr) const {
+                    GT_FORCE_INLINE constexpr decltype(auto) operator()(Key, T ptr) const {
                         return *ptr;
                     }
                 };
@@ -72,21 +73,21 @@ namespace gridtools {
                     Strides const &m_strides;
 
                     template <class Key, class Offset>
-                    GT_FUNCTION decltype(auto) get_ref(Offset offset) const {
+                    GT_FORCE_INLINE constexpr decltype(auto) get_ref(Offset offset) const {
                         return Deref()(
-                            Key(), sid::multi_shifted<Key>(at_key<Key>(m_ptr), m_strides, wstd::move(offset)));
+                            Key(), sid::multi_shifted<Key>(at_key<Key>(m_ptr), m_strides, std::move(offset)));
                     }
 
                     template <class Accessor>
-                    GT_FUNCTION decltype(auto) operator()(Accessor) const {
+                    GT_FORCE_INLINE constexpr decltype(auto) operator()(Accessor) const {
                         return apply_intent<Accessor::intent_v>(get_ref<meta::at_c<Keys, Accessor::index_t::value>>(
                             hymap::keys<dim::c>::values<integral_constant<int_t, Color>>()));
                     }
 
                     template <class Accessor, class Offset>
-                    GT_FUNCTION decltype(auto) neighbor(Accessor, Offset offset) const {
+                    GT_FORCE_INLINE constexpr decltype(auto) neighbor(Accessor, Offset offset) const {
                         return apply_intent<Accessor::intent_v>(
-                            get_ref<meta::at_c<Keys, Accessor::index_t::value>>(wstd::move(offset)));
+                            get_ref<meta::at_c<Keys, Accessor::index_t::value>>(std::move(offset)));
                     }
 
                     static constexpr int_t color = Color;
@@ -94,8 +95,8 @@ namespace gridtools {
                     template <class Fun, class Accessor, class... Accessors>
                     GT_FUNCTION void for_neighbors(Fun &&fun, Accessor, Accessors...) const {
                         static_assert(
-                            std::conjunction<
-                                std::is_same<typename Accessor::location_t, typename Accessors::location_t>...>::value,
+                            std::conjunction_v<
+                                std::is_same<typename Accessor::location_t, typename Accessors::location_t>...>,
                             "All accessors should be of the same location");
                         for_each<neighbor_offsets<LocationType, typename Accessor::location_t, Color>>(
                             [&](auto offset) { fun(neighbor(Accessor(), offset), neighbor(Accessors(), offset)...); });
diff --git a/include/gridtools/stencil/frontend/icosahedral/tmp_arg.hpp b/include/gridtools/stencil/frontend/icosahedral/tmp_arg.hpp
index da8563e8d3..30e97b6b42 100644
--- a/include/gridtools/stencil/frontend/icosahedral/tmp_arg.hpp
+++ b/include/gridtools/stencil/frontend/icosahedral/tmp_arg.hpp
@@ -26,7 +26,7 @@
 #define GT_DECLARE_EXPANDABLE_ICO_TMP(type, location, ...)                                               \
     BOOST_PP_SEQ_FOR_EACH(                                                                               \
         GT_INTERNAL_DECLARE_EXPANDABLE_ICO_TMP, (type, location), BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)) \
-    static_assert(1, "")
+    static_assert(1)
 
 #define GT_INTERNAL_DECLARE_ICO_TMP(r, type_location, name)               \
     constexpr ::gridtools::stencil::icosahedral::tmp_arg<__COUNTER__,     \
@@ -36,7 +36,7 @@
 
 #define GT_DECLARE_ICO_TMP(type, location, ...)                                                                 \
     BOOST_PP_SEQ_FOR_EACH(GT_INTERNAL_DECLARE_ICO_TMP, (type, location), BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)) \
-    static_assert(1, "")
+    static_assert(1)
 
 namespace gridtools {
     namespace stencil {
diff --git a/include/gridtools/stencil/frontend/run.hpp b/include/gridtools/stencil/frontend/run.hpp
index 33fd93e253..af9c0536f1 100644
--- a/include/gridtools/stencil/frontend/run.hpp
+++ b/include/gridtools/stencil/frontend/run.hpp
@@ -125,7 +125,7 @@ namespace gridtools {
                     static_assert(meta::is_set<meta::list<Args...>>::value, "Duplicated arguments.");
                     static_assert(
                         meta::is_set<meta::list<typename Caches::plh_t..., Args...>>::value, "Duplicated caches.");
-                    static_assert(std::conjunction<core::is_tmp_arg<Args>...>::value,
+                    static_assert(std::conjunction_v<core::is_tmp_arg<Args>...>,
                         "Only temporary args can be K-cached without fill or flush policies.");
                     return {};
                 }
@@ -239,7 +239,7 @@ namespace gridtools {
             }
 
             template <class Comp, class Backend, class Grid, class... Fields>
-            void run(Comp comp, Backend &&be, Grid const &grid, Fields &&... fields) {
+            void run(Comp comp, Backend &&be, Grid const &grid, Fields &&...fields) {
                 static_assert(
                     std::conjunction<is_sid<Fields>...>::value, "All computation fields must satisfy SID concept.");
                 run_impl(comp,
@@ -250,7 +250,7 @@ namespace gridtools {
             }
 
             template <class F, class Backend, class Grid, class... Fields>
-            void run_single_stage(F, Backend &&be, Grid const &grid, Fields &&... fields) {
+            void run_single_stage(F, Backend &&be, Grid const &grid, Fields &&...fields) {
                 return run([](auto... args) { return execute_parallel().stage(F(), args...); },
                     std::forward<Backend>(be),
                     grid,
diff --git a/include/gridtools/stencil/global_parameter.hpp b/include/gridtools/stencil/global_parameter.hpp
index 493fa6a317..c6730e7ac0 100644
--- a/include/gridtools/stencil/global_parameter.hpp
+++ b/include/gridtools/stencil/global_parameter.hpp
@@ -26,10 +26,12 @@ namespace gridtools {
 
                 T m_value;
 
-                GT_CONSTEXPR GT_FUNCTION global_parameter operator()() const { return *this; }
-                GT_CONSTEXPR GT_FUNCTION T operator*() const { return m_value; }
+                constexpr global_parameter(T val) : m_value(std::move(val)) {}
 
-                friend GT_FUNCTION global_parameter operator+(global_parameter obj, ptr_diff) { return obj; }
+                GT_FORCE_INLINE constexpr global_parameter operator()() const { return *this; }
+                GT_FORCE_INLINE constexpr T operator*() const { return m_value; }
+
+                friend GT_FORCE_INLINE constexpr global_parameter operator+(global_parameter obj, ptr_diff) { return obj; }
                 friend global_parameter sid_get_origin(global_parameter const &obj) { return obj; }
                 friend ptr_diff sid_get_ptr_diff(global_parameter) { return {}; }
             };
@@ -38,7 +40,7 @@ namespace gridtools {
         using global_parameter_impl_::global_parameter;
 
         template <class T>
-        global_parameter<T> make_global_parameter(T val) {
+        [[deprecated("use global_parameter template deduction")]] global_parameter<T> make_global_parameter(T val) {
             return {std::move(val)};
         }
     } // namespace stencil
diff --git a/include/gridtools/stencil/gpu/entry_point.hpp b/include/gridtools/stencil/gpu/entry_point.hpp
index bd38185f38..4687d07c40 100644
--- a/include/gridtools/stencil/gpu/entry_point.hpp
+++ b/include/gridtools/stencil/gpu/entry_point.hpp
@@ -134,13 +134,13 @@ namespace gridtools {
             struct deref_f {
 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 350
                 template <class Key, class T>
-                GT_FUNCTION std::enable_if_t<is_texture_type<T>::value && meta::st_contains<Keys, Key>::value, T>
+                GT_FORCE_INLINE constexpr std::enable_if_t<is_texture_type<T>::value && meta::st_contains<Keys, Key>::value, T>
                 operator()(Key, T const *ptr) const {
                     return __ldg(ptr);
                 }
 #endif
                 template <class Key, class Ptr>
-                GT_FUNCTION decltype(auto) operator()(Key, Ptr ptr) const {
+                GT_FORCE_INLINE constexpr decltype(auto) operator()(Key, Ptr ptr) const {
                     return *ptr;
                 }
             };
diff --git a/include/gridtools/stencil/gpu/fill_flush.hpp b/include/gridtools/stencil/gpu/fill_flush.hpp
index 21c28ffe16..31658df610 100644
--- a/include/gridtools/stencil/gpu/fill_flush.hpp
+++ b/include/gridtools/stencil/gpu/fill_flush.hpp
@@ -64,28 +64,28 @@ namespace gridtools {
                     enum class check { none, lo, hi };
 
                     template <class Ptrs>
-                    GT_FUNCTION int_t get_k_pos(Ptrs const &ptrs) {
+                    GT_FORCE_INLINE constexpr int_t get_k_pos(Ptrs const &ptrs) {
                         return *at_key<meta::list<k_pos_key>>(ptrs);
                     }
 
                     template <class PlhInfo, class Ptr, class Strides, class Offset>
-                    GT_FUNCTION void shift_orig(Ptr &ptr, Strides const &strides, Offset offset) {
+                    GT_FORCE_INLINE constexpr void shift_orig(Ptr &ptr, Strides const &strides, Offset offset) {
                         sid::shift(
                             ptr, sid::get_stride_element<meta::list<typename PlhInfo::plh_t>, dim::k>(strides), offset);
                     }
 
                     template <class PlhInfo, class Ptr, class Strides, class Offset>
-                    GT_FUNCTION void shift_cached(Ptr &ptr, Strides const &strides, Offset offset) {
+                    GT_FORCE_INLINE constexpr void shift_cached(Ptr &ptr, Strides const &strides, Offset offset) {
                         sid::shift(ptr, sid::get_stride_element<typename PlhInfo::key_t, dim::k>(strides), offset);
                     }
 
                     template <class PlhInfo, class Ptrs>
-                    GT_FUNCTION auto get_orig(Ptrs const &ptrs) {
+                    GT_FORCE_INLINE constexpr auto get_orig(Ptrs const &ptrs) {
                         return at_key<meta::list<typename PlhInfo::plh_t>>(ptrs);
                     }
 
                     template <class PlhInfo, class Ptrs>
-                    GT_FUNCTION auto get_cached(Ptrs const &ptrs) {
+                    GT_FORCE_INLINE constexpr auto get_cached(Ptrs const &ptrs) {
                         return at_key<typename PlhInfo::key_t>(ptrs);
                     }
 
@@ -95,7 +95,7 @@ namespace gridtools {
                         std::enable_if_t<std::is_same<typename PlhInfo::cache_io_policies_t,
                                              meta::list<cache_io_policy::fill>>::value,
                             int> = 0>
-                    GT_FUNCTION void sync(Cached cached, Orig orig) {
+                    GT_FORCE_INLINE constexpr void sync(Cached cached, Orig orig) {
                         *cached = *orig;
                     }
 
@@ -105,18 +105,18 @@ namespace gridtools {
                         std::enable_if_t<std::is_same<typename PlhInfo::cache_io_policies_t,
                                              meta::list<cache_io_policy::flush>>::value,
                             int> = 0>
-                    GT_FUNCTION void sync(Cached cached, Orig orig) {
+                    GT_FORCE_INLINE constexpr void sync(Cached cached, Orig orig) {
                         *orig = *cached;
                     }
 
                     template <class Plh, check>
                     struct bound {};
 
-                    GT_FUNCTION bool is_k_valid(integral_constant<check, check::lo>, int_t k, int_t lim) {
+                    GT_FORCE_INLINE constexpr bool is_k_valid(integral_constant<check, check::lo>, int_t k, int_t lim) {
                         return k >= lim;
                     }
 
-                    GT_FUNCTION bool is_k_valid(integral_constant<check, check::hi>, int_t k, int_t lim) {
+                    GT_FORCE_INLINE constexpr bool is_k_valid(integral_constant<check, check::hi>, int_t k, int_t lim) {
                         return k < lim;
                     }
 
@@ -326,13 +326,13 @@ namespace gridtools {
 
                     template <class Plh, class DataStores>
                     auto make_data_store(bound<Plh, check::lo>, DataStores const &data_stores) {
-                        return make_global_parameter(
+                        return global_parameter(
                             sid::get_lower_bound<dim::k>(sid::get_lower_bounds(at_key<Plh>(data_stores))));
                     }
 
                     template <class Plh, class DataStores>
                     auto make_data_store(bound<Plh, check::hi>, DataStores const &data_stores) {
-                        return make_global_parameter(
+                        return global_parameter(
                             sid::get_upper_bound<dim::k>(sid::get_upper_bounds(at_key<Plh>(data_stores))));
                     }
 
diff --git a/include/gridtools/stencil/gpu/k_cache.hpp b/include/gridtools/stencil/gpu/k_cache.hpp
index a30c91fe05..231e6fd91c 100644
--- a/include/gridtools/stencil/gpu/k_cache.hpp
+++ b/include/gridtools/stencil/gpu/k_cache.hpp
@@ -46,12 +46,12 @@ namespace gridtools {
                 };
 
                 struct fake {
-                    GT_FUNCTION fake operator()() const { return {}; }
+                    constexpr fake operator()() const { return {}; }
                     fake operator*() const;
                 };
                 fake sid_get_ptr_diff(fake);
                 inline fake sid_get_origin(fake) { return {}; }
-                GT_FUNCTION fake operator+(fake, fake) { return {}; }
+                constexpr fake operator+(fake, fake) { return {}; }
                 inline hymap::keys<dim::k>::values<integral_constant<int_t, 1>> sid_get_strides(fake) { return {}; }
 
                 static_assert(is_sid<fake>(), GT_INTERNAL_ERROR);
diff --git a/include/gridtools/stencil/gpu/make_kernel_fun.hpp b/include/gridtools/stencil/gpu/make_kernel_fun.hpp
index e879b38070..ffb9da84f4 100644
--- a/include/gridtools/stencil/gpu/make_kernel_fun.hpp
+++ b/include/gridtools/stencil/gpu/make_kernel_fun.hpp
@@ -15,7 +15,6 @@
 #include "../../common/gt_math.hpp"
 #include "../../common/host_device.hpp"
 #include "../../common/tuple_util.hpp"
-#include "../../common/utility.hpp"
 #include "../../meta.hpp"
 #include "../../sid/blocked_dim.hpp"
 #include "../../sid/concept.hpp"
@@ -54,7 +53,7 @@ namespace gridtools {
                     template <class Ptr, class Strides, class Validator>
                     GT_FUNCTION_DEVICE void operator()(Ptr ptr, Strides const &strides, Validator validator) const {
                         k_caches_type<Mss> k_caches;
-                        auto mixed_ptr = hymap::merge(k_caches.ptr(), wstd::move(ptr));
+                        auto mixed_ptr = hymap::merge(k_caches.ptr(), std::move(ptr));
                         tuple_util::for_each(
                             [&](const int_t size, auto info) GT_FORCE_INLINE_LAMBDA {
 #ifdef __HIPCC__
@@ -138,7 +137,7 @@ namespace gridtools {
                         sid::shift(ptr, sid::get_stride<sid::blocked_dim<dim::j>>(m_strides), blockIdx.y);
                         sid::shift(ptr, sid::get_stride<dim::i>(m_strides), i_block);
                         sid::shift(ptr, sid::get_stride<dim::j>(m_strides), j_block);
-                        k_loop(wstd::move(ptr), m_strides, wstd::move(validator));
+                        k_loop(std::move(ptr), m_strides, std::move(validator));
                     }
                 };
 
diff --git a/include/gridtools/stencil/gpu/shared_allocator.hpp b/include/gridtools/stencil/gpu/shared_allocator.hpp
index 1be7db28a9..e57fbff2a7 100644
--- a/include/gridtools/stencil/gpu/shared_allocator.hpp
+++ b/include/gridtools/stencil/gpu/shared_allocator.hpp
@@ -31,7 +31,7 @@ namespace gridtools {
                         return reinterpret_cast<T *>(ij_cache_shm + m_offset);
                     }
 
-                    friend GT_FUNCTION lazy_alloc operator+(lazy_alloc l, ptrdiff_t r) {
+                    friend GT_FORCE_INLINE constexpr lazy_alloc operator+(lazy_alloc l, ptrdiff_t r) {
                         l.m_offset += r * sizeof(T);
                         return l;
                     }
diff --git a/include/gridtools/stencil/gpu_horizontal/entry_point.hpp b/include/gridtools/stencil/gpu_horizontal/entry_point.hpp
index 3020966637..d2e1d6125d 100644
--- a/include/gridtools/stencil/gpu_horizontal/entry_point.hpp
+++ b/include/gridtools/stencil/gpu_horizontal/entry_point.hpp
@@ -21,7 +21,6 @@
 #include "../../common/hymap.hpp"
 #include "../../common/integral_constant.hpp"
 #include "../../common/tuple_util.hpp"
-#include "../../common/utility.hpp"
 #include "../../meta.hpp"
 #include "../../sid/as_const.hpp"
 #include "../../sid/block.hpp"
@@ -44,13 +43,13 @@ namespace gridtools {
             struct deref_f {
 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 350
                 template <class Key, class T>
-                GT_FUNCTION std::enable_if_t<is_texture_type<T>::value && meta::st_contains<Keys, Key>::value, T>
+                GT_FORCE_INLINE constexpr std::enable_if_t<is_texture_type<T>::value && meta::st_contains<Keys, Key>::value, T>
                 operator()(Key, T const *ptr) const {
                     return __ldg(ptr);
                 }
 #endif
                 template <class Key, class Ptr>
-                GT_FUNCTION decltype(auto) operator()(Key, Ptr ptr) const {
+                GT_FORCE_INLINE constexpr decltype(auto) operator()(Key, Ptr ptr) const {
                     return *ptr;
                 }
             };
@@ -71,7 +70,7 @@ namespace gridtools {
 
                     using j_caches_t = j_caches_type<Info>;
                     j_caches_t j_caches;
-                    auto mixed_ptr = hymap::merge(j_caches.ptr(), wstd::move(ptr));
+                    auto mixed_ptr = hymap::merge(j_caches.ptr(), std::move(ptr));
 
                     auto shift_mixed_ptr = [&](auto dim, auto offset) {
                         sid::shift(mixed_ptr.secondary(), sid::get_stride<decltype(dim)>(strides), offset);
diff --git a/include/gridtools/stencil/gpu_horizontal/j_cache.hpp b/include/gridtools/stencil/gpu_horizontal/j_cache.hpp
index 1a4b90067c..8536ce41b7 100644
--- a/include/gridtools/stencil/gpu_horizontal/j_cache.hpp
+++ b/include/gridtools/stencil/gpu_horizontal/j_cache.hpp
@@ -63,7 +63,7 @@ namespace gridtools {
 
                 template <class Extent, class NumColors>
                 struct fake {
-                    GT_FUNCTION fake operator()() const { return {}; }
+                    constexpr fake operator()() const { return {}; }
                     fake operator*() const;
                 };
                 template <class Extent, class NumColors>
@@ -75,7 +75,7 @@ namespace gridtools {
                 }
 
                 template <class Extent, class NumColors>
-                GT_FUNCTION fake<Extent, NumColors> operator+(fake<Extent, NumColors>, fake<Extent, NumColors>) {
+                constexpr fake<Extent, NumColors> operator+(fake<Extent, NumColors>, fake<Extent, NumColors>) {
                     return {};
                 }
 
diff --git a/include/gridtools/storage/adapter/fortran_array_adapter.hpp b/include/gridtools/storage/adapter/fortran_array_adapter.hpp
index 59729ba9e5..f7b9641522 100644
--- a/include/gridtools/storage/adapter/fortran_array_adapter.hpp
+++ b/include/gridtools/storage/adapter/fortran_array_adapter.hpp
@@ -19,7 +19,7 @@
 namespace gridtools {
     template <class DataStorePtr>
     class fortran_array_adapter {
-        static_assert(storage::is_data_store_ptr<DataStorePtr>::value, "");
+        static_assert(storage::is_data_store_ptr<DataStorePtr>::value);
         using data_store_t = typename DataStorePtr::element_type;
         using lengths_t = std::decay_t<decltype(DataStorePtr()->lengths())>;
         using strides_t = std::decay_t<decltype(DataStorePtr()->strides())>;
diff --git a/include/gridtools/storage/builder.hpp b/include/gridtools/storage/builder.hpp
index 5854f9e961..fac50964a1 100644
--- a/include/gridtools/storage/builder.hpp
+++ b/include/gridtools/storage/builder.hpp
@@ -272,7 +272,7 @@ namespace gridtools {
                 template <class... Args>
                 auto dimensions(Args const &...values) const {
                     static_assert(!has<param::lengths>::value, "storage dimensions are set twice");
-                    static_assert(std::conjunction<std::is_convertible<Args const &, uint_t>...>::value,
+                    static_assert(std::conjunction_v<std::is_convertible<Args const &, uint_t>...>,
                         "builder.dimensions(...) arguments should be convertible to unsigned int");
                     check_dimensions_number<sizeof...(Args)>();
                     return add_value<param::lengths>(
@@ -282,7 +282,7 @@ namespace gridtools {
                 template <class... Args>
                 auto halos(Args const &...values) const {
                     static_assert(!has<param::halos>::value, "storage dimensions are set twice");
-                    static_assert(std::conjunction<std::is_convertible<Args const &, int>...>::value,
+                    static_assert(std::conjunction_v<std::is_convertible<Args const &, int>...>,
                         "builder.halos(...) arguments should be convertible to int");
                     check_dimensions_number<sizeof...(Args)>();
                     return add_value<param::halos>(array<int, sizeof...(Args)>{static_cast<int>(values)...});
diff --git a/include/gridtools/storage/gpu.hpp b/include/gridtools/storage/gpu.hpp
index 7fcfddd57c..49d7651bb5 100644
--- a/include/gridtools/storage/gpu.hpp
+++ b/include/gridtools/storage/gpu.hpp
@@ -19,7 +19,6 @@
 #include "../common/host_device.hpp"
 #include "../common/integral_constant.hpp"
 #include "../common/layout_map.hpp"
-#include "../common/utility.hpp"
 
 namespace gridtools {
     namespace storage {
@@ -57,8 +56,8 @@ namespace gridtools {
 
                 template <class... Args>
                 GT_FUNCTION_DEVICE auto operator()(Args &&... args) const
-                    -> decltype(m_ptr[m_info.index(wstd::forward<Args>(args)...)]) {
-                    return m_ptr[m_info.index(wstd::forward<Args>(args)...)];
+                    -> decltype(m_ptr[m_info.index(std::forward<Args>(args)...)]) {
+                    return m_ptr[m_info.index(std::forward<Args>(args)...)];
                 }
 
                 GT_FUNCTION_DEVICE decltype(auto) operator()(array<int, Info::ndims> const &arg) const {
diff --git a/include/gridtools/storage/info.hpp b/include/gridtools/storage/info.hpp
index de66df1187..6dfb34ebae 100644
--- a/include/gridtools/storage/info.hpp
+++ b/include/gridtools/storage/info.hpp
@@ -91,7 +91,7 @@ namespace gridtools {
             class info<Lengths, Strides, std::index_sequence<Dims...>> : tuple<Lengths, Strides> {
                 static_assert(tuple_util::size<Lengths>::value == tuple_util::size<Strides>::value, GT_INTERNAL_ERROR);
 
-                GT_FUNCTION tuple<Lengths, Strides> const &base() const { return *this; }
+                GT_FORCE_INLINE constexpr tuple<Lengths, Strides> const &base() const { return *this; }
 
               public:
                 static constexpr size_t ndims = tuple_util::size<Lengths>::value;
@@ -99,19 +99,19 @@ namespace gridtools {
                 info(Lengths lengths, Strides strides)
                     : tuple<Lengths, Strides>{std::move(lengths), std::move(strides)} {}
 
-                GT_FUNCTION auto const &native_lengths() const { return tuple_util::get<0>(base()); }
-                GT_FUNCTION auto const &native_strides() const { return tuple_util::get<1>(base()); }
-                GT_FUNCTION int length() const {
+                GT_FORCE_INLINE constexpr auto const &native_lengths() const { return tuple_util::get<0>(base()); }
+                GT_FORCE_INLINE constexpr auto const &native_strides() const { return tuple_util::get<1>(base()); }
+                GT_FORCE_INLINE constexpr int length() const {
                     using tuple_util::get;
                     bool is_empty = false;
                     for (auto empty_dim : {(get<Dims>(native_lengths()) == 0)...})
                         is_empty = is_empty || empty_dim;
                     return is_empty ? 0 : index((get<Dims>(native_lengths()) - integral_constant<int_t, 1>())...) + 1;
                 }
-                GT_FUNCTION array<uint_t, ndims> lengths() const {
+                GT_FORCE_INLINE constexpr array<uint_t, ndims> lengths() const {
                     return {(uint_t)tuple_util::get<Dims>(native_lengths())...};
                 }
-                GT_FUNCTION array<uint_t, ndims> strides() const {
+                GT_FORCE_INLINE constexpr array<uint_t, ndims> strides() const {
                     return {(uint_t)tuple_util::get<Dims>(native_strides())...};
                 }
 
@@ -119,12 +119,12 @@ namespace gridtools {
                     std::enable_if_t<sizeof...(Is) == ndims &&
                                          std::conjunction<std::is_convertible<Is, int_t>...>::value,
                         int> = 0>
-                GT_FUNCTION auto index(Is... indices) const {
+                GT_FORCE_INLINE constexpr auto index(Is... indices) const {
                     return index_from_tuple(tuple(indices...));
                 }
 
                 template <class Indices>
-                GT_FUNCTION auto index_from_tuple(Indices &&indices) const {
+                GT_FORCE_INLINE constexpr auto index_from_tuple(Indices &&indices) const {
                     using namespace tuple_util;
 #ifndef NDEBUG
                     tuple_util::for_each(
diff --git a/include/gridtools/storage/sid.hpp b/include/gridtools/storage/sid.hpp
index 9d94ce35c2..3cce245885 100644
--- a/include/gridtools/storage/sid.hpp
+++ b/include/gridtools/storage/sid.hpp
@@ -28,7 +28,7 @@ namespace gridtools {
         namespace storage_sid_impl_ {
             struct empty_ptr_diff {
                 template <class T>
-                friend GT_CONSTEXPR GT_FUNCTION T *operator+(T *lhs, empty_ptr_diff) {
+                friend GT_FORCE_INLINE constexpr T *operator+(T *lhs, empty_ptr_diff) {
                     return lhs;
                 }
             };
@@ -36,7 +36,7 @@ namespace gridtools {
             template <class T>
             struct ptr_holder {
                 T *m_val;
-                GT_FUNCTION GT_CONSTEXPR T *operator()() const { return m_val; }
+                GT_FORCE_INLINE constexpr T *operator()() const { return m_val; }
 
                 friend GT_FORCE_INLINE constexpr ptr_holder operator+(ptr_holder obj, int_t arg) {
                     return {obj.m_val + arg};
diff --git a/tests/include/cuda_test_helper.hpp b/tests/include/cuda_test_helper.hpp
index b1e35c12be..0a1352e7eb 100644
--- a/tests/include/cuda_test_helper.hpp
+++ b/tests/include/cuda_test_helper.hpp
@@ -45,8 +45,8 @@ namespace gridtools {
         }
         template <class Fun, class... Args>
         auto exec_with_shared_memory(size_t shm_size, Fun fun, Args... args) {
-            static_assert(!std::is_pointer<Fun>::value, "");
-            static_assert(std::conjunction<std::negation<std::is_pointer<Args>>...>::value, "");
+            static_assert(!std::is_pointer<Fun>::value);
+            static_assert(std::conjunction_v<std::negation<std::is_pointer<Args>>...>);
             using res_t = std::decay_t<decltype(fun(args...))>;
             static_assert(std::is_trivially_copy_constructible_v<res_t>);
             auto res = cuda_util::cuda_malloc<res_t>();
@@ -56,7 +56,7 @@ namespace gridtools {
         }
 
         template <class Fun, class... Args>
-        auto exec(Fun &&fun, Args &&... args) {
+        auto exec(Fun &&fun, Args &&...args) {
             return exec_with_shared_memory(0, std::forward<Fun>(fun), std::forward<Args>(args)...);
         }
     } // namespace on_device
diff --git a/tests/include/verifier.hpp b/tests/include/verifier.hpp
index 9c96761e9f..73dabe0aeb 100644
--- a/tests/include/verifier.hpp
+++ b/tests/include/verifier.hpp
@@ -39,19 +39,19 @@ namespace gridtools {
     } // namespace impl_
 
     template <class T>
-    GT_FUNCTION double default_precision() {
+    constexpr double default_precision() {
         return impl_::default_precision_impl<T>::value;
     }
 
     template <class T, std::enable_if_t<std::is_floating_point<T>::value, int> = 0>
-    GT_FUNCTION bool expect_with_threshold(T expected, T actual, double precision = default_precision<T>()) {
+    constexpr bool expect_with_threshold(T expected, T actual, double precision = default_precision<T>()) {
         auto abs_error = math::fabs(expected - actual);
         auto abs_max = math::max(math::fabs(expected), math::fabs(actual));
         return abs_error < precision || abs_error < abs_max * precision;
     }
 
     template <class T, std::enable_if_t<!std::is_floating_point<T>::value, int> = 0>
-    GT_FUNCTION bool expect_with_threshold(T const &expected, T const &actual, double = 0) {
+    constexpr bool expect_with_threshold(T const &expected, T const &actual, double = 0) {
         return actual == expected;
     }
 
diff --git a/tests/regression/c_array_copy.cpp b/tests/regression/c_array_copy.cpp
index 6e9605db2c..6bdfdf8a48 100644
--- a/tests/regression/c_array_copy.cpp
+++ b/tests/regression/c_array_copy.cpp
@@ -31,7 +31,7 @@ struct copy {
 
 template <class T>
 auto grid(T const &) {
-    static_assert(std::rank<T>() == 3, "");
+    static_assert(std::rank_v<T> == 3);
     return make_grid(std::extent<T, 0>(), std::extent<T, 1>(), std::extent<T, 2>());
 }
 
diff --git a/tests/regression/extended_4D.cpp b/tests/regression/extended_4D.cpp
index b4b103348b..5f9ebc23b4 100644
--- a/tests/regression/extended_4D.cpp
+++ b/tests/regression/extended_4D.cpp
@@ -122,8 +122,8 @@ namespace {
         run_single_stage(integration(),
             stencil_backend_t(),
             TypeParam::make_grid(),
-            make_global_parameter(ephi),
-            make_global_parameter(epsi),
+            global_parameter(ephi),
+            global_parameter(epsi),
             const_builder.dimensions(TypeParam::d(0), TypeParam::d(1), TypeParam::d(2), nbQuadPt)
                 .initializer(jac)
                 .build(),
diff --git a/tests/regression/horizontal_diffusion_functions.cpp b/tests/regression/horizontal_diffusion_functions.cpp
index 3859150eb4..7e42b40811 100644
--- a/tests/regression/horizontal_diffusion_functions.cpp
+++ b/tests/regression/horizontal_diffusion_functions.cpp
@@ -203,7 +203,7 @@ namespace {
     GT_REGRESSION_TEST(horizontal_diffusion_functions_##v, test_environment<2>, stencil_backend_t) { \
         do_test<TypeParam, variation::v>();                                                          \
     }                                                                                                \
-    static_assert(1, "")
+    static_assert(1)
 
     TEST_VARIATION(monolithic);
     TEST_VARIATION(call);
diff --git a/tests/regression/py_bindings/implementation.cpp b/tests/regression/py_bindings/implementation.cpp
index fab7aac33f..814d1e3efd 100644
--- a/tests/regression/py_bindings/implementation.cpp
+++ b/tests/regression/py_bindings/implementation.cpp
@@ -48,8 +48,8 @@ struct copy_functor {
 // The input and output fields are passed as SIDs
 template <class From, class To>
 void copy(From &&from, To &&to) {
-    static_assert(is_sid<From>(), "");
-    static_assert(is_sid<To>(), "");
+    static_assert(is_sid<From>());
+    static_assert(is_sid<To>());
     auto &&size = sid::get_upper_bounds(to);
     run_single_stage(copy_functor(),
         naive(),
@@ -73,12 +73,12 @@ void check_cuda_sid(T &&testee,
     size_t expected_ptr,
     std::vector<size_t> const &expected_strides,
     std::vector<size_t> const &expected_dims) {
-    static_assert(is_sid<T>(), "");
+    static_assert(is_sid<T>());
     using lower_bounds_t = sid::lower_bounds_type<T>;
     using upper_bounds_t = sid::upper_bounds_type<T>;
     using strides_t = sid::strides_type<T>;
-    static_assert(tuple_util::size<lower_bounds_t>() == tuple_util::size<strides_t>(), "");
-    static_assert(tuple_util::size<upper_bounds_t>() == tuple_util::size<strides_t>(), "");
+    static_assert(tuple_util::size<lower_bounds_t>() == tuple_util::size<strides_t>());
+    static_assert(tuple_util::size<upper_bounds_t>() == tuple_util::size<strides_t>());
 
     assert(reinterpret_cast<size_t>(sid::get_origin(testee)()) == expected_ptr);
     check_hymap(sid::get_strides(testee), expected_strides);
@@ -107,7 +107,7 @@ PYBIND11_MODULE(py_implementation, m) {
         "Copy from the 1D double buffer to a 3D one.");
     m.def(
         "copy_from_scalar",
-        [](double from, py::buffer to) { copy(make_global_parameter(from), as_sid<double, 3>(to)); },
+        [](double from, py::buffer to) { copy(global_parameter(from), as_sid<double, 3>(to)); },
         "Copy from the scalar to a 3D buffer of doubles.");
     m.def(
         "check_cuda_sid",
diff --git a/tests/regression/vertical_advection_dycore.cpp b/tests/regression/vertical_advection_dycore.cpp
index e00d48dee4..0b350dcbee 100644
--- a/tests/regression/vertical_advection_dycore.cpp
+++ b/tests/regression/vertical_advection_dycore.cpp
@@ -136,7 +136,7 @@ namespace {
                         wcon = TypeParam::make_storage(repo.wcon),
                         u_pos = TypeParam::make_storage(repo.u_pos),
                         utens = TypeParam::make_storage(repo.utens),
-                        dtr_stage = make_global_parameter(typename TypeParam::float_t(repo.dtr_stage))] {
+                        dtr_stage = global_parameter<typename TypeParam::float_t>(repo.dtr_stage)] {
             const auto spec = [](auto utens_stage, auto u_stage, auto wcon, auto u_pos, auto utens, auto dtr_stage) {
                 GT_DECLARE_TMP(typename TypeParam::float_t, ccol, dcol, data_col);
                 return multi_pass(
diff --git a/tests/unit_tests/boundaries/test_bindbc_utilities.cpp b/tests/unit_tests/boundaries/test_bindbc_utilities.cpp
index d905740b10..c356c7c65e 100644
--- a/tests/unit_tests/boundaries/test_bindbc_utilities.cpp
+++ b/tests/unit_tests/boundaries/test_bindbc_utilities.cpp
@@ -37,9 +37,9 @@ namespace collect_indices {
         typename bd::_impl::comm_indices<std::tuple<>>::collect_indices<0, std::index_sequence<>, Tuple>::type,
         std::index_sequence<Is...>>::value;
 
-    static_assert(testee<std::tuple<int, int>, 0, 1>, "");
-    static_assert(testee<std::tuple<int, decltype(_1), int, decltype(_2)>, 0, 2>, "");
-    static_assert(testee<std::tuple<decltype(_1), decltype(_2)>>, "");
+    static_assert(testee<std::tuple<int, int>, 0, 1>);
+    static_assert(testee<std::tuple<int, decltype(_1), int, decltype(_2)>, 0, 2>);
+    static_assert(testee<std::tuple<decltype(_1), decltype(_2)>>);
 } // namespace collect_indices
 
 TEST(DistributedBoundaries, RestTuple) {
@@ -48,10 +48,10 @@ TEST(DistributedBoundaries, RestTuple) {
     EXPECT_EQ(bd::_impl::rest_tuple(std::make_tuple(1, 2), std::make_index_sequence<1>{}), std::make_tuple(2));
 }
 
-static_assert(!bd::_impl::contains_placeholders<decltype(std::make_tuple(3, 4, 5))>::value, "");
-static_assert(!bd::_impl::contains_placeholders<decltype(std::make_tuple())>::value, "");
-static_assert(bd::_impl::contains_placeholders<decltype(std::make_tuple(3, 4, _1))>::value, "");
-static_assert(bd::_impl::contains_placeholders<decltype(std::make_tuple(3, _2, 5))>::value, "");
+static_assert(!bd::_impl::contains_placeholders<decltype(std::make_tuple(3, 4, 5))>::value);
+static_assert(!bd::_impl::contains_placeholders<decltype(std::make_tuple())>::value);
+static_assert(bd::_impl::contains_placeholders<decltype(std::make_tuple(3, 4, _1))>::value);
+static_assert(bd::_impl::contains_placeholders<decltype(std::make_tuple(3, _2, 5))>::value);
 
 TEST(DistributedBoundaries, BoundBC) {
     const auto builder = gt::storage::builder<gt::storage::cpu_kfirst>.type<double>().dimensions(3, 3, 3);
diff --git a/tests/unit_tests/common/CMakeLists.txt b/tests/unit_tests/common/CMakeLists.txt
index 995baa3041..adf042dc75 100644
--- a/tests/unit_tests/common/CMakeLists.txt
+++ b/tests/unit_tests/common/CMakeLists.txt
@@ -9,7 +9,6 @@ gridtools_add_unit_test(test_array SOURCES test_array.cpp)
 gridtools_add_unit_test(test_compose SOURCES test_compose.cpp)
 gridtools_add_unit_test(test_hugepage_alloc SOURCES test_hugepage_alloc.cpp)
 gridtools_add_unit_test(test_hymap SOURCES test_hymap.cpp)
-#gridtools_add_unit_test(test_pair SOURCES test_pair.cpp)
 gridtools_add_unit_test(test_stride_util SOURCES test_stride_util.cpp)
 gridtools_add_unit_test(test_tuple_util SOURCES test_tuple_util.cpp)
 gridtools_add_unit_test(test_for_each SOURCES test_for_each.cpp)
diff --git a/tests/unit_tests/common/test_array.cpp b/tests/unit_tests/common/test_array.cpp
index b1a605f033..4862920464 100644
--- a/tests/unit_tests/common/test_array.cpp
+++ b/tests/unit_tests/common/test_array.cpp
@@ -37,8 +37,8 @@ namespace constexpr_compare {
     constexpr array<uint_t, 3> b{0, 0, 0};
     constexpr array<uint_t, 3> c{0, 0, 1};
 
-    static_assert(a == b, "");
-    static_assert(a != c, "");
+    static_assert(a == b);
+    static_assert(a != c);
 } // namespace constexpr_compare
 
 TEST(array, iterate) {
diff --git a/tests/unit_tests/common/test_cuda_type_traits.cu b/tests/unit_tests/common/test_cuda_type_traits.cu
index bdd3d4d51b..ed4219866f 100644
--- a/tests/unit_tests/common/test_cuda_type_traits.cu
+++ b/tests/unit_tests/common/test_cuda_type_traits.cu
@@ -12,8 +12,8 @@
 #include <gridtools/common/defs.hpp>
 
 namespace gridtools {
-    static_assert(is_texture_type<int>::value, "");
-    static_assert(!is_texture_type<bool>::value, "");
-    static_assert(is_texture_type<double>::value, "");
-    static_assert(is_texture_type<uint_t>::value, "");
+    static_assert(is_texture_type<int>::value);
+    static_assert(!is_texture_type<bool>::value);
+    static_assert(is_texture_type<double>::value);
+    static_assert(is_texture_type<uint_t>::value);
 } // namespace gridtools
diff --git a/tests/unit_tests/common/test_for_each.cpp b/tests/unit_tests/common/test_for_each.cpp
index 73bc9525c1..25a7a2e566 100644
--- a/tests/unit_tests/common/test_for_each.cpp
+++ b/tests/unit_tests/common/test_for_each.cpp
@@ -60,6 +60,6 @@ namespace gridtools {
             for_each<lst<my_int_t<2>>>(f{res});
             return res;
         }
-        static_assert(foo() == 2, "");
+        static_assert(foo() == 2);
     } // namespace test_constexpr
 } // namespace gridtools
diff --git a/tests/unit_tests/common/test_gt_math.cpp b/tests/unit_tests/common/test_gt_math.cpp
index 57ca7dafba..6efd324bba 100644
--- a/tests/unit_tests/common/test_gt_math.cpp
+++ b/tests/unit_tests/common/test_gt_math.cpp
@@ -32,12 +32,12 @@ bool GT_FUNCTION test_exp(Value val, Value result) {
     return expect_with_threshold(math::exp(val), result);
 }
 
-static_assert(std::is_same<decltype(math::fabs(4.0f)), float>::value, "");
-static_assert(std::is_same<decltype(math::fabs(4.0)), double>::value, "");
+static_assert(std::is_same_v<decltype(math::fabs(4.0f)), float>);
+static_assert(std::is_same_v<decltype(math::fabs(4.0)), double>);
 #ifndef __CUDA_ARCH__
-static_assert(std::is_same<decltype(math::fabs((long double)4)), long double>::value, "");
+static_assert(std::is_same_v<decltype(math::fabs((long double)4)), long double>);
 #endif
-static_assert(std::is_same<decltype(math::fabs((int)4)), double>::value, "");
+static_assert(std::is_same_v<decltype(math::fabs((int)4)), double>);
 
 bool GT_FUNCTION test_fabs() {
     if (!expect_with_threshold(math::fabs(5.6), 5.6, 1e-14))
@@ -56,16 +56,16 @@ bool GT_FUNCTION test_fabs() {
         return true;
 }
 
-static_assert(std::is_same<decltype(math::abs(4.0f)), float>::value, "");
-static_assert(std::is_same<decltype(math::abs(4.0)), double>::value, "");
+static_assert(std::is_same_v<decltype(math::abs(4.0f)), float>);
+static_assert(std::is_same_v<decltype(math::abs(4.0)), double>);
 #ifndef __CUDA_ARCH__
-static_assert(std::is_same<decltype(math::abs((long double)4)), long double>::value, "");
+static_assert(std::is_same_v<decltype(math::abs((long double)4)), long double>);
 #endif
 
 // int overloads
-static_assert(std::is_same<decltype(math::abs((int)4)), int>::value, "");
-static_assert(std::is_same<decltype(math::abs((long)4)), long>::value, "");
-static_assert(std::is_same<decltype(math::abs((long long)4)), long long>::value, "");
+static_assert(std::is_same_v<decltype(math::abs((int)4)), int>);
+static_assert(std::is_same_v<decltype(math::abs((long)4)), long>);
+static_assert(std::is_same_v<decltype(math::abs((long long)4)), long long>);
 
 GT_FUNCTION bool test_abs() {
     // float overloads
diff --git a/tests/unit_tests/common/test_hymap.cpp b/tests/unit_tests/common/test_hymap.cpp
index e83a5f1204..14e45c0cab 100644
--- a/tests/unit_tests/common/test_hymap.cpp
+++ b/tests/unit_tests/common/test_hymap.cpp
@@ -25,21 +25,21 @@ namespace gridtools {
         struct b;
         struct c;
 
-        static_assert(!is_hymap<void>::value, "");
-        static_assert(is_hymap<std::array<int, 3>>::value, "");
-        static_assert(is_hymap<tuple<int, double>>::value, "");
-        static_assert(is_hymap<hymap::keys<>::values<>>::value, "");
-        static_assert(is_hymap<hymap::keys<a>::values<int>>::value, "");
-        static_assert(is_hymap<hymap::keys<a, b>::values<int, double>>::value, "");
+        static_assert(!is_hymap<void>::value);
+        static_assert(is_hymap<std::array<int, 3>>::value);
+        static_assert(is_hymap<tuple<int, double>>::value);
+        static_assert(is_hymap<hymap::keys<>::values<>>::value);
+        static_assert(is_hymap<hymap::keys<a>::values<int>>::value);
+        static_assert(is_hymap<hymap::keys<a, b>::values<int, double>>::value);
 
         TEST(tuple_like, smoke) {
             using testee_t = hymap::keys<a, b, c>::values<int, double, void *>;
 
-            static_assert(tuple_util::size<testee_t>::value == 3, "");
+            static_assert(tuple_util::size<testee_t>::value == 3);
 
-            static_assert(std::is_same<tuple_util::element<0, testee_t>, int>::value, "");
-            static_assert(std::is_same<tuple_util::element<1, testee_t>, double>::value, "");
-            static_assert(std::is_same<tuple_util::element<2, testee_t>, void *>::value, "");
+            static_assert(std::is_same_v<tuple_util::element<0, testee_t>, int>);
+            static_assert(std::is_same_v<tuple_util::element<1, testee_t>, double>);
+            static_assert(std::is_same_v<tuple_util::element<2, testee_t>, void *>);
 
             testee_t testee{42, 5.3, nullptr};
             EXPECT_EQ(42, tuple_util::get<0>(testee));
@@ -51,9 +51,9 @@ namespace gridtools {
             using testee_t = hymap::keys<a, b>::values<int, double>;
             testee_t testee{42, 5.3};
 
-            static_assert(has_key<testee_t, a>::value, "");
-            static_assert(has_key<testee_t, b>::value, "");
-            static_assert(!has_key<testee_t, c>::value, "");
+            static_assert(has_key<testee_t, a>::value);
+            static_assert(has_key<testee_t, b>::value);
+            static_assert(!has_key<testee_t, c>::value);
 
             EXPECT_EQ(42, at_key<a>(testee));
             EXPECT_EQ(5.3, at_key<b>(testee));
@@ -63,9 +63,9 @@ namespace gridtools {
             using testee_t = std::tuple<int, double>;
             testee_t testee{42, 5.3};
 
-            static_assert(has_key<testee_t, integral_constant<int, 0>>::value, "");
-            static_assert(has_key<testee_t, integral_constant<int, 1>>::value, "");
-            static_assert(!has_key<testee_t, integral_constant<int, 2>>::value, "");
+            static_assert(has_key<testee_t, integral_constant<int, 0>>::value);
+            static_assert(has_key<testee_t, integral_constant<int, 1>>::value);
+            static_assert(!has_key<testee_t, integral_constant<int, 2>>::value);
 
             EXPECT_EQ(42, (at_key<integral_constant<int, 0>>(testee)));
             EXPECT_EQ(5.3, (at_key<integral_constant<int, 1>>(testee)));
@@ -115,18 +115,16 @@ namespace gridtools {
             using src_t = hymap::keys<a, b>::values<int, double>;
             using dst_t = hymap::to_meta_map<src_t>;
 
-            static_assert(std::is_same<meta::second<meta::mp_find<dst_t, a>>, int>(), "");
-            static_assert(std::is_same<meta::second<meta::mp_find<dst_t, b>>, double>(), "");
+            static_assert(std::is_same_v<meta::second<meta::mp_find<dst_t, a>>, int>);
+            static_assert(std::is_same_v<meta::second<meta::mp_find<dst_t, b>>, double>);
         }
 
         TEST(from_meta_map, smoke) {
             using src_t = meta::list<meta::list<a, int>, meta::list<b, double>>;
             using dst_t = hymap::from_meta_map<src_t>;
 
-            static_assert(
-                std::is_same<typename std::decay<decltype(at_key<a>(std::declval<dst_t>()))>::type, int>(), "");
-            static_assert(
-                std::is_same<typename std::decay<decltype(at_key<b>(std::declval<dst_t>()))>::type, double>(), "");
+            static_assert(std::is_same_v<element_at<a, dst_t>, int>);
+            static_assert(std::is_same_v<element_at<b, dst_t>, double>);
         }
 
         TEST(from_meta_map, empty) {
diff --git a/tests/unit_tests/common/test_hypercube_iterator.cpp b/tests/unit_tests/common/test_hypercube_iterator.cpp
index 26dd720679..e962ac8ff0 100644
--- a/tests/unit_tests/common/test_hypercube_iterator.cpp
+++ b/tests/unit_tests/common/test_hypercube_iterator.cpp
@@ -10,14 +10,15 @@
 
 #include <gridtools/common/hypercube_iterator.hpp>
 
-#include <gridtools/common/pair.hpp>
-#include <gridtools/common/tuple.hpp>
-#include <gridtools/common/tuple_util.hpp>
 #include <vector>
+#include <utility>
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include <gridtools/common/tuple.hpp>
+#include <gridtools/common/tuple_util.hpp>
+
 using namespace gridtools;
 
 class hypercube_iteration : public ::testing::Test {
@@ -47,12 +48,12 @@ class hypercube_iteration : public ::testing::Test {
 
 TEST_F(hypercube_iteration, view_from_array_of_ranges) {
     expect_ranges({1, 3}, {4, 8}, {2, 10});
-    call_testee(array{pair(1, 3), pair(4, 8), pair(2, 10)});
+    call_testee(array{std::pair(1, 3), std::pair(4, 8), std::pair(2, 10)});
 }
 
 TEST_F(hypercube_iteration, view_from_tuple_of_ranges) {
     expect_ranges({1, 3}, {4, 8}, {2, 10});
-    call_testee(tuple(pair(1, 3), pair(4, 8), pair(2, 10)));
+    call_testee(tuple(std::pair(1, 3), std::pair(4, 8), std::pair(2, 10)));
 }
 
 TEST_F(hypercube_iteration, from_array_of_integers) {
@@ -62,7 +63,7 @@ TEST_F(hypercube_iteration, from_array_of_integers) {
 
 TEST_F(hypercube_iteration, from_zero_to_zero) {
     expect_ranges({}, {}, {});
-    call_testee(array{pair(0, 0), pair(0, 0), pair(0, 0)});
+    call_testee(array{std::pair(0, 0), std::pair(0, 0), std::pair(0, 0)});
 }
 
 TEST_F(hypercube_iteration, from_one_to_one) {
@@ -72,8 +73,8 @@ TEST_F(hypercube_iteration, from_one_to_one) {
 
 TEST(hypercube_view_empty_iteration_space, zero_dimensional_range) {
     int count = 0;
-    for (auto it : make_hypercube_view(array<pair<size_t, size_t>, 0>())) {
-        static_assert(tuple_util::size<decltype(it)>::value == 0, "");
+    for (auto it : make_hypercube_view(array<std::pair<size_t, size_t>, 0>())) {
+        static_assert(tuple_util::size<decltype(it)>::value == 0);
         ++count;
     }
     EXPECT_EQ(1, count);
@@ -82,7 +83,7 @@ TEST(hypercube_view_empty_iteration_space, zero_dimensional_range) {
 TEST(hypercube_view_empty_iteration_space, zero_dimensional_size) {
     int count = 0;
     for (auto it : make_hypercube_view(array<size_t, 0>())) {
-        static_assert(tuple_util::size<decltype(it)>::value == 0, "");
+        static_assert(tuple_util::size<decltype(it)>::value == 0);
         ++count;
     }
     EXPECT_EQ(1, count);
diff --git a/tests/unit_tests/common/test_hypercube_iterator.cu b/tests/unit_tests/common/test_hypercube_iterator.cu
index c110d24761..cd493bafa7 100644
--- a/tests/unit_tests/common/test_hypercube_iterator.cu
+++ b/tests/unit_tests/common/test_hypercube_iterator.cu
@@ -13,7 +13,7 @@
 
 static const size_t Size = 2;
 
-GT_FUNCTION int linear_index(gridtools::array<size_t, 2> &index) { return index[0] * Size + index[1]; }
+constexpr int linear_index(gridtools::array<size_t, 2> &index) { return index[0] * Size + index[1]; }
 
 __global__ void test_kernel(int *out_ptr) {
     for (size_t i = 0; i < Size * Size; ++i)
diff --git a/tests/unit_tests/common/test_int_vector.cu b/tests/unit_tests/common/test_int_vector.cu
index ac020dfcc1..a46718519d 100644
--- a/tests/unit_tests/common/test_int_vector.cu
+++ b/tests/unit_tests/common/test_int_vector.cu
@@ -38,9 +38,9 @@ namespace gridtools {
 
             auto testee = on_device::exec(GT_MAKE_INTEGRAL_CONSTANT_FROM_VALUE(&plus_device), m1, m2);
 
-            static_assert(std::is_same<int, std::decay_t<decltype(at_key<a>(testee))>>::value);
-            static_assert(std::is_same<long int, std::decay_t<decltype(at_key<b>(testee))>>::value);
-            static_assert(std::is_same<unsigned int, std::decay_t<decltype(at_key<c>(testee))>>::value);
+            static_assert(std::is_same_v<int, std::decay_t<decltype(at_key<a>(testee))>>);
+            static_assert(std::is_same_v<long int, std::decay_t<decltype(at_key<b>(testee))>>);
+            static_assert(std::is_same_v<unsigned int, std::decay_t<decltype(at_key<c>(testee))>>);
 
             EXPECT_EQ(1, at_key<a>(testee));
             EXPECT_EQ(12, at_key<b>(testee));
@@ -73,7 +73,7 @@ namespace gridtools {
 
             EXPECT_EQ(1, at_key<a>(testee));
             static_assert(!has_key<decltype(testee), b>());
-            static_assert(std::is_same<integral_constant<int, 2>, std::decay_t<decltype(at_key<c>(testee))>>::value);
+            static_assert(std::is_same_v<integral_constant<int, 2>, std::decay_t<decltype(at_key<c>(testee))>>);
         }
 
     } // namespace
diff --git a/tests/unit_tests/common/test_integral_constant.cpp b/tests/unit_tests/common/test_integral_constant.cpp
index d3cc6f2a80..d020b8354d 100644
--- a/tests/unit_tests/common/test_integral_constant.cpp
+++ b/tests/unit_tests/common/test_integral_constant.cpp
@@ -14,21 +14,21 @@ namespace gridtools {
     namespace {
         using namespace literals;
 
-        static_assert(0_c == 0, "");
-        static_assert(42_c == 42, "");
-        static_assert(-12345_c == -12345, "");
+        static_assert(0_c == 0);
+        static_assert(42_c == 42);
+        static_assert(-12345_c == -12345);
 
-        static_assert(0b100_c == 0b100, "");
-        static_assert(0100_c == 0100, "");
-        static_assert(0xDEAD_c == 0xDEAD, "");
+        static_assert(0b100_c == 0b100);
+        static_assert(0100_c == 0100);
+        static_assert(0xDEAD_c == 0xDEAD);
 
-        static_assert(1'000_c == 1000, "");
+        static_assert(1'000_c == 1000);
 
-        static_assert(2_c + 3_c == 5_c, "");
+        static_assert(2_c + 3_c == 5_c);
 
-        static_assert(is_integral_constant<integral_constant<int, 42>>::value, "");
-        static_assert(is_integral_constant<std::integral_constant<int, 42>>::value, "");
-        static_assert(is_gr_integral_constant<integral_constant<int, 42>>::value, "");
-        static_assert(!is_gr_integral_constant<std::integral_constant<int, 42>>::value, "");
+        static_assert(is_integral_constant<integral_constant<int, 42>>::value);
+        static_assert(is_integral_constant<std::integral_constant<int, 42>>::value);
+        static_assert(is_gr_integral_constant<integral_constant<int, 42>>::value);
+        static_assert(!is_gr_integral_constant<std::integral_constant<int, 42>>::value);
     } // namespace
 } // namespace gridtools
diff --git a/tests/unit_tests/common/test_layout_map.cpp b/tests/unit_tests/common/test_layout_map.cpp
index bb6e7fab3a..73c4d992f1 100644
--- a/tests/unit_tests/common/test_layout_map.cpp
+++ b/tests/unit_tests/common/test_layout_map.cpp
@@ -15,55 +15,55 @@ namespace simple_layout {
     typedef layout_map<0, 1, 2> layout1;
 
     // test length
-    static_assert(layout1::masked_length == 3, "");
-    static_assert(layout1::unmasked_length == 3, "");
+    static_assert(layout1::masked_length == 3);
+    static_assert(layout1::unmasked_length == 3);
 
     // test find method
-    static_assert(layout1::find(0) == 0, "");
-    static_assert(layout1::find(1) == 1, "");
-    static_assert(layout1::find(2) == 2, "");
+    static_assert(layout1::find(0) == 0);
+    static_assert(layout1::find(1) == 1);
+    static_assert(layout1::find(2) == 2);
 
     // test at method
-    static_assert(layout1::at(0) == 0, "");
-    static_assert(layout1::at(1) == 1, "");
-    static_assert(layout1::at(2) == 2, "");
+    static_assert(layout1::at(0) == 0);
+    static_assert(layout1::at(1) == 1);
+    static_assert(layout1::at(2) == 2);
 } // namespace simple_layout
 
 namespace extended_layout {
     typedef layout_map<3, 2, 1, 0> layout2;
 
     // test length
-    static_assert(layout2::masked_length == 4, "");
-    static_assert(layout2::unmasked_length == 4, "");
+    static_assert(layout2::masked_length == 4);
+    static_assert(layout2::unmasked_length == 4);
 
     // test find method
-    static_assert(layout2::find(0) == 3, "");
-    static_assert(layout2::find(1) == 2, "");
-    static_assert(layout2::find(2) == 1, "");
-    static_assert(layout2::find(3) == 0, "");
+    static_assert(layout2::find(0) == 3);
+    static_assert(layout2::find(1) == 2);
+    static_assert(layout2::find(2) == 1);
+    static_assert(layout2::find(3) == 0);
 
     // test at method
-    static_assert(layout2::at(0) == 3, "");
-    static_assert(layout2::at(1) == 2, "");
-    static_assert(layout2::at(2) == 1, "");
-    static_assert(layout2::at(3) == 0, "");
+    static_assert(layout2::at(0) == 3);
+    static_assert(layout2::at(1) == 2);
+    static_assert(layout2::at(2) == 1);
+    static_assert(layout2::at(3) == 0);
 } // namespace extended_layout
 
 namespace masked_layout {
     typedef layout_map<2, -1, 1, 0> layout3;
 
     // test length
-    static_assert(layout3::masked_length == 4, "");
-    static_assert(layout3::unmasked_length == 3, "");
+    static_assert(layout3::masked_length == 4);
+    static_assert(layout3::unmasked_length == 3);
 
     // test find method
-    static_assert(layout3::find(0) == 3, "");
-    static_assert(layout3::find(1) == 2, "");
-    static_assert(layout3::find(2) == 0, "");
+    static_assert(layout3::find(0) == 3);
+    static_assert(layout3::find(1) == 2);
+    static_assert(layout3::find(2) == 0);
 
     // test at method
-    static_assert(layout3::at(0) == 2, "");
-    static_assert(layout3::at(1) == -1, "");
-    static_assert(layout3::at(2) == 1, "");
-    static_assert(layout3::at(3) == 0, "");
+    static_assert(layout3::at(0) == 2);
+    static_assert(layout3::at(1) == -1);
+    static_assert(layout3::at(2) == 1);
+    static_assert(layout3::at(3) == 0);
 } // namespace masked_layout
diff --git a/tests/unit_tests/common/test_pair.cpp b/tests/unit_tests/common/test_pair.cpp
deleted file mode 100644
index 9df5f0c882..0000000000
--- a/tests/unit_tests/common/test_pair.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * GridTools
- *
- * Copyright (c) 2014-2021, ETH Zurich
- * All rights reserved.
- *
- * Please, refer to the LICENSE file in the root directory.
- * SPDX-License-Identifier: BSD-3-Clause
- */
-#include <gridtools/common/pair.hpp>
-
-#include <type_traits>
-
-#include <gtest/gtest.h>
-
-TEST(pair, non_uniform_ctor) {
-    int int_val = 1;
-    size_t size_t_val = 2;
-
-    gridtools::pair<size_t, size_t> my_pair(int_val, size_t_val);
-
-    EXPECT_EQ((size_t)int_val, my_pair.first);
-    EXPECT_EQ(size_t_val, my_pair.second);
-}
-
-TEST(pair, get_rval_ref) {
-    size_t val0 = 1;
-    size_t val1 = 2;
-
-    EXPECT_TRUE(
-        std::is_rvalue_reference<decltype(gridtools::get<0>(gridtools::pair<size_t, size_t>{val0, val1}))>::value);
-    EXPECT_EQ(val0, gridtools::get<0>(gridtools::pair<size_t, size_t>{val0, val1}));
-    EXPECT_EQ(val1, gridtools::get<1>(gridtools::pair<size_t, size_t>{val0, val1}));
-}
-
-TEST(pair, eq) {
-    gridtools::pair<size_t, size_t> pair1{1, 2};
-    gridtools::pair<size_t, size_t> pair2{pair1};
-
-    EXPECT_TRUE(pair1 == pair2);
-    EXPECT_FALSE(pair1 != pair2);
-    EXPECT_FALSE(pair1 < pair2);
-    EXPECT_TRUE(pair1 <= pair2);
-    EXPECT_FALSE(pair1 > pair2);
-    EXPECT_TRUE(pair1 >= pair2);
-}
-TEST(pair, compare_first_differ) {
-    gridtools::pair<size_t, size_t> smaller{1, 2};
-    gridtools::pair<size_t, size_t> bigger{2, 2};
-
-    EXPECT_FALSE(smaller == bigger);
-    EXPECT_TRUE(smaller != bigger);
-    EXPECT_TRUE(smaller < bigger);
-    EXPECT_TRUE(smaller <= bigger);
-    EXPECT_FALSE(smaller > bigger);
-    EXPECT_FALSE(smaller >= bigger);
-}
-
-TEST(pair, lt_gt_second_differ) {
-    gridtools::pair<size_t, size_t> smaller{1, 1};
-    gridtools::pair<size_t, size_t> bigger{1, 2};
-
-    EXPECT_FALSE(smaller == bigger);
-    EXPECT_TRUE(smaller != bigger);
-    EXPECT_TRUE(smaller < bigger);
-    EXPECT_TRUE(smaller <= bigger);
-    EXPECT_FALSE(smaller > bigger);
-    EXPECT_FALSE(smaller >= bigger);
-}
-
-TEST(pair, construct_from_std_pair) {
-    std::pair<size_t, size_t> std_pair{1, 2};
-
-    gridtools::pair<size_t, size_t> gt_pair(std_pair);
-
-    ASSERT_EQ(std_pair.first, gt_pair.first);
-    ASSERT_EQ(std_pair.second, gt_pair.second);
-}
diff --git a/tests/unit_tests/common/test_stride_util.cpp b/tests/unit_tests/common/test_stride_util.cpp
index 848a4ba7e7..d077000ede 100644
--- a/tests/unit_tests/common/test_stride_util.cpp
+++ b/tests/unit_tests/common/test_stride_util.cpp
@@ -27,7 +27,7 @@ namespace gridtools {
 
             TEST(make_strides_from_sizes, smoke) {
                 auto testee = make_strides_from_sizes(tuple(20, 30, 40));
-                static_assert(std::is_same<decltype(testee), tuple<integral_constant<int, 1>, int, int>>{}, "");
+                static_assert(std::is_same_v<decltype(testee), tuple<integral_constant<int, 1>, int, int>>);
 
                 EXPECT_EQ(1, tu::get<0>(testee));
                 EXPECT_EQ(20, tu::get<1>(testee));
@@ -36,10 +36,8 @@ namespace gridtools {
 
             TEST(make_strides_from_sizes, integral_constants) {
                 auto testee = make_strides_from_sizes(tuple(20_c, 30_c, 40));
-                static_assert(
-                    std::is_same<decltype(testee),
-                        tuple<integral_constant<int, 1>, integral_constant<int, 20>, integral_constant<int, 600>>>{},
-                    "");
+                static_assert(std::is_same_v<decltype(testee),
+                    tuple<integral_constant<int, 1>, integral_constant<int, 20>, integral_constant<int, 600>>>);
 
                 EXPECT_EQ(1, tu::get<0>(testee));
                 EXPECT_EQ(20, tu::get<1>(testee));
@@ -52,9 +50,8 @@ namespace gridtools {
 
             TEST(make_strides_from_sizes, hymap) {
                 auto testee = make_strides_from_sizes(hymap::keys<a, b, c>::make_values(20, 30, 40));
-                static_assert(
-                    std::is_same<decltype(testee), hymap::keys<a, b, c>::values<integral_constant<int, 1>, int, int>>{},
-                    "");
+                static_assert(std::is_same_v<decltype(testee),
+                    hymap::keys<a, b, c>::values<integral_constant<int, 1>, int, int>>);
 
                 EXPECT_EQ(1, at_key<a>(testee));
                 EXPECT_EQ(20, at_key<b>(testee));
@@ -68,7 +65,7 @@ namespace gridtools {
 
             TEST(total_size, integral_constants) {
                 auto testee = total_size(tuple(20_c, 30_c, 40_c));
-                static_assert(std::is_same<decltype(testee), integral_constant<int, 24000>>{}, "");
+                static_assert(std::is_same_v<decltype(testee), integral_constant<int, 24000>>);
 
                 EXPECT_EQ(24000, testee);
             }
diff --git a/tests/unit_tests/common/test_tuple.cpp b/tests/unit_tests/common/test_tuple.cpp
index 73b3befb91..1c86a97c78 100644
--- a/tests/unit_tests/common/test_tuple.cpp
+++ b/tests/unit_tests/common/test_tuple.cpp
@@ -19,9 +19,9 @@
 
 namespace gridtools {
     namespace {
-        static_assert(is_tuple_like<tuple<>>::value, "");
-        static_assert(is_tuple_like<tuple<int, double>>::value, "");
-        static_assert(is_tuple_like<tuple<int, int const, int&&, int&, int const& >>::value, "");
+        static_assert(is_tuple_like<tuple<>>::value);
+        static_assert(is_tuple_like<tuple<int, double>>::value);
+        static_assert(is_tuple_like<tuple<int, int const, int &&, int &, int const &>>::value);
 
         template <size_t I>
         using an_empty = std::integral_constant<size_t, I>;
@@ -42,18 +42,18 @@ namespace gridtools {
         struct take_move_only {
             int value;
             take_move_only() = default;
-            GT_FUNCTION take_move_only(move_only src) : value(src.value) {}
+            constexpr take_move_only(move_only src) : value(src.value) {}
         };
 
         // empty base optimization works
-        static_assert(sizeof(tuple<an_empty<0>, an_empty<1>, an_empty<3>>) == sizeof(an_empty<0>), "");
+        static_assert(sizeof(tuple<an_empty<0>, an_empty<1>, an_empty<3>>) == sizeof(an_empty<0>));
 
-        static_assert(tuple_util::size<tuple<int, char, double, char>>() == 4, "");
-        static_assert(tuple_util::size<tuple<int>>() == 1, "");
-        static_assert(tuple_util::size<tuple<>>() == 0, "");
+        static_assert(tuple_util::size<tuple<int, char, double, char>>() == 4);
+        static_assert(tuple_util::size<tuple<int>>() == 1);
+        static_assert(tuple_util::size<tuple<>>() == 0);
 
-        static_assert(std::is_same<tuple_util::element<1, tuple<int, char, double, char>>, char>(), "");
-        static_assert(std::is_same<tuple_util::element<0, tuple<int>>, int>(), "");
+        static_assert(std::is_same_v<tuple_util::element<1, tuple<int, char, double, char>>, char>);
+        static_assert(std::is_same_v<tuple_util::element<0, tuple<int>>, int>);
 
         using tuple_util::get;
 
@@ -83,13 +83,13 @@ namespace gridtools {
 
         TEST(tuple, move_get) {
             auto val = get<1>(tuple<char, move_only>{'a', move_only{2}});
-            static_assert(std::is_same<decltype(val), move_only>(), "");
+            static_assert(std::is_same_v<decltype(val), move_only>);
             EXPECT_EQ(2, val.value);
         }
 
         TEST(one_tuple, move_get) {
             auto val = get<0>(tuple<move_only>{move_only{2}});
-            static_assert(std::is_same<decltype(val), move_only>(), "");
+            static_assert(std::is_same_v<decltype(val), move_only>);
             EXPECT_EQ(2, val.value);
         }
 
@@ -198,7 +198,7 @@ namespace gridtools {
             tuple<int, double> src = {1, 1.5};
             tuple<int, double> testee;
             auto &res = testee = src;
-            static_assert(std::is_same<decltype(res), tuple<int, double> &>(), "");
+            static_assert(std::is_same_v<decltype(res), tuple<int, double> &>);
             EXPECT_EQ(&testee, &res);
             EXPECT_EQ(1, get<0>(testee));
             EXPECT_EQ(1.5, get<1>(testee));
@@ -208,7 +208,7 @@ namespace gridtools {
             tuple<int> src = {1};
             tuple<int> testee;
             auto &res = testee = src;
-            static_assert(std::is_same<decltype(res), tuple<int> &>(), "");
+            static_assert(std::is_same_v<decltype(res), tuple<int> &>);
             EXPECT_EQ(&testee, &res);
             EXPECT_EQ(1, get<0>(testee));
         }
@@ -216,7 +216,7 @@ namespace gridtools {
         TEST(tuple, move_assign) {
             tuple<move_only, move_only> testee;
             auto &res = testee = tuple<move_only, move_only>{move_only{47}, move_only{2}};
-            static_assert(std::is_same<decltype(res), tuple<move_only, move_only> &>(), "");
+            static_assert(std::is_same_v<decltype(res), tuple<move_only, move_only> &>);
             EXPECT_EQ(&testee, &res);
             EXPECT_EQ(47, get<0>(testee).value);
             EXPECT_EQ(2, get<1>(testee).value);
@@ -225,7 +225,7 @@ namespace gridtools {
         TEST(one_tuple, move_assign) {
             tuple<take_move_only> testee;
             auto &res = testee = tuple<move_only>{move_only{47}};
-            static_assert(std::is_same<decltype(res), tuple<take_move_only> &>(), "");
+            static_assert(std::is_same_v<decltype(res), tuple<take_move_only> &>);
             EXPECT_EQ(&testee, &res);
             EXPECT_EQ(47, get<0>(testee).value);
         }
@@ -234,7 +234,7 @@ namespace gridtools {
             tuple<char, char> src = {'a', 'b'};
             tuple<int, double> testee;
             auto &res = testee = src;
-            static_assert(std::is_same<decltype(res), tuple<int, double> &>(), "");
+            static_assert(std::is_same_v<decltype(res), tuple<int, double> &>);
             EXPECT_EQ(&testee, &res);
             EXPECT_EQ('a', get<0>(testee));
             EXPECT_EQ('b', get<1>(testee));
@@ -244,7 +244,7 @@ namespace gridtools {
             tuple<char> src = {'a'};
             tuple<int> testee;
             auto &res = testee = src;
-            static_assert(std::is_same<decltype(res), tuple<int> &>(), "");
+            static_assert(std::is_same_v<decltype(res), tuple<int> &>);
             EXPECT_EQ(&testee, &res);
             EXPECT_EQ('a', get<0>(testee));
         }
@@ -252,7 +252,7 @@ namespace gridtools {
         TEST(tuple, move_conversion_assign) {
             tuple<double, move_only> testee;
             auto &res = testee = tuple<char, move_only>{'a', move_only{2}};
-            static_assert(std::is_same<decltype(res), tuple<double, move_only> &>(), "");
+            static_assert(std::is_same_v<decltype(res), tuple<double, move_only> &>);
             EXPECT_EQ(&testee, &res);
             EXPECT_EQ('a', get<0>(testee));
             EXPECT_EQ(2, get<1>(testee).value);
@@ -261,7 +261,7 @@ namespace gridtools {
         TEST(one_tuple, move_conversion_assign) {
             tuple<take_move_only> testee;
             auto &res = testee = tuple<move_only>{move_only{2}};
-            static_assert(std::is_same<decltype(res), tuple<take_move_only> &>(), "");
+            static_assert(std::is_same_v<decltype(res), tuple<take_move_only> &>);
             EXPECT_EQ(&testee, &res);
             EXPECT_EQ(2, get<0>(testee).value);
         }
@@ -303,20 +303,20 @@ namespace gridtools {
             tuple<> dst;
 
             auto copy = src;
-            static_assert(std::is_same<decltype(copy), tuple<>>(), "");
+            static_assert(std::is_same_v<decltype(copy), tuple<>>);
             EXPECT_NE(&src, &copy);
 
             auto move = tuple<>{};
-            static_assert(std::is_same<decltype(move), tuple<>>(), "");
+            static_assert(std::is_same_v<decltype(move), tuple<>>);
             // make nvcc happy
             EXPECT_EQ(&move, &move);
 
             auto &copy_assign = dst = src;
-            static_assert(std::is_same<decltype(copy_assign), tuple<> &>(), "");
+            static_assert(std::is_same_v<decltype(copy_assign), tuple<> &>);
             EXPECT_EQ(&dst, &copy_assign);
 
             auto &move_assign = dst = tuple<>{};
-            static_assert(std::is_same<decltype(move_assign), tuple<> &>(), "");
+            static_assert(std::is_same_v<decltype(move_assign), tuple<> &>);
             EXPECT_EQ(&dst, &move_assign);
 
             src.swap(dst);
diff --git a/tests/unit_tests/common/test_tuple.cu b/tests/unit_tests/common/test_tuple.cu
index 9968c4c930..d12db92da3 100644
--- a/tests/unit_tests/common/test_tuple.cu
+++ b/tests/unit_tests/common/test_tuple.cu
@@ -21,8 +21,8 @@
 namespace gridtools {
     TEST(tuple, get) {
         tuple<int, double> src{42, 2.5};
-        EXPECT_EQ(42, on_device::exec(tuple_util::get_nth_f<0>{}, src));
-        EXPECT_EQ(2.5, on_device::exec(tuple_util::get_nth_f<1>{}, src));
+        EXPECT_EQ(42, on_device::exec(tuple_util::get_f<0>{}, src));
+        EXPECT_EQ(2.5, on_device::exec(tuple_util::get_f<1>{}, src));
     }
 
     __device__ tuple<int, double> element_wise_ctor(int x, double y) { return {x, y}; }
diff --git a/tests/unit_tests/common/test_tuple_util.cpp b/tests/unit_tests/common/test_tuple_util.cpp
index 5563c84e34..256fcf0a4c 100644
--- a/tests/unit_tests/common/test_tuple_util.cpp
+++ b/tests/unit_tests/common/test_tuple_util.cpp
@@ -20,7 +20,6 @@
 #include <gridtools/common/array.hpp>
 #include <gridtools/common/defs.hpp>
 #include <gridtools/common/host_device.hpp>
-#include <gridtools/common/pair.hpp>
 #include <gridtools/meta.hpp>
 
 namespace custom {
@@ -31,16 +30,15 @@ namespace custom {
 
 namespace gridtools {
 
-    static_assert(!is_tuple_like<void>::value, "");
-    static_assert(!is_tuple_like<int>::value, "");
-    static_assert(is_tuple_like<std::array<int, 42>>::value, "");
-    static_assert(is_tuple_like<std::tuple<>>::value, "");
-    static_assert(is_tuple_like<std::tuple<int>>::value, "");
-    static_assert(is_tuple_like<std::pair<int, double>>::value, "");
-    static_assert(is_tuple_like<array<int, 42>>::value, "");
-    static_assert(is_tuple_like<pair<int, double>>::value, "");
-    static_assert(is_tuple_like<custom::foo>::value, "");
-    static_assert(is_tuple_like<std::tuple<int, int const, int &&, int &, int const &>>::value, "");
+    static_assert(!is_tuple_like<void>::value);
+    static_assert(!is_tuple_like<int>::value);
+    static_assert(is_tuple_like<std::array<int, 42>>::value);
+    static_assert(is_tuple_like<std::tuple<>>::value);
+    static_assert(is_tuple_like<std::tuple<int>>::value);
+    static_assert(is_tuple_like<std::pair<int, double>>::value);
+    static_assert(is_tuple_like<array<int, 42>>::value);
+    static_assert(is_tuple_like<custom::foo>::value);
+    static_assert(is_tuple_like<std::tuple<int, int const, int &&, int &, int const &>>::value);
 
 #ifdef __cpp_concepts
     static_assert(!concepts::tuple_like<int>);
@@ -77,7 +75,7 @@ namespace gridtools {
 
         struct add_2_f {
             template <class T>
-            GT_FUNCTION GT_CONSTEXPR T operator()(T val) const {
+            constexpr T operator()(T val) const {
                 return val + 2;
             }
         };
@@ -92,7 +90,7 @@ namespace gridtools {
             EXPECT_EQ(size<custom::foo>::value, 2);
 
             auto res = transform(add_2_f{}, custom::foo{42, 5.3});
-            static_assert(std::is_same<decltype(res), custom::foo>{}, "");
+            static_assert(std::is_same_v<decltype(res), custom::foo>);
             EXPECT_EQ(res.a, 44);
             EXPECT_EQ(res.b, 7.3);
         }
@@ -100,21 +98,21 @@ namespace gridtools {
         TEST(transform, functional) {
             auto src = std::tuple(42, 5.3);
             auto res = transform(add_2_f{}, src);
-            static_assert(std::is_same<decltype(res), decltype(src)>{}, "");
+            static_assert(std::is_same_v<decltype(res), decltype(src)>);
             EXPECT_EQ(res, std::tuple(44, 7.3));
         }
 
         TEST(transform, array) {
             auto src = std::array{42, 5};
             auto res = transform(add_2_f{}, src);
-            static_assert(std::is_same<decltype(res), decltype(src)>{}, "");
+            static_assert(std::is_same_v<decltype(res), decltype(src)>);
             EXPECT_THAT(res, testing::ElementsAre(44, 7));
         }
 
         TEST(transform, gt_array) {
             auto src = gridtools::array{42, 5};
             auto res = transform(add_2_f{}, src);
-            static_assert(std::is_same<decltype(res), decltype(src)>{}, "");
+            static_assert(std::is_same_v<decltype(res), decltype(src)>);
             EXPECT_THAT(res, testing::ElementsAre(44, 7));
         }
 
@@ -130,7 +128,7 @@ namespace gridtools {
 
         struct add_index_f {
             template <size_t I, class T>
-            GT_FUNCTION GT_CONSTEXPR T operator()(T val) const {
+            constexpr T operator()(T val) const {
                 return val + I;
             }
         };
@@ -138,7 +136,7 @@ namespace gridtools {
         TEST(transform_index, functional) {
             auto src = std::tuple(42, 5.3);
             auto res = transform_index(add_index_f{}, src);
-            static_assert(std::is_same<decltype(res), decltype(src)>{}, "");
+            static_assert(std::is_same_v<decltype(res), decltype(src)>);
             EXPECT_EQ(res, std::tuple(42, 6.3));
         }
 
@@ -285,7 +283,6 @@ namespace gridtools {
 
         TEST(convert_to, tuple) {
             EXPECT_EQ(std::tuple(1, 2), convert_to<std::tuple>(std::array{1, 2}));
-            EXPECT_EQ(std::tuple(1, 2), convert_to<std::tuple>(gridtools::pair(1, 2)));
             EXPECT_EQ(std::pair(1, 2), convert_to<std::pair>(gridtools::array{1, 2}));
         }
 
@@ -303,14 +300,6 @@ namespace gridtools {
                 std::pair(std::array{1, 2, 3}, std::array{10, 20, 30}));
         }
 
-        TEST(all_of, functional) {
-            auto testee = all_of([](int i) { return i % 2; });
-            EXPECT_TRUE(testee(std::tuple(1, 3, 99, 7)));
-            EXPECT_FALSE(testee(std::tuple(1, 3, 2, 7, 100)));
-
-            EXPECT_TRUE(all_of([](int l, int r) { return l == r; }, std::tuple(1, 3, 99, 7), std::tuple(1, 3, 99, 7)));
-        }
-
         TEST(reverse, functional) { EXPECT_TRUE(reverse(std::tuple(1, 'a', 42.5)) == std::tuple(42.5, 'a', 1)); }
 
         TEST(insert, functional) { EXPECT_TRUE(insert<2>('a', std::tuple(1, 2, 3)) == std::tuple(1, 2, 'a', 3)); }
diff --git a/tests/unit_tests/fn/test_fn_scan.cpp b/tests/unit_tests/fn/test_fn_scan.cpp
index 8c2161b94d..5568b3388b 100644
--- a/tests/unit_tests/fn/test_fn_scan.cpp
+++ b/tests/unit_tests/fn/test_fn_scan.cpp
@@ -20,13 +20,13 @@ namespace gridtools::fn {
         using sid::property;
 
         struct sum_fold : fwd {
-            static GT_FUNCTION constexpr auto body() {
+            static constexpr auto body() {
                 return [](auto acc, auto const &iter) { return acc + *iter; };
             }
         };
 
         struct sum_scan : fwd {
-            static GT_FUNCTION constexpr auto body() {
+            static constexpr auto body() {
                 return scan_pass(
                     [](auto acc, auto const &iter) { return tuple(get<0>(acc) + *iter, get<1>(acc) * *iter); },
                     [](auto acc) { return get<0>(acc); });
@@ -34,17 +34,17 @@ namespace gridtools::fn {
         };
 
         struct sum_fold_with_logues : sum_fold {
-            static GT_FUNCTION constexpr auto prologue() {
+            static constexpr auto prologue() {
                 return tuple([](auto acc, auto const &iter) { return acc + 2 * *iter; });
             }
-            static GT_FUNCTION constexpr auto epilogue() {
+            static constexpr auto epilogue() {
                 return tuple([](auto acc, auto const &iter) { return acc + 3 * *iter; });
             }
         };
 
         struct make_iterator_mock {
-            auto operator()() const {
-                return [](auto tag, auto const &ptr, auto const &strides) { return at_key<decltype(tag)>(ptr); };
+            auto constexpr operator()() const {
+                return [](auto tag, auto const &ptr, auto const &) { return at_key<decltype(tag)>(ptr); };
             }
         };
 
diff --git a/tests/unit_tests/fn/test_fn_scan.cu b/tests/unit_tests/fn/test_fn_scan.cu
index fd9a9bcc3e..c43892b9d8 100644
--- a/tests/unit_tests/fn/test_fn_scan.cu
+++ b/tests/unit_tests/fn/test_fn_scan.cu
@@ -23,21 +23,21 @@ namespace gridtools::fn {
         using sid::property;
 
         struct sum_scan : fwd {
-            static GT_FUNCTION constexpr auto body() {
+            static constexpr auto body() {
                 return scan_pass(
                     [](auto acc, auto const &iter) { return tuple(get<0>(acc) + *iter, get<1>(acc) * *iter); },
                     [](auto acc) { return get<0>(acc); });
             }
         };
         struct make_iterator_mock {
-            GT_FUNCTION auto operator()() const {
-                return [](auto tag, auto const &ptr, auto const &strides) { return at_key<decltype(tag)>(ptr); };
+            constexpr auto operator()() const {
+                return [](auto tag, auto const &ptr, auto const &) { return at_key<decltype(tag)>(ptr); };
             }
         };
 
         struct device_fun {
             template <class Ptr, class Strides>
-            GT_FUNCTION auto operator()(Ptr ptr, Strides strides) const {
+            constexpr auto operator()(Ptr ptr, Strides strides) const {
                 using vdim_t = integral_constant<int, 0>;
                 return column_stage<vdim_t, sum_scan, make_iterator_mock, 0, 1>()(tuple(42, 1), 5, ptr, strides);
             }
diff --git a/tests/unit_tests/layout_transformation/test_layout_transformation.cpp b/tests/unit_tests/layout_transformation/test_layout_transformation.cpp
index 618fff493d..0493214abd 100644
--- a/tests/unit_tests/layout_transformation/test_layout_transformation.cpp
+++ b/tests/unit_tests/layout_transformation/test_layout_transformation.cpp
@@ -28,7 +28,7 @@ namespace {
     template <class T, class U, size_t N, size_t M, class Dims, class DstStrides, class SrcSrides>
     void testee(
         host, T (&dst)[N], U (&src)[M], Dims const &dims, DstStrides const &dst_strides, SrcSrides const &src_strides) {
-        static_assert(std::is_same<std::remove_all_extents_t<T>, std::remove_all_extents_t<U>>::value, "");
+        static_assert(std::is_same_v<std::remove_all_extents_t<T>, std::remove_all_extents_t<U>>);
         using data_t = std::remove_all_extents_t<T>;
         transform_layout((data_t *)dst, (data_t const *)src, dims, dst_strides, src_strides);
     }
@@ -43,7 +43,7 @@ namespace {
         Dims const &dims,
         DstStrides const &dst_strides,
         SrcSrides const &src_strides) {
-        static_assert(std::is_same<std::remove_all_extents_t<T>, std::remove_all_extents_t<U>>::value, "");
+        static_assert(std::is_same_v<std::remove_all_extents_t<T>, std::remove_all_extents_t<U>>);
         using data_t = std::remove_all_extents_t<T>;
         auto &src_arr = reinterpret_cast<array<U, M> &>(src);
         auto &dst_arr = reinterpret_cast<array<T, N> &>(dst);
diff --git a/tests/unit_tests/sid/test_sid_as_const.cpp b/tests/unit_tests/sid/test_sid_as_const.cpp
index 93e4cf8d56..34d73d2b98 100644
--- a/tests/unit_tests/sid/test_sid_as_const.cpp
+++ b/tests/unit_tests/sid/test_sid_as_const.cpp
@@ -28,8 +28,8 @@ namespace gridtools {
             auto testee = sid::as_const(src);
             using testee_t = decltype(testee);
 
-            static_assert(is_sid<testee_t>(), "");
-            static_assert(std::is_same<sid::ptr_type<testee_t>, double const *>(), "");
+            static_assert(is_sid<testee_t>());
+            static_assert(std::is_same_v<sid::ptr_type<testee_t>, double const *>);
             EXPECT_EQ(sid::get_origin(src)(), sid::get_origin(testee)());
         }
     } // namespace
diff --git a/tests/unit_tests/sid/test_sid_block.cpp b/tests/unit_tests/sid/test_sid_block.cpp
index f0979361aa..c901f62172 100644
--- a/tests/unit_tests/sid/test_sid_block.cpp
+++ b/tests/unit_tests/sid/test_sid_block.cpp
@@ -40,7 +40,7 @@ namespace gridtools {
 
             positional_t s;
             auto blocked_s = sid::block(s, blocks);
-            static_assert(is_sid<decltype(blocked_s)>(), "");
+            static_assert(is_sid<decltype(blocked_s)>());
 
             auto strides = sid::get_strides(blocked_s);
             for (int ib = 0; ib < domain_size_i; ib += block_size_i) {
@@ -74,10 +74,10 @@ namespace gridtools {
             const int block_size_1 = 5;
             const int block_size_2 = 2;
             auto blocked_s = sid::block(s, hymap::keys<dim::i>::make_values(block_size_1));
-            static_assert(is_sid<decltype(blocked_s)>(), "");
+            static_assert(is_sid<decltype(blocked_s)>());
             auto blocked_blocked_s =
                 sid::block(blocked_s, hymap::keys<sid::blocked_dim<dim::i>>::make_values(block_size_2));
-            static_assert(is_sid<decltype(blocked_blocked_s)>(), "");
+            static_assert(is_sid<decltype(blocked_blocked_s)>());
 
             auto ptr = sid::get_origin(blocked_blocked_s)();
             auto strides = sid::get_strides(blocked_blocked_s);
@@ -101,7 +101,7 @@ namespace gridtools {
             positional_t s;
 
             auto same_s = sid::block(s, hymap::keys<some_dim>::make_values(42));
-            static_assert(std::is_same<decltype(s), decltype(same_s)>(), "");
+            static_assert(std::is_same_v<decltype(s), decltype(same_s)>);
         }
 
         TEST(sid_block, reference_wrapper) {
@@ -110,7 +110,7 @@ namespace gridtools {
             const int domain_size = 20;
             const int block_size = 5;
             auto blocked_s = sid::block(std::ref(s), hymap::keys<dim::i>::make_values(block_size));
-            static_assert(is_sid<decltype(blocked_s)>(), "");
+            static_assert(is_sid<decltype(blocked_s)>());
 
             auto ptr = sid::get_origin(blocked_s)();
             auto strides = sid::get_strides(blocked_s);
@@ -138,10 +138,10 @@ namespace gridtools {
                          .set<sid::property::origin>(sid::simple_ptr_holder<int *>{nullptr})
                          .set<sid::property::strides>(strides)
                          .set<sid::property::strides_kind, void>();
-            static_assert(is_sid<decltype(s)>(), "");
+            static_assert(is_sid<decltype(s)>());
 
             auto blocked_s = sid::block(s, blocks);
-            static_assert(is_sid<decltype(blocked_s)>(), "");
+            static_assert(is_sid<decltype(blocked_s)>());
 
             auto blocked_strides = sid::get_strides(blocked_s);
             EXPECT_EQ(sid::get_stride<sid::blocked_dim<dim::i>>(blocked_strides), 2);
diff --git a/tests/unit_tests/sid/test_sid_composite.cpp b/tests/unit_tests/sid/test_sid_composite.cpp
index 6bf1fd6a2f..13429995a2 100644
--- a/tests/unit_tests/sid/test_sid_composite.cpp
+++ b/tests/unit_tests/sid/test_sid_composite.cpp
@@ -34,10 +34,10 @@ namespace gridtools {
 
         TEST(composite, empty) {
             using testee_t = sid::composite::keys<>::values<>;
-            static_assert(is_sid<testee_t>(), "");
-            static_assert(tu::size<sid::strides_type<testee_t>>::value == 0, "");
-            static_assert(tu::size<sid::ptr_holder_type<testee_t>>::value == 0, "");
-            static_assert(tu::size<sid::ptr_type<testee_t>>::value == 0, "");
+            static_assert(is_sid<testee_t>());
+            static_assert(tu::size<sid::strides_type<testee_t>>::value == 0);
+            static_assert(tu::size<sid::ptr_holder_type<testee_t>>::value == 0);
+            static_assert(tu::size<sid::ptr_type<testee_t>>::value == 0);
             testee_t testee;
             sid::get_strides(testee);
             *sid::get_origin(testee)();
@@ -62,7 +62,7 @@ namespace gridtools {
             auto testee = sid::composite::keys<a, b>::make_values(
                 sid::synthetic().set<property::origin>(sid::simple_ptr_holder(&src)),
                 sid::synthetic().set<property::origin>(sid::simple_ptr_holder(&dst)));
-            static_assert(is_sid<decltype(testee)>(), "");
+            static_assert(is_sid<decltype(testee)>());
 
             auto ptrs = sid::get_origin(testee)();
             EXPECT_EQ(&src, at_key<a>(ptrs));
@@ -105,7 +105,7 @@ namespace gridtools {
                     .set<property::strides>(my_strides)                             //
                     .set<property::strides_kind, my_strides_kind>()                 //
             );
-            static_assert(is_sid<decltype(testee)>(), "");
+            static_assert(is_sid<decltype(testee)>());
 
             auto &&strides = sid::get_strides(testee);
             auto &&stride_i = sid::get_stride<dim_i>(strides);
diff --git a/tests/unit_tests/sid/test_sid_concept.cpp b/tests/unit_tests/sid/test_sid_concept.cpp
index e69b6f8a24..dca377fec6 100644
--- a/tests/unit_tests/sid/test_sid_concept.cpp
+++ b/tests/unit_tests/sid/test_sid_concept.cpp
@@ -24,10 +24,10 @@ namespace gridtools {
         using namespace literals;
 
         // several primitive not sids
-        static_assert(!is_sid<void>(), "");
-        static_assert(!is_sid<int>(), "");
+        static_assert(!is_sid<void>());
+        static_assert(!is_sid<int>());
         struct garbage {};
-        static_assert(!is_sid<garbage>(), "");
+        static_assert(!is_sid<garbage>());
 
         // fully custom defined sid
         namespace custom {
@@ -37,12 +37,12 @@ namespace gridtools {
             };
             struct ptr {
                 element *val;
-                GT_FUNCTION element &operator*() const { return *val; }
-                friend GT_FUNCTION ptr operator+(ptr, ptr_diff) { return {}; }
+                constexpr element &operator*() const { return *val; }
+                friend constexpr ptr operator+(ptr, ptr_diff) { return {}; }
             };
             struct stride {
-                friend GT_FUNCTION std::true_type sid_shift(ptr &, stride const &, int) { return {}; }
-                friend GT_FUNCTION std::false_type sid_shift(ptr_diff &, stride const &, int) { return {}; }
+                friend constexpr std::true_type sid_shift(ptr &, stride const &, int) { return {}; }
+                friend constexpr std::false_type sid_shift(ptr_diff &, stride const &, int) { return {}; }
             };
 
             struct dim_0;
@@ -62,25 +62,24 @@ namespace gridtools {
                 friend bounds_validator_kind sid_get_bounds_validator_kind(testee);
             };
 
-            static_assert(sid::concept_impl_::is_sid<testee>(), "");
-            static_assert(std::is_same<sid::ptr_diff_type<testee>, ptr_diff>(), "");
-            static_assert(std::is_same<sid::reference_type<testee>, element &>(), "");
-            static_assert(std::is_same<sid::element_type<testee>, element>(), "");
-            static_assert(std::is_same<sid::const_reference_type<testee>, element const &>(), "");
-            static_assert(std::is_same<sid::strides_kind<testee>, strides_kind>(), "");
+            static_assert(sid::concept_impl_::is_sid<testee>());
+            static_assert(std::is_same_v<sid::ptr_diff_type<testee>, ptr_diff>);
+            static_assert(std::is_same_v<sid::reference_type<testee>, element &>);
+            static_assert(std::is_same_v<sid::element_type<testee>, element>);
+            static_assert(std::is_same_v<sid::const_reference_type<testee>, element const &>);
+            static_assert(std::is_same_v<sid::strides_kind<testee>, strides_kind>);
 
-            static_assert(
-                std::is_same<std::decay_t<decltype(sid::get_origin(std::declval<testee &>())())>, ptr>::value, "");
-            static_assert(std::is_same<decltype(sid::get_strides(testee{})), strides>(), "");
+            static_assert(std::is_same_v<std::decay_t<decltype(sid::get_origin(std::declval<testee &>())())>, ptr>);
+            static_assert(std::is_same_v<decltype(sid::get_strides(testee{})), strides>);
 
-            static_assert(std::is_same<std::decay_t<decltype(sid::get_stride<dim_0>(strides{}))>, stride>(), "");
-            static_assert(std::is_same<std::decay_t<decltype(sid::get_stride<dim_1>(strides{}))>, stride>(), "");
-            static_assert(decltype(sid::get_stride<void>(strides()))::value == 0, "");
-            static_assert(decltype(sid::get_stride<void *>(strides()))::value == 0, "");
+            static_assert(std::is_same_v<std::decay_t<decltype(sid::get_stride<dim_0>(strides{}))>, stride>);
+            static_assert(std::is_same_v<std::decay_t<decltype(sid::get_stride<dim_1>(strides{}))>, stride>);
+            static_assert(decltype(sid::get_stride<void>(strides()))::value == 0);
+            static_assert(decltype(sid::get_stride<void *>(strides()))::value == 0);
 
-            static_assert(std::is_same<decltype(sid::shift(std::declval<ptr &>(), stride{}, 0)), std::true_type>(), "");
+            static_assert(std::is_same_v<decltype(sid::shift(std::declval<ptr &>(), stride{}, 0)), std::true_type>);
             static_assert(
-                std::is_same<decltype(sid::shift(std::declval<ptr_diff &>(), stride{}, 0)), std::false_type>(), "");
+                std::is_same_v<decltype(sid::shift(std::declval<ptr_diff &>(), stride{}, 0)), std::false_type>);
         } // namespace custom
 
         namespace fallbacks {
@@ -89,31 +88,31 @@ namespace gridtools {
                 friend sid::simple_ptr_holder<testee *> sid_get_origin(testee &obj) { return {&obj}; }
             };
 
-            static_assert(is_sid<testee>(), "");
-            static_assert(std::is_same<sid::ptr_type<testee>, testee *>(), "");
-            static_assert(std::is_same<sid::ptr_diff_type<testee>, ptrdiff_t>(), "");
-            static_assert(std::is_same<sid::reference_type<testee>, testee &>(), "");
-            static_assert(std::is_same<sid::element_type<testee>, testee>(), "");
-            static_assert(std::is_same<sid::const_reference_type<testee>, testee const &>(), "");
+            static_assert(is_sid<testee>());
+            static_assert(std::is_same_v<sid::ptr_type<testee>, testee *>);
+            static_assert(std::is_same_v<sid::ptr_diff_type<testee>, ptrdiff_t>);
+            static_assert(std::is_same_v<sid::reference_type<testee>, testee &>);
+            static_assert(std::is_same_v<sid::element_type<testee>, testee>);
+            static_assert(std::is_same_v<sid::const_reference_type<testee>, testee const &>);
 
             using strides = sid::strides_type<testee>;
-            static_assert(tuple_util::size<strides>() == 0, "");
+            static_assert(tuple_util::size<strides>() == 0);
 
             static_assert(
-                std::is_same<std::decay_t<decltype(sid::get_origin(std::declval<testee &>())())>, testee *>(), "");
-            static_assert(std::is_same<decltype(sid::get_strides(testee{})), strides>(), "");
+                std::is_same_v<std::decay_t<decltype(sid::get_origin(std::declval<testee &>())())>, testee *>);
+            static_assert(std::is_same_v<decltype(sid::get_strides(testee{})), strides>);
 
             auto stride = sid::get_stride<void>(strides{});
-            static_assert(decltype(stride)::value == 0, "");
+            static_assert(decltype(stride)::value == 0);
 
-            static_assert(std::is_void<std::void_t<decltype(sid::shift(std::declval<testee *&>(), stride, 42))>>(), "");
-            static_assert(std::is_void<std::void_t<decltype(sid::shift(std::declval<ptrdiff_t *&>(), stride, 42))>>(), "");
+            static_assert(std::is_void_v<std::void_t<decltype(sid::shift(std::declval<testee *&>(), stride, 42))>>);
+            static_assert(std::is_void_v<std::void_t<decltype(sid::shift(std::declval<ptrdiff_t *&>(), stride, 42))>>);
 
             using lower_bounds = sid::lower_bounds_type<testee>;
-            static_assert(tuple_util::size<lower_bounds>() == 0, "");
+            static_assert(tuple_util::size<lower_bounds>() == 0);
 
             using upper_bounds = sid::upper_bounds_type<testee>;
-            static_assert(tuple_util::size<upper_bounds>() == 0, "");
+            static_assert(tuple_util::size<upper_bounds>() == 0);
         } // namespace fallbacks
 
         template <class T, class Stride, class Offset>
@@ -151,10 +150,10 @@ namespace gridtools {
 
             sid::simple_ptr_holder<testee *> sid_get_origin(testee &obj) { return {&obj}; }
             tuple<stride> sid_get_strides(testee const &) { return {}; }
-            GT_FUNCTION int operator*(stride, int) { return 100; }
+            constexpr int operator*(stride, int) { return 100; }
             integral_constant<int, 42> sid_get_strides_kind(testee const &);
 
-            static_assert(is_sid<testee>(), "");
+            static_assert(is_sid<testee>());
 
             TEST(non_static_value, shift) {
                 ptrdiff_t val = 22;
@@ -168,7 +167,7 @@ namespace gridtools {
 
         TEST(c_array, smoke) {
             double testee[15][43] = {};
-            static_assert(is_sid<decltype(testee)>(), "");
+            static_assert(is_sid<decltype(testee)>());
 
             EXPECT_EQ(&testee[0][0], sid::get_origin(testee)());
 
@@ -178,13 +177,13 @@ namespace gridtools {
 
             using strides_t = decltype(strides);
 
-            static_assert(tuple_util::size<strides_t>::value == 2, "");
+            static_assert(tuple_util::size<strides_t>::value == 2);
 
             using stride_0_t = tuple_util::element<0, strides_t>;
             using stride_1_t = tuple_util::element<1, strides_t>;
 
-            static_assert(stride_0_t::value == 43, "");
-            static_assert(stride_1_t::value == 1, "");
+            static_assert(stride_0_t::value == 43);
+            static_assert(stride_1_t::value == 1);
 
             testee[7][8] = 555;
 
@@ -205,7 +204,7 @@ namespace gridtools {
 
         TEST(c_array, 4D) {
             double testee[2][3][4][5] = {};
-            static_assert(is_sid<decltype(testee)>(), "");
+            static_assert(is_sid<decltype(testee)>());
 
             EXPECT_EQ(&testee[0][0][0][0], sid::get_origin(testee)());
 
diff --git a/tests/unit_tests/sid/test_sid_contiguous.cpp b/tests/unit_tests/sid/test_sid_contiguous.cpp
index 4c5c6d6cd3..a99e12809f 100644
--- a/tests/unit_tests/sid/test_sid_contiguous.cpp
+++ b/tests/unit_tests/sid/test_sid_contiguous.cpp
@@ -44,8 +44,8 @@ namespace gridtools {
             using strides_kind_t = sid::strides_kind<testee_t>;
 
             static_assert(is_sid<testee_t>());
-            static_assert(std::is_same<ptrdiff_t, ptr_diff_t>());
-            static_assert(std::is_same<strides_kind_t, strides_t>());
+            static_assert(std::is_same_v<ptrdiff_t, ptr_diff_t>);
+            static_assert(std::is_same_v<strides_kind_t, strides_t>);
 
             auto lower_bounds = sid::get_lower_bounds(testee);
             EXPECT_EQ(0, at_key<a>(lower_bounds));
diff --git a/tests/unit_tests/sid/test_sid_delegate.cpp b/tests/unit_tests/sid/test_sid_delegate.cpp
index 57d5ad49fa..d29d1c913b 100644
--- a/tests/unit_tests/sid/test_sid_delegate.cpp
+++ b/tests/unit_tests/sid/test_sid_delegate.cpp
@@ -52,7 +52,7 @@ namespace gridtools {
 
             auto testee = i_shift(std::move(src));
 
-            static_assert(is_sid<decltype(testee)>(), "");
+            static_assert(is_sid<decltype(testee)>());
 
             EXPECT_EQ(&data[1][0], sid::get_origin(testee)());
         }
@@ -61,7 +61,7 @@ namespace gridtools {
             double src[3][5];
             auto testee = i_shift(src);
 
-            static_assert(is_sid<decltype(testee)>(), "");
+            static_assert(is_sid<decltype(testee)>());
 
             EXPECT_EQ(&src[1][0], sid::get_origin(testee)());
             auto strides = sid::get_strides(testee);
diff --git a/tests/unit_tests/sid/test_sid_rename_dimensions.cpp b/tests/unit_tests/sid/test_sid_rename_dimensions.cpp
index 777ef5b1de..c04b5dd2a1 100644
--- a/tests/unit_tests/sid/test_sid_rename_dimensions.cpp
+++ b/tests/unit_tests/sid/test_sid_rename_dimensions.cpp
@@ -47,7 +47,7 @@ namespace gridtools {
             EXPECT_EQ(1, sid::get_stride<c>(strides));
             EXPECT_EQ(7, sid::get_stride<d>(strides));
 
-            static_assert(meta::is_empty<get_keys<sid::lower_bounds_type<testee_t>>>(), "");
+            static_assert(meta::is_empty<get_keys<sid::lower_bounds_type<testee_t>>>());
             auto u_bound = sid::get_upper_bounds(testee);
             EXPECT_EQ(3, at_key<a>(u_bound));
             EXPECT_EQ(5, at_key<d>(u_bound));
diff --git a/tests/unit_tests/sid/test_sid_shift_sid_origin.cpp b/tests/unit_tests/sid/test_sid_shift_sid_origin.cpp
index 285ec56bc3..44e9d5aea0 100644
--- a/tests/unit_tests/sid/test_sid_shift_sid_origin.cpp
+++ b/tests/unit_tests/sid/test_sid_shift_sid_origin.cpp
@@ -49,7 +49,7 @@ namespace gridtools {
             auto offset = tuple(1_c, 2);
             auto testee = sid::shift_sid_origin(data, offset);
 
-            static_assert(is_sid<decltype(testee)>(), "");
+            static_assert(is_sid<decltype(testee)>());
 
             EXPECT_EQ(&data[1][2][0], sid::get_origin(testee)());
 
diff --git a/tests/unit_tests/sid/test_sid_synthetic.cpp b/tests/unit_tests/sid/test_sid_synthetic.cpp
index 90acdf30f2..283e696879 100644
--- a/tests/unit_tests/sid/test_sid_synthetic.cpp
+++ b/tests/unit_tests/sid/test_sid_synthetic.cpp
@@ -25,7 +25,7 @@ namespace gridtools {
         TEST(sid_synthetic, smoke) {
             double a = 100;
             auto testee = sid::synthetic().set<property::origin>(sid::simple_ptr_holder(&a));
-            static_assert(is_sid<decltype(testee)>::value, "");
+            static_assert(is_sid<decltype(testee)>::value);
 
             EXPECT_EQ(a, *sid::get_origin(testee)());
         }
@@ -37,13 +37,13 @@ namespace gridtools {
             };
             struct ptr {
                 element const *val;
-                GT_FUNCTION element const &operator*() const { return *val; }
-                friend GT_FUNCTION ptr operator+(ptr, ptr_diff) { return {}; }
+                constexpr element const &operator*() const { return *val; }
+                friend constexpr ptr operator+(ptr, ptr_diff) { return {}; }
             };
             struct stride {
                 int val;
-                friend GT_FUNCTION std::true_type sid_shift(ptr &, stride const &, int) { return {}; }
-                friend GT_FUNCTION std::false_type sid_shift(ptr_diff &, stride const &, int) { return {}; }
+                friend constexpr std::true_type sid_shift(ptr &, stride const &, int) { return {}; }
+                friend constexpr std::false_type sid_shift(ptr_diff &, stride const &, int) { return {}; }
             };
             using strides = array<stride, 2>;
 
@@ -65,10 +65,10 @@ namespace gridtools {
                 static_assert(is_sid<testee>());
                 static_assert(std::is_trivially_copy_constructible_v<testee>);
 
-                static_assert(std::is_same<sid::ptr_type<testee>, ptr>());
-                static_assert(std::is_same<sid::strides_type<testee>, strides>());
-                static_assert(std::is_same<sid::ptr_diff_type<testee>, ptr_diff>());
-                static_assert(std::is_same<sid::strides_kind<testee>, strides_kind>());
+                static_assert(std::is_same_v<sid::ptr_type<testee>, ptr>);
+                static_assert(std::is_same_v<sid::strides_type<testee>, strides>);
+                static_assert(std::is_same_v<sid::ptr_diff_type<testee>, ptr_diff>);
+                static_assert(std::is_same_v<sid::strides_kind<testee>, strides_kind>);
 
                 EXPECT_EQ(&the_element, sid::get_origin(the_testee)().val);
                 EXPECT_EQ(3, tuple_util::get<0>(sid::get_strides(the_testee)).val);
diff --git a/tests/unit_tests/stencil/core/test_esf_metafunctions.cpp b/tests/unit_tests/stencil/core/test_esf_metafunctions.cpp
index 47b1c856d6..e5f7f55905 100644
--- a/tests/unit_tests/stencil/core/test_esf_metafunctions.cpp
+++ b/tests/unit_tests/stencil/core/test_esf_metafunctions.cpp
@@ -125,16 +125,17 @@ using mss_t = meta::first<decltype(execute_parallel()
                                        .stage(functor6(), o6(), o5(), in1(), in2()))>;
 
 template <class Arg, int_t... ExpectedExtentValues>
-using testee = std::is_same<lookup_extent_map<get_extent_map_from_mss<mss_t>, Arg>, extent<ExpectedExtentValues...>>;
-
-static_assert(testee<o0, -5, 11, -10, 10, -5, 13>::value, "");
-static_assert(testee<o1, -5, 9, -10, 8, -3, 10>::value, "");
-static_assert(testee<o2, -2, 8, -8, 7, -3, 8>::value, "");
-static_assert(testee<o3, -1, 5, -5, 7, 0, 6>::value, "");
-static_assert(testee<o4, 0, 4, -5, 4, 0, 3>::value, "");
-static_assert(testee<o5, 0, 3, -3, 2, 0, 0>::value, "");
-static_assert(testee<o6, 0, 0, 0, 0, 0, 0>::value, "");
-static_assert(testee<in0, -8, 11, -13, 13, -7, 13>::value, "");
-static_assert(testee<in1, -6, 12, -10, 12, -6, 15>::value, "");
-static_assert(testee<in2, -8, 14, -11, 12, -5, 14>::value, "");
-static_assert(testee<in3, -5, 10, -11, 10, -3, 10>::value, "");
+constexpr bool testee =
+    std::is_same_v<lookup_extent_map<get_extent_map_from_mss<mss_t>, Arg>, extent<ExpectedExtentValues...>>;
+
+static_assert(testee<o0, -5, 11, -10, 10, -5, 13>);
+static_assert(testee<o1, -5, 9, -10, 8, -3, 10>);
+static_assert(testee<o2, -2, 8, -8, 7, -3, 8>);
+static_assert(testee<o3, -1, 5, -5, 7, 0, 6>);
+static_assert(testee<o4, 0, 4, -5, 4, 0, 3>);
+static_assert(testee<o5, 0, 3, -3, 2, 0, 0>);
+static_assert(testee<o6, 0, 0, 0, 0, 0, 0>);
+static_assert(testee<in0, -8, 11, -13, 13, -7, 13>);
+static_assert(testee<in1, -6, 12, -10, 12, -6, 15>);
+static_assert(testee<in2, -8, 14, -11, 12, -5, 14>);
+static_assert(testee<in3, -5, 10, -11, 10, -3, 10>);
diff --git a/tests/unit_tests/stencil/core/test_functor_metafunctions.cpp b/tests/unit_tests/stencil/core/test_functor_metafunctions.cpp
index e8fc5a5ec5..bcb731dc2e 100644
--- a/tests/unit_tests/stencil/core/test_functor_metafunctions.cpp
+++ b/tests/unit_tests/stencil/core/test_functor_metafunctions.cpp
@@ -19,13 +19,13 @@ namespace gridtools {
                 using interval_t = interval<level<0, 1, 3>, level<2, -1, 3>>;
 
                 struct empty {};
-                //                static_assert(check_valid_apply_overloads<empty, interval_t>::value, "");
+                //                static_assert(check_valid_apply_overloads<empty, interval_t>::value);
 
                 struct simple {
                     template <class T>
                     static void apply(T);
                 };
-                static_assert(check_valid_apply_overloads<simple, interval_t>::value, "");
+                static_assert(check_valid_apply_overloads<simple, interval_t>::value);
 
                 using expected_simple_map_t = meta::list<meta::list<interval<level<0, 1, 3>, level<0, 1, 3>>, simple>,
                     meta::list<interval<level<0, 2, 3>, level<0, 2, 3>>, simple>,
@@ -38,7 +38,7 @@ namespace gridtools {
                     meta::list<interval<level<2, -2, 3>, level<2, -2, 3>>, simple>,
                     meta::list<interval<level<2, -1, 3>, level<2, -1, 3>>, simple>>;
 
-                static_assert(std::is_same<make_functor_map<simple, interval_t>, expected_simple_map_t>::value, "");
+                static_assert(std::is_same_v<make_functor_map<simple, interval_t>, expected_simple_map_t>);
 
                 struct good {
                     template <class T>
@@ -50,7 +50,7 @@ namespace gridtools {
                     template <class T>
                     static void apply(T, interval<level<1, 2, 3>, level<2, -3, 3>>);
                 };
-                static_assert(check_valid_apply_overloads<good, interval_t>::value, "");
+                static_assert(check_valid_apply_overloads<good, interval_t>::value);
 
                 using expected_good_map_t = meta::list<
                     meta::list<interval<level<0, 1, 3>, level<0, 1, 3>>,
@@ -71,7 +71,7 @@ namespace gridtools {
                     meta::list<interval<level<2, -2, 3>, level<2, -2, 3>>, good>,
                     meta::list<interval<level<2, -1, 3>, level<2, -1, 3>>, good>>;
 
-                static_assert(std::is_same<make_functor_map<good, interval_t>, expected_good_map_t>::value, "");
+                static_assert(std::is_same_v<make_functor_map<good, interval_t>, expected_good_map_t>);
 
                 struct intersect {
                     template <class T>
@@ -79,7 +79,7 @@ namespace gridtools {
                     template <class T>
                     static void apply(T, interval<level<1, -2, 3>, level<2, -3, 3>>);
                 };
-                //                static_assert(check_valid_apply_overloads<intersect, interval_t>::value, "");
+                //                static_assert(check_valid_apply_overloads<intersect, interval_t>::value);
 
                 struct gaps {
                     template <class T>
@@ -87,7 +87,7 @@ namespace gridtools {
                     template <class T>
                     static void apply(T, interval<level<1, 3, 3>, level<2, -3, 3>>);
                 };
-                static_assert(check_valid_apply_overloads<gaps, interval_t>::value, "");
+                static_assert(check_valid_apply_overloads<gaps, interval_t>::value);
 
                 using expected_gaps_map_t = meta::list<meta::list<interval<level<0, 1, 3>, level<0, 1, 3>>>,
                     meta::list<interval<level<0, 2, 3>, level<0, 2, 3>>>,
@@ -101,7 +101,7 @@ namespace gridtools {
                         functor_metafunctions_impl_::bound_functor<gaps, interval<level<1, 3, 3>, level<2, -3, 3>>>>,
                     meta::list<interval<level<2, -2, 3>, level<2, -2, 3>>>,
                     meta::list<interval<level<2, -1, 3>, level<2, -1, 3>>>>;
-                static_assert(std::is_same<make_functor_map<gaps, interval_t>, expected_gaps_map_t>::value, "");
+                static_assert(std::is_same_v<make_functor_map<gaps, interval_t>, expected_gaps_map_t>);
 
                 struct good_intervals {
                     template <class T>
@@ -112,19 +112,19 @@ namespace gridtools {
                     static void apply(T, interval<level<2, 3, 3>, level<2, 3, 3>>);
                 };
                 static_assert(
-                    check_valid_apply_overloads<good_intervals, interval<level<0, -3, 3>, level<2, 2, 3>>>::value, "");
+                    check_valid_apply_overloads<good_intervals, interval<level<0, -3, 3>, level<2, 2, 3>>>::value);
 
                 struct bad_from_level {
                     template <class T>
                     static void apply(T, interval<level<1, -3, 3>, level<4, 1, 3>>);
                 };
-                //                static_assert(check_valid_apply_overloads<bad_from_level, interval_t>::value, "");
+                //                static_assert(check_valid_apply_overloads<bad_from_level, interval_t>::value);
 
                 struct bad_to_level {
                     template <class T>
                     static void apply(T, interval<level<1, 1, 3>, level<1, 3, 3>>);
                 };
-                //                static_assert(check_valid_apply_overloads<bad_to_level, interval_t>::value, "");
+                //                static_assert(check_valid_apply_overloads<bad_to_level, interval_t>::value);
             } // namespace
         }     // namespace core
     }         // namespace stencil
diff --git a/tests/unit_tests/stencil/core/test_interval.cpp b/tests/unit_tests/stencil/core/test_interval.cpp
index 218eeeb376..ceeb6aa236 100644
--- a/tests/unit_tests/stencil/core/test_interval.cpp
+++ b/tests/unit_tests/stencil/core/test_interval.cpp
@@ -22,10 +22,9 @@ using level_t = level<Splitter, Offset, level_offset_limit>;
 using my_interval = interval<level_t<0, -1>, level_t<1, -1>>;
 
 template <class T, uint_t FromSplitter, int_t FromOffset, uint_t ToSplitter, int_t ToOffset>
-constexpr bool testee =
-    std::is_same<T, interval<level_t<FromSplitter, FromOffset>, level_t<ToSplitter, ToOffset>>>::value;
+constexpr bool testee = std::is_same_v<T, interval<level_t<FromSplitter, FromOffset>, level_t<ToSplitter, ToOffset>>>;
 
-static_assert(testee<my_interval::modify<-1, 0>, 0, -2, 1, -1>, "");
-static_assert(testee<my_interval::modify<1, 1>, 0, 1, 1, 1>, "");
-static_assert(testee<my_interval::modify<-2, 0>, 0, -3, 1, -1>, "");
-static_assert(testee<my_interval::modify<2, 2>, 0, 2, 1, 2>, "");
+static_assert(testee<my_interval::modify<-1, 0>, 0, -2, 1, -1>);
+static_assert(testee<my_interval::modify<1, 1>, 0, 1, 1, 1>);
+static_assert(testee<my_interval::modify<-2, 0>, 0, -3, 1, -1>);
+static_assert(testee<my_interval::modify<2, 2>, 0, 2, 1, 2>);
diff --git a/tests/unit_tests/stencil/core/test_level.cpp b/tests/unit_tests/stencil/core/test_level.cpp
index 35a2dcfc48..ffaf6e1f64 100644
--- a/tests/unit_tests/stencil/core/test_level.cpp
+++ b/tests/unit_tests/stencil/core/test_level.cpp
@@ -16,36 +16,36 @@ using namespace core;
 
 namespace test_level_to_index {
     template <class L, class I>
-    constexpr bool testee = std::is_same<level_to_index<L>, I>::value;
+    constexpr bool testee = std::is_same_v<level_to_index<L>, I>;
 
-    static_assert(testee<level<0, -2, 2>, level_index<0, 2>>, "");
-    static_assert(testee<level<0, -1, 2>, level_index<1, 2>>, "");
-    static_assert(testee<level<0, 1, 2>, level_index<2, 2>>, "");
-    static_assert(testee<level<0, 2, 2>, level_index<3, 2>>, "");
-    static_assert(testee<level<1, -2, 2>, level_index<4, 2>>, "");
-    static_assert(testee<level<1, -1, 2>, level_index<5, 2>>, "");
-    static_assert(testee<level<1, 1, 2>, level_index<6, 2>>, "");
-    static_assert(testee<level<1, 2, 2>, level_index<7, 2>>, "");
-    static_assert(testee<level<2, -2, 2>, level_index<8, 2>>, "");
-    static_assert(testee<level<2, -1, 2>, level_index<9, 2>>, "");
-    static_assert(testee<level<2, 1, 2>, level_index<10, 2>>, "");
-    static_assert(testee<level<2, 2, 2>, level_index<11, 2>>, "");
+    static_assert(testee<level<0, -2, 2>, level_index<0, 2>>);
+    static_assert(testee<level<0, -1, 2>, level_index<1, 2>>);
+    static_assert(testee<level<0, 1, 2>, level_index<2, 2>>);
+    static_assert(testee<level<0, 2, 2>, level_index<3, 2>>);
+    static_assert(testee<level<1, -2, 2>, level_index<4, 2>>);
+    static_assert(testee<level<1, -1, 2>, level_index<5, 2>>);
+    static_assert(testee<level<1, 1, 2>, level_index<6, 2>>);
+    static_assert(testee<level<1, 2, 2>, level_index<7, 2>>);
+    static_assert(testee<level<2, -2, 2>, level_index<8, 2>>);
+    static_assert(testee<level<2, -1, 2>, level_index<9, 2>>);
+    static_assert(testee<level<2, 1, 2>, level_index<10, 2>>);
+    static_assert(testee<level<2, 2, 2>, level_index<11, 2>>);
 } // namespace test_level_to_index
 
 namespace test_index_to_level {
     template <class L, class I>
-    constexpr bool testee = std::is_same<L, index_to_level<I>>::value;
+    constexpr bool testee = std::is_same_v<L, index_to_level<I>>;
 
-    static_assert(testee<level<0, -2, 2>, level_index<0, 2>>, "");
-    static_assert(testee<level<0, -1, 2>, level_index<1, 2>>, "");
-    static_assert(testee<level<0, 1, 2>, level_index<2, 2>>, "");
-    static_assert(testee<level<0, 2, 2>, level_index<3, 2>>, "");
-    static_assert(testee<level<1, -2, 2>, level_index<4, 2>>, "");
-    static_assert(testee<level<1, -1, 2>, level_index<5, 2>>, "");
-    static_assert(testee<level<1, 1, 2>, level_index<6, 2>>, "");
-    static_assert(testee<level<1, 2, 2>, level_index<7, 2>>, "");
-    static_assert(testee<level<2, -2, 2>, level_index<8, 2>>, "");
-    static_assert(testee<level<2, -1, 2>, level_index<9, 2>>, "");
-    static_assert(testee<level<2, 1, 2>, level_index<10, 2>>, "");
-    static_assert(testee<level<2, 2, 2>, level_index<11, 2>>, "");
+    static_assert(testee<level<0, -2, 2>, level_index<0, 2>>);
+    static_assert(testee<level<0, -1, 2>, level_index<1, 2>>);
+    static_assert(testee<level<0, 1, 2>, level_index<2, 2>>);
+    static_assert(testee<level<0, 2, 2>, level_index<3, 2>>);
+    static_assert(testee<level<1, -2, 2>, level_index<4, 2>>);
+    static_assert(testee<level<1, -1, 2>, level_index<5, 2>>);
+    static_assert(testee<level<1, 1, 2>, level_index<6, 2>>);
+    static_assert(testee<level<1, 2, 2>, level_index<7, 2>>);
+    static_assert(testee<level<2, -2, 2>, level_index<8, 2>>);
+    static_assert(testee<level<2, -1, 2>, level_index<9, 2>>);
+    static_assert(testee<level<2, 1, 2>, level_index<10, 2>>);
+    static_assert(testee<level<2, 2, 2>, level_index<11, 2>>);
 } // namespace test_index_to_level
diff --git a/tests/unit_tests/stencil/cpu_ifirst/test_tmp_storage_sid.cpp b/tests/unit_tests/stencil/cpu_ifirst/test_tmp_storage_sid.cpp
index 38e38d92e6..85493b771f 100644
--- a/tests/unit_tests/stencil/cpu_ifirst/test_tmp_storage_sid.cpp
+++ b/tests/unit_tests/stencil/cpu_ifirst/test_tmp_storage_sid.cpp
@@ -47,8 +47,8 @@ TEST(tmp_storage_sid, nonzero_k_extents) {
 
     using tmp_t = decltype(tmp);
 
-    static_assert(is_sid<tmp_t>(), "");
-    static_assert(std::is_same<sid::ptr_type<tmp_t>, double *>(), "");
+    static_assert(is_sid<tmp_t>());
+    static_assert(std::is_same_v<sid::ptr_type<tmp_t>, double *>);
 
     auto f = [](int_t i, int_t j, int_t k, int_t t) { return i + j * 100 + k * 200 + t * 400; };
 
@@ -115,8 +115,8 @@ TEST(tmp_storage_sid, zero_k_extents) {
 
     using tmp_t = decltype(tmp);
 
-    static_assert(is_sid<tmp_t>(), "");
-    static_assert(std::is_same<sid::ptr_type<tmp_t>, double *>(), "");
+    static_assert(is_sid<tmp_t>());
+    static_assert(std::is_same_v<sid::ptr_type<tmp_t>, double *>);
 
     auto f = [](int_t i, int_t j, int_t t) { return i + j * 100 + t * 200; };
 
diff --git a/tests/unit_tests/stencil/frontend/cartesian/test_accessor.cpp b/tests/unit_tests/stencil/frontend/cartesian/test_accessor.cpp
index 300f06ccbf..c7dfcaecbc 100644
--- a/tests/unit_tests/stencil/frontend/cartesian/test_accessor.cpp
+++ b/tests/unit_tests/stencil/frontend/cartesian/test_accessor.cpp
@@ -20,15 +20,15 @@ using namespace stencil;
 using namespace cartesian;
 using namespace expressions;
 
-static_assert(is_accessor<inout_accessor<6, extent<3, 4, 4, 5>>>::value, "");
-static_assert(is_accessor<in_accessor<2>>::value, "");
-static_assert(!is_accessor<int>::value, "");
-static_assert(!is_accessor<double &>::value, "");
-static_assert(!is_accessor<double const &>::value, "");
+static_assert(is_accessor<inout_accessor<6, extent<3, 4, 4, 5>>>::value);
+static_assert(is_accessor<in_accessor<2>>::value);
+static_assert(!is_accessor<int>::value);
+static_assert(!is_accessor<double &>::value);
+static_assert(!is_accessor<double const &>::value);
 
 TEST(accessor, smoke) {
     using testee_t = inout_accessor<0, extent<0, 3, 0, 2, -1, 0>>;
-    static_assert(tuple_util::size<testee_t>::value == 3, "");
+    static_assert(tuple_util::size<testee_t>::value == 3);
 
     testee_t testee{3, 2, -1};
 
@@ -39,14 +39,14 @@ TEST(accessor, smoke) {
 
 TEST(accessor, zero_accessor) {
     using testee_t = accessor<0>;
-    static_assert(tuple_util::size<testee_t>::value == 0, "");
+    static_assert(tuple_util::size<testee_t>::value == 0);
     testee_t{0, 0, 0, 0};
     testee_t{dimension<3>{}};
 }
 
 TEST(accessor, extra_args) {
     using testee_t = inout_accessor<0, extent<-1, 1>>;
-    static_assert(tuple_util::size<testee_t>::value == 1, "");
+    static_assert(tuple_util::size<testee_t>::value == 1);
     testee_t{1, 0};
     testee_t{dimension<2>{0}};
 }
diff --git a/tests/unit_tests/stencil/frontend/cartesian/test_arg_extent_intent.cpp b/tests/unit_tests/stencil/frontend/cartesian/test_arg_extent_intent.cpp
index 6e0f2baf0a..be9494f300 100644
--- a/tests/unit_tests/stencil/frontend/cartesian/test_arg_extent_intent.cpp
+++ b/tests/unit_tests/stencil/frontend/cartesian/test_arg_extent_intent.cpp
@@ -36,7 +36,7 @@ struct stage2 {
 
 template <class Arg, int... Is, class Spec>
 constexpr bool test_extent(Spec spec) {
-    return std::is_same<decltype(get_arg_extent(spec, Arg())), extent<Is...>>::value;
+    return std::is_same_v<decltype(get_arg_extent(spec, Arg())), extent<Is...>>;
 }
 
 template <class Plh, class Spec>
@@ -53,25 +53,25 @@ struct f {};
 
 constexpr auto mss0 = execute_parallel().stage(stage1(), a(), b(), c());
 
-static_assert(test_extent<a, 0, 1, -1, 0, 0, 1>(mss0), "");
-static_assert(test_extent<b, 0, 1, -1, 0, -1, 1>(mss0), "");
-static_assert(test_extent<c>(mss0), "");
+static_assert(test_extent<a, 0, 1, -1, 0, 0, 1>(mss0));
+static_assert(test_extent<b, 0, 1, -1, 0, -1, 1>(mss0));
+static_assert(test_extent<c>(mss0));
 
-static_assert(test_intent<a>(mss0, intent::in), "");
-static_assert(test_intent<b>(mss0, intent::in), "");
-static_assert(test_intent<c>(mss0, intent::inout), "");
+static_assert(test_intent<a>(mss0, intent::in));
+static_assert(test_intent<b>(mss0, intent::in));
+static_assert(test_intent<c>(mss0, intent::inout));
 
 constexpr auto mss1 = execute_parallel().stage(stage1(), a(), b(), c()).stage(stage2(), a(), c(), d());
 
-static_assert(test_extent<a, -1, 2, -2, 1, -1, 2>(mss1), "");
-static_assert(test_extent<b, -1, 2, -2, 0, -2, 2>(mss1), "");
-static_assert(test_extent<c, -1, 1, -1, 0, -1, 1>(mss1), "");
-static_assert(test_extent<d>(mss1), "");
+static_assert(test_extent<a, -1, 2, -2, 1, -1, 2>(mss1));
+static_assert(test_extent<b, -1, 2, -2, 0, -2, 2>(mss1));
+static_assert(test_extent<c, -1, 1, -1, 0, -1, 1>(mss1));
+static_assert(test_extent<d>(mss1));
 
-static_assert(test_intent<a>(mss1, intent::in), "");
-static_assert(test_intent<b>(mss1, intent::in), "");
-static_assert(test_intent<c>(mss1, intent::inout), "");
-static_assert(test_intent<d>(mss1, intent::inout), "");
+static_assert(test_intent<a>(mss1, intent::in));
+static_assert(test_intent<b>(mss1, intent::in));
+static_assert(test_intent<c>(mss1, intent::inout));
+static_assert(test_intent<d>(mss1, intent::inout));
 
 constexpr auto mss2 = execute_parallel()
                           .stage(stage1(), a(), b(), c())
@@ -107,16 +107,16 @@ constexpr auto mss2 = execute_parallel()
 //   b:  {-2, 3, -3, 1, -3, 3}
 //   a:  {-2, 3, -3, 1, -2, 3}
 
-static_assert(test_extent<a, -2, 3, -3, 1, -2, 3>(mss2), "");
-static_assert(test_extent<b, -2, 3, -3, 1, -3, 3>(mss2), "");
-static_assert(test_extent<c, -2, 2, -2, 1, -2, 2>(mss2), "");
-static_assert(test_extent<d, -1, 0, 0, 1, -1, 0>(mss2), "");
-static_assert(test_extent<e, -1, 1, -1, 0, -1, 1>(mss2), "");
-static_assert(test_extent<f>(mss2), "");
-
-static_assert(test_intent<a>(mss2, intent::in), "");
-static_assert(test_intent<b>(mss2, intent::in), "");
-static_assert(test_intent<c>(mss2, intent::inout), "");
-static_assert(test_intent<d>(mss2, intent::inout), "");
-static_assert(test_intent<e>(mss2, intent::inout), "");
-static_assert(test_intent<f>(mss2, intent::inout), "");
+static_assert(test_extent<a, -2, 3, -3, 1, -2, 3>(mss2));
+static_assert(test_extent<b, -2, 3, -3, 1, -3, 3>(mss2));
+static_assert(test_extent<c, -2, 2, -2, 1, -2, 2>(mss2));
+static_assert(test_extent<d, -1, 0, 0, 1, -1, 0>(mss2));
+static_assert(test_extent<e, -1, 1, -1, 0, -1, 1>(mss2));
+static_assert(test_extent<f>(mss2));
+
+static_assert(test_intent<a>(mss2, intent::in));
+static_assert(test_intent<b>(mss2, intent::in));
+static_assert(test_intent<c>(mss2, intent::inout));
+static_assert(test_intent<d>(mss2, intent::inout));
+static_assert(test_intent<e>(mss2, intent::inout));
+static_assert(test_intent<f>(mss2, intent::inout));
diff --git a/tests/unit_tests/stencil/frontend/cartesian/test_call_proc_stress_types.cpp b/tests/unit_tests/stencil/frontend/cartesian/test_call_proc_stress_types.cpp
index 03d987b6d7..bd0f9e6129 100644
--- a/tests/unit_tests/stencil/frontend/cartesian/test_call_proc_stress_types.cpp
+++ b/tests/unit_tests/stencil/frontend/cartesian/test_call_proc_stress_types.cpp
@@ -30,7 +30,7 @@ void do_test() {
 }
 
 template <class Eval, class Acc, class Expected>
-using check_acceessor = std::is_same<std::decay_t<decltype(std::declval<Eval &>()(Acc()))>, Expected>;
+constexpr bool check_acceessor = std::is_same_v<std::decay_t<decltype(std::declval<Eval &>()(Acc()))>, Expected>;
 
 struct in_tag {};
 struct out_tag {};
@@ -43,8 +43,8 @@ struct triple_nesting_with_type_switching_third_stage {
 
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
-        static_assert(check_acceessor<Evaluation, out, out_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, local, local_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, out_tag>);
+        static_assert(check_acceessor<Evaluation, local, local_tag>);
     }
 };
 
@@ -55,8 +55,8 @@ struct triple_nesting_with_type_switching_second_stage {
 
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
-        static_assert(check_acceessor<Evaluation, out, out_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in, in_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, out_tag>);
+        static_assert(check_acceessor<Evaluation, in, in_tag>);
 
         local_tag local;
         call_proc<triple_nesting_with_type_switching_third_stage>::with(eval, out(), local);
@@ -70,8 +70,8 @@ struct triple_nesting_with_type_switching_first_stage {
 
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
-        static_assert(check_acceessor<Evaluation, out, out_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in, in_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, out_tag>);
+        static_assert(check_acceessor<Evaluation, in, in_tag>);
 
         call_proc<triple_nesting_with_type_switching_second_stage>::with(eval, in(), out());
     }
diff --git a/tests/unit_tests/stencil/frontend/cartesian/test_call_stress_types.cpp b/tests/unit_tests/stencil/frontend/cartesian/test_call_stress_types.cpp
index dfe7534053..df5ca347e9 100644
--- a/tests/unit_tests/stencil/frontend/cartesian/test_call_stress_types.cpp
+++ b/tests/unit_tests/stencil/frontend/cartesian/test_call_stress_types.cpp
@@ -30,7 +30,7 @@ void do_test() {
 }
 
 template <class Eval, class Acc, class Expected>
-using check_acceessor = std::is_same<std::decay_t<decltype(std::declval<Eval &>()(Acc()))>, Expected>;
+constexpr bool check_acceessor = std::is_same_v<std::decay_t<decltype(std::declval<Eval &>()(Acc()))>, Expected>;
 
 struct in1_tag {};
 struct in2_tag {};
@@ -45,8 +45,8 @@ struct simple_callee_with_forced_return_type {
 
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
-        static_assert(check_acceessor<Evaluation, out, forced_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in, in1_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, forced_tag>);
+        static_assert(check_acceessor<Evaluation, in, in1_tag>);
     }
 };
 
@@ -58,7 +58,7 @@ struct simple_caller_with_forced_return_type {
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
         auto result = call<simple_callee_with_forced_return_type>::return_type<forced_tag>::with(eval, in{});
-        static_assert(std::is_same<decltype(result), forced_tag>::value, "");
+        static_assert(std::is_same_v<decltype(result), forced_tag>);
     }
 
     void dummy() { do_test<simple_caller_with_forced_return_type, in1_tag, out_tag>(); }
@@ -71,8 +71,8 @@ struct simple_callee_with_deduced_return_type {
 
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
-        static_assert(check_acceessor<Evaluation, out, in1_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in, in1_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, in1_tag>);
+        static_assert(check_acceessor<Evaluation, in, in1_tag>);
     }
 };
 
@@ -84,7 +84,7 @@ struct simple_caller_with_deduced_return_type {
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
         auto result = call<simple_callee_with_deduced_return_type>::with(eval, in{});
-        static_assert(std::is_same<decltype(result), in1_tag>::value, "");
+        static_assert(std::is_same_v<decltype(result), in1_tag>);
     }
     void dummy() { do_test<simple_caller_with_deduced_return_type, in1_tag, out_tag>(); }
 };
@@ -99,10 +99,10 @@ struct triple_nesting_with_type_switching_third_stage {
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
         // the new convention is that the return type (here "out) is deduced from the first argument in the call
-        static_assert(check_acceessor<Evaluation, out, in2_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in1, in1_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in2, in2_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, local, local_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, in2_tag>);
+        static_assert(check_acceessor<Evaluation, in1, in1_tag>);
+        static_assert(check_acceessor<Evaluation, in2, in2_tag>);
+        static_assert(check_acceessor<Evaluation, local, local_tag>);
     }
 };
 
@@ -116,14 +116,14 @@ struct triple_nesting_with_type_switching_second_stage {
     GT_FUNCTION static void apply(Evaluation &eval) {
         using out_type = std::decay_t<decltype(eval(out{}))>;
         // the expected type differs here in "call" vs "call_proc"
-        static_assert(check_acceessor<Evaluation, out, in1_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in1, in1_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in2, in2_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, in1_tag>);
+        static_assert(check_acceessor<Evaluation, in1, in1_tag>);
+        static_assert(check_acceessor<Evaluation, in2, in2_tag>);
 
         local_tag local;
 
         auto result = call<triple_nesting_with_type_switching_third_stage>::with(eval, in2(), local, in1());
-        static_assert(std::is_same<decltype(result), in2_tag>::value, "");
+        static_assert(std::is_same_v<decltype(result), in2_tag>);
     }
 };
 
@@ -135,12 +135,12 @@ struct triple_nesting_with_type_switching_first_stage {
 
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
-        static_assert(check_acceessor<Evaluation, out, out_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in1, in1_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in2, in2_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, out_tag>);
+        static_assert(check_acceessor<Evaluation, in1, in1_tag>);
+        static_assert(check_acceessor<Evaluation, in2, in2_tag>);
 
         auto result = call<triple_nesting_with_type_switching_second_stage>::with(eval, in1(), in2());
-        static_assert(std::is_same<decltype(result), in1_tag>::value, "");
+        static_assert(std::is_same_v<decltype(result), in1_tag>);
     }
     void dummy() { do_test<triple_nesting_with_type_switching_first_stage, in1_tag, out_tag, in2_tag>(); }
 };
@@ -155,14 +155,14 @@ struct triple_nesting_with_type_switching_and_call_proc_second_stage {
     GT_FUNCTION static void apply(Evaluation &eval) {
         // in contrast to the example where this is stage is called from "call" (not "call_proc")
         // the type here is different!
-        static_assert(check_acceessor<Evaluation, out, out_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in1, in1_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in2, in2_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, out_tag>);
+        static_assert(check_acceessor<Evaluation, in1, in1_tag>);
+        static_assert(check_acceessor<Evaluation, in2, in2_tag>);
 
         local_tag local;
 
         auto result = call<triple_nesting_with_type_switching_third_stage>::with(eval, in2(), local, in1());
-        static_assert(std::is_same<decltype(result), in2_tag>::value, "");
+        static_assert(std::is_same_v<decltype(result), in2_tag>);
     }
 };
 
@@ -174,9 +174,9 @@ struct triple_nesting_with_type_switching_and_call_proc_first_stage {
 
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
-        static_assert(check_acceessor<Evaluation, out, out_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in1, in1_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in2, in2_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, out_tag>);
+        static_assert(check_acceessor<Evaluation, in1, in1_tag>);
+        static_assert(check_acceessor<Evaluation, in2, in2_tag>);
 
         call_proc<triple_nesting_with_type_switching_and_call_proc_second_stage>::with(eval, in1(), out(), in2());
     }
diff --git a/tests/unit_tests/stencil/frontend/cartesian/test_expressions.cpp b/tests/unit_tests/stencil/frontend/cartesian/test_expressions.cpp
index 6d060dfeb3..d55b3bafcc 100644
--- a/tests/unit_tests/stencil/frontend/cartesian/test_expressions.cpp
+++ b/tests/unit_tests/stencil/frontend/cartesian/test_expressions.cpp
@@ -46,11 +46,11 @@ namespace gridtools {
 
                 using val = accessor_mock<float>;
 
-#define EXPRESSION_TEST(name, expr)                                      \
-    GT_FUNCTION float test_##name() {                                    \
-        auto result = iterate_domain_mock()(expr);                       \
-        static_assert(std::is_same<decltype(result), float>::value, ""); \
-        return result;                                                   \
+#define EXPRESSION_TEST(name, expr)                             \
+    GT_FUNCTION float test_##name() {                           \
+        auto result = iterate_domain_mock()(expr);              \
+        static_assert(std::is_same_v<decltype(result), float>); \
+        return result;                                          \
     }
 
                 EXPRESSION_TEST(add_accessors, val{1} + val{2})
diff --git a/tests/unit_tests/stencil/frontend/cartesian/test_expressions_integration.cpp b/tests/unit_tests/stencil/frontend/cartesian/test_expressions_integration.cpp
index be07ab3761..af67a8c9d4 100644
--- a/tests/unit_tests/stencil/frontend/cartesian/test_expressions_integration.cpp
+++ b/tests/unit_tests/stencil/frontend/cartesian/test_expressions_integration.cpp
@@ -107,8 +107,8 @@ namespace {
         run_single_stage(test_functor(),
             naive(),
             env_t::make_grid(),
-            make_global_parameter(2.),
-            make_global_parameter(3.),
+            global_parameter(2.),
+            global_parameter(3.),
             out,
             positional<dim::i>());
         env_t::verify(0, out);
diff --git a/tests/unit_tests/stencil/frontend/cartesian/test_stage_with_extents.cpp b/tests/unit_tests/stencil/frontend/cartesian/test_stage_with_extents.cpp
index 65cbed2682..5802a5fc63 100644
--- a/tests/unit_tests/stencil/frontend/cartesian/test_stage_with_extents.cpp
+++ b/tests/unit_tests/stencil/frontend/cartesian/test_stage_with_extents.cpp
@@ -34,12 +34,12 @@ namespace gridtools {
                                           .stage(stage(), c(), d());
 
                 template <class Arg, int_t... Is>
-                constexpr bool testee = std::is_same<decltype(get_arg_extent(spec, Arg())), extent<Is...>>::value;
+                constexpr bool testee = std::is_same_v<decltype(get_arg_extent(spec, Arg())), extent<Is...>>;
 
-                static_assert(testee<a, -6, 6>, "");
-                static_assert(testee<b, -5, 5>, "");
-                static_assert(testee<c, -3, 3>, "");
-                static_assert(testee<d>, "");
+                static_assert(testee<a, -6, 6>);
+                static_assert(testee<b, -5, 5>);
+                static_assert(testee<c, -3, 3>);
+                static_assert(testee<d>);
             } // namespace
         }     // namespace cartesian
     }         // namespace stencil
diff --git a/tests/unit_tests/stencil/frontend/icosahedral/test_from_to_mapping.cpp b/tests/unit_tests/stencil/frontend/icosahedral/test_from_to_mapping.cpp
index 8f8cf590ab..7cd27a9e73 100644
--- a/tests/unit_tests/stencil/frontend/icosahedral/test_from_to_mapping.cpp
+++ b/tests/unit_tests/stencil/frontend/icosahedral/test_from_to_mapping.cpp
@@ -20,37 +20,37 @@ template <class From, class To, int Color>
 constexpr bool testee = meta::first<meta::first<neighbor_offsets<From, To, Color>>>::value < 10;
 
 // From Cells to XXX
-static_assert(testee<cells, cells, 0>, "");
-static_assert(testee<cells, cells, 1>, "");
-static_assert(testee<cells, edges, 0>, "");
-static_assert(testee<cells, edges, 1>, "");
-static_assert(testee<cells, vertices, 0>, "");
-static_assert(testee<cells, vertices, 1>, "");
+static_assert(testee<cells, cells, 0>);
+static_assert(testee<cells, cells, 1>);
+static_assert(testee<cells, edges, 0>);
+static_assert(testee<cells, edges, 1>);
+static_assert(testee<cells, vertices, 0>);
+static_assert(testee<cells, vertices, 1>);
 
 // From Edges to XXX
-static_assert(testee<edges, cells, 0>, "");
-static_assert(testee<edges, cells, 1>, "");
-static_assert(testee<edges, cells, 2>, "");
-static_assert(testee<edges, edges, 0>, "");
-static_assert(testee<edges, edges, 1>, "");
-static_assert(testee<edges, edges, 2>, "");
-static_assert(testee<edges, vertices, 0>, "");
-static_assert(testee<edges, vertices, 1>, "");
-static_assert(testee<edges, vertices, 2>, "");
+static_assert(testee<edges, cells, 0>);
+static_assert(testee<edges, cells, 1>);
+static_assert(testee<edges, cells, 2>);
+static_assert(testee<edges, edges, 0>);
+static_assert(testee<edges, edges, 1>);
+static_assert(testee<edges, edges, 2>);
+static_assert(testee<edges, vertices, 0>);
+static_assert(testee<edges, vertices, 1>);
+static_assert(testee<edges, vertices, 2>);
 
 // From Vertices to XXX
-static_assert(testee<vertices, cells, 0>, "");
-static_assert(testee<vertices, edges, 0>, "");
-static_assert(testee<vertices, vertices, 0>, "");
+static_assert(testee<vertices, cells, 0>);
+static_assert(testee<vertices, edges, 0>);
+static_assert(testee<vertices, vertices, 0>);
 
-static_assert(std::is_same<neighbors_extent<cells, cells>, extent<-1, 1, -1, 1>>::value, "");
-static_assert(std::is_same<neighbors_extent<cells, edges>, extent<0, 1, 0, 1>>::value, "");
-static_assert(std::is_same<neighbors_extent<cells, vertices>, extent<0, 1, 0, 1>>::value, "");
+static_assert(std::is_same_v<neighbors_extent<cells, cells>, extent<-1, 1, -1, 1>>);
+static_assert(std::is_same_v<neighbors_extent<cells, edges>, extent<0, 1, 0, 1>>);
+static_assert(std::is_same_v<neighbors_extent<cells, vertices>, extent<0, 1, 0, 1>>);
 
-static_assert(std::is_same<neighbors_extent<edges, cells>, extent<-1, 0, -1, 0>>::value, "");
-static_assert(std::is_same<neighbors_extent<edges, edges>, extent<-1, 1, -1, 1>>::value, "");
-static_assert(std::is_same<neighbors_extent<edges, vertices>, extent<0, 1, 0, 1>>::value, "");
+static_assert(std::is_same_v<neighbors_extent<edges, cells>, extent<-1, 0, -1, 0>>);
+static_assert(std::is_same_v<neighbors_extent<edges, edges>, extent<-1, 1, -1, 1>>);
+static_assert(std::is_same_v<neighbors_extent<edges, vertices>, extent<0, 1, 0, 1>>);
 
-static_assert(std::is_same<neighbors_extent<vertices, cells>, extent<-1, 0, -1, 0>>::value, "");
-static_assert(std::is_same<neighbors_extent<vertices, edges>, extent<-1, 0, -1, 0>>::value, "");
-static_assert(std::is_same<neighbors_extent<vertices, vertices>, extent<-1, 1, -1, 1>>::value, "");
+static_assert(std::is_same_v<neighbors_extent<vertices, cells>, extent<-1, 0, -1, 0>>);
+static_assert(std::is_same_v<neighbors_extent<vertices, edges>, extent<-1, 0, -1, 0>>);
+static_assert(std::is_same_v<neighbors_extent<vertices, vertices>, extent<-1, 1, -1, 1>>);
diff --git a/tests/unit_tests/stencil/frontend/test_axis.cpp b/tests/unit_tests/stencil/frontend/test_axis.cpp
index 51546fc809..056b79acf2 100644
--- a/tests/unit_tests/stencil/frontend/test_axis.cpp
+++ b/tests/unit_tests/stencil/frontend/test_axis.cpp
@@ -36,15 +36,15 @@ namespace intervals {
 
     template <class T, uint_t FromSplitter, int_t FromOffset, uint_t ToSplitter, int_t ToOffset>
     constexpr bool testee =
-        std::is_same<T, interval<level_t<FromSplitter, FromOffset>, level_t<ToSplitter, ToOffset>>>::value;
+        std::is_same_v<T, interval<level_t<FromSplitter, FromOffset>, level_t<ToSplitter, ToOffset>>>;
 
     // full interval
-    static_assert(testee<axis_t::full_interval, 0, 1, 3, -1>, "");
+    static_assert(testee<axis_t::full_interval, 0, 1, 3, -1>);
 
     // intervals by id
-    static_assert(testee<axis_t::get_interval<0>, 0, 1, 1, -1>, "");
-    static_assert(testee<axis_t::get_interval<1>, 1, 1, 2, -1>, "");
+    static_assert(testee<axis_t::get_interval<0>, 0, 1, 1, -1>);
+    static_assert(testee<axis_t::get_interval<1>, 1, 1, 2, -1>);
 
     // hull of multiple intervals
-    static_assert(testee<axis_t::get_interval<1, 2>, 1, 1, 3, -1>, "");
+    static_assert(testee<axis_t::get_interval<1, 2>, 1, 1, 3, -1>);
 } // namespace intervals
diff --git a/tests/unit_tests/stencil/gpu/test_ij_cache.cu b/tests/unit_tests/stencil/gpu/test_ij_cache.cu
index 0aac1ca075..06da9740b6 100644
--- a/tests/unit_tests/stencil/gpu/test_ij_cache.cu
+++ b/tests/unit_tests/stencil/gpu/test_ij_cache.cu
@@ -34,13 +34,13 @@ namespace gridtools {
 
                 using ij_cache_t = decltype(testee);
 
-                static_assert(is_sid<ij_cache_t>(), "");
-                static_assert(std::is_same<sid::ptr_type<ij_cache_t>, double *>(), "");
-                static_assert(std::is_same<sid::ptr_diff_type<ij_cache_t>, int_t>(), "");
+                static_assert(is_sid<ij_cache_t>());
+                static_assert(std::is_same_v<sid::ptr_type<ij_cache_t>, double *>);
+                static_assert(std::is_same_v<sid::ptr_diff_type<ij_cache_t>, int_t>);
 
                 using expected_kind = hymap::keys<dim::c, dim::i, dim::j>::
                     values<integral_constant<int_t, 1>, integral_constant<int_t, 1>, integral_constant<int_t, 9>>;
-                static_assert(std::is_same<sid::strides_kind<ij_cache_t>, expected_kind>(), "");
+                static_assert(std::is_same_v<sid::strides_kind<ij_cache_t>, expected_kind>);
                 auto strides = sid::get_strides(testee);
                 EXPECT_EQ(1, at_key<dim::i>(strides));
                 EXPECT_EQ(9, at_key<dim::j>(strides));
diff --git a/tests/unit_tests/stencil/gpu/test_shared_allocator.cu b/tests/unit_tests/stencil/gpu/test_shared_allocator.cu
index ffa8265d2f..959970bbf9 100644
--- a/tests/unit_tests/stencil/gpu/test_shared_allocator.cu
+++ b/tests/unit_tests/stencil/gpu/test_shared_allocator.cu
@@ -53,9 +53,9 @@ namespace gridtools {
                 template <class PtrHolderFloat, class PtrHolderInt>
                 __global__ void fill_and_check_test(
                     PtrHolderFloat holder1, PtrHolderFloat holder1_shifted, PtrHolderInt holder2, bool *result) {
-                    static_assert(std::is_same<decltype(holder1()), float *>::value, "");
-                    static_assert(std::is_same<decltype(holder1_shifted()), float *>::value, "");
-                    static_assert(std::is_same<decltype(holder2()), int16_t *>::value, "");
+                    static_assert(std::is_same_v<decltype(holder1()), float *>);
+                    static_assert(std::is_same_v<decltype(holder1_shifted()), float *>);
+                    static_assert(std::is_same_v<decltype(holder2()), int16_t *>);
 
                     auto ptr1 = holder1();
                     auto ptr1_shifted = holder1_shifted();
diff --git a/tests/unit_tests/stencil/test_global_parameter.cpp b/tests/unit_tests/stencil/test_global_parameter.cpp
index 47661677a8..601b098c6f 100644
--- a/tests/unit_tests/stencil/test_global_parameter.cpp
+++ b/tests/unit_tests/stencil/test_global_parameter.cpp
@@ -17,17 +17,17 @@ namespace gridtools {
     namespace stencil {
         namespace {
             TEST(global_parameter, smoke) {
-                auto testee = make_global_parameter(42.);
+                auto testee = global_parameter(42.);
                 using testee_t = decltype(testee);
 
-                static_assert(is_sid<testee_t>(), "");
-                static_assert(std::is_same<sid::element_type<testee_t>, double>(), "");
-                static_assert(std::is_same<sid::reference_type<testee_t>, double>(), "");
-                static_assert(sizeof(sid::ptr_holder_type<testee_t>) == sizeof(double), "");
-                static_assert(sizeof(sid::ptr_type<testee_t>) == sizeof(double), "");
-                static_assert(std::is_empty<sid::ptr_diff_type<testee_t>>(), "");
-                static_assert(std::is_empty<sid::strides_type<testee_t>>(), "");
-                static_assert(tuple_util::size<sid::strides_type<testee_t>>::value == 0, "");
+                static_assert(is_sid<testee_t>());
+                static_assert(std::is_same_v<sid::element_type<testee_t>, double>);
+                static_assert(std::is_same_v<sid::reference_type<testee_t>, double>);
+                static_assert(sizeof(sid::ptr_holder_type<testee_t>) == sizeof(double));
+                static_assert(sizeof(sid::ptr_type<testee_t>) == sizeof(double));
+                static_assert(std::is_empty_v<sid::ptr_diff_type<testee_t>>);
+                static_assert(std::is_empty_v<sid::strides_type<testee_t>>);
+                static_assert(tuple_util::size<sid::strides_type<testee_t>>::value == 0);
 
                 EXPECT_EQ(42., *sid::get_origin(testee)());
             }
diff --git a/tests/unit_tests/stencil/test_positional.cpp b/tests/unit_tests/stencil/test_positional.cpp
index d388f9eee1..53c1091927 100644
--- a/tests/unit_tests/stencil/test_positional.cpp
+++ b/tests/unit_tests/stencil/test_positional.cpp
@@ -20,7 +20,7 @@ namespace gridtools {
             struct d;
             using testee_t = positional<d>;
 
-            static_assert(is_sid<testee_t>(), "");
+            static_assert(is_sid<testee_t>());
 
             TEST(positional, smoke) {
                 testee_t testee{1};
diff --git a/tests/unit_tests/storage/test_storage_facility.cpp b/tests/unit_tests/storage/test_storage_facility.cpp
index 18ac0d5daa..46f96c6ba3 100644
--- a/tests/unit_tests/storage/test_storage_facility.cpp
+++ b/tests/unit_tests/storage/test_storage_facility.cpp
@@ -66,143 +66,143 @@ TEST(StorageFacility, ViewTests) {
 
 template <int... Args>
 static constexpr bool expect_layout =
-    std::is_same<typename decltype(builder.dimensions(Args...)())::element_type::layout_t, layout_map<Args...>>::value;
+    std::is_same_v<typename decltype(builder.dimensions(Args...)())::element_type::layout_t, layout_map<Args...>>;
 
 template <class Layout, int... Args>
 static constexpr bool expect_special_layout =
-    std::is_same<typename decltype(builder.selector<Args...>().dimensions(Args...)())::element_type::layout_t,
-        Layout>::value;
+    std::is_same_v<typename decltype(builder.selector<Args...>().dimensions(Args...)())::element_type::layout_t,
+        Layout>;
 
 template <int... Args>
 static constexpr bool expect_custom_layout =
-    std::is_same<typename decltype(builder.layout<Args...>().dimensions(Args...)())::element_type::layout_t,
-        layout_map<Args...>>::value;
+    std::is_same_v<typename decltype(builder.layout<Args...>().dimensions(Args...)())::element_type::layout_t,
+        layout_map<Args...>>;
 
-static_assert(expect_custom_layout<2, 1, 0>, "");
-static_assert(expect_custom_layout<1, 0>, "");
-static_assert(expect_custom_layout<2, -1, 1, 0>, "");
+static_assert(expect_custom_layout<2, 1, 0>);
+static_assert(expect_custom_layout<1, 0>);
+static_assert(expect_custom_layout<2, -1, 1, 0>);
 
 #if defined(GT_STORAGE_CPU_KFIRST)
 
-static_assert(expect_layout<0>, "");
-static_assert(expect_layout<0, 1>, "");
-static_assert(expect_layout<0, 1, 2>, "");
-static_assert(expect_layout<1, 2, 3, 0>, "");
-static_assert(expect_layout<2, 3, 4, 0, 1>, "");
-
-static_assert(expect_special_layout<layout_map<2, 3, 4, 0, 1>, 1, 1, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<-1, 2, 3, 0, 1>, 0, 1, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<2, -1, 3, 0, 1>, 1, 0, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<2, 3, -1, 0, 1>, 1, 1, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<1, 2, 3, -1, 0>, 1, 1, 1, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<1, 2, 3, 0, -1>, 1, 1, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, -1, 2, 0, 1>, 0, 0, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<2, -1, -1, 0, 1>, 1, 0, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<1, 2, -1, -1, 0>, 1, 1, 0, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<0, 1, 2, -1, -1>, 1, 1, 1, 0, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, 2, -1, 0, 1>, 0, 1, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<1, -1, 2, -1, 0>, 1, 0, 1, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<1, 2, -1, 0, -1>, 1, 1, 0, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, 1, 2, -1, 0>, 0, 1, 1, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<1, -1, 2, 0, -1>, 1, 0, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, 1, 2, 0, -1>, 0, 1, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, -1, -1, 0, 1>, 0, 0, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<1, -1, -1, -1, 0>, 1, 0, 0, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<0, 1, -1, -1, -1>, 1, 1, 0, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, 0, 1, -1, -1>, 0, 1, 1, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, 1, 0, -1>, 0, 0, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<0, -1, -1, -1, -1>, 1, 0, 0, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, 0, -1, -1, -1>, 0, 1, 0, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, 0, -1, -1>, 0, 0, 1, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, -1, 0, -1>, 0, 0, 0, 1, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, -1, -1, 0>, 0, 0, 0, 0, 1>, "");
+static_assert(expect_layout<0>);
+static_assert(expect_layout<0, 1>);
+static_assert(expect_layout<0, 1, 2>);
+static_assert(expect_layout<1, 2, 3, 0>);
+static_assert(expect_layout<2, 3, 4, 0, 1>);
+
+static_assert(expect_special_layout<layout_map<2, 3, 4, 0, 1>, 1, 1, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<-1, 2, 3, 0, 1>, 0, 1, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<2, -1, 3, 0, 1>, 1, 0, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<2, 3, -1, 0, 1>, 1, 1, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<1, 2, 3, -1, 0>, 1, 1, 1, 0, 1>);
+static_assert(expect_special_layout<layout_map<1, 2, 3, 0, -1>, 1, 1, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, -1, 2, 0, 1>, 0, 0, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<2, -1, -1, 0, 1>, 1, 0, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<1, 2, -1, -1, 0>, 1, 1, 0, 0, 1>);
+static_assert(expect_special_layout<layout_map<0, 1, 2, -1, -1>, 1, 1, 1, 0, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, 2, -1, 0, 1>, 0, 1, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<1, -1, 2, -1, 0>, 1, 0, 1, 0, 1>);
+static_assert(expect_special_layout<layout_map<1, 2, -1, 0, -1>, 1, 1, 0, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, 1, 2, -1, 0>, 0, 1, 1, 0, 1>);
+static_assert(expect_special_layout<layout_map<1, -1, 2, 0, -1>, 1, 0, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, 1, 2, 0, -1>, 0, 1, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, -1, -1, 0, 1>, 0, 0, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<1, -1, -1, -1, 0>, 1, 0, 0, 0, 1>);
+static_assert(expect_special_layout<layout_map<0, 1, -1, -1, -1>, 1, 1, 0, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, 0, 1, -1, -1>, 0, 1, 1, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, 1, 0, -1>, 0, 0, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<0, -1, -1, -1, -1>, 1, 0, 0, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, 0, -1, -1, -1>, 0, 1, 0, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, 0, -1, -1>, 0, 0, 1, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, -1, 0, -1>, 0, 0, 0, 1, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, -1, -1, 0>, 0, 0, 0, 0, 1>);
 
 #elif defined(GT_STORAGE_CPU_IFIRST)
 
-static_assert(expect_layout<0>, "");
-static_assert(expect_layout<1, 0>, "");
-static_assert(expect_layout<2, 0, 1>, "");
-static_assert(expect_layout<3, 1, 2, 0>, "");
-static_assert(expect_layout<4, 2, 3, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<4, 2, 3, 1, 0>, 1, 1, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<-1, 2, 3, 1, 0>, 0, 1, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<3, -1, 2, 1, 0>, 1, 0, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<3, 2, -1, 1, 0>, 1, 1, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<3, 1, 2, -1, 0>, 1, 1, 1, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<3, 1, 2, 0, -1>, 1, 1, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, -1, 2, 1, 0>, 0, 0, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<2, -1, -1, 1, 0>, 1, 0, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<2, 1, -1, -1, 0>, 1, 1, 0, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<2, 0, 1, -1, -1>, 1, 1, 1, 0, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, 2, -1, 1, 0>, 0, 1, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<2, -1, 1, -1, 0>, 1, 0, 1, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<2, 1, -1, 0, -1>, 1, 1, 0, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, 1, 2, -1, 0>, 0, 1, 1, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<2, -1, 1, 0, -1>, 1, 0, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, 1, 2, 0, -1>, 0, 1, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, -1, -1, 1, 0>, 0, 0, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<1, -1, -1, -1, 0>, 1, 0, 0, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<1, 0, -1, -1, -1>, 1, 1, 0, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, 0, 1, -1, -1>, 0, 1, 1, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, 1, 0, -1>, 0, 0, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<0, -1, -1, -1, -1>, 1, 0, 0, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, 0, -1, -1, -1>, 0, 1, 0, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, 0, -1, -1>, 0, 0, 1, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, -1, 0, -1>, 0, 0, 0, 1, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, -1, -1, 0>, 0, 0, 0, 0, 1>, "");
+static_assert(expect_layout<0>);
+static_assert(expect_layout<1, 0>);
+static_assert(expect_layout<2, 0, 1>);
+static_assert(expect_layout<3, 1, 2, 0>);
+static_assert(expect_layout<4, 2, 3, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<4, 2, 3, 1, 0>, 1, 1, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<-1, 2, 3, 1, 0>, 0, 1, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<3, -1, 2, 1, 0>, 1, 0, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<3, 2, -1, 1, 0>, 1, 1, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<3, 1, 2, -1, 0>, 1, 1, 1, 0, 1>);
+static_assert(expect_special_layout<layout_map<3, 1, 2, 0, -1>, 1, 1, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, -1, 2, 1, 0>, 0, 0, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<2, -1, -1, 1, 0>, 1, 0, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<2, 1, -1, -1, 0>, 1, 1, 0, 0, 1>);
+static_assert(expect_special_layout<layout_map<2, 0, 1, -1, -1>, 1, 1, 1, 0, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, 2, -1, 1, 0>, 0, 1, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<2, -1, 1, -1, 0>, 1, 0, 1, 0, 1>);
+static_assert(expect_special_layout<layout_map<2, 1, -1, 0, -1>, 1, 1, 0, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, 1, 2, -1, 0>, 0, 1, 1, 0, 1>);
+static_assert(expect_special_layout<layout_map<2, -1, 1, 0, -1>, 1, 0, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, 1, 2, 0, -1>, 0, 1, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, -1, -1, 1, 0>, 0, 0, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<1, -1, -1, -1, 0>, 1, 0, 0, 0, 1>);
+static_assert(expect_special_layout<layout_map<1, 0, -1, -1, -1>, 1, 1, 0, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, 0, 1, -1, -1>, 0, 1, 1, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, 1, 0, -1>, 0, 0, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<0, -1, -1, -1, -1>, 1, 0, 0, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, 0, -1, -1, -1>, 0, 1, 0, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, 0, -1, -1>, 0, 0, 1, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, -1, 0, -1>, 0, 0, 0, 1, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, -1, -1, 0>, 0, 0, 0, 0, 1>);
 
 #elif defined(GT_STORAGE_GPU)
 
-static_assert(expect_layout<0>, "");
-static_assert(expect_layout<1, 0>, "");
-static_assert(expect_layout<2, 1, 0>, "");
-static_assert(expect_layout<3, 2, 1, 0>, "");
-static_assert(expect_layout<4, 3, 2, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<4, 3, 2, 1, 0>, 1, 1, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<-1, 3, 2, 1, 0>, 0, 1, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<3, -1, 2, 1, 0>, 1, 0, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<3, 2, -1, 1, 0>, 1, 1, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<3, 2, 1, -1, 0>, 1, 1, 1, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<3, 2, 1, 0, -1>, 1, 1, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, -1, 2, 1, 0>, 0, 0, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<2, -1, -1, 1, 0>, 1, 0, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<2, 1, -1, -1, 0>, 1, 1, 0, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<2, 1, 0, -1, -1>, 1, 1, 1, 0, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, 2, -1, 1, 0>, 0, 1, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<2, -1, 1, -1, 0>, 1, 0, 1, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<2, 1, -1, 0, -1>, 1, 1, 0, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, 2, 1, -1, 0>, 0, 1, 1, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<2, -1, 1, 0, -1>, 1, 0, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, 2, 1, 0, -1>, 0, 1, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, -1, -1, 1, 0>, 0, 0, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<1, -1, -1, -1, 0>, 1, 0, 0, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<1, 0, -1, -1, -1>, 1, 1, 0, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, 1, 0, -1, -1>, 0, 1, 1, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, 1, 0, -1>, 0, 0, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<0, -1, -1, -1, -1>, 1, 0, 0, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, 0, -1, -1, -1>, 0, 1, 0, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, 0, -1, -1>, 0, 0, 1, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, -1, 0, -1>, 0, 0, 0, 1, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, -1, -1, 0>, 0, 0, 0, 0, 1>, "");
+static_assert(expect_layout<0>);
+static_assert(expect_layout<1, 0>);
+static_assert(expect_layout<2, 1, 0>);
+static_assert(expect_layout<3, 2, 1, 0>);
+static_assert(expect_layout<4, 3, 2, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<4, 3, 2, 1, 0>, 1, 1, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<-1, 3, 2, 1, 0>, 0, 1, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<3, -1, 2, 1, 0>, 1, 0, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<3, 2, -1, 1, 0>, 1, 1, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<3, 2, 1, -1, 0>, 1, 1, 1, 0, 1>);
+static_assert(expect_special_layout<layout_map<3, 2, 1, 0, -1>, 1, 1, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, -1, 2, 1, 0>, 0, 0, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<2, -1, -1, 1, 0>, 1, 0, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<2, 1, -1, -1, 0>, 1, 1, 0, 0, 1>);
+static_assert(expect_special_layout<layout_map<2, 1, 0, -1, -1>, 1, 1, 1, 0, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, 2, -1, 1, 0>, 0, 1, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<2, -1, 1, -1, 0>, 1, 0, 1, 0, 1>);
+static_assert(expect_special_layout<layout_map<2, 1, -1, 0, -1>, 1, 1, 0, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, 2, 1, -1, 0>, 0, 1, 1, 0, 1>);
+static_assert(expect_special_layout<layout_map<2, -1, 1, 0, -1>, 1, 0, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, 2, 1, 0, -1>, 0, 1, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, -1, -1, 1, 0>, 0, 0, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<1, -1, -1, -1, 0>, 1, 0, 0, 0, 1>);
+static_assert(expect_special_layout<layout_map<1, 0, -1, -1, -1>, 1, 1, 0, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, 1, 0, -1, -1>, 0, 1, 1, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, 1, 0, -1>, 0, 0, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<0, -1, -1, -1, -1>, 1, 0, 0, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, 0, -1, -1, -1>, 0, 1, 0, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, 0, -1, -1>, 0, 0, 1, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, -1, 0, -1>, 0, 0, 0, 1, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, -1, -1, 0>, 0, 0, 0, 0, 1>);
 
 #endif
diff --git a/tests/unit_tests/storage/test_storage_sid.cpp b/tests/unit_tests/storage/test_storage_sid.cpp
index 4d124bfc3a..e0d2430d44 100644
--- a/tests/unit_tests/storage/test_storage_sid.cpp
+++ b/tests/unit_tests/storage/test_storage_sid.cpp
@@ -36,18 +36,18 @@ namespace gridtools {
             auto testee = builder.dimensions(10, 20, 30, 40)();
             using testee_t = decltype(testee);
 
-            static_assert(sid::concept_impl_::is_sid<testee_t>(), "");
-            static_assert(std::is_same<sid::ptr_type<testee_t>, double *>(), "");
-            static_assert(std::is_same<sid::ptr_diff_type<testee_t>, int_t>(), "");
-            static_assert(std::is_same<sid::strides_kind<testee_t>, typename testee_t::element_type::kind_t>(), "");
+            static_assert(sid::concept_impl_::is_sid<testee_t>());
+            static_assert(std::is_same_v<sid::ptr_type<testee_t>, double *>);
+            static_assert(std::is_same_v<sid::ptr_diff_type<testee_t>, int_t>);
+            static_assert(std::is_same_v<sid::strides_kind<testee_t>, typename testee_t::element_type::kind_t>);
 
             using strides_t = sid::strides_type<testee_t>;
 
-            static_assert(tu::size<strides_t>() == 4, "");
-            static_assert(std::is_same<tu::element<0, strides_t>, int_t>(), "");
-            static_assert(std::is_same<tu::element<1, strides_t>, integral_constant<int_t, 0>>(), "");
-            static_assert(std::is_same<tu::element<2, strides_t>, integral_constant<int_t, 1>>(), "");
-            static_assert(std::is_same<tu::element<3, strides_t>, int_t>(), "");
+            static_assert(tu::size<strides_t>() == 4);
+            static_assert(std::is_same_v<tu::element<0, strides_t>, int_t>);
+            static_assert(std::is_same_v<tu::element<1, strides_t>, integral_constant<int_t, 0>>);
+            static_assert(std::is_same_v<tu::element<2, strides_t>, integral_constant<int_t, 1>>);
+            static_assert(std::is_same_v<tu::element<3, strides_t>, int_t>);
 
             EXPECT_EQ(testee->get_target_ptr(), sid::get_origin(testee)());
 
@@ -87,10 +87,10 @@ namespace gridtools {
             auto testee = storage::builder<storage_traits_t>.type<double>().layout<-1>().dimensions(10)();
             using testee_t = decltype(testee);
 
-            static_assert(sid::concept_impl_::is_sid<testee_t>(), "");
+            static_assert(sid::concept_impl_::is_sid<testee_t>());
 
             using diff_t = sid::ptr_diff_type<testee_t>;
-            static_assert(std::is_empty<diff_t>(), "");
+            static_assert(std::is_empty_v<diff_t>);
 
             auto ptr = sid::get_origin(testee)();
 
@@ -99,28 +99,28 @@ namespace gridtools {
             using lower_bounds_t = sid::lower_bounds_type<testee_t>;
             using upper_bounds_t = sid::upper_bounds_type<testee_t>;
 
-            static_assert(tuple_util::size<lower_bounds_t>() == 0, "");
-            static_assert(tuple_util::size<upper_bounds_t>() == 0, "");
+            static_assert(tuple_util::size<lower_bounds_t>() == 0);
+            static_assert(tuple_util::size<upper_bounds_t>() == 0);
         }
 
         TEST(storage_sid, compile_time_lengths) {
             auto testee = storage::builder<storage_traits_t>.type<int>().layout<0, 1>().dimensions(10_c, 10_c)();
             using testee_t = decltype(testee);
 
-            static_assert(sid::concept_impl_::is_sid<testee_t>(), "");
+            static_assert(sid::is_sid<testee_t>());
 
             using strides_t = sid::strides_type<testee_t>;
             using bounds_t = sid::upper_bounds_type<testee_t>;
 
-            static_assert(tuple_util::is_empty_or_tuple_of_empties<strides_t>(), "");
-            static_assert(tuple_util::is_empty_or_tuple_of_empties<bounds_t>(), "");
+            static_assert(tuple_util::is_empty_or_tuple_of_empties<strides_t>());
+            static_assert(tuple_util::is_empty_or_tuple_of_empties<bounds_t>());
 
-            static_assert(tu::size<bounds_t>() == 2, "");
-            static_assert(tu::element<1, bounds_t>::value == 10, "");
-            static_assert(tu::element<0, bounds_t>::value == 10, "");
+            static_assert(tu::size<bounds_t>() == 2);
+            static_assert(tu::element<1, bounds_t>::value == 10);
+            static_assert(tu::element<0, bounds_t>::value == 10);
 
             auto expected_strides = testee->strides();
-            static_assert(tu::size<strides_t>() == 2, "");
+            static_assert(tu::size<strides_t>() == 2);
             EXPECT_EQ(expected_strides[0], (tu::element<0, strides_t>::value));
             EXPECT_EQ(expected_strides[1], (tu::element<1, strides_t>::value));
         }
diff --git a/tests/unit_tests/test_meta.cpp b/tests/unit_tests/test_meta.cpp
index 4f99d72775..5d24d7747c 100644
--- a/tests/unit_tests/test_meta.cpp
+++ b/tests/unit_tests/test_meta.cpp
@@ -24,135 +24,128 @@ namespace gridtools {
         struct h;
 
         // is_list
-        static_assert(!is_list<int>{}, "");
-        static_assert(is_list<list<int, void>>{}, "");
-        static_assert(is_list<f<void, int>>{}, "");
-        static_assert(is_list<std::pair<int, double>>{}, "");
-        static_assert(is_list<std::tuple<int, double>>{}, "");
+        static_assert(!is_list<int>{});
+        static_assert(is_list<list<int, void>>{});
+        static_assert(is_list<f<void, int>>{});
+        static_assert(is_list<std::pair<int, double>>{});
+        static_assert(is_list<std::tuple<int, double>>{});
 
         // has_type
-        static_assert(!has_type<int>{}, "");
-        static_assert(!has_type<g<>>{}, "");
-        static_assert(has_type<lazy::id<void>>{}, "");
-        static_assert(has_type<std::is_void<int>>{}, "");
+        static_assert(!has_type<int>{});
+        static_assert(!has_type<g<>>{});
+        static_assert(has_type<lazy::id<void>>{});
+        static_assert(has_type<std::is_void<int>>{});
 
         // length
-        static_assert(length<list<>>::value == 0, "");
-        static_assert(length<std::tuple<int>>::value == 1, "");
-        static_assert(length<std::pair<int, double>>::value == 2, "");
-        static_assert(length<f<int, int, double>>::value == 3, "");
+        static_assert(length<list<>>::value == 0);
+        static_assert(length<std::tuple<int>>::value == 1);
+        static_assert(length<std::pair<int, double>>::value == 2);
+        static_assert(length<f<int, int, double>>::value == 3);
 
         // ctor
-        static_assert(std::is_same<ctor<f<double>>::apply<int, void>, f<int, void>>{}, "");
+        static_assert(std::is_same_v<ctor<f<double>>::apply<int, void>, f<int, void>>);
 
         // rename
-        static_assert(std::is_same<rename<f, g<int, double>>, f<int, double>>{}, "");
+        static_assert(std::is_same_v<rename<f, g<int, double>>, f<int, double>>);
 
         // transform
-        static_assert(std::is_same<transform<f, g<>>, g<>>{}, "");
-        static_assert(std::is_same<transform<f, g<int, void>>, g<f<int>, f<void>>>{}, "");
-        static_assert(std::is_same<transform<f, g<int, void>, g<int *, void *>, g<int **, void **>>,
-                          g<f<int, int *, int **>, f<void, void *, void **>>>{},
-            "");
+        static_assert(std::is_same_v<transform<f, g<>>, g<>>);
+        static_assert(std::is_same_v<transform<f, g<int, void>>, g<f<int>, f<void>>>);
+        static_assert(std::is_same_v<transform<f, g<int, void>, g<int *, void *>, g<int **, void **>>,
+            g<f<int, int *, int **>, f<void, void *, void **>>>);
 
         // st_contains
-        static_assert(st_contains<g<int, bool>, int>{}, "");
-        static_assert(!st_contains<g<int, bool>, void>{}, "");
+        static_assert(st_contains<g<int, bool>, int>{});
+        static_assert(!st_contains<g<int, bool>, void>{});
 
         // mp_find
         using map = f<g<int, void *>, g<void, double *>, g<float, double *>>;
-        static_assert(std::is_same<mp_find<map, int>, g<int, void *>>{}, "");
-        static_assert(std::is_same<mp_find<map, double>, void>{}, "");
+        static_assert(std::is_same_v<mp_find<map, int>, g<int, void *>>);
+        static_assert(std::is_same_v<mp_find<map, double>, void>);
 
         // repeat
-        static_assert(std::is_same<repeat_c<0, f<int>>, f<>>{}, "");
-        static_assert(std::is_same<repeat_c<3, f<int>>, f<int, int, int>>{}, "");
+        static_assert(std::is_same_v<repeat_c<0, f<int>>, f<>>);
+        static_assert(std::is_same_v<repeat_c<3, f<int>>, f<int, int, int>>);
 
         // drop_front
-        static_assert(std::is_same<drop_front_c<0, f<int, double>>, f<int, double>>{}, "");
-        static_assert(std::is_same<drop_front_c<1, f<int, double>>, f<double>>{}, "");
-        static_assert(std::is_same<drop_front_c<2, f<int, double>>, f<>>{}, "");
+        static_assert(std::is_same_v<drop_front_c<0, f<int, double>>, f<int, double>>);
+        static_assert(std::is_same_v<drop_front_c<1, f<int, double>>, f<double>>);
+        static_assert(std::is_same_v<drop_front_c<2, f<int, double>>, f<>>);
 
         // at
-        static_assert(std::is_same<at_c<f<int, double>, 0>, int>{}, "");
-        static_assert(std::is_same<at_c<f<int, double>, 1>, double>{}, "");
-        static_assert(std::is_same<last<f<int, double>>, double>{}, "");
+        static_assert(std::is_same_v<at_c<f<int, double>, 0>, int>);
+        static_assert(std::is_same_v<at_c<f<int, double>, 1>, double>);
+        static_assert(std::is_same_v<last<f<int, double>>, double>);
 
         // conjunction
-        static_assert(conjunction_fast<>{}, "");
-        static_assert(conjunction_fast<std::true_type, std::true_type>{}, "");
-        static_assert(!conjunction_fast<std::true_type, std::false_type>{}, "");
-        static_assert(!conjunction_fast<std::false_type, std::true_type>{}, "");
-        static_assert(!conjunction_fast<std::false_type, std::false_type>{}, "");
+        static_assert(conjunction_fast<>{});
+        static_assert(conjunction_fast<std::true_type, std::true_type>{});
+        static_assert(!conjunction_fast<std::true_type, std::false_type>{});
+        static_assert(!conjunction_fast<std::false_type, std::true_type>{});
+        static_assert(!conjunction_fast<std::false_type, std::false_type>{});
 
         // disjunction
-        static_assert(!disjunction_fast<>{}, "");
-        static_assert(disjunction_fast<std::true_type, std::true_type>{}, "");
-        static_assert(disjunction_fast<std::true_type, std::false_type>{}, "");
-        static_assert(disjunction_fast<std::false_type, std::true_type>{}, "");
-        static_assert(!disjunction_fast<std::false_type, std::false_type>{}, "");
+        static_assert(!disjunction_fast<>{});
+        static_assert(disjunction_fast<std::true_type, std::true_type>{});
+        static_assert(disjunction_fast<std::true_type, std::false_type>{});
+        static_assert(disjunction_fast<std::false_type, std::true_type>{});
+        static_assert(!disjunction_fast<std::false_type, std::false_type>{});
 
         // st_position
-        static_assert(st_position<f<int, double>, int>{} == 0, "");
-        static_assert(st_position<f<double, int>, int>{} == 1, "");
-        static_assert(st_position<f<double, int>, void>{} == 2, "");
+        static_assert(st_position<f<int, double>, int>{} == 0);
+        static_assert(st_position<f<double, int>, int>{} == 1);
+        static_assert(st_position<f<double, int>, void>{} == 2);
 
         // combine
-        static_assert(std::is_same<combine<f, g<int>>, int>{}, "");
-        static_assert(std::is_same<combine<f, repeat_c<8, g<int>>>,
-                          f<f<f<int, int>, f<int, int>>, f<f<int, int>, f<int, int>>>>{},
-            "");
-        static_assert(std::is_same<combine<f, g<int, int, int>>, f<int, f<int, int>>>{}, "");
-        static_assert(std::is_same<combine<f, repeat_c<4, g<int>>>, f<f<int, int>, f<int, int>>>{}, "");
+        static_assert(std::is_same_v<combine<f, g<int>>, int>);
+        static_assert(std::is_same_v<combine<f, repeat_c<8, g<int>>>,
+            f<f<f<int, int>, f<int, int>>, f<f<int, int>, f<int, int>>>>);
+        static_assert(std::is_same_v<combine<f, g<int, int, int>>, f<int, f<int, int>>>);
+        static_assert(std::is_same_v<combine<f, repeat_c<4, g<int>>>, f<f<int, int>, f<int, int>>>);
 
         // concat
-        static_assert(std::is_same<concat<g<int>>, g<int>>{}, "");
-        static_assert(std::is_same<concat<g<int>, f<void>>, g<int, void>>{}, "");
-        static_assert(
-            std::is_same<concat<g<int>, g<void, double>, g<void, int>>, g<int, void, double, void, int>>{}, "");
+        static_assert(std::is_same_v<concat<g<int>>, g<int>>);
+        static_assert(std::is_same_v<concat<g<int>, f<void>>, g<int, void>>);
+        static_assert(std::is_same_v<concat<g<int>, g<void, double>, g<void, int>>, g<int, void, double, void, int>>);
 
         // flatten
-        static_assert(std::is_same<flatten<f<g<int>>>, g<int>>{}, "");
-        static_assert(std::is_same<flatten<f<g<int>, f<bool>>>, g<int, bool>>{}, "");
+        static_assert(std::is_same_v<flatten<f<g<int>>>, g<int>>);
+        static_assert(std::is_same_v<flatten<f<g<int>, f<bool>>>, g<int, bool>>);
 
         // filter
-        static_assert(std::is_same<filter<std::is_pointer, f<>>, f<>>{}, "");
-        static_assert(
-            std::is_same<filter<std::is_pointer, f<void, int *, double, double **>>, f<int *, double **>>{}, "");
+        static_assert(std::is_same_v<filter<std::is_pointer, f<>>, f<>>);
+        static_assert(std::is_same_v<filter<std::is_pointer, f<void, int *, double, double **>>, f<int *, double **>>);
 
         // all_of
-        static_assert(all_of<is_list, f<f<>, f<int>>>{}, "");
+        static_assert(all_of<is_list, f<f<>, f<int>>>{});
 
         // dedup
-        static_assert(std::is_same<dedup<f<>>, f<>>{}, "");
-        static_assert(std::is_same<dedup<f<int>>, f<int>>{}, "");
-        static_assert(std::is_same<dedup<f<int, void>>, f<int, void>>{}, "");
-        static_assert(std::is_same<dedup<f<int, void, void, void, int, void>>, f<int, void>>{}, "");
+        static_assert(std::is_same_v<dedup<f<>>, f<>>);
+        static_assert(std::is_same_v<dedup<f<int>>, f<int>>);
+        static_assert(std::is_same_v<dedup<f<int, void>>, f<int, void>>);
+        static_assert(std::is_same_v<dedup<f<int, void, void, void, int, void>>, f<int, void>>);
 
         // zip
-        static_assert(std::is_same<zip<f<int>, f<void>>, f<list<int, void>>>{}, "");
-        static_assert(std::is_same<zip<f<int, int *, int **>, f<void, void *, void **>, f<char, char *, char **>>,
-                          f<list<int, void, char>, list<int *, void *, char *>, list<int **, void **, char **>>>{},
-            "");
+        static_assert(std::is_same_v<zip<f<int>, f<void>>, f<list<int, void>>>);
+        static_assert(std::is_same_v<zip<f<int, int *, int **>, f<void, void *, void **>, f<char, char *, char **>>,
+            f<list<int, void, char>, list<int *, void *, char *>, list<int **, void **, char **>>>);
 
         // bind
-        static_assert(std::is_same<bind<f, _2, void, _1>::apply<int, double>, f<double, void, int>>{}, "");
+        static_assert(std::is_same_v<bind<f, _2, void, _1>::apply<int, double>, f<double, void, int>>);
 
         // is_instantiation_of
-        static_assert(is_instantiation_of<f, f<>>{}, "");
-        static_assert(is_instantiation_of<f, f<int, void>>{}, "");
-        static_assert(!is_instantiation_of<f, g<>>{}, "");
-        static_assert(!is_instantiation_of<f, int>{}, "");
-        static_assert(is_instantiation_of<f>::apply<f<int, void>>{}, "");
+        static_assert(is_instantiation_of<f, f<>>{});
+        static_assert(is_instantiation_of<f, f<int, void>>{});
+        static_assert(!is_instantiation_of<f, g<>>{});
+        static_assert(!is_instantiation_of<f, int>{});
+        static_assert(is_instantiation_of<f>::apply<f<int, void>>{});
 
-        static_assert(std::is_same<replace<f<int, double, int, double>, double, void>, f<int, void, int, void>>{}, "");
+        static_assert(std::is_same_v<replace<f<int, double, int, double>, double, void>, f<int, void, int, void>>);
 
-        static_assert(std::is_same<mp_replace<f<g<int, int *>, g<double, double *>>, int, void>,
-                          f<g<int, void>, g<double, double *>>>{},
-            "");
+        static_assert(std::is_same_v<mp_replace<f<g<int, int *>, g<double, double *>>, int, void>,
+            f<g<int, void>, g<double, double *>>>);
 
-        static_assert(
-            std::is_same<replace_at_c<f<int, double, int, double>, 1, void>, f<int, void, int, double>>{}, "");
+        static_assert(std::is_same_v<replace_at_c<f<int, double, int, double>, 1, void>, f<int, void, int, double>>);
 
         namespace nvcc_sizeof_workaround {
             template <class...>
@@ -170,121 +163,108 @@ namespace gridtools {
             using e = typename d<a<Ts>...>::c;
         } // namespace nvcc_sizeof_workaround
 
-        static_assert(is_set<f<>>{}, "");
-        static_assert(is_set<f<int>>{}, "");
-        static_assert(is_set<f<void>>{}, "");
-        static_assert(is_set<f<int, void>>{}, "");
-        static_assert(!is_set<int>{}, "");
-        static_assert(!is_set<f<int, void, int>>{}, "");
+        static_assert(is_set<f<>>{});
+        static_assert(is_set<f<int>>{});
+        static_assert(is_set<f<void>>{});
+        static_assert(is_set<f<int, void>>{});
+        static_assert(!is_set<int>{});
+        static_assert(!is_set<f<int, void, int>>{});
 
-        static_assert(is_set_fast<f<>>{}, "");
-        static_assert(is_set_fast<f<int>>{}, "");
-        static_assert(is_set_fast<f<void>>{}, "");
-        static_assert(is_set_fast<f<int, void>>{}, "");
-        static_assert(!is_set_fast<int>{}, "");
-        //        static_assert(!is_set_fast< f< int, void, int > >{}, "");
+        static_assert(is_set_fast<f<>>{});
+        static_assert(is_set_fast<f<int>>{});
+        static_assert(is_set_fast<f<void>>{});
+        static_assert(is_set_fast<f<int, void>>{});
+        static_assert(!is_set_fast<int>{});
+        //        static_assert(!is_set_fast< f< int, void, int > >{});
 
         // rfold
-        static_assert(std::is_same<foldl<f, int, g<>>, int>{}, "");
-        static_assert(std::is_same<foldl<f, int, g<int>>, f<int, int>>{}, "");
-        static_assert(std::is_same<foldl<f, int, g<int, int>>, f<f<int, int>, int>>{}, "");
-        static_assert(std::is_same<foldl<f, int, g<int, int>>, f<f<int, int>, int>>{}, "");
-        static_assert(std::is_same<foldl<f, int, g<int, int, int>>, f<f<f<int, int>, int>, int>>{}, "");
-        static_assert(std::is_same<foldl<f, int, g<int, int, int, int>>, f<f<f<f<int, int>, int>, int>, int>>{}, "");
+        static_assert(std::is_same_v<foldl<f, int, g<>>, int>);
+        static_assert(std::is_same_v<foldl<f, int, g<int>>, f<int, int>>);
+        static_assert(std::is_same_v<foldl<f, int, g<int, int>>, f<f<int, int>, int>>);
+        static_assert(std::is_same_v<foldl<f, int, g<int, int>>, f<f<int, int>, int>>);
+        static_assert(std::is_same_v<foldl<f, int, g<int, int, int>>, f<f<f<int, int>, int>, int>>);
+        static_assert(std::is_same_v<foldl<f, int, g<int, int, int, int>>, f<f<f<f<int, int>, int>, int>, int>>);
         static_assert(
-            std::is_same<foldl<f, int, g<int, int, int, int, int>>, f<f<f<f<f<int, int>, int>, int>, int>, int>>{}, "");
-        static_assert(std::is_same<foldl<f, int, g<int, int, int, int, int, int>>,
-                          f<f<f<f<f<f<int, int>, int>, int>, int>, int>, int>>{},
-            "");
+            std::is_same_v<foldl<f, int, g<int, int, int, int, int>>, f<f<f<f<f<int, int>, int>, int>, int>, int>>);
+        static_assert(std::is_same_v<foldl<f, int, g<int, int, int, int, int, int>>,
+            f<f<f<f<f<f<int, int>, int>, int>, int>, int>, int>>);
 
         // foldr
-        static_assert(std::is_same<foldr<f, int, g<>>, int>{}, "");
-        static_assert(std::is_same<foldr<f, int, g<int>>, f<int, int>>{}, "");
-        static_assert(std::is_same<foldr<f, int, g<int, int>>, f<f<int, int>, int>>{}, "");
-        static_assert(std::is_same<foldr<f, int, g<int, int, int>>, f<f<f<int, int>, int>, int>>{}, "");
-        static_assert(std::is_same<foldr<f, int, g<int, int, int, int>>, f<f<f<f<int, int>, int>, int>, int>>{}, "");
-        static_assert(
-            std::is_same<foldr<f, int, g<int, int, int, int, int>>, f<f<f<f<f<int, int>, int>, int>, int>, int>>{}, "");
-        static_assert(std::is_same<foldr<f, int, g<int, int, int, int, int, int>>,
-                          f<f<f<f<f<f<int, int>, int>, int>, int>, int>, int>>{},
-            "");
-
-        static_assert(std::is_same<cartesian_product<>, list<list<>>>{}, "");
-        static_assert(std::is_same<cartesian_product<f<>>, list<>>{}, "");
-        static_assert(std::is_same<cartesian_product<f<int>>, list<list<int>>>{}, "");
-        static_assert(std::is_same<cartesian_product<f<int, double>>, list<list<int>, list<double>>>{}, "");
-        static_assert(
-            std::is_same<cartesian_product<f<int, double>, g<void>>, list<list<int, void>, list<double, void>>>{}, "");
-        static_assert(std::is_same<cartesian_product<f<int, double>, g<int *, double *>>,
-                          list<list<int, int *>, list<int, double *>, list<double, int *>, list<double, double *>>>{},
-            "");
-        static_assert(std::is_same<cartesian_product<f<int, double>, g<>, f<void>>, list<>>{}, "");
-        static_assert(std::is_same<cartesian_product<f<>, g<int, double>>, list<>>{}, "");
-        static_assert(
-            std::is_same<cartesian_product<f<int>, g<double>, list<void>>, list<list<int, double, void>>>{}, "");
-
-        static_assert(std::is_same<reverse<f<int, int *, int **, int ***, int ****, int *****, int ******>>,
-                          f<int ******, int *****, int ****, int ***, int **, int *, int>>{},
-            "");
-
-        static_assert(find<f<>, int>::type::value == 0, "");
-        static_assert(find<f<void>, int>::type::value == 1, "");
-        static_assert(find<f<double, int, int, double, int>, int>::type::value == 1, "");
-        static_assert(find<f<double, int, int, double, int>, void>::type::value == 5, "");
-
-        static_assert(std::is_same<mp_insert<f<>, g<int, int *>>, f<g<int, int *>>>{}, "");
+        static_assert(std::is_same_v<foldr<f, int, g<>>, int>);
+        static_assert(std::is_same_v<foldr<f, int, g<int>>, f<int, int>>);
+        static_assert(std::is_same_v<foldr<f, int, g<int, int>>, f<f<int, int>, int>>);
+        static_assert(std::is_same_v<foldr<f, int, g<int, int, int>>, f<f<f<int, int>, int>, int>>);
+        static_assert(std::is_same_v<foldr<f, int, g<int, int, int, int>>, f<f<f<f<int, int>, int>, int>, int>>);
         static_assert(
-            std::is_same<mp_insert<f<g<void, void *>>, g<int, int *>>, f<g<void, void *>, g<int, int *>>>{}, "");
-        static_assert(std::is_same<mp_insert<f<g<int, int *>>, g<int, int **>>, f<g<int, int *, int **>>>{}, "");
-
-        static_assert(std::is_same<mp_remove<f<g<int, int *>>, void>, f<g<int, int *>>>{}, "");
-        static_assert(std::is_same<mp_remove<f<g<int, int *>>, int>, f<>>{}, "");
-        static_assert(std::is_same<mp_remove<f<g<int, int *>, g<void, void *>>, int>, f<g<void, void *>>>{}, "");
-
-        static_assert(std::is_same<mp_inverse<f<>>, f<>>{}, "");
+            std::is_same_v<foldr<f, int, g<int, int, int, int, int>>, f<f<f<f<f<int, int>, int>, int>, int>, int>>);
+        static_assert(std::is_same_v<foldr<f, int, g<int, int, int, int, int, int>>,
+            f<f<f<f<f<f<int, int>, int>, int>, int>, int>, int>>);
+
+        static_assert(std::is_same_v<cartesian_product<>, list<list<>>>);
+        static_assert(std::is_same_v<cartesian_product<f<>>, list<>>);
+        static_assert(std::is_same_v<cartesian_product<f<int>>, list<list<int>>>);
+        static_assert(std::is_same_v<cartesian_product<f<int, double>>, list<list<int>, list<double>>>);
         static_assert(
-            std::is_same<mp_inverse<f<g<int, int *>, g<void, void *>>>, f<g<int *, int>, g<void *, void>>>{}, "");
-        static_assert(std::is_same<mp_inverse<f<g<int, int *, int **>, g<void, void *>>>,
-                          f<g<int *, int>, g<int **, int>, g<void *, void>>>{},
-            "");
-        static_assert(std::is_same<mp_inverse<f<g<int *, int>, g<int **, int>, g<void *, void>>>,
-                          f<g<int, int *, int **>, g<void, void *>>>{},
-            "");
+            std::is_same_v<cartesian_product<f<int, double>, g<void>>, list<list<int, void>, list<double, void>>>);
+        static_assert(std::is_same_v<cartesian_product<f<int, double>, g<int *, double *>>,
+            list<list<int, int *>, list<int, double *>, list<double, int *>, list<double, double *>>>);
+        static_assert(std::is_same_v<cartesian_product<f<int, double>, g<>, f<void>>, list<>>);
+        static_assert(std::is_same_v<cartesian_product<f<>, g<int, double>>, list<>>);
+        static_assert(std::is_same_v<cartesian_product<f<int>, g<double>, list<void>>, list<list<int, double, void>>>);
+
+        static_assert(std::is_same_v<reverse<f<int, int *, int **, int ***, int ****, int *****, int ******>>,
+            f<int ******, int *****, int ****, int ***, int **, int *, int>>);
+
+        static_assert(find<f<>, int>::type::value == 0);
+        static_assert(find<f<void>, int>::type::value == 1);
+        static_assert(find<f<double, int, int, double, int>, int>::type::value == 1);
+        static_assert(find<f<double, int, int, double, int>, void>::type::value == 5);
+
+        static_assert(std::is_same_v<mp_insert<f<>, g<int, int *>>, f<g<int, int *>>>);
+        static_assert(std::is_same_v<mp_insert<f<g<void, void *>>, g<int, int *>>, f<g<void, void *>, g<int, int *>>>);
+        static_assert(std::is_same_v<mp_insert<f<g<int, int *>>, g<int, int **>>, f<g<int, int *, int **>>>);
+
+        static_assert(std::is_same_v<mp_remove<f<g<int, int *>>, void>, f<g<int, int *>>>);
+        static_assert(std::is_same_v<mp_remove<f<g<int, int *>>, int>, f<>>);
+        static_assert(std::is_same_v<mp_remove<f<g<int, int *>, g<void, void *>>, int>, f<g<void, void *>>>);
+
+        static_assert(std::is_same_v<mp_inverse<f<>>, f<>>);
+        static_assert(std::is_same_v<mp_inverse<f<g<int, int *>, g<void, void *>>>, f<g<int *, int>, g<void *, void>>>);
+        static_assert(std::is_same_v<mp_inverse<f<g<int, int *, int **>, g<void, void *>>>,
+            f<g<int *, int>, g<int **, int>, g<void *, void>>>);
+        static_assert(std::is_same_v<mp_inverse<f<g<int *, int>, g<int **, int>, g<void *, void>>>,
+            f<g<int, int *, int **>, g<void, void *>>>);
 
         // take
-        static_assert(std::is_same<take_c<2, f<int, double, void, void>>, f<int, double>>::value, "");
-        static_assert(std::is_same<take_c<20, repeat_c<100, g<int>>>, repeat_c<20, g<int>>>::value, "");
+        static_assert(std::is_same_v<take_c<2, f<int, double, void, void>>, f<int, double>>);
+        static_assert(std::is_same_v<take_c<20, repeat_c<100, g<int>>>, repeat_c<20, g<int>>>);
 
         // insert
-        static_assert(std::is_same<insert_c<3, f<void, void, void, void, void>, int, double>,
-                          f<void, void, void, int, double, void, void>>::value,
-            "");
+        static_assert(std::is_same_v<insert_c<3, f<void, void, void, void, void>, int, double>,
+            f<void, void, void, int, double, void, void>>);
 
         // group
-        static_assert(std::is_same<group<are_same, g, f<>>, f<>>::value, "");
-        static_assert(std::is_same<group<are_same, g, f<int>>, f<g<int>>>::value, "");
-        static_assert(std::is_same<group<are_same, g, f<int, int, int, double, void, void, int, int>>,
-                          f<g<int, int, int>, g<double>, g<void, void>, g<int, int>>>::value,
-            "");
+        static_assert(std::is_same_v<group<are_same, g, f<>>, f<>>);
+        static_assert(std::is_same_v<group<are_same, g, f<int>>, f<g<int>>>);
+        static_assert(std::is_same_v<group<are_same, g, f<int, int, int, double, void, void, int, int>>,
+            f<g<int, int, int>, g<double>, g<void, void>, g<int, int>>>);
 
         // trim
-        static_assert(std::is_same<trim<std::is_void, f<int, void, int>>, f<int, void, int>>::value, "");
-        static_assert(std::is_same<trim<std::is_void, f<>>, f<>>::value, "");
-        static_assert(std::is_same<trim<std::is_void, f<void, void>>, f<>>::value, "");
+        static_assert(std::is_same_v<trim<std::is_void, f<int, void, int>>, f<int, void, int>>);
+        static_assert(std::is_same_v<trim<std::is_void, f<>>, f<>>);
+        static_assert(std::is_same_v<trim<std::is_void, f<void, void>>, f<>>);
         static_assert(
-            std::is_same<trim<std::is_void, f<void, void, int, int, void, int, void>>, f<int, int, void, int>>::value,
-            "");
+            std::is_same_v<trim<std::is_void, f<void, void, int, int, void, int, void>>, f<int, int, void, int>>);
 
         // mp_make
-        static_assert(std::is_same<mp_make<h, f<>>, f<>>::value, "");
-        static_assert(std::is_same<mp_make<h, f<g<int, int *>>>, f<h<g<int, int *>>>>::value, "");
+        static_assert(std::is_same_v<mp_make<h, f<>>, f<>>);
+        static_assert(std::is_same_v<mp_make<h, f<g<int, int *>>>, f<h<g<int, int *>>>>);
+        static_assert(
+            std::is_same_v<mp_make<h, f<g<int, int *>, g<void, void *>>>, f<h<g<int, int *>>, h<g<void, void *>>>>);
         static_assert(
-            std::is_same<mp_make<h, f<g<int, int *>, g<void, void *>>>, f<h<g<int, int *>>, h<g<void, void *>>>>::value,
-            "");
+            std::is_same_v<mp_make<h, f<g<int, int *>, g<int, int **>>>, f<h<g<int, int *>, g<int, int **>>>>);
         static_assert(
-            std::is_same<mp_make<h, f<g<int, int *>, g<int, int **>>>, f<h<g<int, int *>, g<int, int **>>>>::value, "");
-        static_assert(std::is_same<mp_make<h, f<g<void, void *>, g<int, int *>, g<int, int **>, g<double, double **>>>,
-                          f<h<g<void, void *>>, h<g<int, int *>, g<int, int **>>, h<g<double, double **>>>>::value,
-            "");
+            std::is_same_v<mp_make<h, f<g<void, void *>, g<int, int *>, g<int, int **>, g<double, double **>>>,
+                f<h<g<void, void *>>, h<g<int, int *>, g<int, int **>>, h<g<double, double **>>>>);
     } // namespace meta
 } // namespace gridtools

From f1ec938610b2f55015de71af16cc2d4396248d08 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Sat, 25 Dec 2021 18:13:30 +0100
Subject: [PATCH 16/19] fix clang compilation

---
 include/gridtools/fn/scan.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/gridtools/fn/scan.hpp b/include/gridtools/fn/scan.hpp
index f5024a16c1..6ff2a3627b 100644
--- a/include/gridtools/fn/scan.hpp
+++ b/include/gridtools/fn/scan.hpp
@@ -47,7 +47,7 @@ namespace gridtools::fn {
             GT_FUNCTION auto operator()(Seed seed, std::size_t size, Ptr ptr, Strides const &strides) const {
                 constexpr std::size_t prologue_size = std::tuple_size_v<decltype(ScanOrFold::prologue())>;
                 constexpr std::size_t epilogue_size = std::tuple_size_v<decltype(ScanOrFold::epilogue())>;
-                if constexpr (prologue_size + epilogue_size)
+                if constexpr (prologue_size + epilogue_size > 0)
                     assert(size >= prologue_size + epilogue_size);
                 using step_t = integral_constant<int, ScanOrFold::value ? -1 : 1>;
                 auto const &v_stride = sid::get_stride<Vertical>(strides);

From 6bd0d4587289ffaf31a5b29647d8f7c4887ed1d4 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Mon, 3 Jan 2022 09:51:37 +0100
Subject: [PATCH 17/19] try to fix jenkins

---
 include/gridtools/common/array.hpp                       | 7 +------
 include/gridtools/common/hymap.hpp                       | 3 +--
 include/gridtools/storage/adapter/python_sid_adapter.hpp | 2 +-
 3 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/include/gridtools/common/array.hpp b/include/gridtools/common/array.hpp
index 3ee69c6acc..89f9228995 100644
--- a/include/gridtools/common/array.hpp
+++ b/include/gridtools/common/array.hpp
@@ -14,7 +14,6 @@
 */
 
 #include <algorithm>
-#include <cassert>
 #include <iterator>
 #include <tuple>
 #include <type_traits>
@@ -72,14 +71,10 @@ namespace gridtools {
 
         constexpr T const &operator[](size_t i) const { return m_array[i]; }
 
-        constexpr T &operator[](size_t i) {
-            assert(i < D);
-            return m_array[i];
-        }
+        constexpr T &operator[](size_t i) { return m_array[i]; }
 
         template <typename A>
         constexpr array &operator=(A const &a) {
-            assert(a.size() == D);
             std::copy(a.begin(), a.end(), m_array);
             return *this;
         }
diff --git a/include/gridtools/common/hymap.hpp b/include/gridtools/common/hymap.hpp
index a591a27cd0..ec4c241cd6 100644
--- a/include/gridtools/common/hymap.hpp
+++ b/include/gridtools/common/hymap.hpp
@@ -45,8 +45,7 @@
  *
  *  User API
  *  --------
- *  Run time: a single function `target_name::at_key<Key>(hymap_obj)` is provided where `target_name` is `host`,
- * `device` or `host_device`. `at_key` without `target_name` is an alias of `host::at_key`.
+ *  Run time: a single function `at_key<Key>(hymap_obj)` is provided.
  *
  *  Compile time:
  *  - `get_keys` metafunction. Usage: `get_keys<Hymap>`
diff --git a/include/gridtools/storage/adapter/python_sid_adapter.hpp b/include/gridtools/storage/adapter/python_sid_adapter.hpp
index 64bd1f66f0..0c9f6017dc 100644
--- a/include/gridtools/storage/adapter/python_sid_adapter.hpp
+++ b/include/gridtools/storage/adapter/python_sid_adapter.hpp
@@ -340,7 +340,7 @@ namespace gridtools {
 
             using sid::property;
             return sid::synthetic()
-                .template set<property::origin>(sid::host_device::simple_ptr_holder<T *>{ptr})
+                .template set<property::origin>(sid::simple_ptr_holder<T *>{ptr})
                 .template set<property::strides>(assign_unit_stride<UnitStrideDim>(std::move(strides), shape))
                 .template set<property::strides_kind, kind<Dim, Kind>>()
                 .template set<property::lower_bounds>(array<integral_constant<size_t, 0>, Dim>())

From cd965cb213966053011a867508dd642c672f002e Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Mon, 3 Jan 2022 10:26:44 +0100
Subject: [PATCH 18/19] fix gcl comp

---
 .../gcl/high_level/wrap_argument.hpp          | 32 ++++++++++++++++---
 1 file changed, 28 insertions(+), 4 deletions(-)

diff --git a/include/gridtools/gcl/high_level/wrap_argument.hpp b/include/gridtools/gcl/high_level/wrap_argument.hpp
index 2fcef60864..9ac757f08a 100644
--- a/include/gridtools/gcl/high_level/wrap_argument.hpp
+++ b/include/gridtools/gcl/high_level/wrap_argument.hpp
@@ -12,10 +12,34 @@
 struct wrap_argument {
     int data[27];
 
-    constexpr wrap_argument(int const *ptr) {
-        for (int i = 0; i < 27; ++i)
-            data[i] = ptr[i];
-    }
+    constexpr wrap_argument(int const *ptr)
+        : data{ptr[0],
+              ptr[1],
+              ptr[2],
+              ptr[3],
+              ptr[4],
+              ptr[5],
+              ptr[6],
+              ptr[7],
+              ptr[8],
+              ptr[9],
+              ptr[10],
+              ptr[11],
+              ptr[12],
+              ptr[13],
+              ptr[14],
+              ptr[15],
+              ptr[16],
+              ptr[17],
+              ptr[18],
+              ptr[19],
+              ptr[20],
+              ptr[21],
+              ptr[22],
+              ptr[23],
+              ptr[24],
+              ptr[25],
+              ptr[26]} {}
 
     constexpr int &operator[](int i) { return data[i]; }
 

From 5a4d0a0bd0d80f519d03a1ba3f579bdcb985eb1d Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Mon, 3 Jan 2022 14:04:46 +0100
Subject: [PATCH 19/19] try to fix nvcc/gcc debug compilation

---
 include/gridtools/common/array.hpp       | 37 +++++-----
 include/gridtools/common/tuple.hpp       | 89 ++++++++++++------------
 include/gridtools/reduction/frontend.hpp |  8 ++-
 3 files changed, 69 insertions(+), 65 deletions(-)

diff --git a/include/gridtools/common/array.hpp b/include/gridtools/common/array.hpp
index 89f9228995..790faaa6e7 100644
--- a/include/gridtools/common/array.hpp
+++ b/include/gridtools/common/array.hpp
@@ -23,6 +23,7 @@
 #include "../meta/list.hpp"
 #include "../meta/macros.hpp"
 #include "../meta/repeat.hpp"
+#include "host_device.hpp"
 
 namespace gridtools {
 
@@ -58,28 +59,28 @@ namespace gridtools {
         using reverse_iterator = std::reverse_iterator<iterator>;
         using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
-        constexpr T const *begin() const { return &m_array[0]; }
+        GT_FORCE_INLINE constexpr T const *begin() const { return &m_array[0]; }
 
-        constexpr T *begin() { return &m_array[0]; }
+        GT_FORCE_INLINE constexpr T *begin() { return &m_array[0]; }
 
-        constexpr T const *end() const { return &m_array[D]; }
+        GT_FORCE_INLINE constexpr T const *end() const { return &m_array[D]; }
 
-        constexpr T *end() { return &m_array[D]; }
+        GT_FORCE_INLINE constexpr T *end() { return &m_array[D]; }
 
-        constexpr const T *data() const noexcept { return m_array; }
-        constexpr T *data() noexcept { return m_array; }
+        GT_FORCE_INLINE constexpr const T *data() const noexcept { return m_array; }
+        GT_FORCE_INLINE constexpr T *data() noexcept { return m_array; }
 
-        constexpr T const &operator[](size_t i) const { return m_array[i]; }
+        GT_FORCE_INLINE constexpr T const &operator[](size_t i) const { return m_array[i]; }
 
-        constexpr T &operator[](size_t i) { return m_array[i]; }
+        GT_FORCE_INLINE constexpr T &operator[](size_t i) { return m_array[i]; }
 
         template <typename A>
-        constexpr array &operator=(A const &a) {
+        GT_FORCE_INLINE constexpr array &operator=(A const &a) {
             std::copy(a.begin(), a.end(), m_array);
             return *this;
         }
 
-        static constexpr size_t size() { return D; }
+        static GT_FORCE_INLINE constexpr size_t size() { return D; }
     };
 
     template <class T, class... Ts>
@@ -101,19 +102,19 @@ namespace gridtools {
 
         struct getter {
             template <size_t I, typename T, size_t D>
-            static constexpr T &get(array<T, D> &arr) noexcept {
+            static GT_FORCE_INLINE constexpr T &get(array<T, D> &arr) noexcept {
                 static_assert(I < D, "index is out of bounds");
                 return arr.m_array[I];
             }
 
             template <size_t I, typename T, size_t D>
-            static constexpr const T &get(const array<T, D> &arr) noexcept {
+            static GT_FORCE_INLINE constexpr const T &get(const array<T, D> &arr) noexcept {
                 static_assert(I < D, "index is out of bounds");
                 return arr.m_array[I];
             }
 
             template <size_t I, typename T, size_t D>
-            static constexpr T &&get(array<T, D> &&arr) noexcept {
+            static GT_FORCE_INLINE constexpr T &&get(array<T, D> &&arr) noexcept {
                 static_assert(I < D, "index is out of bounds");
                 return std::move(arr.m_array[I]);
             }
@@ -131,7 +132,7 @@ namespace gridtools {
 
     // in case we need a constexpr version we need to implement a recursive one for c++11
     template <typename T, typename U, size_t D>
-    constexpr bool operator==(array<T, D> const &a, array<U, D> const &b) {
+    GT_FORCE_INLINE constexpr bool operator==(array<T, D> const &a, array<U, D> const &b) {
 #ifndef __GNUC__
 #pragma unroll
 #endif
@@ -143,7 +144,7 @@ namespace gridtools {
     }
 
     template <typename T, typename U, size_t D>
-    constexpr bool operator!=(array<T, D> const &a, array<U, D> const &b) {
+    GT_FORCE_INLINE constexpr bool operator!=(array<T, D> const &a, array<U, D> const &b) {
         return !(a == b);
     }
 
@@ -160,19 +161,19 @@ namespace gridtools {
     struct is_array_of<array<Value, D>, Value> : std::true_type {};
 
     template <size_t I, typename T, size_t D>
-    constexpr T &get(array<T, D> &arr) noexcept {
+    GT_FORCE_INLINE constexpr T &get(array<T, D> &arr) noexcept {
         static_assert(I < D, "index is out of bounds");
         return arr.m_array[I];
     }
 
     template <size_t I, typename T, size_t D>
-    constexpr const T &get(const array<T, D> &arr) noexcept {
+    GT_FORCE_INLINE constexpr const T &get(const array<T, D> &arr) noexcept {
         static_assert(I < D, "index is out of bounds");
         return arr.m_array[I];
     }
 
     template <size_t I, typename T, size_t D>
-    constexpr T &&get(array<T, D> &&arr) noexcept {
+    GT_FORCE_INLINE constexpr T &&get(array<T, D> &&arr) noexcept {
         static_assert(I < D, "index is out of bounds");
         return std::move(get<I>(arr));
     }
diff --git a/include/gridtools/common/tuple.hpp b/include/gridtools/common/tuple.hpp
index 0895ea95ee..56667937ea 100644
--- a/include/gridtools/common/tuple.hpp
+++ b/include/gridtools/common/tuple.hpp
@@ -15,6 +15,7 @@
 #include <type_traits>
 
 #include "../meta/at.hpp"
+#include "host_device.hpp"
 
 namespace gridtools {
 
@@ -28,10 +29,10 @@ namespace gridtools {
             tuple_leaf &operator=(tuple_leaf const &) = default;
             tuple_leaf &operator=(tuple_leaf &&) = default;
 
-            constexpr tuple_leaf() noexcept : m_value() {}
+            GT_FORCE_INLINE constexpr tuple_leaf() noexcept : m_value() {}
 
             template <class Arg, std::enable_if_t<std::is_constructible<T, Arg &&>::value, int> = 0>
-            constexpr tuple_leaf(Arg &&arg) noexcept : m_value(std::forward<Arg>(arg)) {}
+            GT_FORCE_INLINE constexpr tuple_leaf(Arg &&arg) noexcept : m_value(std::forward<Arg>(arg)) {}
         };
 
         template <size_t I, class T>
@@ -43,37 +44,37 @@ namespace gridtools {
             tuple_leaf &operator=(tuple_leaf &&) = default;
 
             template <class Arg, std::enable_if_t<std::is_constructible<T, Arg &&>::value, int> = 0>
-            constexpr tuple_leaf(Arg &&arg) noexcept : T(std::forward<Arg>(arg)) {}
+            GT_FORCE_INLINE constexpr tuple_leaf(Arg &&arg) noexcept : T(std::forward<Arg>(arg)) {}
         };
 
         struct tuple_leaf_getter {
             template <size_t I, class T>
-            static constexpr T const &get(tuple_leaf<I, T, false> const &obj) noexcept {
+            static GT_FORCE_INLINE constexpr T const &get(tuple_leaf<I, T, false> const &obj) noexcept {
                 return obj.m_value;
             }
 
             template <size_t I, class T>
-            static constexpr T &get(tuple_leaf<I, T, false> &obj) noexcept {
+            static GT_FORCE_INLINE constexpr T &get(tuple_leaf<I, T, false> &obj) noexcept {
                 return obj.m_value;
             }
 
             template <size_t I, class T>
-            static constexpr T&& get(tuple_leaf<I, T, false> &&obj) noexcept {
+            static GT_FORCE_INLINE constexpr T &&get(tuple_leaf<I, T, false> &&obj) noexcept {
                 return static_cast<T &&>(get<I>(obj));
             }
 
             template <size_t I, class T>
-            static constexpr T const &get(tuple_leaf<I, T, true> const &obj) noexcept {
+            static GT_FORCE_INLINE constexpr T const &get(tuple_leaf<I, T, true> const &obj) noexcept {
                 return obj;
             }
 
             template <size_t I, class T>
-            static constexpr T &get(tuple_leaf<I, T, true> &obj) noexcept {
+            static GT_FORCE_INLINE constexpr T &get(tuple_leaf<I, T, true> &obj) noexcept {
                 return obj;
             }
 
             template <size_t I, class T>
-            static constexpr T&& get(tuple_leaf<I, T, true> &&obj) noexcept {
+            static GT_FORCE_INLINE constexpr T &&get(tuple_leaf<I, T, true> &&obj) noexcept {
                 return static_cast<T &&>(obj);
             }
         };
@@ -90,14 +91,14 @@ namespace gridtools {
             tuple_impl &operator=(tuple_impl &&) = default;
 
             template <class... Args>
-            constexpr tuple_impl(Args &&... args) noexcept
+            GT_FORCE_INLINE constexpr tuple_impl(Args &&...args) noexcept
                 : tuple_leaf<Is, Ts>(std::forward<Args>(args))... {}
 
             template <class Src>
-            constexpr tuple_impl(Src &&src) noexcept
+            GT_FORCE_INLINE constexpr tuple_impl(Src &&src) noexcept
                 : tuple_leaf<Is, Ts>(tuple_leaf_getter::get<Is>(std::forward<Src>(src)))... {}
 
-            constexpr void swap(tuple_impl &other) noexcept {
+            GT_FORCE_INLINE constexpr void swap(tuple_impl &other) noexcept {
                 using std::swap;
                 (..., swap(tuple_leaf_getter::get<Is>(*this), tuple_leaf_getter::get<Is>(other)));
             }
@@ -106,18 +107,16 @@ namespace gridtools {
                 std::enable_if_t<sizeof...(Ts) == sizeof...(Args) &&
                                      std::conjunction<std::is_assignable<Ts &, Args const &>...>::value,
                     int> = 0>
-            constexpr void assign(tuple_impl<std::index_sequence<Is...>, Args...> const &src) noexcept {
-                using loop_t = int[sizeof...(Is)];
-                void(loop_t{(tuple_leaf_getter::get<Is>(*this) = tuple_leaf_getter::get<Is>(src), 0)...});
+            GT_FORCE_INLINE constexpr void assign(tuple_impl<std::index_sequence<Is...>, Args...> const &src) noexcept {
+                (..., (tuple_leaf_getter::get<Is>(*this) = tuple_leaf_getter::get<Is>(src)));
             }
 
             template <class... Args,
                 std::enable_if_t<sizeof...(Ts) == sizeof...(Args) &&
                                      std::conjunction<std::is_assignable<Ts &, Args &&>...>::value,
                     int> = 0>
-            constexpr void assign(tuple_impl<std::index_sequence<Is...>, Args...> &&src) noexcept {
-                using loop_t = int[sizeof...(Is)];
-                void(loop_t{(tuple_leaf_getter::get<Is>(*this) = tuple_leaf_getter::get<Is>(std::move(src)), 0)...});
+            GT_FORCE_INLINE constexpr void assign(tuple_impl<std::index_sequence<Is...>, Args...> &&src) noexcept {
+                (..., (tuple_leaf_getter::get<Is>(*this) = tuple_leaf_getter::get<Is>(std::move(src))));
             }
         };
     } // namespace impl_
@@ -143,17 +142,17 @@ namespace gridtools {
 
         struct getter {
             template <size_t I>
-            static constexpr decltype(auto) get(tuple const &obj) noexcept {
+            static GT_FORCE_INLINE constexpr decltype(auto) get(tuple const &obj) noexcept {
                 return impl_::tuple_leaf_getter::get<I>(obj.m_impl);
             }
 
             template <size_t I>
-            static constexpr decltype(auto) get(tuple &obj) noexcept {
+            static GT_FORCE_INLINE constexpr decltype(auto) get(tuple &obj) noexcept {
                 return impl_::tuple_leaf_getter::get<I>(obj.m_impl);
             }
 
             template <size_t I>
-            static constexpr decltype(auto) get(tuple &&obj) noexcept {
+            static GT_FORCE_INLINE constexpr decltype(auto) get(tuple &&obj) noexcept {
                 return impl_::tuple_leaf_getter::get<I>(std::move(obj.m_impl));
             }
         };
@@ -169,30 +168,30 @@ namespace gridtools {
         tuple &operator=(tuple const &) = default;
         tuple &operator=(tuple &&) = default;
 
-        constexpr tuple(Ts const &... args) noexcept : m_impl(args...) {}
+        GT_FORCE_INLINE constexpr tuple(Ts const &...args) noexcept : m_impl(args...) {}
 
         template <class... Args,
             std::enable_if_t<sizeof...(Ts) == sizeof...(Args) &&
                                  std::conjunction<std::is_constructible<Ts, Args &&>...>::value,
                 int> = 0>
-        constexpr tuple(Args &&...args) noexcept : m_impl(std::forward<Args>(args)...) {}
+        GT_FORCE_INLINE constexpr tuple(Args &&...args) noexcept : m_impl(std::forward<Args>(args)...) {}
 
         template <class... Args,
             std::enable_if_t<sizeof...(Ts) == sizeof...(Args) &&
                                  std::conjunction<std::is_constructible<Ts, Args const &>...>::value,
                 int> = 0>
-        constexpr tuple(tuple<Args...> const &src) noexcept : m_impl(src.m_impl) {}
+        GT_FORCE_INLINE constexpr tuple(tuple<Args...> const &src) noexcept : m_impl(src.m_impl) {}
 
         template <class... Args,
             std::enable_if_t<sizeof...(Ts) == sizeof...(Args) &&
                                  std::conjunction<std::is_constructible<Ts, Args &&>...>::value,
                 int> = 0>
-        constexpr tuple(tuple<Args...> &&src) noexcept : m_impl(std::move(src).m_impl) {}
+        GT_FORCE_INLINE constexpr tuple(tuple<Args...> &&src) noexcept : m_impl(std::move(src).m_impl) {}
 
-        constexpr void swap(tuple &other) noexcept { m_impl.swap(other.m_impl); }
+        GT_FORCE_INLINE constexpr void swap(tuple &other) noexcept { m_impl.swap(other.m_impl); }
 
         template <class Other>
-        constexpr tuple &operator=(Other &&other) {
+        GT_FORCE_INLINE constexpr tuple &operator=(Other &&other) {
             m_impl.assign(std::forward<Other>(other).m_impl);
             return *this;
         }
@@ -203,64 +202,64 @@ namespace gridtools {
         T m_value;
         struct getter {
             template <size_t I, std::enable_if_t<I == 0, int> = 0>
-            static constexpr T const &get(tuple const &obj) noexcept {
+            static GT_FORCE_INLINE constexpr T const &get(tuple const &obj) noexcept {
                 return obj.m_value;
             }
 
             template <size_t I, std::enable_if_t<I == 0, int> = 0>
-            static constexpr T &get(tuple &obj) noexcept {
+            static GT_FORCE_INLINE constexpr T &get(tuple &obj) noexcept {
                 return obj.m_value;
             }
 
             template <size_t I, std::enable_if_t<I == 0, int> = 0>
-            static constexpr T &&get(tuple &&obj) noexcept {
+            static GT_FORCE_INLINE constexpr T &&get(tuple &&obj) noexcept {
                 return static_cast<T &&>(obj.m_value);
             }
         };
         friend getter tuple_getter(tuple const &) { return {}; }
 
-        template <class...> 
+        template <class...>
         friend class tuple;
 
       public:
-        constexpr tuple() noexcept : m_value() {}
+        GT_FORCE_INLINE constexpr tuple() noexcept : m_value() {}
 
         tuple(tuple const &) = default;
         tuple(tuple &&) = default;
         tuple &operator=(tuple const &) = default;
-        tuple &operator=(tuple &&) = default; 
+        tuple &operator=(tuple &&) = default;
 
-        constexpr tuple(T const &arg) noexcept : m_value(arg) {}
+        GT_FORCE_INLINE constexpr tuple(T const &arg) noexcept : m_value(arg) {}
 
         template <class Arg, std::enable_if_t<std::is_constructible<T, Arg &&>::value, int> = 0>
-        constexpr tuple(Arg &&arg) noexcept : m_value(std::forward<Arg>(arg)) {}
+        GT_FORCE_INLINE constexpr tuple(Arg &&arg) noexcept : m_value(std::forward<Arg>(arg)) {}
 
         template <class Arg,
             std::enable_if_t<std::is_constructible<T, Arg const &>::value &&
                                  !std::is_convertible<tuple<Arg> const &, T>::value &&
                                  !std::is_constructible<T, tuple<Arg> const &>::value && !std::is_same<T, Arg>::value,
                 int> = 0>
-        constexpr tuple(tuple<Arg> const &src) noexcept : m_value(src.m_value) {}
+        GT_FORCE_INLINE constexpr tuple(tuple<Arg> const &src) noexcept : m_value(src.m_value) {}
 
         template <class Arg,
             std::enable_if_t<std::is_constructible<T, Arg &&>::value && !std::is_convertible<tuple<Arg>, T>::value &&
                                  !std::is_constructible<T, tuple<Arg>>::value && !std::is_same<T, Arg>::value,
                 int> = 0>
-        constexpr tuple(tuple<Arg> &&src) noexcept : m_value(std::move(src).m_value) {}
+        GT_FORCE_INLINE constexpr tuple(tuple<Arg> &&src) noexcept : m_value(std::move(src).m_value) {}
 
-        constexpr void swap(tuple &other) noexcept {
+        GT_FORCE_INLINE constexpr void swap(tuple &other) noexcept {
             using std::swap;
             swap(m_value, other.m_value);
         }
 
         template <class Arg, std::enable_if_t<std::is_assignable<T &, Arg const &>::value, int> = 0>
-        constexpr tuple &operator=(tuple<Arg> const &src) noexcept {
+        GT_FORCE_INLINE constexpr tuple &operator=(tuple<Arg> const &src) noexcept {
             m_value = src.m_value;
             return *this;
         }
 
         template <class Arg, std::enable_if_t<std::is_assignable<T &, Arg &&>::value, int> = 0>
-        constexpr tuple &operator=(tuple<Arg> &&src) noexcept {
+        GT_FORCE_INLINE constexpr tuple &operator=(tuple<Arg> &&src) noexcept {
             m_value = std::move(src).m_value;
             return *this;
         }
@@ -271,26 +270,26 @@ namespace gridtools {
         friend tuple tuple_getter(tuple const &) { return {}; }
 
       public:
-        constexpr void swap(tuple &) noexcept {}
+        GT_FORCE_INLINE constexpr void swap(tuple &) noexcept {}
     };
 
     template <class... Ts>
-    constexpr void swap(tuple<Ts...> &lhs, tuple<Ts...> &rhs) noexcept {
+    GT_FORCE_INLINE constexpr void swap(tuple<Ts...> &lhs, tuple<Ts...> &rhs) noexcept {
         lhs.swap(rhs);
     }
 
     template <size_t I, class... Ts>
-    constexpr decltype(auto) get(tuple<Ts...> const &obj) noexcept {
+    GT_FORCE_INLINE constexpr decltype(auto) get(tuple<Ts...> const &obj) noexcept {
         return decltype(tuple_getter(obj))::template get<I>(obj);
     }
 
     template <size_t I, class... Ts>
-    constexpr decltype(auto) get(tuple<Ts...> &obj) noexcept {
+    GT_FORCE_INLINE constexpr decltype(auto) get(tuple<Ts...> &obj) noexcept {
         return decltype(tuple_getter(std::declval<tuple<Ts...> const &>()))::template get<I>(obj);
     }
 
     template <size_t I, class... Ts>
-    constexpr decltype(auto) get(tuple<Ts...> &&obj) noexcept {
+    GT_FORCE_INLINE constexpr decltype(auto) get(tuple<Ts...> &&obj) noexcept {
         return decltype(tuple_getter(std::declval<tuple<Ts...> const &>()))::template get<I>(std::move(obj));
     }
 } // namespace gridtools
diff --git a/include/gridtools/reduction/frontend.hpp b/include/gridtools/reduction/frontend.hpp
index 6aeda287ba..d0889400d8 100644
--- a/include/gridtools/reduction/frontend.hpp
+++ b/include/gridtools/reduction/frontend.hpp
@@ -32,6 +32,11 @@ namespace gridtools {
             template <class Sizes>
             using zeros_type = decltype(zeros(std::declval<Sizes const &>()));
 
+            template <class StorageTraits>
+            struct alloc_fun {
+                auto operator()(size_t size) const { return storage::traits::allocate<StorageTraits, char>(size); }
+            };
+
             template <class Backend, class T, class Origin, class Strides, class StridesKind, class Sizes>
             struct reducible {
                 std::shared_ptr<void> m_alloc;
@@ -58,8 +63,7 @@ namespace gridtools {
 
             template <class Backend, class StorageTraits, class Id = void, class T, class... Dims>
             auto make_reducible(T const &neutral_value, Dims... dims) {
-                auto alloc = sid::cached_allocator(
-                    [](size_t size) { return storage::traits::allocate<StorageTraits, char>(size); });
+                sid::cached_allocator<alloc_fun<StorageTraits>> alloc;
                 auto lengths = tuple(dims...);
                 auto info = storage::traits::make_info<StorageTraits, T>(lengths);
                 auto strides = info.native_strides();