Split strided_slice into extent_slice and range_slice for C++26

This paper proposes two changes:

1. Rename strided_slice to extent_stride and adjust the meaning of extent member, to designate the desired number of elements in the produced range.
2. Introduce a new non-canonical slice type range_slice, that expresses the (first, last, stride) interface for range slicing provided by other programming languages.

From the above only the first change need to be applied in the C++26 timeframe. The others are extensions that could be applied to future standards.

4.1. Proposed polls

1. Foward P3982R1 as resolution for PL007 NB comment to LWG for inclusion to C++26.

2. Foward P3982R1 without range_slice adition as resolution for PL007 NB comment to LWG for inclusion to C++26.

4.2. extent_slice needs to target C++26

strided_slice is one of the canonical slice types that define the interface between submdspan (and potentially other components providing such facility) and custom layouts. Thus, it is important that the interface is both mininal (reducing the burden on layouts implementers) and able to represent a wide range of input without loss of information. As this document explains, the current specification of strided_slice fails in both accounts (it incurs cost of division, and cannot be used for non-unique layouts).

We currently reserve rights to introduce additional canonical stride types. We could imagine introducing a separate canonical_strided_slice type in a later standard. However, in contrast to amending strided_slice, this would essentially duplicate the number of types that layouts would need to handle, as pre-existing code depending on sliceable layout requirements may still produce strided_slice objects.

4.3. range_slice should target C++26

While range_slice could be added later as an extension, the authors strongly believe that the ergonomics of submdspan would be severly degraded, without the ability to specify a slice using an input span.

During the work on this paper, one of the authors (Tomasz) made the following mistakes, when transforming the input span span to an output extent:

• using span / stride,
• using (span - 1) / stride (missing +1),
• not accounting for span equal to zero.

5. Impact and Implementability

This paper only impacts the behavior of the std::submdspan library function that was introduced in C++26.

Here is a patch series implementing the proposed wording changes to submdspan in libstdc++.

6. Proposed Wording

The proposed wording changes refer to N5032 (C++ Working Draft, 2025-12-15).

Apply following changes to section [mdspan.syn] Header <mdspan> synopsis:

  // [mdspan.sub], submdspan creation
  template<class OffsetType, class LengthType, class StrideType>
    struct strided_slice;
  template<class FirstType, class LastType,
           class StrideType = std::constant_wrapper<1zu>>
    struct range_slice;

  template<class LayoutMapping>
    struct submdspan_mapping_result;

Apply following changes to section [mdspan.sub.overview] Overview :

-1- The submdspan facilities create a new mdspan viewing a subset of elements of an existing input mdspan. The subset viewed by the created mdspan is determined by the SliceSpecifier arguments.

-2- Given a signed or unsigned integer type IndexType, a type S is a submdspan slice type for IndexType if at least one of the following holds:

• -2.1- is_convertible_v<S, full_extent_t> is true;
• -2.2- is_convertible_v<S, IndexType> is true;
• -2.3- S is a specialization of strided_slice and is_convertible_v<X, IndexType> is true for X denoting S::offset_type, S::extent_type, and S::stride_type;or
• -2.?- S is a specialization of range_slice and is_convertible_v<X, IndexType> is true for X denoting type of S::first, S::last, and S::stride members; or
• -2.4- all of the following hold:
  • -2.4.1- the declaration auto [...ls] = std::move(s); is well-formed for some object s of type S,
  • -2.4.2- sizeof...(ls) is equal to 2, and
  • -2.4.3- (is_convertible_v<decltype(std::move(ls)), IndexType> && ...) is true.

-3- Given a signed or unsigned integer type IndexType, a type S is a canonical submdspan index type for IndexType if S is either IndexType or constant_wrapper<v> for some value v of type IndexType, such that v is greater than or equal to zero.

-4- Given a signed or unsigned integer type IndexType, a type S is a canonical submdspan slice type for IndexType if exactly one of the following is true:

