diff --git a/include/experimental/__p2630_bits/submdspan.hpp b/include/experimental/__p2630_bits/submdspan.hpp
index abddd0b5..f2f18e17 100644
--- a/include/experimental/__p2630_bits/submdspan.hpp
+++ b/include/experimental/__p2630_bits/submdspan.hpp
@@ -17,6 +17,7 @@
 #pragma once
 
 #include "submdspan_extents.hpp"
+#include "submdspan_canonicalize_slices.hpp"
 #include "submdspan_mapping.hpp"
 
 namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
diff --git a/include/experimental/__p2630_bits/submdspan_canonicalize_slices.hpp b/include/experimental/__p2630_bits/submdspan_canonicalize_slices.hpp
new file mode 100644
index 00000000..ab732f56
--- /dev/null
+++ b/include/experimental/__p2630_bits/submdspan_canonicalize_slices.hpp
@@ -0,0 +1,469 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#pragma once
+
+#include "submdspan_extents.hpp"
+#include <complex>
+
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
+
+#if MDSPAN_HAS_CXX_17
+
+namespace detail {
+
+// ============================================================
+// de_ice: extract the value of an integral-constant-like type
+// ============================================================
+
+MDSPAN_TEMPLATE_REQUIRES(
+  class T,
+  /* requires */ (std::is_integral_v<remove_cvref_t<T>>)
+)
+MDSPAN_INLINE_FUNCTION
+constexpr T de_ice(T val) {
+  return val;
+}
+
+MDSPAN_TEMPLATE_REQUIRES(
+  class T,
+  /* requires */ (is_integral_constant_like_v<remove_cvref_t<T>>)
+)
+MDSPAN_INLINE_FUNCTION
+constexpr decltype(T::value) de_ice([[maybe_unused]] T) {
+  return T::value;
+}
+
+// ============================================================
+// index_cast: cast to IndexType, preserving integral-constant nature
+// ============================================================
+
+MDSPAN_TEMPLATE_REQUIRES(
+  class IndexType,
+  class OtherIndexType,
+  /* requires */ (
+    std::is_signed_v<remove_cvref_t<OtherIndexType>> ||
+    std::is_unsigned_v<remove_cvref_t<OtherIndexType>>
+  )
+)
+MDSPAN_INLINE_FUNCTION
+constexpr auto index_cast(OtherIndexType&& i) noexcept {
+  return i;
+}
+
+MDSPAN_TEMPLATE_REQUIRES(
+  class IndexType,
+  class OtherIndexType,
+  /* requires */ (
+    ! std::is_signed_v<remove_cvref_t<OtherIndexType>> &&
+    ! std::is_unsigned_v<remove_cvref_t<OtherIndexType>>
+  )
+)
+MDSPAN_INLINE_FUNCTION
+constexpr auto index_cast(OtherIndexType&& i) noexcept {
+  return static_cast<IndexType>(i);
+}
+
+// ============================================================
+// canonical_ice: canonicalize a value to IndexType,
+//   preserving integral-constant nature when possible
+// ============================================================
+
+MDSPAN_TEMPLATE_REQUIRES(
+  class IndexType,
+  class S,
+  /* requires */ (std::is_convertible_v<S, IndexType>)
+)
+MDSPAN_INLINE_FUNCTION
+constexpr auto canonical_ice([[maybe_unused]] S s) {
+  static_assert(std::is_signed_v<IndexType> || std::is_unsigned_v<IndexType>);
+  if constexpr (is_integral_constant_like_v<S>) {
+    return cw<static_cast<IndexType>(index_cast<IndexType>(S::value))>;
+  }
+  else {
+    return static_cast<IndexType>(index_cast<IndexType>(s));
+  }
+}
+
+// ============================================================
+// subtract_ice: subtract two values, preserving integral-constant
+//   nature when both inputs are integral-constant-like
+// ============================================================
+
+template<class IndexType, class X, class Y>
+MDSPAN_INLINE_FUNCTION
+constexpr auto subtract_ice([[maybe_unused]] X x, [[maybe_unused]] Y y) {
+  if constexpr (
+    is_integral_constant_like_v<remove_cvref_t<X>> &&
+    is_integral_constant_like_v<remove_cvref_t<Y>>)
+  {
+    return cw<IndexType(canonical_ice<IndexType>(Y::value) - canonical_ice<IndexType>(X::value))>;
+  }
+  else {
+    return canonical_ice<IndexType>(y) - canonical_ice<IndexType>(x);
+  }
+}
+
+// ============================================================
+// check_static_bounds_result: result of a compile-time bounds check
+// ============================================================
+
+enum class check_static_bounds_result {
+  in_bounds,
+  out_of_bounds,
+  unknown
+};
+
+// ============================================================
+// is_std_complex: detect std::complex (for pre-tuple-like compilers)
+// ============================================================
+
+// Clang 21.0.0 does not define __cpp_lib_tuple_like, so it does not
+// support the tuple protocol for std::complex.  Interestingly, it permits
+// structured binding, but decomposes it into one element, not two.
+// We work around with a special canonicalization case.
+#if ! defined(__cpp_lib_tuple_like) || (__cpp_lib_tuple_like < 202311L)
+template<class T>
+constexpr bool is_std_complex = false;
+template<class T>
+constexpr bool is_std_complex<std::complex<T>> = true;
+#endif
+
+// ============================================================
+// check_static_bounds: compile-time bounds check for a slice
+//
+// Returns whether the k-th slice is statically in bounds,
+// out of bounds, or unknown (dynamic bounds or dynamic slice values).
+//
+// This function is called only in static_assert contexts.
+// ============================================================
+
+template<size_t k, class S_k, class IndexType, size_t... Exts>
+constexpr check_static_bounds_result check_static_bounds(
+  const extents<IndexType, Exts...>&)
+{
+#if defined(__cpp_pack_indexing)
+  constexpr size_t Exts_k = Exts...[k];
+#else
+  constexpr size_t Exts_k = [] () {
+    size_t result = 0;
+    size_t i = 0;
+    (void) ((i++ == k ? (result = Exts, true) : false) || ...);
+    return result;
+  } ();
+#endif
+
+  if constexpr (std::is_convertible_v<S_k, full_extent_t>) {
+    return check_static_bounds_result::in_bounds;
+  }
+  else if constexpr (std::is_convertible_v<S_k, IndexType>) {
+    if constexpr (is_integral_constant_like_v<S_k>) {
+      if constexpr (de_ice(S_k{}) < 0) {
+        return check_static_bounds_result::out_of_bounds;
+      }
+      else if constexpr (
+        Exts_k != dynamic_extent &&
+        Exts_k <= static_cast<size_t>(de_ice(S_k{})))
+      {
+        return check_static_bounds_result::out_of_bounds;
+      }
+      else if constexpr (
+        Exts_k != dynamic_extent &&
+        static_cast<size_t>(de_ice(S_k{})) < Exts_k)
+      {
+        return check_static_bounds_result::in_bounds;
+      }
+      else {
+        return check_static_bounds_result::unknown;
+      }
+    }
+    else {
+      return check_static_bounds_result::unknown;
+    }
+  }
+  else if constexpr (is_strided_slice<S_k>::value) {
+    using offset_type = typename S_k::offset_type;
+
+    if constexpr (is_integral_constant_like_v<offset_type>) {
+      if constexpr (de_ice(offset_type{}) < 0) {
+        return check_static_bounds_result::out_of_bounds;
+      }
+      else if constexpr (
+        Exts_k != dynamic_extent &&
+        Exts_k < static_cast<size_t>(de_ice(offset_type{})))
+      {
+        return check_static_bounds_result::out_of_bounds;
+      }
+      else if constexpr (is_integral_constant_like_v<typename S_k::extent_type>) {
+        using extent_type = typename S_k::extent_type;
+
+        if constexpr (de_ice(offset_type{}) + de_ice(extent_type{}) < 0) {
+          return check_static_bounds_result::out_of_bounds;
+        }
+        else if constexpr (
+          Exts_k != dynamic_extent &&
+          Exts_k <
+            static_cast<size_t>(de_ice(offset_type{}) + de_ice(extent_type{})))
+        {
+          return check_static_bounds_result::out_of_bounds;
+        }
+        else if constexpr (
+          Exts_k != dynamic_extent &&
+          0 <= de_ice(offset_type{}) &&
+          de_ice(offset_type{}) <=
+            de_ice(offset_type{}) + de_ice(extent_type{}) &&
+          static_cast<size_t>(
+            de_ice(offset_type{}) + de_ice(extent_type{})) <= Exts_k)
+        {
+          return check_static_bounds_result::in_bounds;
+        }
+        else {
+          return check_static_bounds_result::unknown;
+        }
+      }
+      else {
+        return check_static_bounds_result::unknown;
+      }
+    }
+    else {
+      return check_static_bounds_result::unknown;
+    }
+  }
+#if ! defined(__cpp_lib_tuple_like) || (__cpp_lib_tuple_like < 202311L)
+  else if constexpr (is_std_complex<S_k>) {
+    return check_static_bounds_result::unknown;
+  }
+#endif
+  else {
+    // General pair-like case: attempt to get the first and second elements.
+    // If S_k cannot be structured-bound into two elements, this is ill-formed,
+    // which implements the Mandates clause.
+    auto get_first = [] (S_k s_k) {
+      auto [s_k0, _x] = s_k;
+      return s_k0;
+    };
+    auto get_second = [] (S_k s_k) {
+      auto [_x, s_k1] = s_k;
+      return s_k1;
+    };
+    using S_k0 = decltype(get_first(std::declval<S_k>()));
+    using S_k1 = decltype(get_second(std::declval<S_k>()));
+    if constexpr (is_integral_constant_like_v<S_k0>) {
+      if constexpr (de_ice(S_k0{}) < 0) {
+        return check_static_bounds_result::out_of_bounds;
+      }
+      else if constexpr (
+        Exts_k != dynamic_extent &&
+        Exts_k < static_cast<size_t>(de_ice(S_k0{})))
+      {
+        return check_static_bounds_result::out_of_bounds;
+      }
+      else if constexpr (is_integral_constant_like_v<S_k1>) {
+        if constexpr (de_ice(S_k1{}) < de_ice(S_k0{})) {
+          return check_static_bounds_result::out_of_bounds;
+        }
+        else if constexpr (
+          Exts_k != dynamic_extent &&
+          Exts_k < static_cast<size_t>(de_ice(S_k1{})))
+        {
+          return check_static_bounds_result::out_of_bounds;
+        }
+        else if constexpr (
+          Exts_k != dynamic_extent &&
+          0 <= de_ice(S_k0{}) &&
+          de_ice(S_k0{}) <= de_ice(S_k1{}) &&
+          static_cast<size_t>(de_ice(S_k1{})) <= Exts_k)
+        {
+          return check_static_bounds_result::in_bounds;
+        }
+        else {
+          return check_static_bounds_result::unknown;
+        }
+      }
+      else {
+        return check_static_bounds_result::unknown;
+      }
+    }
+    else {
+      return check_static_bounds_result::unknown;
+    }
+  }
+}
+
+// ============================================================
+// check_submdspan_slice_mandate: mandate check for the k-th slice
+//
+// Contains only static_asserts; no actual computation.
+// Separated from submdspan_canonicalize_one_slice so that
+// mandate checking and canonicalization are distinct concerns.
+// ============================================================
+
+template<size_t k, class IndexType, size_t... Extents, class Slice>
+MDSPAN_INLINE_FUNCTION
+constexpr void check_submdspan_slice_mandate(
+  const extents<IndexType, Extents...>&,
+  [[maybe_unused]] Slice)
+{
+  static_assert(
+    check_static_bounds<k, Slice>(extents<IndexType, Extents...>{}) !=
+    check_static_bounds_result::out_of_bounds);
+}
+
+// ============================================================
+// check_submdspan_slice_mandates: mandate check for all slices
+//
+// Calls check_submdspan_slice_mandate for each slice.
+// Separated from canonicalization so mandate checking is explicit.
+// ============================================================
+
+template<size_t... Inds, class IndexType, size_t... Extents, class... Slices>
+MDSPAN_INLINE_FUNCTION
+constexpr void check_submdspan_slice_mandates(
+  std::index_sequence<Inds...>,
+  const extents<IndexType, Extents...>& exts,
+  Slices... slices)
+{
+  (check_submdspan_slice_mandate<Inds>(exts, slices), ...);
+}
+
+// ============================================================
+// submdspan_canonicalize_one_slice: canonicalize a single slice
+//
+// This function performs ONLY the conversion to canonical form.
+// Mandate checking (static_asserts) is NOT done here; it is
+// done separately by check_submdspan_slice_mandates.
+//
+// Templated only on IndexType (the extents index type) and Slice.
+// Neither k nor the extents are needed for the actual conversion.
+// ============================================================
+
+template<class IndexType, class Slice>
+MDSPAN_INLINE_FUNCTION
+constexpr auto submdspan_canonicalize_one_slice([[maybe_unused]] Slice s)
+{
+  if constexpr (std::is_convertible_v<Slice, full_extent_t>) {
+    return full_extent; // canonical full-extent slice
+  }
+  else if constexpr (std::is_convertible_v<Slice, IndexType>) {
+    return canonical_ice<IndexType>(s); // canonical integer index
+  }
+  else if constexpr (is_strided_slice<Slice>::value) {
+    // Canonicalize each component of the strided_slice
+    auto offset = canonical_ice<IndexType>(s.offset);
+    auto extent = canonical_ice<IndexType>(s.extent);
+    auto stride = canonical_ice<IndexType>(s.stride);
+    return strided_slice<decltype(offset), decltype(extent), decltype(stride)>{
+      /* .offset = */ offset,
+      /* .extent = */ extent,
+      /* .stride = */ stride
+    };
+  }
+#if ! defined(__cpp_lib_tuple_like) || (__cpp_lib_tuple_like < 202311L)
+  else if constexpr (is_std_complex<Slice>) {
+    // std::complex<T> used as [real, imag) range (offset, offset+extent)
+    auto offset = canonical_ice<IndexType>(s.real());
+    auto extent = canonical_ice<IndexType>(s.imag() - s.real());
+    auto stride = cw<IndexType(1)>;
+    return strided_slice<decltype(offset), decltype(extent), decltype(stride)>{
+      /* .offset = */ offset,
+      /* .extent = */ extent,
+      /* .stride = */ stride
+    };
+  }
+#endif
+  else {
+    // General pair-like case: structured binding into [first, last)
+    auto [s_k0, s_k1] = s;
+    using S_k0 = decltype(s_k0);
+    using S_k1 = decltype(s_k1);
+    static_assert(std::is_convertible_v<S_k0, IndexType>);
+    static_assert(std::is_convertible_v<S_k1, IndexType>);
+
+    auto offset = canonical_ice<IndexType>(s_k0);
+    auto extent = subtract_ice<IndexType>(s_k0, s_k1);
+    auto stride = cw<IndexType(1)>;
+    return strided_slice<decltype(offset), decltype(extent), decltype(stride)>{
+      /* .offset = */ offset,
+      /* .extent = */ extent,
+      /* .stride = */ stride
+    };
+  }
+}
+
+// ============================================================
+// submdspan_canonicalize_slices_impl: implementation helper
+//
+// First performs mandate checks (static_asserts), then
+// returns a detail::tuple of canonical slices.
+// Using detail::tuple instead of std::tuple ensures device
+// code compatibility (e.g., CUDA).
+// ============================================================
+
+MDSPAN_TEMPLATE_REQUIRES(
+  size_t... Inds,
+  class IndexType,
+  size_t... Extents,
+  class... Slices,
+  /* requires */ (sizeof...(Slices) == sizeof...(Extents))
+)
+MDSPAN_INLINE_FUNCTION
+constexpr auto submdspan_canonicalize_slices_impl(
+  std::index_sequence<Inds...>,
+  const extents<IndexType, Extents...>& exts,
+  Slices... slices)
+{
+  // Mandate checks (static_asserts only, no computation).
+  // Separated from canonicalization for clarity.
+  check_submdspan_slice_mandates(
+    std::make_index_sequence<sizeof...(Slices)>(), exts, slices...);
+
+  // Actual canonicalization: returns detail::tuple for device compatibility.
+  return detail::tuple{
+    submdspan_canonicalize_one_slice<IndexType>(slices)...
+  };
+}
+
+} // namespace detail
+
+// ============================================================
+// submdspan_canonicalize_slices: public API
+//
+// Given an extents object and a pack of slice specifiers,
+// returns a detail::tuple of canonical slice specifiers.
+// Each canonical slice is one of:
+//   - full_extent_t (for full-extent slices)
+//   - IndexType (for integer index slices)
+//   - strided_slice<...> (for range and strided-range slices)
+// ============================================================
+
+MDSPAN_TEMPLATE_REQUIRES(
+  class IndexType,
+  size_t... Extents,
+  class... Slices,
+  /* requires */ (sizeof...(Slices) == sizeof...(Extents))
+)
+MDSPAN_INLINE_FUNCTION
+constexpr auto submdspan_canonicalize_slices(
+  const extents<IndexType, Extents...>& exts,
+  Slices&&... slices)
+{
+  return detail::submdspan_canonicalize_slices_impl(
+    std::make_index_sequence<sizeof...(Slices)>(), exts, slices...);
+}
+
+#endif // MDSPAN_HAS_CXX_17
+
+} // namespace MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 1693ac65..eb87423d 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -99,6 +99,7 @@ if(NOT CMAKE_CXX_STANDARD STREQUAL "14")
   mdspan_add_test(test_submdspan_static_slice)
   mdspan_add_test(test_layout_padded_left ENABLE_PRECONDITIONS)
   mdspan_add_test(test_layout_padded_right ENABLE_PRECONDITIONS)
