diff --git a/include/xtensor/core/xassign.hpp b/include/xtensor/core/xassign.hpp
index 904113814..d3339cf5f 100644
--- a/include/xtensor/core/xassign.hpp
+++ b/include/xtensor/core/xassign.hpp
@@ -214,7 +214,7 @@ namespace xt
     template <class E1, class E2>
     inline void assign_xexpression(xexpression<E1>& e1, const xexpression<E2>& e2)
     {
-        if constexpr (has_assign_to<E1, E2>::value)
+        if constexpr (has_assign_to<E1, E2>())
         {
             e2.derived_cast().assign_to(e1);
         }
@@ -266,15 +266,14 @@ namespace xt
         }
 
         template <class E1, class E2>
-        inline auto is_linear_assign(const E1& e1, const E2& e2)
-            -> std::enable_if_t<has_strides<E1>::value, bool>
+        inline auto is_linear_assign(const E1& e1, const E2& e2) -> std::enable_if_t<has_strides<E1>(), bool>
         {
             return (E1::contiguous_layout && E2::contiguous_layout && linear_static_layout<E1, E2>())
                    || (e1.is_contiguous() && e2.has_linear_assign(e1.strides()));
         }
 
         template <class E1, class E2>
-        inline auto is_linear_assign(const E1&, const E2&) -> std::enable_if_t<!has_strides<E1>::value, bool>
+        inline auto is_linear_assign(const E1&, const E2&) -> std::enable_if_t<!has_strides<E1>(), bool>
         {
             return false;
         }
@@ -304,8 +303,8 @@ namespace xt
                 return std::is_reference<typename T::stepper::reference>::value;
             }
 
-            static constexpr bool value = has_strides<T>::value
-                                          && has_step_leading<typename T::stepper>::value && stepper_deref();
+            static constexpr bool value = has_strides<T>() && has_step_leading<typename T::stepper>::value
+                                          && stepper_deref();
         };
 
         template <class T>
@@ -1002,13 +1001,13 @@ namespace xt
             const strides_type& m_strides;
         };
 
-        template <bool possible = true, class E1, class E2, std::enable_if_t<!has_strides<E1>::value || !possible, bool> = true>
+        template <bool possible = true, class E1, class E2, std::enable_if_t<!has_strides<E1>() || !possible, bool> = true>
         loop_sizes_t get_loop_sizes(const E1& e1, const E2&)
         {
             return {false, true, 1, e1.size(), e1.dimension(), e1.dimension()};
         }
 
