diff --git a/include/xtensor/misc/xtl_concepts.hpp b/include/xtensor/misc/xtl_concepts.hpp
index 163139812..22ef7b212 100644
--- a/include/xtensor/misc/xtl_concepts.hpp
+++ b/include/xtensor/misc/xtl_concepts.hpp
@@ -17,10 +17,15 @@ namespace xtl
 {
     template <typename T>
     concept integral_concept = xtl::is_integral<T>::value;
+
     template <typename T>
     concept non_integral_concept = !xtl::is_integral<T>::value;
+
     template <typename T>
     concept complex_concept = xtl::is_complex<typename std::decay<T>::type::value_type>::value;
+
+    template <typename T>
+    concept pointer_concept = std::is_pointer<T>::value;
 }
 
 #endif  // XTENSOR_CONCEPTS_HPP
diff --git a/include/xtensor/views/xaxis_iterator.hpp b/include/xtensor/views/xaxis_iterator.hpp
index 62489b08f..41da6822f 100644
--- a/include/xtensor/views/xaxis_iterator.hpp
+++ b/include/xtensor/views/xaxis_iterator.hpp
@@ -68,10 +68,7 @@ namespace xt
         value_type m_sv;
 
         template <class T, class CTA>
-        std::enable_if_t<std::is_pointer<T>::value, T> get_storage_init(CTA&& e) const;
-
-        template <class T, class CTA>
-        std::enable_if_t<!std::is_pointer<T>::value, T> get_storage_init(CTA&& e) const;
+        T get_storage_init(CTA&& e) const;
     };
 
     template <class CT>
@@ -125,16 +122,16 @@ namespace xt
 
     template <class CT>
     template <class T, class CTA>
-    inline std::enable_if_t<std::is_pointer<T>::value, T> xaxis_iterator<CT>::get_storage_init(CTA&& e) const
+    inline T xaxis_iterator<CT>::get_storage_init(CTA&& e) const
     {
-        return &e;
-    }
-
-    template <class CT>
-    template <class T, class CTA>
-    inline std::enable_if_t<!std::is_pointer<T>::value, T> xaxis_iterator<CT>::get_storage_init(CTA&& e) const
-    {
-        return e;
+        if constexpr (xtl::pointer_concept<T>)
+        {
+            return &e;
+        }
+        else
+        {
+            return e;
+        }
     }
 
     /**
diff --git a/include/xtensor/views/xaxis_slice_iterator.hpp b/include/xtensor/views/xaxis_slice_iterator.hpp
index 108955595..6ee904df9 100644
--- a/include/xtensor/views/xaxis_slice_iterator.hpp
+++ b/include/xtensor/views/xaxis_slice_iterator.hpp
@@ -69,10 +69,7 @@ namespace xt
         value_type m_sv;
 
         template <class T, class CTA>
-        std::enable_if_t<std::is_pointer<T>::value, T> get_storage_init(CTA&& e) const;
-
-        template <class T, class CTA>
-        std::enable_if_t<!std::is_pointer<T>::value, T> get_storage_init(CTA&& e) const;
+        T get_storage_init(CTA&& e) const;
     };
 
     template <class CT>
@@ -99,18 +96,16 @@ namespace xt
 
     template <class CT>
     template <class T, class CTA>
-    inline std::enable_if_t<std::is_pointer<T>::value, T>
-    xaxis_slice_iterator<CT>::get_storage_init(CTA&& e) const
-    {
-        return &e;
-    }
-
-    template <class CT>
-    template <class T, class CTA>
-    inline std::enable_if_t<!std::is_pointer<T>::value, T>
-    xaxis_slice_iterator<CT>::get_storage_init(CTA&& e) const
+    T xaxis_slice_iterator<CT>::get_storage_init(CTA&& e) const
     {
-        return e;
+        if constexpr (xtl::pointer_concept<T>)
+        {
+            return &e;
+        }
+        else
+        {
+            return e;
+        }
     }
 
     /**
diff --git a/include/xtensor/views/xbroadcast.hpp b/include/xtensor/views/xbroadcast.hpp
index 412c81fce..1626faaa3 100644
--- a/include/xtensor/views/xbroadcast.hpp
+++ b/include/xtensor/views/xbroadcast.hpp
@@ -72,6 +72,9 @@ namespace xt
     template <class CT, class X>
     class xbroadcast;
 
+    template <class E>
+    concept xbroadcast_concept = is_specialization_of<xbroadcast, E>::value;
+
     template <class CT, class X>
     struct xiterable_inner_types<xbroadcast<CT, X>>
     {
@@ -122,10 +125,9 @@ namespace xt
      * overlapping_memory_checker_traits *
      *************************************/
 
