diff --git a/include/xtensor/views/xdynamic_view.hpp b/include/xtensor/views/xdynamic_view.hpp
index 5ab298f23..b270392b8 100644
--- a/include/xtensor/views/xdynamic_view.hpp
+++ b/include/xtensor/views/xdynamic_view.hpp
@@ -324,7 +324,7 @@ namespace xt
     namespace detail
     {
         template <class T>
-        class xfake_slice : public xslice<xfake_slice<T>>
+        class xfake_slice
         {
         public:
 
diff --git a/include/xtensor/views/xslice.hpp b/include/xtensor/views/xslice.hpp
index a7a4dae6e..4ea322152 100644
--- a/include/xtensor/views/xslice.hpp
+++ b/include/xtensor/views/xslice.hpp
@@ -10,6 +10,7 @@
 #ifndef XTENSOR_SLICE_HPP
 #define XTENSOR_SLICE_HPP
 
+#include <concepts>
 #include <cstddef>
 #include <map>
 #include <type_traits>
@@ -19,6 +20,7 @@
 
 #include "../containers/xstorage.hpp"
 #include "../core/xtensor_config.hpp"
+#include "../misc/xtl_concepts.hpp"
 #include "../utils/xutils.hpp"
 
 #ifndef XTENSOR_CONSTEXPR
@@ -35,36 +37,94 @@ namespace xt
 {
 
     /**********************
-     * xslice declaration *
+     * xslice type traits *
      **********************/
 
-    template <class D>
-    class xslice
-    {
-    public:
+    // Forward declarations
+    template <class T>
+    class xrange;
+
+    template <class T>
+    class xstepped_range;
 
-        using derived_type = D;
+    template <class T>
+    class xall;
+
+    template <class T>
+    class xnewaxis;
 
-        derived_type& derived_cast() noexcept;
-        const derived_type& derived_cast() const noexcept;
+    template <class T>
+    class xkeep_slice;
 
-    protected:
+    template <class T>
+    class xdrop_slice;
 
-        xslice() = default;
-        ~xslice() = default;
+    namespace detail
+    {
+        template <class S, template <class> class SliceType>
+        struct is_specific_slice_impl : std::false_type
+        {
+        };
 
-        xslice(const xslice&) = default;
-        xslice& operator=(const xslice&) = default;
+        template <class T, template <class> class SliceType>
+        struct is_specific_slice_impl<SliceType<T>, SliceType> : std::true_type
+        {
+        };
 
-        xslice(xslice&&) = default;
-        xslice& operator=(xslice&&) = default;
+        template <class S>
+        struct is_xslice_impl : std::disjunction<
+                                    is_specific_slice_impl<S, xrange>,
+                                    is_specific_slice_impl<S, xstepped_range>,
+                                    is_specific_slice_impl<S, xall>,
+                                    is_specific_slice_impl<S, xnewaxis>,
+                                    is_specific_slice_impl<S, xkeep_slice>,
+                                    is_specific_slice_impl<S, xdrop_slice>>
+        {
+        };
+    }
+
+    template <class S>
+    struct is_xslice : detail::is_xslice_impl<S>
+    {
     };
 
     template <class S>
-    using is_xslice = std::is_base_of<xslice<S>, S>;
+    concept xslice_concept = is_xslice<S>::value;
+
+    template <class S>
+    concept xrange_concept = detail::is_specific_slice_impl<std::remove_cvref_t<S>, xrange>::value;
+
+    template <class S>
+    concept xstepped_range_concept = detail::is_specific_slice_impl<std::remove_cvref_t<S>, xstepped_range>::value;
+
+    template <class S>
+    concept xall_concept = detail::is_specific_slice_impl<std::remove_cvref_t<S>, xall>::value;
+
+    template <class S>
+    concept xnewaxis_concept = detail::is_specific_slice_impl<std::remove_cvref_t<S>, xnewaxis>::value;
+
+    template <class S>
+    concept xkeep_slice_concept = detail::is_specific_slice_impl<std::remove_cvref_t<S>, xkeep_slice>::value;
+
+    template <class S>
+    concept xdrop_slice_concept = detail::is_specific_slice_impl<std::remove_cvref_t<S>, xdrop_slice>::value;
+
+    template <class S>
+    concept nonstrided_slice_concept = xkeep_slice_concept<S> || xdrop_slice_concept<S>;
+
+    template <class S>
+    concept strided_slice_concept = xslice_concept<S> && !nonstrided_slice_concept<S>;
+
+    template <class S>
+    concept slice_or_scalar_concept = xslice_concept<S> || xtl::integral_concept<S>;
+
+    template <class S>
+    concept strided_compatible_concept = slice_or_scalar_concept<S> && !nonstrided_slice_concept<S>;
 
     template <class... E>
-    using has_xslice = std::disjunction<is_xslice<E>...>;
+    struct has_xslice : std::bool_constant<(xslice_concept<E> || ...)>
+    {
+    };
 
     /**************
      * slice tags *
@@ -99,7 +159,7 @@ namespace xt
      **********************/
 
     template <class T>
-    class xrange : public xslice<xrange<T>>
+    class xrange
     {
     public:
 
@@ -143,7 +203,7 @@ namespace xt
      ******************************/
 
     template <class T>
-    class xstepped_range : public xslice<xstepped_range<T>>
+    class xstepped_range
     {
     public:
 
@@ -188,7 +248,7 @@ namespace xt
      ********************/
 
     template <class T>
-    class xall : public xslice<xall<T>>
+    class xall
     {
     public:
 
@@ -259,7 +319,7 @@ namespace xt
      ************************/
 
     template <class T>
-    class xnewaxis : public xslice<xnewaxis<T>>
+    class xnewaxis
     {
     public:
 
@@ -306,21 +366,8 @@ namespace xt
     template <class T>
     class xkeep_slice;
 
-    namespace detail
-    {
-        template <class T>
-        struct is_xkeep_slice : std::false_type
-        {
-        };
-
-        template <class T>
-        struct is_xkeep_slice<xkeep_slice<T>> : std::true_type
-        {
-        };
-    }
-
     template <class T>
-    class xkeep_slice : public xslice<xkeep_slice<T>>
+    class xkeep_slice
     {
     public:
 
@@ -330,7 +377,7 @@ namespace xt
 
         template <class C>
         explicit xkeep_slice(C& cont)
-            requires(!detail::is_xkeep_slice<std::decay_t<C>>::value);
+            requires(!xkeep_slice_concept<C>);
         explicit xkeep_slice(container_type&& cont);
 
         template <class S>
@@ -385,7 +432,7 @@ namespace xt
     template <class R = std::ptrdiff_t, class T>
     inline auto keep(T&& indices)
     {
-        if constexpr (xtl::is_integral<std::decay_t<T>>::value)
+        if constexpr (xtl::integral_concept<std::decay_t<T>>)
         {
             using slice_type = xkeep_slice<R>;
             using container_type = typename slice_type::container_type;
@@ -414,21 +461,8 @@ namespace xt
     template <class T>
     class xdrop_slice;
 
-    namespace detail
-    {
-        template <class T>
-        struct is_xdrop_slice : std::false_type
-        {
-        };
-
-        template <class T>
-        struct is_xdrop_slice<xdrop_slice<T>> : std::true_type
-        {
-        };
-    }
-
     template <class T>
-    class xdrop_slice : public xslice<xdrop_slice<T>>
+    class xdrop_slice
     {
     public:
 
@@ -438,7 +472,7 @@ namespace xt
 
         template <class C>
         explicit xdrop_slice(C& cont)
-            requires(!detail::is_xdrop_slice<std::decay_t<C>>::value);
+            requires(!xdrop_slice_concept<C>);
         explicit xdrop_slice(container_type&& cont);
 
         template <class S>
@@ -494,7 +528,7 @@ namespace xt
     template <class R = std::ptrdiff_t, class T>
     inline auto drop(T&& indices)
     {
-        if constexpr (xtl::is_integral<T>::value)
+        if constexpr (xtl::integral_concept<T>)
         {
             using slice_type = xdrop_slice<R>;
             using container_type = typename slice_type::container_type;
@@ -533,11 +567,11 @@ namespace xt
         template <class MI = A, class MA = B, class STEP = C>
         auto get(std::size_t size) const
         {
-            if constexpr (xtl::is_integral<MI>::value && xtl::is_integral<MA>::value && xtl::is_integral<STEP>::value)
+            if constexpr (xtl::integral_concept<MI> && xtl::integral_concept<MA> && xtl::integral_concept<STEP>)
             {
                 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)
+            else if constexpr (!xtl::integral_concept<MI> && xtl::integral_concept<MA> && xtl::integral_concept<STEP>)
             {
                 return get_stepped_range(
                     m_step > 0 ? 0 : static_cast<std::ptrdiff_t>(size) - 1,
@@ -546,30 +580,30 @@ namespace xt
                     size
                 );
             }
-            else if constexpr (xtl::is_integral<MI>::value && !xtl::is_integral<MA>::value && xtl::is_integral<STEP>::value)
+            else if constexpr (xtl::integral_concept<MI> && !xtl::integral_concept<MA> && xtl::integral_concept<STEP>)
             {
                 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)
+            else if constexpr (xtl::integral_concept<MI> && xtl::integral_concept<MA> && !xtl::integral_concept<STEP>)
             {
                 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)
+            else if constexpr (!xtl::integral_concept<MI> && !xtl::integral_concept<MA> && xtl::integral_concept<STEP>)
             {
                 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)
+            else if constexpr (xtl::integral_concept<MI> && !xtl::integral_concept<MA> && !xtl::integral_concept<STEP>)
             {
                 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)
+            else if constexpr (!xtl::integral_concept<MI> && xtl::integral_concept<MA> && !xtl::integral_concept<STEP>)
             {
                 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)
+            else if constexpr (!xtl::integral_concept<MI> && !xtl::integral_concept<MA> && !xtl::integral_concept<STEP>)
             {
                 return xall<std::ptrdiff_t>(static_cast<std::ptrdiff_t>(size));
             }
@@ -714,11 +748,18 @@ namespace xt
         template <class T>
         struct cast_if_integer
         {
-            using type = std::conditional_t<xtl::is_integral<T>::value, std::ptrdiff_t, T>;
+            using type = std::conditional_t<xtl::integral_concept<T>, std::ptrdiff_t, T>;
 
             type operator()(T t)
             {
-                return (xtl::is_integral<T>::value) ? static_cast<type>(t) : t;
+                if constexpr (xtl::integral_concept<T>)
+                {
+                    return static_cast<std::ptrdiff_t>(t);
+                }
+                else
+                {
+                    return t;
+                }
             }
         };
 
@@ -778,7 +819,7 @@ namespace xt
     template <class S>
     inline std::size_t get_size(const S& slice) noexcept
     {
-        if constexpr (is_xslice<S>::value)
+        if constexpr (xslice_concept<S>)
         {
             return slice.size();
         }
@@ -795,7 +836,7 @@ namespace xt
     template <class S>
     inline std::size_t step_size(const S& slice, std::size_t idx) noexcept
     {
-        if constexpr (is_xslice<S>::value)
+        if constexpr (xslice_concept<S>)
         {
             return slice.step_size(idx);
         }
@@ -808,7 +849,7 @@ namespace xt
     template <class S>
     inline std::size_t step_size(const S& slice, std::size_t idx, std::size_t n) noexcept
     {
-        if constexpr (is_xslice<S>::value)
+        if constexpr (xslice_concept<S>)
         {
             return slice.step_size(idx, n);
         }
@@ -823,9 +864,9 @@ namespace xt
      *********************************************/
 
     template <class S, class I>
-    inline std::size_t value(const S& slice, I i) noexcept
+    inline auto value(const S& slice, I i) noexcept
     {
-        if constexpr (is_xslice<S>::value)
+        if constexpr (xslice_concept<S>)
         {
             using ST = typename S::size_type;
             return slice(static_cast<ST>(i));
@@ -966,22 +1007,6 @@ namespace xt
     template <class E, class SL>
     using get_slice_type = typename detail::get_slice_type_impl<E, std::remove_reference_t<SL>>::type;
 
-    /*************************
-     * xslice implementation *
-     *************************/
-
-    template <class D>
-    inline auto xslice<D>::derived_cast() noexcept -> derived_type&
-    {
-        return *static_cast<derived_type*>(this);
-    }
-
-    template <class D>
-    inline auto xslice<D>::derived_cast() const noexcept -> const derived_type&
-    {
-        return *static_cast<const derived_type*>(this);
-    }
-
     /*************************
      * xrange implementation *
      *************************/
@@ -1283,7 +1308,7 @@ namespace xt
     template <class T>
     template <class C>
     inline xkeep_slice<T>::xkeep_slice(C& cont)
-        requires(!detail::is_xkeep_slice<std::decay_t<C>>::value)
+        requires(!xkeep_slice_concept<C>)
         : m_raw_indices(cont.begin(), cont.end())
     {
     }
@@ -1427,7 +1452,7 @@ namespace xt
     template <class T>
     template <class C>
     inline xdrop_slice<T>::xdrop_slice(C& cont)
-        requires(!detail::is_xdrop_slice<std::decay_t<C>>::value)
+        requires(!xdrop_slice_concept<C>)
         : m_raw_indices(cont.begin(), cont.end())
     {
     }
diff --git a/include/xtensor/views/xview.hpp b/include/xtensor/views/xview.hpp
index ea546d4ff..6ca444044 100644
--- a/include/xtensor/views/xview.hpp
+++ b/include/xtensor/views/xview.hpp
@@ -135,27 +135,12 @@ namespace xt
                                               : false;
         };
 
-        template <class S>
-        struct is_strided_slice_impl : std::true_type
-        {
-        };
-
-        template <class T>
-        struct is_strided_slice_impl<xkeep_slice<T>> : std::false_type
-        {
-        };
-
-        template <class T>
-        struct is_strided_slice_impl<xdrop_slice<T>> : std::false_type
-        {
-        };
-
         // 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>
+                  has_data_interface<E>::value && (strided_compatible_concept<std::decay_t<S>> && ...)>
         {
         };
 
@@ -713,15 +698,15 @@ namespace xt
         template <typename std::decay_t<CT>::size_type I, class... Args>
         size_type index(Args... args) const;
 
-        template <typename std::decay_t<CT>::size_type, class T>
-        size_type sliced_access(const xslice<T>& slice) const;
+        template <typename std::decay_t<CT>::size_type I, xslice_concept T>
+        size_type sliced_access(const T& slice) const;
 
-        template <typename std::decay_t<CT>::size_type I, class T, class Arg, class... Args>
-        size_type sliced_access(const xslice<T>& slice, Arg arg, Args... args) const;
+        template <typename std::decay_t<CT>::size_type I, xslice_concept T, class Arg, class... Args>
+        size_type sliced_access(const T& slice, Arg arg, Args... args) const;
 
         template <typename std::decay_t<CT>::size_type I, class T, class... Args>
         size_type sliced_access(const T& squeeze, Args...) const
-            requires(!is_xslice<T>::value);
+            requires(!xslice_concept<T>);
 
         using base_index_type = xindex_type_t<typename xexpression_type::shape_type>;
 
@@ -1657,26 +1642,24 @@ namespace xt
     }
 
     template <class CT, class... S>
-    template <typename std::decay_t<CT>::size_type I, class T>
-    inline auto xview<CT, S...>::sliced_access(const xslice<T>& slice) const -> size_type
+    template <typename std::decay_t<CT>::size_type I, xslice_concept T>
+    inline auto xview<CT, S...>::sliced_access(const T& slice) const -> size_type
     {
-        return static_cast<size_type>(slice.derived_cast()(0));
+        return static_cast<size_type>(slice(0));
     }
 
     template <class CT, class... S>
-    template <typename std::decay_t<CT>::size_type I, class T, class Arg, class... Args>
-    inline auto xview<CT, S...>::sliced_access(const xslice<T>& slice, Arg arg, Args... args) const -> size_type
+    template <typename std::decay_t<CT>::size_type I, xslice_concept T, class Arg, class... Args>
+    inline auto xview<CT, S...>::sliced_access(const T& slice, Arg arg, Args... args) const -> size_type
     {
         using ST = typename T::size_type;
-        return static_cast<size_type>(
-            slice.derived_cast()(argument<I>(static_cast<ST>(arg), static_cast<ST>(args)...))
-        );
+        return static_cast<size_type>(slice(argument<I>(static_cast<ST>(arg), static_cast<ST>(args)...)));
     }
 
     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 -> size_type
-        requires(!is_xslice<T>::value)
+        requires(!xslice_concept<T>)
     {
         return static_cast<size_type>(squeeze);
     }
diff --git a/include/xtensor/views/xview_utils.hpp b/include/xtensor/views/xview_utils.hpp
index f74eb07e2..8ea89302f 100644
--- a/include/xtensor/views/xview_utils.hpp
+++ b/include/xtensor/views/xview_utils.hpp
@@ -50,7 +50,7 @@ namespace xt
     template <class S, class It>
     inline auto get_slice_value(const S& slice, It& it) noexcept
     {
-        if constexpr (is_xslice<S>::value)
+        if constexpr (xslice_concept<S>)
         {
             return slice(typename S::size_type(*it));
         }