• -4.1- S is full_extent_t;
• -4.2- S is a canonical submdspan index type for IndexType; or
• -4.3- S a specialization of strided_slice where all of the following hold:
  • -4.3.1- S::offset_type, S::extent_type, and S::stride_type are all canonical submdspan index types for IndexType; and
  • -4.2.2- if S::stride_type and S::extent_type are both specializations of constant_wrapper, then S::stride_type::value is greater than zero.

-5- A type S is a collapsing slice type if […]

-6- A type S is a unit-stride slice type if […]

-7- Given an object e of type E that is a specialization of extents, and an object s of type S that is a canonical submdspan slice type for E::index_type, the submdspan slice range of s for the k^th extent of e is:

• -7.1- [0, e.extent(k)), if S is full_extent_t;
• -7.?- [E::index_type(s.offset), E::index_type(s.offset)), if S is a specialization of strided_slice and E::index_type(s.extent) is zero; otherwise
• -7.2- [E::index_type(s.offset), E::index_type(s.offset + 1 + (s.extent - 1) * s.stride)), if S is a specialization of strided_slice; otherwise
• -7.3- [E::index_type(s), E::index_type(s)+1)

-8- Given a type E that is a specialization of extents, a type S is a valid submdspan slice type for the k^th extent of E if S is a canonical slice type for E::index_type, and for x equal to E::static_extent(k), either x is equal to dynamic_extent; or

• -8.1- if S is a specialization of strided_slice:
  • -8.1.1- if S::offset_type is a specialization of constant_wrapper, then S::offset_type::valueo is less than or equal to x;
  • -8.1.2- if S::extent_type is a specialization of constant_wrapper then S::extent_type::value e is less than or equal to x;
  • -8.1.?- if e is greater than one, then t is greater than zero,
  • -8.1.3- if both S::offset_type andS::extent_type are specializations of constant_wrapper then, S::offset_type::value + S::extent_type::value
    if e is greater than zero, then o + 1 + (e - 1) * t is less than or equal to x
  where
  • -8.1.4- o is value of S::offset_type::value if S::offset_type is a specialization of constant_wrapper and 0 otherwise,
  • -8.1.5- e is value of S::extent_type::value if S::extent_type is a specialization of constant_wrapper and 0 otherwise,
  • -8.1.6- t is value of S::stride_type::value if S::stride_type is a specialization of constant_wrapper and 1 otherwise.
• -8.2- if S is a specialization of constant_wrapper, then S::value is less than x

-9- Given an object e of type E that is a specialization of extents and an object s of type S, s is a valid submdspan slice for the k^th extent of e if:

• -9.1- S is a valid submdspan slice type for k^th extent of E;
• -9.2- the k^th interval of e contains the submdspan slice range of s for the k^th extent of e; and
• -9.3- if S a specialization of strided_slice then:
  • -9.3.1- s.extent is greater than or equal to zero, and
  • -9.3.2- either s.extent equals zerois less than two or s.stride is greater than zero.

Apply following changes to section [mdspan.sub.strided.slice] strided_slice:

23.7.3.7.2 strided_sliceRange slices [mdspan.sub.stridedrange.slices]

-1- strided_slice and range_slice represents a set of extent regularly spaced integer indices. The indices start at offset and first respectively, and increase by increments of stride.

  namespace std {
    template<class OffsetType, class ExtentType, class StrideType>
    struct strided_slice {
      using offset_type = OffsetType;
      using extent_type = ExtentType;
      using stride_type = StrideType;

      [[no_unique_address]] offset_type offset{};
      [[no_unique_address]] extent_type extent{};
      [[no_unique_address]] stride_type stride{};
    };

    template<class FirstType, class LastType,
             class StrideType = std::constant_wrapper<1zu>>
    struct range_slice {
      [[no_unique_address]] FirstType first{};
      [[no_unique_address]] LastType last{};
      [[no_unique_address]] StrideType stride{};
    };
  }