-    template <class E>
-    struct overlapping_memory_checker_traits<
-        E,
-        std::enable_if_t<!has_memory_address<E>::value && is_specialization_of<xbroadcast, E>::value>>
+    template <xbroadcast_concept E>
+        requires(without_memory_address_concept<E>)
+    struct overlapping_memory_checker_traits<E>
     {
         static bool check_overlap(const E& expr, const memory_range& dst_range)
         {
@@ -223,7 +225,7 @@ namespace xt
         template <class S>
         const_stepper stepper_end(const S& shape, layout_type l) const noexcept;
 
-        template <class E, class XCT = CT, class = std::enable_if_t<xt::is_xscalar<XCT>::value>>
+        template <class E, xscalar_concept XCT = CT>
         void assign_to(xexpression<E>& e) const;
 
         template <class E>
@@ -463,7 +465,7 @@ namespace xt
     }
 
     template <class CT, class X>
-    template <class E, class XCT, class>
+    template <class E, xscalar_concept XCT>
     inline void xbroadcast<CT, X>::assign_to(xexpression<E>& e) const
     {
         auto& ed = e.derived_cast();
diff --git a/include/xtensor/views/xoffset_view.hpp b/include/xtensor/views/xoffset_view.hpp
index db94e4061..6c8792aa1 100644
--- a/include/xtensor/views/xoffset_view.hpp
+++ b/include/xtensor/views/xoffset_view.hpp
@@ -38,16 +38,9 @@ namespace xt
                 return xtl::forward_offset<M, I>(std::forward<T>(t));
             }
 
-            template <
-                class align,
-                class requested_type,
-                std::size_t N,
-                class E,
-                class MF = M,
-                class = std::enable_if_t<
-                    (std::is_same<MF, double>::value || std::is_same<MF, float>::value) && I <= sizeof(MF),
-                    int>>
+            template <class align, class requested_type, std::size_t N, class E, class MF = M>
             auto proxy_simd_load(const E& expr, std::size_t n) const
+                requires((std::is_same<MF, double>::value || std::is_same<MF, float>::value) && I <= sizeof(MF))
             {
                 // TODO refactor using shuffle only
                 auto batch = expr.template load_simd<align, requested_type, N>(n);
@@ -61,15 +54,9 @@ namespace xt
                 }
             }
 
-            template <
-                class align,
-                class simd,
-                class E,
-                class MF = M,
-                class = std::enable_if_t<
-                    (std::is_same<MF, double>::value || std::is_same<MF, float>::value) && I <= sizeof(MF),
-                    int>>
+            template <class align, class simd, class E, class MF = M>
             auto proxy_simd_store(E& expr, std::size_t n, const simd& batch) const
+                requires((std::is_same<MF, double>::value || std::is_same<MF, float>::value) && I <= sizeof(MF))
             {
                 auto x = expr.template load_simd<align, double, simd::size>(n);
                 if (I == 0)
diff --git a/include/xtensor/views/xslice.hpp b/include/xtensor/views/xslice.hpp
index 4faa17cca..b9d960196 100644
--- a/include/xtensor/views/xslice.hpp
+++ b/include/xtensor/views/xslice.hpp
@@ -63,9 +63,6 @@ namespace xt
     template <class S>
     using is_xslice = std::is_base_of<xslice<S>, S>;
 
-    template <class E, class R = void>
-    using disable_xslice = typename std::enable_if<!is_xslice<E>::value, R>::type;
-
     template <class... E>
     using has_xslice = std::disjunction<is_xslice<E>...>;
 
@@ -112,12 +109,12 @@ namespace xt
         xrange() = default;
         xrange(size_type start_val, size_type stop_val) noexcept;
 
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         operator xrange<S>() const noexcept;
 
         // Same as implicit conversion operator but more convenient to call
         // from a variant visitor
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         xrange<S> convert() const noexcept;
 
         size_type operator()(size_type i) const noexcept;
@@ -156,12 +153,12 @@ namespace xt
         xstepped_range() = default;
         xstepped_range(size_type start_val, size_type stop_val, size_type step) noexcept;
 
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         operator xstepped_range<S>() const noexcept;
 
         // Same as implicit conversion operator but more convenient to call
         // from a variant visitor
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         xstepped_range<S> convert() const noexcept;
 
         size_type operator()(size_type i) const noexcept;
@@ -201,12 +198,12 @@ namespace xt
         xall() = default;
         explicit xall(size_type size) noexcept;
 
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         operator xall<S>() const noexcept;
 
         // Same as implicit conversion operator but more convenient to call
         // from a variant visitor
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         xall<S> convert() const noexcept;
 
         size_type operator()(size_type i) const noexcept;
@@ -271,12 +268,12 @@ namespace xt
 
         xnewaxis() = default;
 
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         operator xnewaxis<S>() const noexcept;
 
         // Same as implicit conversion operator but more convenient to call
         // from a variant visitor
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         xnewaxis<S> convert() const noexcept;
 
         size_type operator()(size_type i) const noexcept;
@@ -320,12 +317,6 @@ namespace xt
         struct is_xkeep_slice<xkeep_slice<T>> : std::true_type
         {
         };
-
-        template <class T>
-        using disable_xkeep_slice_t = std::enable_if_t<!is_xkeep_slice<std::decay_t<T>>::value, void>;
-
-        template <class T>
-        using enable_xkeep_slice_t = std::enable_if_t<is_xkeep_slice<std::decay_t<T>>::value, void>;
     }
 
     template <class T>