-        template <bool possible = true, class E1, class E2, std::enable_if_t<has_strides<E1>::value && possible, bool> = true>
+        template <bool possible = true, class E1, class E2, std::enable_if_t<has_strides<E1>() && possible, bool> = true>
         loop_sizes_t get_loop_sizes(const E1& e1, const E2& e2)
         {
             using shape_value_type = typename E1::shape_type::value_type;
diff --git a/include/xtensor/core/xeval.hpp b/include/xtensor/core/xeval.hpp
index 5ccbc1db9..f54987635 100644
--- a/include/xtensor/core/xeval.hpp
+++ b/include/xtensor/core/xeval.hpp
@@ -147,7 +147,7 @@ namespace xt
      */
     template <layout_type L = layout_type::any, class E>
     inline auto as_strided(E&& e)
-        -> std::enable_if_t<has_data_interface<std::decay_t<E>>::value && detail::has_same_layout<L, E>(), E&&>
+        -> std::enable_if_t<has_data_interface<std::decay_t<E>>() && detail::has_same_layout<L, E>(), E&&>
     {
         return std::forward<E>(e);
     }
@@ -155,8 +155,7 @@ namespace xt
     /// @cond DOXYGEN_INCLUDE_SFINAE
     template <layout_type L = layout_type::any, class E>
     inline auto as_strided(E&& e) -> std::enable_if_t<
-        (!(has_data_interface<std::decay_t<E>>::value && detail::has_same_layout<L, E>()))
-            && detail::has_fixed_dims<E>(),
+        (!(has_data_interface<std::decay_t<E>>() && detail::has_same_layout<L, E>())) && detail::has_fixed_dims<E>(),
         detail::as_xtensor_container_t<E, L>>
     {
         return e;
@@ -164,7 +163,7 @@ namespace xt
 
     template <layout_type L = layout_type::any, class E>
     inline auto as_strided(E&& e) -> std::enable_if_t<
-        (!(has_data_interface<std::decay_t<E>>::value && detail::has_same_layout<L, E>()))
+        (!(has_data_interface<std::decay_t<E>>() && detail::has_same_layout<L, E>()))
             && (!detail::has_fixed_dims<E>()),
         detail::as_xarray_container_t<E, L>>
     {
diff --git a/include/xtensor/core/xexpression.hpp b/include/xtensor/core/xexpression.hpp
index 855c69706..75f4234d8 100644
--- a/include/xtensor/core/xexpression.hpp
+++ b/include/xtensor/core/xexpression.hpp
@@ -525,15 +525,16 @@ namespace xt
         using inner_shape_type = typename E::inner_shape_type;
         using shape_type = typename E::shape_type;
 
-        using strides_type = xtl::mpl::
-            eval_if_t<has_strides<E>, detail::expr_strides_type<E>, get_strides_type<shape_type>>;
-        using backstrides_type = xtl::mpl::
-            eval_if_t<has_strides<E>, detail::expr_backstrides_type<E>, get_strides_type<shape_type>>;
-        using inner_strides_type = xtl::mpl::
-            eval_if_t<has_strides<E>, detail::expr_inner_strides_type<E>, get_strides_type<shape_type>>;
-        using inner_backstrides_type = xtl::mpl::
-            eval_if_t<has_strides<E>, detail::expr_inner_backstrides_type<E>, get_strides_type<shape_type>>;
-        using storage_type = xtl::mpl::eval_if_t<has_storage_type<E>, detail::expr_storage_type<E>, make_invalid_type<>>;
+        using strides_type = typename std::
+            conditional_t<has_strides<E>(), detail::expr_strides_type<E>, get_strides_type<shape_type>>::type;
+        using backstrides_type = typename std::
+            conditional_t<has_strides<E>(), detail::expr_backstrides_type<E>, get_strides_type<shape_type>>::type;
+        using inner_strides_type = typename std::
+            conditional_t<has_strides<E>(), detail::expr_inner_strides_type<E>, get_strides_type<shape_type>>::type;
+        using inner_backstrides_type = typename std::
+            conditional_t<has_strides<E>(), detail::expr_inner_backstrides_type<E>, get_strides_type<shape_type>>::type;
+        using storage_type = typename std::
+            conditional_t<has_storage_type<E>(), detail::expr_storage_type<E>, make_invalid_type<>>::type;
 
         using stepper = typename E::stepper;
         using const_stepper = typename E::const_stepper;
@@ -638,43 +639,43 @@ namespace xt
         }
 
         template <class T = E>
-        std::enable_if_t<has_strides<T>::value, const inner_strides_type&> strides() const
+        std::enable_if_t<has_strides<T>(), const inner_strides_type&> strides() const
         {
             return m_ptr->strides();
         }
 
         template <class T = E>
-        std::enable_if_t<has_strides<T>::value, const inner_strides_type&> backstrides() const
+        std::enable_if_t<has_strides<T>(), const inner_strides_type&> backstrides() const
         {
             return m_ptr->backstrides();
         }
 
         template <class T = E>
-        std::enable_if_t<has_data_interface<T>::value, pointer> data() noexcept
+        std::enable_if_t<has_data_interface<T>(), pointer> data() noexcept
         {
             return m_ptr->data();
         }
 
         template <class T = E>
-        std::enable_if_t<has_data_interface<T>::value, pointer> data() const noexcept
+        std::enable_if_t<has_data_interface<T>(), pointer> data() const noexcept
         {
             return m_ptr->data();
         }
 
         template <class T = E>
-        std::enable_if_t<has_data_interface<T>::value, size_type> data_offset() const noexcept
+        std::enable_if_t<has_data_interface<T>(), size_type> data_offset() const noexcept
         {
             return m_ptr->data_offset();
         }
 
         template <class T = E>
-        std::enable_if_t<has_data_interface<T>::value, typename T::storage_type&> storage() noexcept
+        std::enable_if_t<has_data_interface<T>(), typename T::storage_type&> storage() noexcept
         {
             return m_ptr->storage();
         }
 
         template <class T = E>
-        std::enable_if_t<has_data_interface<T>::value, const typename T::storage_type&> storage() const noexcept
+        std::enable_if_t<has_data_interface<T>(), const typename T::storage_type&> storage() const noexcept
         {
             return m_ptr->storage();
         }
diff --git a/include/xtensor/core/xfunction.hpp b/include/xtensor/core/xfunction.hpp
index 6459e998d..929f9dc77 100644
--- a/include/xtensor/core/xfunction.hpp
+++ b/include/xtensor/core/xfunction.hpp
@@ -133,7 +133,7 @@ namespace xt
     struct xcontainer_inner_types<xfunction<F, CT...>>
     {
         // Added indirection for MSVC 2017 bug with the operator value_type()
-        using func_return_type = typename meta_identity<
+        using func_return_type = typename std::type_identity<
             decltype(std::declval<F>()(std::declval<xvalue_type_t<std::decay_t<CT>>>()...))>::type;
         using value_type = std::decay_t<func_return_type>;
         using reference = func_return_type;
@@ -156,7 +156,7 @@ namespace xt
     template <class E>
     struct overlapping_memory_checker_traits<
         E,
-        std::enable_if_t<!has_memory_address<E>::value && is_specialization_of<xfunction, E>::value>>
+        std::enable_if_t<!has_memory_address<E>() && is_specialization_of<xfunction, E>::value>>
     {
         template <std::size_t I = 0, class... T, std::enable_if_t<(I == sizeof...(T)), int> = 0>
         static bool check_tuple(const std::tuple<T...>&, const memory_range&)
diff --git a/include/xtensor/core/xiterable.hpp b/include/xtensor/core/xiterable.hpp
index 14d386207..1abdc1220 100644
--- a/include/xtensor/core/xiterable.hpp
+++ b/include/xtensor/core/xiterable.hpp
@@ -293,7 +293,7 @@ namespace xt
         };
 
         template <class D>
-        using linear_iterator_traits = linear_iterator_traits_impl<D, has_storage_type<D>::value>;
+        using linear_iterator_traits = linear_iterator_traits_impl<D, has_storage_type<D>()>;
     }
 
     /**
diff --git a/include/xtensor/core/xmath.hpp b/include/xtensor/core/xmath.hpp
index 827e84219..16fe8bcc9 100644
--- a/include/xtensor/core/xmath.hpp
+++ b/include/xtensor/core/xmath.hpp
@@ -350,13 +350,13 @@ namespace xt
     namespace detail
     {
         template <class R, class T>
-        std::enable_if_t<!has_iterator_interface<R>::value, R> fill_init(T init)
+        std::enable_if_t<!has_iterator_interface<R>(), R> fill_init(T init)
         {
             return R(init);
         }
 
         template <class R, class T>
-        std::enable_if_t<has_iterator_interface<R>::value, R> fill_init(T init)
+        std::enable_if_t<has_iterator_interface<R>(), R> fill_init(T init)
         {
             R result;
             std::fill(std::begin(result), std::end(result), init);
diff --git a/include/xtensor/core/xsemantic.hpp b/include/xtensor/core/xsemantic.hpp
index bafad4aca..8a7bca37e 100644
--- a/include/xtensor/core/xsemantic.hpp
+++ b/include/xtensor/core/xsemantic.hpp
@@ -224,7 +224,7 @@ namespace xt
     template <class E>
     struct overlapping_memory_checker_traits<
         E,
-        std::enable_if_t<!has_memory_address<E>::value && is_crtp_base_of<xview_semantic, E>::value>>
+        std::enable_if_t<!has_memory_address<E>() && is_crtp_base_of<xview_semantic, E>::value>>
     {
         static bool check_overlap(const E& expr, const memory_range& dst_range)
         {
diff --git a/include/xtensor/core/xshape.hpp b/include/xtensor/core/xshape.hpp
index 6988e69f3..e395d6157 100644
--- a/include/xtensor/core/xshape.hpp
+++ b/include/xtensor/core/xshape.hpp
@@ -138,7 +138,7 @@ namespace xt
      * @param shape the shape to test
      * @return bool
      */
-    template <class E, class S, class = typename std::enable_if_t<has_iterator_interface<S>::value>>
+    template <class E, class S, class = typename std::enable_if_t<has_iterator_interface<S>()>>
     inline bool has_shape(const E& e, const S& shape)
     {
         return e.shape().size() == shape.size()
diff --git a/include/xtensor/misc/xmanipulation.hpp b/include/xtensor/misc/xmanipulation.hpp
index e20095f3e..9272f4c7c 100644
--- a/include/xtensor/misc/xmanipulation.hpp
+++ b/include/xtensor/misc/xmanipulation.hpp
@@ -214,7 +214,7 @@ namespace xt
         template <class E, class S, class X>
         inline void compute_transposed_strides(E&& e, const S& shape, X& strides)
         {
-            if constexpr (has_data_interface<std::decay_t<E>>::value)
+            if constexpr (has_data_interface<std::decay_t<E>>())
             {
                 std::copy(e.strides().crbegin(), e.strides().crend(), strides.begin());
             }
diff --git a/include/xtensor/utils/xutils.hpp b/include/xtensor/utils/xutils.hpp
index e93d8e688..ee302bde1 100644
--- a/include/xtensor/utils/xutils.hpp
+++ b/include/xtensor/utils/xutils.hpp
@@ -101,16 +101,6 @@ namespace xt
     template <class T, class R>
     using disable_integral_t = std::enable_if_t<!xtl::is_integral<T>::value, R>;
 
-    /********************************
-     * meta identity implementation *
-     ********************************/
-
-    template <class T>
-    struct meta_identity
-    {
-        using type = T;
-    };
-
     /***************************************
      * is_specialization_of implementation *
      ***************************************/
@@ -370,14 +360,16 @@ namespace xt
             res[i] = normalize_axis(expr.dimension(), axes[i]);
         }
 
-        XTENSOR_ASSERT(std::all_of(
-            res.begin(),
-            res.end(),
-            [&expr](auto ax_el)
-            {
-                return ax_el < expr.dimension();
-            }
-        ));
+        XTENSOR_ASSERT(
+            std::all_of(
+                res.begin(),
+                res.end(),
+                [&expr](auto ax_el)
+                {
+                    return ax_el < expr.dimension();
+                }
+            )
+        );
 
         return res;
     }
@@ -389,14 +381,16 @@ namespace xt
     normalize_axis(E& expr, C&& axes)
     {
         static_cast<void>(expr);
-        XTENSOR_ASSERT(std::all_of(
-            axes.begin(),
-            axes.end(),
-            [&expr](auto ax_el)
-            {
-                return ax_el < expr.dimension();
-            }
-        ));
+        XTENSOR_ASSERT(
+            std::all_of(
+                axes.begin(),
+                axes.end(),
+                [&expr](auto ax_el)
+                {
+                    return ax_el < expr.dimension();
+                }
+            )
+        );
         return std::forward<C>(axes);
     }
 
@@ -417,14 +411,16 @@ namespace xt
             }
         );
 