-2- strided_slice and range_slice has have the data members and special members specified above. It has They have no base classes or members other than those specified.

-3- Mandates:

OffsetType, ExtentType, FirstType, LastType, and StrideType are signed or unsigned integer types, or model integral-constant-like.

[ Note: Both strided_slice{ .offset = 1, .extent = 104, .stride = 3} and range_slice{ .first = 1, .last = 11, .stride = 3} indicates the indices 1, 4, 7, and 10. Indices are selected from the half-open interval [1, 1 + 10). — end note]

Apply following changes to section [mdspan.sub.helpers] Exposition-only helpers:

    template<class T>
      concept is-strided-slice = see below;

-2- The concept is-strided-slice<T> is satisfied and modeled if and only if T is a specialization of strided_slice.

    template<class T>
      concept is-range-slice = see below;

-?- The concept is-range-slice<T> is satisfied and modeled if and only if T is a specialization of range_slice.

    template<class IndexType, class S>
      constexpr auto canonical-index(S s);

-3- Mandates:

[…];

-4- Preconditions:

[…];

-5- Effects:

[…];

    template<class IndexType, class OffsetType, class SpanType, class... StrideTypes>
      constexpr auto canonical-range-slice(OffsetType offset, SpanType span, StrideTypes... strides);

-?- Let:

• StrideType denote
  • constant_wrapper<IndexType(1)> if StrideTypes is an empty pack or SpanType denotes constant_wrapper<IndexType(0)>, otherwise
  • StrideTypes...[0];
• stride be
  • StrideType() if StrideType is a specialization of constant_wrapper, otherwise
  • IndexType(1) if span == 0 is true, otherwise
  • strides...[0];
• extent-value be 1 + (span - 1) / stride if span != 0 is true, and 0 otherwise;
• extent be cw<IndexType(extent-value)> if both SpanType and StrideType are specializations of constant_wrapper, and IndexType(extent-value) otherwise.

-?- Mandates:

• sizeof...(StrideTypes) <= 1 is true, and
• if StrideType is a specialization of constant_wrapper, then StrideType::value > 0 is true.

-?- Preconditions:

stride > 0 is true.

-?- Returns:

strided_slice{ .offset = offset, .extent = extent, .stride = stride };

    template<class IndexType, class S>
      constexpr auto canonical-slice(S s);

-6- Mandates:

S is a submdspan slice type for IndexTye.

-7- Effects:

Equivalent to:

    if constexpr (is_convertible_v<S, full_extent_t>) {
      return static_cast<full_extent_t>(std::move(s));
    } else if constexpr (is_convertible_v<S, IndexType>) {
      return canonical-index<IndexType>(std::move(s));
    } else if constexpr (is-strided-slice<S>) {
      return strided_slice{
        .offset = canonical-index<IndexType>(std::move(s.extent)),
        .extent = canonical-index<IndexType>(std::move(s.offset)),
        .stride = canonical-index<IndexType>(std::move(s.stride))
      };
      auto c_extent = canonical-index<IndexType>(std::move(s.extent));
      auto c_offset = canonical-index<IndexType>(std::move(s.offset));
      if constexpr (is_same_v<decltype(c_extent), constant_wrapper<IndexType(0)>>) {
        return strided_slice{
          .offset = c_offset,
          .extent = c_extent,
          .stride = cw<IndexType(1)>
         };
      } else {
         return strided_slice{
           .offset = c_offset,
           .extent = c_extent,
           .stride = canonical-index<IndexType>(std::move(s.stride))
	 };
      }
    } else if constexpr (is-range-slice<S>) {
      auto c_first = canonical-index<IndexType>(std::move(s.first));
      auto c_last  = canonical-index<IndexType>(std::move(s.last));
      return canonical-slice-range<IndexType>(
                c_first,
		canonical-index<IndexType>(c_last - c_first),
		canonical-index<IndexType>(std::move(s.stride));
    } else {
      auto [s_first, s_last] = std::move(s);
      auto c_first = canonical-index<IndexType>(std::move(s_first));
      auto c_last  = canonical-index<IndexType>(std::move(s_last));
      return strided_slice{
          .offset = c_first,
          .extent = canonical-index<IndexType>(c_last - c_first),
          .stride = cw<IndexType(1)>
        };
      return canonical-slice-range<IndexType>(
               c_first,
	       canonical-index<IndexType>(c_last - c_first));
    }
    

Apply following changes to section [mdspan.sub.extents] submdspan_extents function:

    template<class IndexType, size_t... Extents, class... SliceSpecifiers>
      constexpr auto submdspan_extents(const extents<IndexType, Extents...>& src,
                                       SliceSpecifiers... raw_slices);

-1- Let slices be […];

-2- Constraints:

[…];

-3- Mandates:

[…];

-4- Preconditions:

[…];

-5- Let SubExtents be a specialization of extents such that:

• -5.1- SubExtents::rank() equals MAP_RANK(slices, Extents::rank()); and;
• -5.2- for each rank index k of Extents extents<IndexType, Extents...> such that the type of slices...[k] is not a collapsing slice type, SubExtents::static_extent(MAP_RANK(slices, k)) equals the following, where Σk denotes the type of slices...[k]:
  • -5.2.1- Extents::static_extent(k) if Σk denotes the full_extent_t; otherwise
  • -5.2.2- 0, if Σk is a specialization of strided_slice and Σk::extent_type denotes constant_wrapper<IndexType(0)>; otherwise
  • -5.2.3- 1 + ((Σk::extent_type::value - 1) / Σk::stride_type::value) Σk::extent_type::value if Σk is a specialization of strided_slice whose extent_type and stride_type denotes a specializations of constant_wrapper;
  • -5.2.4- otherwise, dynamic_extent.

-6- Returns:

A value ext of type SubExtents such that for each index k of extents<IndexType, Extents...>, where the type of slices...[k] is not a collapsing slice type, ext.extent(MAP_RANK(slices, k)) equals the following where σk denotes slices...[k]:

• -6.1- σk.extent == 0 ? 0 : 1 + (σk.extent - 1) / σk.stride if the type of σ_k is a specialization of strided_slice,
• -6.2- otherwise, U−L, where [L, U) is the submdspan slice range of σk for the kth extent of src.

Apply following changes to section [mdspan.sub.map.common] Common:

-6- Let sub_strides be an array<SubExtents::index_type, SubExtents::rank()> such that for each rank index k of extents() for which the type of slices...[k] is not a collapsing slice type, sub_strides[MAP_RANK(slices,k)] equals:

• -6.1- stride(k) * s.stride if type of s is a specialization of strided_slice and s.stride < s.extent s.extent > 1 is true, where s is slices...[k];
• -6.2- otherwise, stride(k).

Replace all occurrences of strided_slice and is-strided-slice in [mdspan.syn] and [mdspan.sub] with extent_slice and is-extent-slice respectively.

Update the value of the __cpp_lib_submdspan in [version.syn] Header <version> synopsis to reflect the date of approval of this proposal.

7. Acknowledgements

Christian Trott and Charles Hussong offered many useful suggestions and corrections to the proposal.

8. References

1. Poland, "PL007 23.7.3.7 [mdspan.sub] [mdspan.sub] Define the extent member of the strided_slice", (PL007, https://github.com/cplusplus/nbballot/issues/816)
2. Tomasz Kamiński, "[RFC v2 0/4] libstdc++: Implement P3982R1 range_slice and", (https://gcc.gnu.org/pipermail/libstdc++/2026-March/065843.html)
3. Christian Trott, Damien Lebrun-Grandie, Mark Hoemmen, Nevin Liber "Submdspan", (P2630R4, https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2630r4.html)
4. Thomas Köppe, "Working Draft, Standard for Programming Language C++" (N5032, https://wg21.link/n5032)