@@ -337,19 +328,20 @@ namespace xt
         using size_type = typename container_type::value_type;
         using self_type = xkeep_slice<T>;
 
-        template <class C, typename = detail::disable_xkeep_slice_t<C>>
-        explicit xkeep_slice(C& cont);
+        template <class C>
+        explicit xkeep_slice(C& cont)
+            requires(!detail::is_xkeep_slice<std::decay_t<C>>::value);
         explicit xkeep_slice(container_type&& cont);
 
         template <class S>
         xkeep_slice(std::initializer_list<S> t);
 
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         operator xkeep_slice<S>() const noexcept;
 
         // Same as implicit conversion operator but more convenient to call
         // from a variant visitor
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         xkeep_slice<S> convert() const noexcept;
 
         size_type operator()(size_type i) const noexcept;
@@ -376,17 +368,6 @@ namespace xt
         friend class xkeep_slice;
     };
 
-    namespace detail
-    {
-        template <class T>
-        using disable_integral_keep = std::enable_if_t<
-            !xtl::is_integral<std::decay_t<T>>::value,
-            xkeep_slice<typename std::decay_t<T>::value_type>>;
-
-        template <class T, class R>
-        using enable_integral_keep = std::enable_if_t<xtl::is_integral<T>::value, xkeep_slice<R>>;
-    }
-
     /**
      * Create a non-contigous slice from a container of indices to keep.
      * Note: this slice cannot be used in the xstrided_view!
@@ -401,19 +382,20 @@ namespace xt
      * @param indices The indices container
      * @return instance of xkeep_slice
      */
-    template <class T>
-    inline detail::disable_integral_keep<T> keep(T&& indices)
-    {
-        return xkeep_slice<typename std::decay_t<T>::value_type>(std::forward<T>(indices));
-    }
-
     template <class R = std::ptrdiff_t, class T>
-    inline detail::enable_integral_keep<T, R> keep(T i)
+    inline auto keep(T&& indices)
     {
-        using slice_type = xkeep_slice<R>;
-        using container_type = typename slice_type::container_type;
-        container_type tmp = {static_cast<R>(i)};
-        return slice_type(std::move(tmp));
+        if constexpr (xtl::is_integral<std::decay_t<T>>::value)
+        {
+            using slice_type = xkeep_slice<R>;
+            using container_type = typename slice_type::container_type;
+            container_type tmp = {static_cast<R>(std::forward<T>(indices))};
+            return slice_type(std::move(tmp));
+        }
+        else
+        {
+            return xkeep_slice<typename std::decay_t<T>::value_type>(std::forward<T>(indices));
+        }
     }
 
     template <class R = std::ptrdiff_t, class Arg0, class Arg1, class... Args>
@@ -443,12 +425,6 @@ namespace xt
         struct is_xdrop_slice<xdrop_slice<T>> : std::true_type
         {
         };
-
-        template <class T>
-        using disable_xdrop_slice_t = std::enable_if_t<!is_xdrop_slice<std::decay_t<T>>::value, void>;
-
-        template <class T>
-        using enable_xdrop_slice_t = std::enable_if_t<is_xdrop_slice<std::decay_t<T>>::value, void>;
     }
 
     template <class T>
@@ -460,19 +436,20 @@ namespace xt
         using size_type = typename container_type::value_type;
         using self_type = xdrop_slice<T>;
 
-        template <class C, typename = detail::disable_xdrop_slice_t<C>>
-        explicit xdrop_slice(C& cont);
+        template <class C>
+        explicit xdrop_slice(C& cont)
+            requires(!detail::is_xdrop_slice<std::decay_t<C>>::value);
         explicit xdrop_slice(container_type&& cont);
 
         template <class S>
         xdrop_slice(std::initializer_list<S> t);
 
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         operator xdrop_slice<S>() const noexcept;
 
         // Same as implicit conversion operator but more convenient to call
         // from a variant visitor
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         xdrop_slice<S> convert() const noexcept;
 
         size_type operator()(size_type i) const noexcept;
@@ -501,17 +478,6 @@ namespace xt
         friend class xdrop_slice;
     };
 