-        XTENSOR_ASSERT(std::all_of(
-            res.begin(),
-            res.end(),
-            [&expr](auto ax_el)
-            {
-                return ax_el < expr.dimension();
-            }
-        ));
+        XTENSOR_ASSERT(
+            std::all_of(
+                res.begin(),
+                res.end(),
+                [&expr](auto ax_el)
+                {
+                    return ax_el < expr.dimension();
+                }
+            )
+        );
 
         return res;
     }
@@ -439,14 +435,16 @@ namespace xt
         R res;
         xt::resize_container(res, std::size(axes));
         std::copy(std::begin(axes), std::end(axes), std::begin(res));
-        XTENSOR_ASSERT(std::all_of(
-            res.begin(),
-            res.end(),
-            [&expr](auto ax_el)
-            {
-                return ax_el < expr.dimension();
-            }
-        ));
+        XTENSOR_ASSERT(
+            std::all_of(
+                res.begin(),
+                res.end(),
+                [&expr](auto ax_el)
+                {
+                    return ax_el < expr.dimension();
+                }
+            )
+        );
         return res;
     }
 
@@ -456,14 +454,16 @@ namespace xt
         R&&>
     {
         static_cast<void>(expr);
-        XTENSOR_ASSERT(std::all_of(
-            std::begin(axes),
-            std::end(axes),
-            [&expr](auto ax_el)
-            {
-                return ax_el < expr.dimension();
-            }
-        ));
+        XTENSOR_ASSERT(
+            std::all_of(
+                std::begin(axes),
+                std::end(axes),
+                [&expr](auto ax_el)
+                {
+                    return ax_el < expr.dimension();
+                }
+            )
+        );
         return std::move(axes);
     }
 
@@ -471,20 +471,21 @@ namespace xt
      * get_value_type *
      ******************/
 
-    template <class T, class = void_t<>>
-    struct get_value_type
-    {
-        using type = T;
-    };
-
     template <class T>
-    struct get_value_type<T, void_t<typename T::value_type>>
+    constexpr auto get_value_type()
     {
-        using type = typename T::value_type;
-    };
+        if constexpr (requires { typename T::value_type; })
+        {
+            return std::type_identity<typename T::value_type>{};
+        }
+        else
+        {
+            return std::type_identity<T>{};
+        }
+    }
 
     template <class T>
-    using get_value_type_t = typename get_value_type<T>::type;
+    using get_value_type_t = typename decltype(get_value_type<T>())::type;
 
     /**********************
      * get implementation *
@@ -533,81 +534,70 @@ namespace xt
      * has_storage_type implementation *
      ***********************************/
 
-    template <class T, class = void>
-    struct has_storage_type : std::false_type
-    {
-    };
-
     template <class T>
     struct xcontainer_inner_types;
 
     template <class T>