+  mdspan_add_test(test_canonicalize_slices)
 endif()
 # both of those don't work yet since its using vector
 if(NOT MDSPAN_ENABLE_CUDA AND NOT MDSPAN_ENABLE_HIP)
diff --git a/tests/test_canonicalize_slices.cpp b/tests/test_canonicalize_slices.cpp
new file mode 100644
index 00000000..d85a9507
--- /dev/null
+++ b/tests/test_canonicalize_slices.cpp
@@ -0,0 +1,332 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+#include <mdspan/mdspan.hpp>
+#include <type_traits>
+#include <utility>
+
+#include <gtest/gtest.h>
+
+namespace my_test {
+
+// Aggregate pair type (supports structured binding natively as aggregate)
+template<class First, class Second>
+struct my_aggregate_pair {
+  First first;
+  Second second;
+};
+
+// Non-aggregate pair type (uses the tuple protocol)
+template<class First, class Second>
+class my_nonaggregate_pair {
+public:
+  constexpr my_nonaggregate_pair(First first, Second second)
+    : first_(first), second_(second)
+  {}
+
+  template<std::size_t Index>
+  constexpr auto get() -> std::conditional_t<Index == 0, First, Second> {
+    if constexpr (Index == 0) {
+      return first_;
+    }
+    else {
+      static_assert(Index == 1);
+      return second_;
+    }
+  }
+
+  template<std::size_t Index>
+  constexpr auto get() const -> std::conditional_t<Index == 0, First, Second> {
+    if constexpr (Index == 0) {
+      return first_;
+    }
+    else {
+      static_assert(Index == 1);
+      return second_;
+    }
+  }
+
+private:
+  First first_;
+  Second second_;
+};
+
+} // namespace my_test
+
+template<class First, class Second>
+struct std::tuple_size<my_test::my_nonaggregate_pair<First, Second>>
+  : std::integral_constant<std::size_t, 2> {};
+
+template<std::size_t Index, class First, class Second>
+struct std::tuple_element<Index, my_test::my_nonaggregate_pair<First, Second>> {
+  static_assert(Index == 0 || Index == 1, "Index out of range");
+};
+
+template<class First, class Second>
+struct std::tuple_element<0, my_test::my_nonaggregate_pair<First, Second>> {
+  using type = First;
+};
+
+template<class First, class Second>
+struct std::tuple_element<1, my_test::my_nonaggregate_pair<First, Second>> {
+  using type = Second;
+};
+
+template<std::size_t Index, class First, class Second>
+constexpr auto get(my_test::my_nonaggregate_pair<First, Second>& p)
+  -> std::conditional_t<Index == 0, First, Second>
+{
+  return p.template get<Index>();
+}
+
+template<std::size_t Index, class First, class Second>
+constexpr auto get(const my_test::my_nonaggregate_pair<First, Second>& p)
+  -> std::conditional_t<Index == 0, First, Second>
+{
+  return p.template get<Index>();
+}
+
+namespace {
+
+// ============================================================
+// Helpers for comparing slices
+// ============================================================
+
+// full_extent_t lacks operator==; two full_extent_t values are always equal
+constexpr bool slice_equal(
+  MDSPAN_IMPL_STANDARD_NAMESPACE::full_extent_t,
+  MDSPAN_IMPL_STANDARD_NAMESPACE::full_extent_t)
+{
+  return true;
+}
+
+template<class O1, class E1, class S1, class O2, class E2, class S2>
+constexpr bool slice_equal(
+  const MDSPAN_IMPL_STANDARD_NAMESPACE::strided_slice<O1, E1, S1>& left,
+  const MDSPAN_IMPL_STANDARD_NAMESPACE::strided_slice<O2, E2, S2>& right)
+{
+  return left.offset == right.offset &&
+         left.extent == right.extent &&
+         left.stride == right.stride;
+}
+
+// Integer (index) slices: compare by value
+template<class T,
+  std::enable_if_t<std::is_integral_v<T>, int> = 0>
+constexpr bool slice_equal(T left, T right) {
+  return left == right;
+}
+
+// Integral-constant-like slices: compare their values
+template<class T, class U,
+  std::enable_if_t<
+    MDSPAN_IMPL_STANDARD_NAMESPACE::detail::is_integral_constant_like_v<T> &&
+    MDSPAN_IMPL_STANDARD_NAMESPACE::detail::is_integral_constant_like_v<U>,
+    int> = 0>
+constexpr bool slice_equal(T, U) {
+  return T::value == U::value;
+}
+
+// ============================================================
+// Test helpers: compare the k-th element of result vs expected
+// ============================================================
+
+template<size_t Index, class Result, class ExpectedResult>
+void test_canonicalize_slices_impl_one(
+  std::integral_constant<size_t, Index>,
+  const Result& result,
+  const ExpectedResult& expected_result)
+{
+  // Use ADL to find the right get<>() for each tuple type
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::get;
+  using std::get;
+  auto left = get<Index>(result);
+  auto right = get<Index>(expected_result);
+  const bool outcome = slice_equal(left, right);
+  ASSERT_TRUE(outcome) << " failed for k=" << Index;
+}
+
+template<size_t... Indices, class Result, class ExpectedResult>
+void test_canonicalize_slices_impl(
+  std::index_sequence<Indices...>,
+  const Result& result,
+  const ExpectedResult& expected_result)
+{
+  (test_canonicalize_slices_impl_one(
+    std::integral_constant<size_t, Indices>{}, result, expected_result), ...);
+}
+
+template<class ExpectedResult, class InputExtents, class... Slices>
+void test_canonicalize_slices(
+  const ExpectedResult& expected_result,
+  const InputExtents& input_extents,
+  Slices... slices)
+{
+  auto result = MDSPAN_IMPL_STANDARD_NAMESPACE::submdspan_canonicalize_slices(
+    input_extents, slices...);
+  test_canonicalize_slices_impl(
+    std::make_index_sequence<sizeof...(Slices)>(), result, expected_result);
+}
+
+// ============================================================
+// Tests
+// ============================================================
+
+TEST(CanonicalizeSlices, Rank0) {
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::tuple;
+  test_canonicalize_slices(tuple{}, MDSPAN_IMPL_STANDARD_NAMESPACE::extents<int>{});
+  test_canonicalize_slices(tuple{}, MDSPAN_IMPL_STANDARD_NAMESPACE::extents<size_t>{});
+}
+
+TEST(CanonicalizeSlices, Rank1_full) {
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::tuple;
+  constexpr auto full = MDSPAN_IMPL_STANDARD_NAMESPACE::full_extent;
+  const auto expected_result = tuple{full};
+  test_canonicalize_slices(expected_result,
+    MDSPAN_IMPL_STANDARD_NAMESPACE::extents<int, 10>{}, full);
+  test_canonicalize_slices(expected_result,
+    MDSPAN_IMPL_STANDARD_NAMESPACE::extents<size_t,
+      MDSPAN_IMPL_STANDARD_NAMESPACE::dynamic_extent>{},
+    full);
+}
+
+TEST(CanonicalizeSlices, Rank1_integer_dynamic) {
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::cw;
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::tuple;
+
+  constexpr auto slice0 = int(7);
+  constexpr auto expected_slices = tuple{size_t(7u)};
+  constexpr auto exts = MDSPAN_IMPL_STANDARD_NAMESPACE::extents<size_t, 10>{};
+  test_canonicalize_slices(expected_slices, exts, slice0);
+}
+
+TEST(CanonicalizeSlices, Rank1_integer_static) {
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::cw;
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::tuple;
+
+  constexpr auto slice0 = std::integral_constant<int, 7>{};
+  constexpr auto expected_slices = tuple{cw<size_t(7u)>};
+  constexpr auto exts = MDSPAN_IMPL_STANDARD_NAMESPACE::extents<size_t, 10>{};
+  test_canonicalize_slices(expected_slices, exts, slice0);
+}
+
+TEST(CanonicalizeSlices, Rank1_pair) {
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::cw;
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::tuple;
+
+  // std::pair with static first element, dynamic second
+  constexpr auto slice0 = std::pair{std::integral_constant<int, 7>{}, 11};
+
+  constexpr auto offset = cw<size_t(7u)>;
+  constexpr auto extent = size_t(4u); // 11 - 7
+  constexpr auto stride = cw<size_t(1u)>;
+
+  const auto expected_slices = tuple{
+    MDSPAN_IMPL_STANDARD_NAMESPACE::strided_slice<
+      decltype(offset), decltype(extent), decltype(stride)
+    >{offset, extent, stride}
+  };
+  constexpr auto exts = MDSPAN_IMPL_STANDARD_NAMESPACE::extents<size_t, 13>{};
+  test_canonicalize_slices(expected_slices, exts, slice0);
+}
+
+TEST(CanonicalizeSlices, Rank1_aggregate_pair) {
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::cw;
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::tuple;
+
+  constexpr auto slice0 = my_test::my_aggregate_pair<int, int>{7, 11};
+
+  constexpr auto offset = size_t(7u);
+  constexpr auto extent = size_t(4u); // 11 - 7
+  constexpr auto stride = cw<size_t(1u)>;
+
+  const auto expected_slices = tuple{
+    MDSPAN_IMPL_STANDARD_NAMESPACE::strided_slice<
+      decltype(offset), decltype(extent), decltype(stride)
+    >{offset, extent, stride}
+  };
+  constexpr auto exts = MDSPAN_IMPL_STANDARD_NAMESPACE::extents<size_t, 13>{};
+  test_canonicalize_slices(expected_slices, exts, slice0);
+}
+
+TEST(CanonicalizeSlices, Rank1_nonaggregate_pair) {
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::cw;
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::tuple;
+
+  auto slice0 = my_test::my_nonaggregate_pair<int, int>(7, 11);
+
+  constexpr auto offset = size_t(7u);
+  constexpr auto extent = size_t(4u); // 11 - 7
+  constexpr auto stride = cw<size_t(1u)>;
+
+  const auto expected_slices = tuple{
+    MDSPAN_IMPL_STANDARD_NAMESPACE::strided_slice<
+      decltype(offset), decltype(extent), decltype(stride)
+    >{offset, extent, stride}
+  };
+  constexpr auto exts = MDSPAN_IMPL_STANDARD_NAMESPACE::extents<size_t, 13>{};
+  test_canonicalize_slices(expected_slices, exts, slice0);
+}
+
+TEST(CanonicalizeSlices, Rank2_full) {
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::tuple;
+  constexpr auto full = MDSPAN_IMPL_STANDARD_NAMESPACE::full_extent;
+  const auto expected_result = tuple{full, full};
+  test_canonicalize_slices(expected_result,
+    MDSPAN_IMPL_STANDARD_NAMESPACE::extents<int, 11, 13>{}, full, full);
+}
+
+TEST(CanonicalizeSlices, Rank1_strided_slice_dynamic) {
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::cw;
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::tuple;
+
+  // strided_slice with all dynamic values
+  const auto slice0 = MDSPAN_IMPL_STANDARD_NAMESPACE::strided_slice<int, int, int>{
+    /* .offset = */ 1,
+    /* .extent = */ 4,
+    /* .stride = */ 2
+  };
+
+  const auto expected_slices = tuple{
+    MDSPAN_IMPL_STANDARD_NAMESPACE::strided_slice<size_t, size_t, size_t>{
+      size_t(1), size_t(4), size_t(2)
+    }
+  };
+  const auto exts = MDSPAN_IMPL_STANDARD_NAMESPACE::extents<size_t, 10>{};
+  test_canonicalize_slices(expected_slices, exts, slice0);
+}
+
+TEST(CanonicalizeSlices, Rank1_strided_slice_static) {
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::cw;
+  using MDSPAN_IMPL_STANDARD_NAMESPACE::detail::tuple;
+
+  using offset_t = std::integral_constant<int, 1>;
+  using extent_t = std::integral_constant<int, 4>;
+  using stride_t = std::integral_constant<int, 2>;
+  const auto slice0 =
+    MDSPAN_IMPL_STANDARD_NAMESPACE::strided_slice<offset_t, extent_t, stride_t>{};
+
+  const auto expected_slices = tuple{
+    MDSPAN_IMPL_STANDARD_NAMESPACE::strided_slice<
+      decltype(cw<size_t(1)>),
+      decltype(cw<size_t(4)>),
+      decltype(cw<size_t(2)>)
+    >{cw<size_t(1)>, cw<size_t(4)>, cw<size_t(2)>}
+  };
+  const auto exts = MDSPAN_IMPL_STANDARD_NAMESPACE::extents<size_t, 10>{};
+  test_canonicalize_slices(expected_slices, exts, slice0);
+}
+
+} // namespace (anonymous)