-    namespace detail
-    {
-        template <class T>
-        using disable_integral_drop = std::enable_if_t<
-            !xtl::is_integral<std::decay_t<T>>::value,
-            xdrop_slice<typename std::decay_t<T>::value_type>>;
-
-        template <class T, class R>
-        using enable_integral_drop = std::enable_if_t<xtl::is_integral<T>::value, xdrop_slice<R>>;
-    }
-
     /**
      * Create a non-contigous slice from a container of indices to drop.
      * Note: this slice cannot be used in the xstrided_view!
@@ -525,19 +491,20 @@ namespace xt
      * @param indices The container of indices to drop
      * @return instance of xdrop_slice
      */
-    template <class T>
-    inline detail::disable_integral_drop<T> drop(T&& indices)
-    {
-        return xdrop_slice<typename std::decay_t<T>::value_type>(std::forward<T>(indices));
-    }
-
     template <class R = std::ptrdiff_t, class T>
-    inline detail::enable_integral_drop<T, R> drop(T i)
+    inline auto drop(T&& indices)
     {
-        using slice_type = xdrop_slice<R>;
-        using container_type = typename slice_type::container_type;
-        container_type tmp = {static_cast<R>(i)};
-        return slice_type(std::move(tmp));
+        if constexpr (xtl::is_integral<T>::value)
+        {
+            using slice_type = xdrop_slice<R>;
+            using container_type = typename slice_type::container_type;
+            container_type tmp = {static_cast<R>(std::forward<T>(indices))};
+            return slice_type(std::move(tmp));
+        }
+        else
+        {
+            return xdrop_slice<typename std::decay_t<T>::value_type>(std::forward<T>(indices));
+        }
     }
 
     template <class R = std::ptrdiff_t, class Arg0, class Arg1, class... Args>
@@ -564,78 +531,48 @@ namespace xt
         }
 
         template <class MI = A, class MA = B, class STEP = C>