-    struct has_storage_type<T, void_t<typename xcontainer_inner_types<T>::storage_type>>
-        : std::negation<
-              std::is_same<typename std::remove_cv<typename xcontainer_inner_types<T>::storage_type>::type, invalid_type>>
-    {
+    concept has_storage_type_concept = requires {
+        typename xcontainer_inner_types<T>::storage_type;
+        requires !std::is_same_v<typename std::remove_cv<typename xcontainer_inner_types<T>::storage_type>::type, invalid_type>;
     };
 
+    template <class T>
+    constexpr bool has_storage_type()
+    {
+        return has_storage_type_concept<T>;
+    }
+
     /*************************************
      * has_data_interface implementation *
      *************************************/
 
-    template <class E, class = void>
-    struct has_data_interface : std::false_type
-    {
-    };
-
     template <class E>
-    struct has_data_interface<E, void_t<decltype(std::declval<E>().data())>> : std::true_type
-    {
-    };
+    concept has_data_interface_concept = requires { std::declval<E>().data(); };
 
     template <class E>
-    concept has_data_interface_concept = has_data_interface<E>::value;
-
-    template <class E, class = void>
-    struct has_strides : std::false_type
+    constexpr bool has_data_interface()
     {
-    };
+        return has_data_interface_concept<E>;
+    }
 
     template <class E>
-    struct has_strides<E, void_t<decltype(std::declval<E>().strides())>> : std::true_type
-    {
-    };
+    concept has_strides_concept = requires { std::declval<E>().strides(); };
 
-    template <class E, class = void>
-    struct has_iterator_interface : std::false_type
+    template <class E>
+    constexpr bool has_strides()
     {
-    };
+        return has_strides_concept<E>;
+    }
 
     template <class E>
-    struct has_iterator_interface<E, void_t<decltype(std::declval<E>().begin())>> : std::true_type
-    {
-    };
+    concept has_iterator_interface_concept = requires { std::declval<E>().begin(); };
 
     template <class E>
-    concept has_iterator_interface_concept = has_iterator_interface<E>::value;
+    constexpr bool has_iterator_interface()
+    {
+        return has_iterator_interface_concept<E>;
+    }
 
     /******************************
      * is_iterator implementation *
      ******************************/
 
-    template <class E, class = void>
-    struct is_iterator : std::false_type
-    {
+    template <typename E>
+    concept iterator_concept = requires {
+        *std::declval<const E>();
+        std::declval<const E>() == std::declval<const E>();
+        std::declval<const E>() != std::declval<const E>();
+        ++(*std::declval<E*>());
+        (*std::declval<E*>())++;
     };
 
     template <class E>
-    struct is_iterator<
-        E,
-        void_t<
-            decltype(*std::declval<const E>(), std::declval<const E>() == std::declval<const E>(), std::declval<const E>() != std::declval<const E>(), ++(*std::declval<E*>()), (*std::declval<E*>())++, std::true_type())>>
-        : std::true_type
+    constexpr bool is_iterator()
     {
-    };
-
-    template <typename E>
-    concept iterator_concept = is_iterator<E>::value;
+        return iterator_concept<E>;
+    }
 
     /*************************
      * conditional type cast *
@@ -739,38 +729,35 @@ namespace xt
      * has_assign_to *
      *****************/
 
-    template <class E1, class E2, class = void>
-    struct has_assign_to : std::false_type
-    {
-    };
+    template <class E1, class E2>
+    concept has_assign_to_concept = requires { std::declval<const E2&>().assign_to(std::declval<E1&>()); };
 
     template <class E1, class E2>
-    struct has_assign_to<E1, E2, void_t<decltype(std::declval<const E2&>().assign_to(std::declval<E1&>()))>>
-        : std::true_type
+    constexpr bool has_assign_to()
     {
-    };
+        return has_assign_to_concept<E1, E2>;
+    }
 
     template <class E1, class E2>
-    constexpr bool has_assign_to_v = has_assign_to<E1, E2>::value;
+    constexpr bool has_assign_to_v = has_assign_to<E1, E2>();
 
     /*************************************
      * overlapping_memory_checker_traits *
      *************************************/
 
-    template <class T, class Enable = void>
-    struct has_memory_address : std::false_type
-    {
-    };
+    template <class T>
+    concept has_memory_address_concept = requires { std::addressof(*std::declval<T>().begin()); };
 
     template <class T>
-    struct has_memory_address<T, void_t<decltype(std::addressof(*std::declval<T>().begin()))>> : std::true_type
+    constexpr bool has_memory_address()
     {
-    };
+        return has_memory_address_concept<T>;
+    }
 
     template <typename T>
-    concept with_memory_address_concept = has_memory_address<std::decay_t<T>>::value;
+    concept with_memory_address_concept = has_memory_address_concept<std::decay_t<T>>;
     template <typename T>
-    concept without_memory_address_concept = !has_memory_address<std::decay_t<T>>::value;
+    concept without_memory_address_concept = !has_memory_address_concept<std::decay_t<T>>;
 
     struct memory_range
     {
@@ -814,7 +801,7 @@ namespace xt
     };
 
     template <class E>
-    struct overlapping_memory_checker_traits<E, std::enable_if_t<has_memory_address<E>::value>>
+    struct overlapping_memory_checker_traits<E, std::enable_if_t<has_memory_address<E>()>>
     {
         static bool check_overlap(const E& expr, const memory_range& dst_range)
         {
@@ -864,23 +851,23 @@ namespace xt
     };
 
     template <class Dst>
-    struct overlapping_memory_checker<Dst, std::enable_if_t<has_memory_address<Dst>::value>>
+    struct overlapping_memory_checker<Dst, std::enable_if_t<has_memory_address<Dst>()>>
         : overlapping_memory_checker_base
     {
         explicit overlapping_memory_checker(const Dst& aDst)
             : overlapping_memory_checker_base(
-                [&]()
-                {
-                    if (aDst.size() == 0)
-                    {
-                        return memory_range();
-                    }
-                    else
-                    {
-                        return memory_range(std::addressof(*aDst.begin()), std::addressof(*aDst.rbegin()));
-                    }
-                }()
-            )
+                  [&]()
+                  {
+                      if (aDst.size() == 0)
+                      {
+                          return memory_range();
+                      }
+                      else
+                      {
+                          return memory_range(std::addressof(*aDst.begin()), std::addressof(*aDst.rbegin()));
+                      }
+                  }()
+              )
         {
         }
     };
@@ -918,102 +905,120 @@ namespace xt
     };
 #endif
 
-    /********************
-     * get_strides_type *
-     ********************/
+    /***************
+     * get_strides *
+     ***************/
 
-    template <class S>
-    struct get_strides_type
-    {
-        using type = typename rebind_container<std::ptrdiff_t, S>::type;
-    };
+    template <class CP, class O, class A>
+    class xbuffer_adaptor;
 
-    template <std::size_t... I>
-    struct get_strides_type<fixed_shape<I...>>
+    namespace detail
     {
-        // TODO we could compute the strides statically here.
-        //  But we'll need full constexpr support to have a
-        //  homogenous ``compute_strides`` method
-        using type = std::array<std::ptrdiff_t, sizeof...(I)>;
-    };
+        template <class>
+        inline constexpr bool is_fixed_shape_v = false;
 
-    template <class CP, class O, class A>
-    class xbuffer_adaptor;
+        template <std::size_t... I>
+        inline constexpr bool is_fixed_shape_v<fixed_shape<I...>> = true;
 
-    template <class CP, class O, class A>
-    struct get_strides_type<xbuffer_adaptor<CP, O, A>>
-    {
-        // In bindings this mapping is called by reshape_view with an inner shape of type
-        // xbuffer_adaptor.
-        // Since we cannot create a buffer adaptor holding data, we map it to an std::vector.
-        using type = std::vector<
-            typename xbuffer_adaptor<CP, O, A>::value_type,
-            typename xbuffer_adaptor<CP, O, A>::allocator_type>;
-    };
+        template <class>
+        inline constexpr bool is_xbuffer_adaptor_v = false;
 
+        template <class CP, class O, class A>
+        inline constexpr bool is_xbuffer_adaptor_v<xbuffer_adaptor<CP, O, A>> = true;
 
-    template <class C>
-    using get_strides_t = typename get_strides_type<C>::type;
+        template <class S>
+        concept fixed_shape_type = is_fixed_shape_v<S>;
+
+        template <class S>
+        concept xbuffer_adaptor_type = is_xbuffer_adaptor_v<S>;
+    }
+
+    template <class S>
+    constexpr auto get_strides()
+    {
+        if constexpr (detail::fixed_shape_type<S>)
+        {
+            // TODO we could compute the strides statically here.
+            //  But we'll need full constexpr support to have a
+            //  homogenous ``compute_strides`` method
+            return std::type_identity<std::array<std::ptrdiff_t, S::size()>>{};
+        }
+        else if constexpr (detail::xbuffer_adaptor_type<S>)
+        {
+            // In bindings this mapping is called by reshape_view with an inner shape of type
+            // xbuffer_adaptor.
+            // Since we cannot create a buffer adaptor holding data, we map it to an std::vector.
+            return std::type_identity<std::vector<typename S::value_type, typename S::allocator_type>>{};
+        }
+        else
+        {
+            return std::type_identity<typename rebind_container<std::ptrdiff_t, S>::type>{};
+        }
+    }
+
+    template <class S>
+    using get_strides_t = typename decltype(get_strides<S>())::type;
+
+    // Lazy metafunction wrapper around ``get_strides``. Kept so callers can defer the mapping
+    // inside ``std::conditional_t<cond, A, B>::type``, where ``::type`` is only evaluated on the
+    // selected branch (see xshared_expression in xexpression.hpp).
+    template <class S>
+    struct get_strides_type
+    {
+        using type = get_strides_t<S>;
+    };
 
     /*******************
      * inner_reference *
      *******************/
-
     template <class ST>
-    struct inner_reference
+    constexpr auto get_inner_reference()
     {
         using storage_type = std::decay_t<ST>;
-        using type = std::conditional_t<
-            std::is_const<std::remove_reference_t<ST>>::value,
-            typename storage_type::const_reference,
-            typename storage_type::reference>;
-    };
+        if constexpr (std::is_const<std::remove_reference_t<ST>>::value)
+        {
+            return std::type_identity<typename storage_type::const_reference>{};
+        }
+        else
+        {
+            return std::type_identity<typename storage_type::reference>{};
+        }
+    }
 
     template <class ST>
-    using inner_reference_t = typename inner_reference<ST>::type;
+    using inner_reference_t = typename decltype(get_inner_reference<ST>())::type;
 
     /************
      * get_rank *
      ************/
 
-    template <class E, typename = void>
-    struct get_rank
-    {
-        static constexpr std::size_t value = SIZE_MAX;
+    // Define the requirement
+    template <typename T>
+    concept HasRank = requires {
+        T::rank;  // Checks if T::rank exists as a type nested member
     };
 
     template <class E>
-    struct get_rank<E, decltype((void) E::rank, void())>
+    constexpr std::size_t has_rank()
     {
-        static constexpr std::size_t value = E::rank;
-    };
-
-    /******************
-     * has_fixed_rank *
-     ******************/
+        return HasRank<E>;
+    }
 
     template <class E>
-    struct has_fixed_rank
+    constexpr std::size_t get_rank()
     {
-        using type = std::integral_constant<bool, get_rank<std::decay_t<E>>::value != SIZE_MAX>;
-    };
+        if constexpr (HasRank<std::decay_t<E>>)
+        {
+            return std::decay_t<E>::rank;
+        }
+        return SIZE_MAX;
+    }
 
     template <class E>
-    using has_fixed_rank_t = typename has_fixed_rank<std::decay_t<E>>::type;
-
-    /************
-     * has_rank *
-     ************/
-
-    template <class E, size_t N>
-    struct has_rank
+    constexpr std::size_t has_fixed_rank()
     {
-        using type = std::integral_constant<bool, get_rank<std::decay_t<E>>::value == N>;
-    };
-
-    template <class E, size_t N>
-    using has_rank_t = typename has_rank<std::decay_t<E>, N>::type;
-
+        return get_rank<E>() != SIZE_MAX;
+    }
 }
 
 #endif
diff --git a/include/xtensor/views/xdynamic_view.hpp b/include/xtensor/views/xdynamic_view.hpp
index 5ab298f23..c100d2cae 100644
--- a/include/xtensor/views/xdynamic_view.hpp
+++ b/include/xtensor/views/xdynamic_view.hpp
@@ -50,9 +50,9 @@ namespace xt
 
 #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ == 8
         static constexpr auto
-            random_instantiation_var_for_gcc8_data_iface = has_data_interface<xdynamic_view<CT, S, L, FST>>::value;
+            random_instantiation_var_for_gcc8_data_iface = has_data_interface<xdynamic_view<CT, S, L, FST>>();
         static constexpr auto