-        inline std::enable_if_t<
-            xtl::is_integral<MI>::value && xtl::is_integral<MA>::value && xtl::is_integral<STEP>::value,
-            xstepped_range<std::ptrdiff_t>>
-        get(std::size_t size) const
-        {
-            return get_stepped_range(m_start, m_stop, m_step, size);
-        }
-
-        template <class MI = A, class MA = B, class STEP = C>
-        inline std::enable_if_t<
-            !xtl::is_integral<MI>::value && xtl::is_integral<MA>::value && xtl::is_integral<STEP>::value,
-            xstepped_range<std::ptrdiff_t>>
-        get(std::size_t size) const
-        {
-            return get_stepped_range(m_step > 0 ? 0 : static_cast<std::ptrdiff_t>(size) - 1, m_stop, m_step, size);
-        }
-
-        template <class MI = A, class MA = B, class STEP = C>
-        inline std::enable_if_t<
-            xtl::is_integral<MI>::value && !xtl::is_integral<MA>::value && xtl::is_integral<STEP>::value,
-            xstepped_range<std::ptrdiff_t>>
-        get(std::size_t size) const
-        {
-            auto sz = static_cast<std::ptrdiff_t>(size);
-            return get_stepped_range(m_start, m_step > 0 ? sz : -(sz + 1), m_step, size);
-        }
-
-        template <class MI = A, class MA = B, class STEP = C>
-        inline std::enable_if_t<
-            xtl::is_integral<MI>::value && xtl::is_integral<MA>::value && !xtl::is_integral<STEP>::value,
-            xrange<std::ptrdiff_t>>
-        get(std::size_t size) const
-        {
-            return xrange<std::ptrdiff_t>(normalize(m_start, size), normalize(m_stop, size));
-        }
-
-        template <class MI = A, class MA = B, class STEP = C>
-        inline std::enable_if_t<
-            !xtl::is_integral<MI>::value && !xtl::is_integral<MA>::value && xtl::is_integral<STEP>::value,
-            xstepped_range<std::ptrdiff_t>>
-        get(std::size_t size) const
-        {
-            std::ptrdiff_t start = m_step >= 0 ? 0 : static_cast<std::ptrdiff_t>(size) - 1;
-            std::ptrdiff_t stop = m_step >= 0 ? static_cast<std::ptrdiff_t>(size) : -1;
-            return xstepped_range<std::ptrdiff_t>(start, stop, m_step);
-        }
-
-        template <class MI = A, class MA = B, class STEP = C>
-        inline std::enable_if_t<
-            xtl::is_integral<MI>::value && !xtl::is_integral<MA>::value && !xtl::is_integral<STEP>::value,
-            xrange<std::ptrdiff_t>>
-        get(std::size_t size) const
-        {
-            return xrange<std::ptrdiff_t>(normalize(m_start, size), static_cast<std::ptrdiff_t>(size));
-        }
-
-        template <class MI = A, class MA = B, class STEP = C>
-        inline std::enable_if_t<
-            !xtl::is_integral<MI>::value && xtl::is_integral<MA>::value && !xtl::is_integral<STEP>::value,
-            xrange<std::ptrdiff_t>>
-        get(std::size_t size) const
-        {
-            return xrange<std::ptrdiff_t>(0, normalize(m_stop, size));
-        }
-
-        template <class MI = A, class MA = B, class STEP = C>
-        inline std::enable_if_t<
-            !xtl::is_integral<MI>::value && !xtl::is_integral<MA>::value && !xtl::is_integral<STEP>::value,
-            xall<std::ptrdiff_t>>
-        get(std::size_t size) const
+        auto get(std::size_t size) const
         {
-            return xall<std::ptrdiff_t>(static_cast<std::ptrdiff_t>(size));
+            if constexpr (xtl::is_integral<MI>::value && xtl::is_integral<MA>::value && xtl::is_integral<STEP>::value)
+            {
+                return get_stepped_range(m_start, m_stop, m_step, size);
+            }
+            else if constexpr (!xtl::is_integral<MI>::value && xtl::is_integral<MA>::value && xtl::is_integral<STEP>::value)
+            {
+                return get_stepped_range(
+                    m_step > 0 ? 0 : static_cast<std::ptrdiff_t>(size) - 1,
+                    m_stop,
+                    m_step,
+                    size
+                );
+            }
+            else if constexpr (xtl::is_integral<MI>::value && !xtl::is_integral<MA>::value && xtl::is_integral<STEP>::value)
+            {
+                auto sz = static_cast<std::ptrdiff_t>(size);
+                return get_stepped_range(m_start, m_step > 0 ? sz : -(sz + 1), m_step, size);
+            }
+            else if constexpr (xtl::is_integral<MI>::value && xtl::is_integral<MA>::value && !xtl::is_integral<STEP>::value)
+            {
+                return xrange<std::ptrdiff_t>(normalize(m_start, size), normalize(m_stop, size));
+            }
+            else if constexpr (!xtl::is_integral<MI>::value && !xtl::is_integral<MA>::value && xtl::is_integral<STEP>::value)
+            {
+                std::ptrdiff_t start = m_step >= 0 ? 0 : static_cast<std::ptrdiff_t>(size) - 1;
+                std::ptrdiff_t stop = m_step >= 0 ? static_cast<std::ptrdiff_t>(size) : -1;
+                return xstepped_range<std::ptrdiff_t>(start, stop, m_step);
+            }
+            else if constexpr (xtl::is_integral<MI>::value && !xtl::is_integral<MA>::value && !xtl::is_integral<STEP>::value)
+            {
+                return xrange<std::ptrdiff_t>(normalize(m_start, size), static_cast<std::ptrdiff_t>(size));
+            }
+            else if constexpr (!xtl::is_integral<MI>::value && xtl::is_integral<MA>::value && !xtl::is_integral<STEP>::value)
+            {
+                return xrange<std::ptrdiff_t>(0, normalize(m_stop, size));
+            }
+            else if constexpr (!xtl::is_integral<MI>::value && !xtl::is_integral<MA>::value && !xtl::is_integral<STEP>::value)
+            {
+                return xall<std::ptrdiff_t>(static_cast<std::ptrdiff_t>(size));
+            }
         }
 
         A start() const
@@ -774,25 +711,14 @@ namespace xt
 
     namespace detail
     {
-        template <class T, class E = void>
-        struct cast_if_integer
-        {
-            using type = T;
-
-            type operator()(T t)
-            {
-                return t;
-            }
-        };
-
         template <class T>
-        struct cast_if_integer<T, std::enable_if_t<xtl::is_integral<T>::value>>
+        struct cast_if_integer
         {
-            using type = std::ptrdiff_t;
+            using type = std::conditional_t<xtl::is_integral<T>::value, std::ptrdiff_t, T>;
 
             type operator()(T t)
             {
-                return static_cast<type>(t);
+                return (xtl::is_integral<T>::value) ? static_cast<type>(t) : t;
             }
         };
 
@@ -850,15 +776,16 @@ namespace xt
      ******************************************************/
 
     template <class S>
-    inline disable_xslice<S, std::size_t> get_size(const S&) noexcept
-    {
-        return 1;
-    }
-
-    template <class S>
-    inline auto get_size(const xslice<S>& slice) noexcept
+    inline std::size_t get_size(const S& slice) noexcept
     {
-        return slice.derived_cast().size();
+        if constexpr (is_xslice<S>::value)
+        {
+            return slice.size();
+        }
+        else
+        {
+            return 1;
+        }
     }
 
     /*******************************************************
@@ -866,27 +793,29 @@ namespace xt
      *******************************************************/
 
     template <class S>
-    inline disable_xslice<S, std::size_t> step_size(const S&, std::size_t) noexcept
-    {
-        return 0;
-    }
-
-    template <class S>
-    inline disable_xslice<S, std::size_t> step_size(const S&, std::size_t, std::size_t) noexcept
+    inline std::size_t step_size(const S& slice, std::size_t idx) noexcept
     {
-        return 0;
-    }
-
-    template <class S>
-    inline auto step_size(const xslice<S>& slice, std::size_t idx) noexcept
-    {
-        return slice.derived_cast().step_size(idx);
+        if constexpr (is_xslice<S>::value)
+        {
+            return slice.step_size(idx);
+        }
+        else
+        {
+            return 0;
+        }
     }
 
     template <class S>
-    inline auto step_size(const xslice<S>& slice, std::size_t idx, std::size_t n) noexcept
+    inline std::size_t step_size(const S& slice, std::size_t idx, std::size_t n) noexcept
     {
-        return slice.derived_cast().step_size(idx, n);
+        if constexpr (is_xslice<S>::value)
+        {
+            return slice.step_size(idx, n);
+        }
+        else
+        {
+            return 0;
+        }
     }
 
     /*********************************************
@@ -894,16 +823,17 @@ namespace xt
      *********************************************/
 
     template <class S, class I>
-    inline disable_xslice<S, std::size_t> value(const S& s, I) noexcept
+    inline std::size_t value(const S& slice, I i) noexcept
     {
-        return static_cast<std::size_t>(s);
-    }
-
-    template <class S, class I>
-    inline auto value(const xslice<S>& slice, I i) noexcept
-    {
-        using ST = typename S::size_type;
-        return slice.derived_cast()(static_cast<ST>(i));
+        if constexpr (is_xslice<S>::value)
+        {
+            using ST = typename S::size_type;
+            return slice(static_cast<ST>(i));
+        }
+        else
+        {
+            return static_cast<std::size_t>(slice);
+        }
     }
 
     /****************************************
@@ -1064,7 +994,7 @@ namespace xt
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xrange<T>::operator xrange<S>() const noexcept
     {
         xrange<S> ret;
@@ -1074,7 +1004,7 @@ namespace xt
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xrange<S> xrange<T>::convert() const noexcept
     {
         return xrange<S>(*this);
@@ -1143,7 +1073,7 @@ namespace xt
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xstepped_range<T>::operator xstepped_range<S>() const noexcept
     {
         xstepped_range<S> ret;
@@ -1154,7 +1084,7 @@ namespace xt
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xstepped_range<S> xstepped_range<T>::convert() const noexcept
     {
         return xstepped_range<S>(*this);
@@ -1219,14 +1149,14 @@ namespace xt
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xall<T>::operator xall<S>() const noexcept
     {
         return xall<S>(static_cast<S>(m_size));
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xall<S> xall<T>::convert() const noexcept
     {
         return xall<S>(*this);
@@ -1285,14 +1215,14 @@ namespace xt
      ***************************/
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xnewaxis<T>::operator xnewaxis<S>() const noexcept
     {
         return xnewaxis<S>();
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xnewaxis<S> xnewaxis<T>::convert() const noexcept
     {
         return xnewaxis<S>(*this);
@@ -1351,8 +1281,9 @@ namespace xt
      ******************************/
 
     template <class T>
-    template <class C, typename>
+    template <class C>
     inline xkeep_slice<T>::xkeep_slice(C& cont)
+        requires(!detail::is_xkeep_slice<std::decay_t<C>>::value)
         : m_raw_indices(cont.begin(), cont.end())
     {
     }
@@ -1380,7 +1311,7 @@ namespace xt
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xkeep_slice<T>::operator xkeep_slice<S>() const noexcept
     {
         xkeep_slice<S> ret;
@@ -1410,7 +1341,7 @@ namespace xt
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xkeep_slice<S> xkeep_slice<T>::convert() const noexcept
     {
         return xkeep_slice<S>(*this);
@@ -1494,8 +1425,9 @@ namespace xt
      ******************************/
 
     template <class T>
-    template <class C, typename>
+    template <class C>
     inline xdrop_slice<T>::xdrop_slice(C& cont)
+        requires(!detail::is_xdrop_slice<std::decay_t<C>>::value)
         : m_raw_indices(cont.begin(), cont.end())
     {
     }
@@ -1523,7 +1455,7 @@ namespace xt
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xdrop_slice<T>::operator xdrop_slice<S>() const noexcept
     {
         xdrop_slice<S> ret;
@@ -1561,7 +1493,7 @@ namespace xt
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xdrop_slice<S> xdrop_slice<T>::convert() const noexcept
     {
         return xdrop_slice<S>(*this);
diff --git a/include/xtensor/views/xstrided_view.hpp b/include/xtensor/views/xstrided_view.hpp
index b52da8e30..f0fda4214 100644
--- a/include/xtensor/views/xstrided_view.hpp
+++ b/include/xtensor/views/xstrided_view.hpp
@@ -180,6 +180,9 @@ namespace xt
         using simd_value_type = xt_simd::simd_type<value_type>;
         using bool_load_type = typename base_type::bool_load_type;
 
+        static constexpr bool provides_simd_interface = has_simd_interface<xexpression_type>::value
+                                                        && L != layout_type::dynamic;
+
         template <class CTA, class SA>
         xstrided_view(CTA&& e, SA&& shape, strides_type&& strides, std::size_t offset, layout_type layout) noexcept;
 
@@ -254,17 +257,13 @@ namespace xt
         template <class requested_type>
         using simd_return_type = xt_simd::simd_return_type<value_type, requested_type>;
 
-        template <class T, class R>
-        using enable_simd_interface = std::enable_if_t<has_simd_interface<T>::value && L != layout_type::dynamic, R>;
+        template <class align, class simd>
+        void store_simd(size_type i, const simd& e)
+            requires provides_simd_interface;
 
-        template <class align, class simd, class T = xexpression_type>
-        enable_simd_interface<T, void> store_simd(size_type i, const simd& e);
-        template <
-            class align,
-            class requested_type = value_type,
-            std::size_t N = xt_simd::simd_traits<requested_type>::size,
-            class T = xexpression_type>
-        enable_simd_interface<T, simd_return_type<requested_type>> load_simd(size_type i) const;
+        template <class align, class requested_type = value_type, std::size_t N = xt_simd::simd_traits<requested_type>::size>
+        simd_return_type<requested_type> load_simd(size_type i) const
+            requires provides_simd_interface;
 
         reference data_element(size_type i);
         const_reference data_element(size_type i) const;
@@ -672,18 +671,18 @@ namespace xt
     }
 
     template <class CT, class S, layout_type L, class FST>
-    template <class alignment, class simd, class T>
-    inline auto xstrided_view<CT, S, L, FST>::store_simd(size_type i, const simd& e)
-        -> enable_simd_interface<T, void>
+    template <class alignment, class simd>
+    inline void xstrided_view<CT, S, L, FST>::store_simd(size_type i, const simd& e)
+        requires provides_simd_interface
     {
         using align_mode = driven_align_mode_t<alignment, data_alignment>;
         xt_simd::store_as(&(storage()[i]), e, align_mode());
     }
 
     template <class CT, class S, layout_type L, class FST>
-    template <class alignment, class requested_type, std::size_t N, class T>
-    inline auto xstrided_view<CT, S, L, FST>::load_simd(size_type i) const
-        -> enable_simd_interface<T, simd_return_type<requested_type>>
+    template <class alignment, class requested_type, std::size_t N>
+    inline auto xstrided_view<CT, S, L, FST>::load_simd(size_type i) const -> simd_return_type<requested_type>
+        requires provides_simd_interface
     {
         using align_mode = driven_align_mode_t<alignment, data_alignment>;
         return xt_simd::load_as<requested_type>(&(storage()[i]), align_mode());
@@ -824,29 +823,23 @@ namespace xt
             using type = rebind_container_t<size_t, S>;
         };
 
-        template <
-            class S,
-            std::enable_if_t<std::is_signed<get_value_type_t<typename std::decay<S>::type>>::value, bool> = true>
+        template <class S>
         inline void recalculate_shape_impl(S& shape, size_t size)
         {
-            using value_type = get_value_type_t<typename std::decay_t<S>>;
-            XTENSOR_ASSERT(std::count(shape.cbegin(), shape.cend(), -1) <= 1);
-            auto iter = std::find(shape.begin(), shape.end(), -1);
-            if (iter != std::end(shape))
+            if constexpr (std::is_signed_v<get_value_type_t<typename std::decay<S>::type>>)
             {
-                const auto total = std::accumulate(shape.cbegin(), shape.cend(), -1, std::multiplies<int>{});
-                const auto missing_dimension = size / total;
-                (*iter) = static_cast<value_type>(missing_dimension);
+                using value_type = get_value_type_t<typename std::decay_t<S>>;
+                XTENSOR_ASSERT(std::count(shape.cbegin(), shape.cend(), -1) <= 1);
+                auto iter = std::find(shape.begin(), shape.end(), -1);
+                if (iter != std::end(shape))
+                {
+                    const auto total = std::accumulate(shape.cbegin(), shape.cend(), -1, std::multiplies<int>{});
+                    const auto missing_dimension = size / total;
+                    (*iter) = static_cast<value_type>(missing_dimension);
+                }
             }
         }
 
-        template <
-            class S,
-            std::enable_if_t<!std::is_signed<get_value_type_t<typename std::decay<S>::type>>::value, bool> = true>
-        inline void recalculate_shape_impl(S&, size_t)
-        {
-        }
-
         template <class S>
         inline auto recalculate_shape(S&& shape, size_t size)
         {
diff --git a/include/xtensor/views/xstrided_view_base.hpp b/include/xtensor/views/xstrided_view_base.hpp
index be67ee191..28f233d87 100644
--- a/include/xtensor/views/xstrided_view_base.hpp
+++ b/include/xtensor/views/xstrided_view_base.hpp
@@ -133,6 +133,9 @@ namespace xt
         static constexpr bool contiguous_layout = static_layout != layout_type::dynamic
                                                   && xexpression_type::contiguous_layout;
 
+        static constexpr bool
+            provides_data_interface = detail::provides_data_interface<xexpression_type, storage_type>::value;
+
         template <class CTA, class SA>
         xstrided_view_base(CTA&& e, SA&& shape, strides_type&& strides, size_type offset, layout_type layout) noexcept;
 
@@ -171,10 +174,11 @@ namespace xt
         storage_type& storage() noexcept;
         const storage_type& storage() const noexcept;
 
-        template <class E = xexpression_type, class ST = storage_type>
-        std::enable_if_t<detail::provides_data_interface<E, ST>::value, pointer> data() noexcept;
-        template <class E = xexpression_type, class ST = storage_type>
-        std::enable_if_t<detail::provides_data_interface<E, ST>::value, const_pointer> data() const noexcept;
+        pointer data() noexcept
+            requires(provides_data_interface);
+        const_pointer data() const noexcept
+            requires(provides_data_interface);
+
         size_type data_offset() const noexcept;
 
         xexpression_type& expression() noexcept;
@@ -578,9 +582,8 @@ namespace xt
      * The first element of the view is at data() + data_offset().
      */
     template <class D>
-    template <class E, class ST>
-    inline auto xstrided_view_base<D>::data() noexcept
-        -> std::enable_if_t<detail::provides_data_interface<E, ST>::value, pointer>
+    inline auto xstrided_view_base<D>::data() noexcept -> pointer
+        requires(provides_data_interface)
     {
         return m_e.data();
     }
@@ -590,9 +593,8 @@ namespace xt
      * The first element of the view is at data() + data_offset().
      */
     template <class D>
-    template <class E, class ST>
-    inline auto xstrided_view_base<D>::data() const noexcept
-        -> std::enable_if_t<detail::provides_data_interface<E, ST>::value, const_pointer>
+    inline auto xstrided_view_base<D>::data() const noexcept -> const_pointer
+        requires(provides_data_interface)
     {
         return m_e.data();
     }
diff --git a/include/xtensor/views/xview.hpp b/include/xtensor/views/xview.hpp
index be4c05e1a..ea546d4ff 100644
--- a/include/xtensor/views/xview.hpp
+++ b/include/xtensor/views/xview.hpp
@@ -720,7 +720,8 @@ namespace xt
         size_type sliced_access(const xslice<T>& slice, Arg arg, Args... args) const;
 
         template <typename std::decay_t<CT>::size_type I, class T, class... Args>
-        disable_xslice<T, size_type> sliced_access(const T& squeeze, Args...) const;
+        size_type sliced_access(const T& squeeze, Args...) const
+            requires(!is_xslice<T>::value);
 
         using base_index_type = xindex_type_t<typename xexpression_type::shape_type>;
 
@@ -1674,7 +1675,8 @@ namespace xt
 
     template <class CT, class... S>
     template <typename std::decay_t<CT>::size_type I, class T, class... Args>
-    inline auto xview<CT, S...>::sliced_access(const T& squeeze, Args...) const -> disable_xslice<T, size_type>
+    inline auto xview<CT, S...>::sliced_access(const T& squeeze, Args...) const -> size_type
+        requires(!is_xslice<T>::value)
     {
         return static_cast<size_type>(squeeze);
     }
diff --git a/include/xtensor/views/xview_utils.hpp b/include/xtensor/views/xview_utils.hpp
index 5c072dbf0..f74eb07e2 100644
--- a/include/xtensor/views/xview_utils.hpp
+++ b/include/xtensor/views/xview_utils.hpp
@@ -48,15 +48,16 @@ namespace xt
     constexpr std::size_t newaxis_skip(std::size_t i);
 
     template <class S, class It>
-    inline disable_xslice<S, std::size_t> get_slice_value(const S& s, It&) noexcept
+    inline auto get_slice_value(const S& slice, It& it) noexcept
     {
-        return static_cast<std::size_t>(s);
-    }
-
-    template <class S, class It>
-    inline auto get_slice_value(const xslice<S>& slice, It& it) noexcept
-    {
-        return slice.derived_cast()(typename S::size_type(*it));
+        if constexpr (is_xslice<S>::value)
+        {
+            return slice(typename S::size_type(*it));
+        }
+        else
+        {
+            return static_cast<std::size_t>(slice);
+        }
     }
 
     /***********************