-            random_instantiation_var_for_gcc8_has_strides = has_strides<xdynamic_view<CT, S, L, FST>>::value;
+            random_instantiation_var_for_gcc8_has_strides = has_strides<xdynamic_view<CT, S, L, FST>>();
 #endif
 
         // TODO: implement efficient stepper specific to the dynamic_view
diff --git a/include/xtensor/views/xfunctor_view.hpp b/include/xtensor/views/xfunctor_view.hpp
index 1c76a91b5..8325d07e5 100644
--- a/include/xtensor/views/xfunctor_view.hpp
+++ b/include/xtensor/views/xfunctor_view.hpp
@@ -93,24 +93,24 @@ namespace xt
         using difference_type = typename xexpression_type::difference_type;
 
         using shape_type = typename xexpression_type::shape_type;
-        using strides_type = xtl::mpl::eval_if_t<
-            has_strides<xexpression_type>,
+        using strides_type = typename std::conditional_t<
+            has_strides<xexpression_type>(),
             detail::expr_strides_type<xexpression_type>,
-            get_strides_type<shape_type>>;
-        using backstrides_type = xtl::mpl::eval_if_t<
-            has_strides<xexpression_type>,
+            get_strides_type<shape_type>>::type;
+        using backstrides_type = typename std::conditional_t<
+            has_strides<xexpression_type>(),
             detail::expr_backstrides_type<xexpression_type>,
-            get_strides_type<shape_type>>;
+            get_strides_type<shape_type>>::type;
 
         using inner_shape_type = typename xexpression_type::inner_shape_type;
-        using inner_strides_type = xtl::mpl::eval_if_t<
-            has_strides<xexpression_type>,
+        using inner_strides_type = typename std::conditional_t<
+            has_strides<xexpression_type>(),
             detail::expr_inner_strides_type<xexpression_type>,
-            get_strides_type<shape_type>>;
-        using inner_backstrides_type = xtl::mpl::eval_if_t<
-            has_strides<xexpression_type>,
+            get_strides_type<shape_type>>::type;
+        using inner_backstrides_type = typename std::conditional_t<
+            has_strides<xexpression_type>(),
             detail::expr_inner_backstrides_type<xexpression_type>,
-            get_strides_type<shape_type>>;
+            get_strides_type<shape_type>>::type;
 
         using bool_load_type = xt::bool_load_type<value_type>;
 
diff --git a/include/xtensor/views/xrepeat.hpp b/include/xtensor/views/xrepeat.hpp
index 0c119c9af..c43873c6c 100644
--- a/include/xtensor/views/xrepeat.hpp
+++ b/include/xtensor/views/xrepeat.hpp
@@ -64,10 +64,10 @@ namespace xt
 
         static constexpr bool is_const = std::is_const<std::remove_reference_t<CT>>::value;
 
-        using extract_storage_type = xtl::mpl::eval_if_t<
-            has_data_interface<xexpression_type>,
+        using extract_storage_type = typename std::conditional_t<
+            has_data_interface<xexpression_type>(),
             detail::expr_storage_type<xexpression_type>,
-            make_invalid_type<>>;
+            make_invalid_type<>>::type;
         using storage_type = std::conditional_t<is_const, const extract_storage_type, extract_storage_type>;
     };
 
diff --git a/include/xtensor/views/xstrided_view_base.hpp b/include/xtensor/views/xstrided_view_base.hpp
index 28f233d87..0591f9eaa 100644
--- a/include/xtensor/views/xstrided_view_base.hpp
+++ b/include/xtensor/views/xstrided_view_base.hpp
@@ -87,7 +87,7 @@ namespace xt
 
         template <class E, class ST>
         struct provides_data_interface
-            : std::conjunction<has_data_interface<std::decay_t<E>>, std::negation<is_flat_expression_adaptor<ST>>>
+            : std::bool_constant<has_data_interface<std::decay_t<E>>() && !is_flat_expression_adaptor<ST>::value>
         {
         };
     }
@@ -278,7 +278,7 @@ namespace xt
 
         template <class CT, layout_type L>
         using flat_storage_getter = std::conditional_t<
-            has_data_interface<std::decay_t<CT>>::value,
+            has_data_interface<std::decay_t<CT>>(),
             inner_storage_getter<CT>,
             flat_adaptor_getter<CT, L>>;
 
@@ -654,7 +654,7 @@ namespace xt
     template <class O>
     inline bool xstrided_view_base<D>::has_linear_assign(const O& str) const noexcept
     {
-        return has_data_interface<xexpression_type>::value && str.size() == strides().size()
+        return has_data_interface<xexpression_type>() && str.size() == strides().size()
                && std::equal(str.cbegin(), str.cend(), strides().begin());
     }
 
diff --git a/include/xtensor/views/xview.hpp b/include/xtensor/views/xview.hpp
index 025df0ae4..780836959 100644
--- a/include/xtensor/views/xview.hpp
+++ b/include/xtensor/views/xview.hpp
@@ -135,27 +135,26 @@ namespace xt
                                               : false;
         };
 
-        template <class S>
-        struct is_strided_slice_impl : std::true_type
-        {
-        };
+        template <typename S>
+        inline constexpr bool is_strided_slice_impl = true;
+        template <typename T>
+        inline constexpr bool is_strided_slice_impl<xkeep_slice<T>> = false;
+        template <typename T>
+        inline constexpr bool is_strided_slice_impl<xdrop_slice<T>> = false;
 
-        template <class T>
-        struct is_strided_slice_impl<xkeep_slice<T>> : std::false_type
-        {
-        };
+        template <typename S>
+        concept is_strided_slice_concept = is_strided_slice_impl<S>;
 
-        template <class T>
-        struct is_strided_slice_impl<xdrop_slice<T>> : std::false_type
+        template <class... S>
+        constexpr bool is_strided_slice()
         {
-        };
+            return (is_strided_slice_concept<std::decay_t<S>> && ...);
+        }
 
         // If we have no discontiguous slices, we can calculate strides for this view.
         template <class E, class... S>
         struct is_strided_view
-            : std::integral_constant<
-                  bool,
-                  std::conjunction<has_data_interface<E>, is_strided_slice_impl<std::decay_t<S>>...>::value>
+            : std::integral_constant<bool, has_data_interface<E>() && is_strided_slice<S...>()>
         {
         };
 
@@ -228,7 +227,7 @@ namespace xt
         struct is_contiguous_view
             : std::integral_constant<
                   bool,
-                  has_data_interface<E>::value
+                  has_data_interface<E>()
                       && !(
                           E::static_layout == layout_type::column_major
                           && static_cast<std::size_t>(static_dimension<typename E::shape_type>::value) != sizeof...(S)
@@ -309,10 +308,10 @@ namespace xt
 
         static constexpr bool is_const = std::is_const<std::remove_reference_t<CT>>::value;
 
-        using extract_storage_type = xtl::mpl::eval_if_t<
-            has_data_interface<xexpression_type>,
+        using extract_storage_type = typename std::conditional_t<
+            has_data_interface<xexpression_type>(),
             detail::expr_storage_type<xexpression_type>,
-            make_invalid_type<>>;
+            make_invalid_type<>>::type;
         using storage_type = std::conditional_t<is_const, const extract_storage_type, extract_storage_type>;
     };
 
@@ -397,15 +396,15 @@ namespace xt
         using inner_shape_type = typename iterable_base::inner_shape_type;
         using shape_type = typename xview_shape_type<typename xexpression_type::shape_type, S...>::type;
 
-        using xexpression_inner_strides_type = xtl::mpl::eval_if_t<
-            has_strides<xexpression_type>,
+        using xexpression_inner_strides_type = typename std::conditional_t<
+            has_strides<xexpression_type>(),
             detail::expr_inner_strides_type<xexpression_type>,
-            get_strides_type<shape_type>>;
+            get_strides_type<shape_type>>::type;
 
-        using xexpression_inner_backstrides_type = xtl::mpl::eval_if_t<
-            has_strides<xexpression_type>,
+        using xexpression_inner_backstrides_type = typename std::conditional_t<
+            has_strides<xexpression_type>(),
             detail::expr_inner_backstrides_type<xexpression_type>,
-            get_strides_type<shape_type>>;
+            get_strides_type<shape_type>>::type;
 
         using storage_type = typename inner_types::storage_type;
 
@@ -437,11 +436,11 @@ namespace xt
         using const_stepper = typename iterable_base::const_stepper;
 
         using linear_iterator = std::conditional_t<
-            has_data_interface<xexpression_type>::value && is_strided_view,
+            has_data_interface<xexpression_type>() && is_strided_view,
             std::conditional_t<is_const, typename xexpression_type::const_linear_iterator, typename xexpression_type::linear_iterator>,
             typename iterable_base::linear_iterator>;
         using const_linear_iterator = std::conditional_t<
-            has_data_interface<xexpression_type>::value && is_strided_view,
+            has_data_interface<xexpression_type>() && is_strided_view,
             typename xexpression_type::const_linear_iterator,
             typename iterable_base::const_linear_iterator>;
 
diff --git a/test/test_sfinae.cpp b/test/test_sfinae.cpp
index f79277ac7..d2e8cc8ca 100644
--- a/test/test_sfinae.cpp
+++ b/test/test_sfinae.cpp
@@ -20,13 +20,13 @@
 
 namespace xt
 {
-    template <class E, std::enable_if_t<!xt::has_rank_t<E, 2>::value, int> = 0>
+    template <class E, std::enable_if_t<(xt::get_rank<E>() != 2), int> = 0>
     inline size_t sfinae_rank_basic_func(E&&)
     {
         return 0;
     }
 
-    template <class E, std::enable_if_t<xt::has_rank_t<E, 2>::value, int> = 0>
+    template <class E, std::enable_if_t<(xt::get_rank<E>() == 2), int> = 0>
     inline size_t sfinae_rank_basic_func(E&&)
     {
         return 2;
@@ -50,19 +50,19 @@ namespace xt
         EXPECT_TRUE(sfinae_rank_basic_func(2ul * c) == 0ul);
     }
 
-    template <class E, std::enable_if_t<xt::has_rank_t<E, SIZE_MAX>::value, int> = 0>
+    template <class E, std::enable_if_t<(xt::get_rank<E>() == SIZE_MAX), int> = 0>
     inline size_t sfinae_rank_func(E&&)
     {
         return 0;
     }
 
-    template <class E, std::enable_if_t<xt::has_rank_t<E, 1>::value, int> = 0>
+    template <class E, std::enable_if_t<(xt::get_rank<E>() == 1), int> = 0>
     inline size_t sfinae_rank_func(E&&)
     {
         return 1;
     }
 
-    template <class E, std::enable_if_t<xt::has_rank_t<E, 2>::value, int> = 0>
+    template <class E, std::enable_if_t<(xt::get_rank<E>() == 2), int> = 0>
     inline size_t sfinae_rank_func(E&&)
     {
         return 2;
@@ -86,13 +86,13 @@ namespace xt
         EXPECT_TRUE(sfinae_rank_func(2ul * c) == 0ul);
     }
 
-    template <class E, std::enable_if_t<!xt::has_fixed_rank_t<E>::value, int> = 0>
+    template <class E, std::enable_if_t<!xt::has_fixed_rank<E>(), int> = 0>
     inline bool sfinae_fixed_func(E&&)
     {
         return false;
     }
 
-    template <class E, std::enable_if_t<xt::has_fixed_rank_t<E>::value, int> = 0>
+    template <class E, std::enable_if_t<xt::has_fixed_rank<E>(), int> = 0>
     inline bool sfinae_fixed_func(E&&)
     {
         return true;
@@ -116,28 +116,17 @@ namespace xt
         EXPECT_TRUE(sfinae_fixed_func(2ul * c) == false);
     }
 
-    template <class T>
-    struct sfinae_get_rank
-    {
-        static const size_t rank = xt::get_rank<T>::value;
-
-        static size_t value()
-        {
-            return rank;
-        }
-    };
-
     TEST(sfinae, get_rank)
     {
         xt::xtensor<double, 1> A = xt::zeros<double>({2});
         xt::xtensor<double, 2> B = xt::zeros<double>({2, 2});
         xt::xarray<double> C = xt::zeros<double>({2, 2});
 
-        EXPECT_TRUE(sfinae_get_rank<decltype(A)>::value() == 1ul);
-        EXPECT_TRUE(sfinae_get_rank<decltype(B)>::value() == 2ul);
-        EXPECT_TRUE(sfinae_get_rank<decltype(C)>::value() == SIZE_MAX);
-        EXPECT_TRUE(sfinae_get_rank<decltype(2.0 * A)>::value() == SIZE_MAX);
-        EXPECT_TRUE(sfinae_get_rank<decltype(2.0 * B)>::value() == SIZE_MAX);
-        EXPECT_TRUE(sfinae_get_rank<decltype(2.0 * C)>::value() == SIZE_MAX);
+        static_assert(get_rank<decltype(A)>() == 1ul);
+        static_assert(get_rank<decltype(B)>() == 2ul);
+        static_assert(get_rank<decltype(C)>() == SIZE_MAX);
+        static_assert(get_rank<decltype(2.0 * A)>() == SIZE_MAX);
+        static_assert(get_rank<decltype(2.0 * B)>() == SIZE_MAX);
+        static_assert(get_rank<decltype(2.0 * C)>() == SIZE_MAX);
     }
 }
diff --git a/test/test_xeval.cpp b/test/test_xeval.cpp
index f585bfd43..c788b325f 100644
--- a/test/test_xeval.cpp
+++ b/test/test_xeval.cpp
@@ -61,7 +61,7 @@ namespace xt
 
 #define EXPECT_LAYOUT(EXPRESSION, LAYOUT) EXPECT_TRUE((decltype(EXPRESSION)::static_layout == LAYOUT))
 
-#define HAS_DATA_INTERFACE(EXPRESSION) has_data_interface<std::decay_t<decltype(EXPRESSION)>>::value
+#define HAS_DATA_INTERFACE(EXPRESSION) has_data_interface<std::decay_t<decltype(EXPRESSION)>>()
 
 #define EXPECT_XARRAY(EXPRESSION) \
     EXPECT_TRUE(!detail::is_array<typename std::decay_t<decltype(EXPRESSION)>::shape_type>::value)
diff --git a/test/test_xutils.cpp b/test/test_xutils.cpp
index e46a883c8..4fbf476a3 100644
--- a/test/test_xutils.cpp
+++ b/test/test_xutils.cpp
@@ -124,14 +124,10 @@ namespace xt
 
     TEST(utils, has_data_interface)
     {
-        bool b = has_data_interface<xarray<int>>::value;
-        EXPECT_TRUE(b);
-        b = has_data_interface<const xarray<int>>::value;
-        EXPECT_TRUE(b);
-        b = has_data_interface<const xtensor<double, 2>>::value;
-        EXPECT_TRUE(b);
-        b = has_data_interface<const xtensor_fixed<double, xshape<3, 4>>>::value;
-        EXPECT_TRUE(b);
+        static_assert(has_data_interface_concept<xarray<int>>);
+        static_assert(has_data_interface_concept<const xarray<int>>);
+        static_assert(has_data_interface_concept<const xtensor<double, 2>>);
+        static_assert(has_data_interface_concept<const xtensor_fixed<double, xshape<3, 4>>>);
 
         xarray<int> a = xarray<int>::from_shape({3, 4, 5});
         auto f = a + a - 23;
@@ -139,39 +135,27 @@ namespace xt
         auto vv2 = strided_view(v2, {all(), 2});
         auto v3 = strided_view(f, {all(), 2});
 
-        b = has_data_interface<decltype(v2)>::value;
-        EXPECT_TRUE(b);
-        b = has_data_interface<decltype(vv2)>::value;
-        EXPECT_TRUE(b);
-        b = has_data_interface<decltype(v3)>::value;
-        EXPECT_FALSE(b);
+        static_assert(has_data_interface_concept<decltype(v2)>);
+        static_assert(has_data_interface_concept<decltype(vv2)>);
+        static_assert(!has_data_interface_concept<decltype(v3)>);
     }
 
     TEST(utils, has_storage_type)
     {
-        bool b = has_storage_type<xarray<int>>::value;
-        EXPECT_TRUE(b);
+        static_assert(has_storage_type<xarray<int>>());
 
         xarray<int> x, y;
-        b = has_storage_type<decltype(x + y)>::value;
-        EXPECT_FALSE(b);
-
-        b = has_storage_type<decltype(view(x, all()))>::value;
-        EXPECT_TRUE(b);
-        b = has_storage_type<decltype(view(2 * x, all()))>::value;
-        EXPECT_FALSE(b);
+        static_assert(!has_storage_type<decltype(x + y)>());
+        static_assert(has_storage_type<decltype(view(x, all()))>());
+        static_assert(!has_storage_type<decltype(view(2 * x, all()))>());
     }
 
     TEST(utils, has_strides)
     {
-        bool b = has_strides<xarray<int>>::value;
-        EXPECT_TRUE(b);
-        b = has_strides<const xarray<int>>::value;
-        EXPECT_TRUE(b);
-        b = has_strides<const xtensor<double, 2>>::value;
-        EXPECT_TRUE(b);
-        b = has_strides<const xtensor_fixed<double, xshape<3, 4>>>::value;
-        EXPECT_TRUE(b);
+        static_assert(has_strides<xarray<int>>());
+        static_assert(has_strides<const xarray<int>>());
+        static_assert(has_strides<const xtensor<double, 2>>());
+        static_assert(has_strides<const xtensor_fixed<double, xshape<3, 4>>>());
 
         xarray<int> a = xarray<int>::from_shape({3, 4, 5});
         auto f = a + a - 23;
@@ -179,15 +163,12 @@ namespace xt
         auto vv2 = strided_view(v2, {all(), 2});
         auto v3 = strided_view(f, {all(), 2});
 
-        b = has_strides<decltype(v2)>::value;
-        EXPECT_TRUE(b);
-        b = has_strides<decltype(vv2)>::value;
-        EXPECT_TRUE(b);
+        static_assert(has_strides<decltype(v2)>());
+        static_assert(has_strides<decltype(vv2)>());
 
 #ifndef _MSC_VER
         // TODO fix this test for MSVC 2015!
-        b = has_strides<decltype(v3)>::value;
-        EXPECT_TRUE(b);
+        static_assert(has_strides<decltype(v3)>());
 #endif
     }