libstdc++: questions about P3663

Luc Grosheintz luc.grosheintz@gmail.com
Sun Nov 2 13:51:38 GMT 2025


Hi Mark,

thank you for your detailed response!

On 10/31/25 7:46 PM, Mark Hoemmen wrote:
> 
>> 1. What are the requirements for user provided integer-like objects?
> 
> The reference implementation copies slices all over the place.  I
> think it's fair to assume that slice specifiers are copyable and
> movable.

The context is that for libstdc++ we've been careful to not require
move or copy ctors for mapping::operator(), or in `extents`. This
means we've been very careful to immediately convert them to
index_type, via `static_cast<index_type>(std::move(i))`.

Therefore, I wanted to double check the following (8.15.2):

auto [...slices] = submdspan_canonicalize_slices(src, raw_slices...);

this copies `raw_slices`, while later in during canonicalization
`std::move` is used very carefully. Allowing strange types like:

   struct RValueInt {
     operator int()&& {
       return 42;
     }
   };

i.e. object that can convert to `int` only via an r-value reference.

As for Tomasz point: "it's not explicit and anything for which
submdspan_canonicalize_slices is well-formed is valid". That's
true and I'm not suggesting to change the code. However, I thought
it would make sense to understand which ctors are intended/implied.
(It helps checking for typos.)

> 
>> 2. What happens if the standard adds a new kind of *canonical* selection?
> 
> The idea is that it's never a breaking change to go from "ill-formed"
> (status quo after adopting P3663) to "well-formed and well-defined"
> (after hypothetical addition of a new kind of selection).

Thank you, that's also how I understood it. Thanks for confirming.
> 
>> 3. Is there a way to `static_assert` the mandate ...?
> 
> If you're referring to [mdspan.sub.helpers] 6, in the specification of
> _`canonical-slice`_, then the way that you implement the Mandates is
> by means of the code in [mdspan.sub.helpers] 7.  That code will be
> ill-formed otherwise.

No, I mean the one for non-canonical slice types. Tomasz confirmed
it's not static assertable. I just wanted to make sure that it's
really not possible and not intended to be statically assertable.
(There's always the risk that of: not possible "by me".)

> 
> We do it that way because you can't write an expression (to use in a
> `static_assert` or the definition of a concept) to express that a
> structured binding declaration is well-formed.

Offtopic: Is there's a good intuitive reason why it's impossible
to check if a structured binding is well-formed?

> 
>> 4. The notion of "unit-stride slice" [...]
> 
> I debated that with Tomasz (CC'd) and lost ; - ) [...]

In his reply he makes the point again. I don't feel to strongly
either way. Personally, I think it would be nice to only define
the idea: "canonical unit-stride slice". The advantage is that
if I read that term I correctly guess the definition. Whereas
if I read "unit-stride slice" my brain tries to be "clever" and
find the other slices with unit-stride; and hence as a result
guesses incorrectly how it's defined.

> 
>> 5. [...] the question is what is the "lower bound"?
> 
> [mdspan.sub.overview] 8.2 defines the lower bound for this case as the
> offset `n`.  The upper bound is also `n` for this case.

I'm sorry I can't find it:

   * In N5014 the first time the string "lower" appears after
     [mdspan.sub.overview] is lower_bound (think bisection).

   * In P3663, the term is string "lower" appears exactly
     twice, neither defines it. Both are: "lower bound of
     the submdspan slice range"; and the slice range is
     defined as an interval.

The term is perfectly clear if the interval is non-empty.
However for empty intervals, I wanted to point out that
one possible way of reading P3663 is that's "lower bound"
isn't obviously n if the interval is `[n,n)`.

It's really just double checking some pedantry. If the
two of you think it's perfectly clear, then there's nothing
left to discuss :)

> 
>> Is `pair{n, n}` a valid slice for dimension `i`?
> 
> Yes, it is. [...]
> 
>> `pair{n+1, n+1}` would be valid, but not `pair{cw<n+1>, cw<n+1>}`
> 
> That's a good point.  `pair{cw<n+1>, cw<n+1>}` would have a
> canonicalization that is invalid per [mdspan.sub.overview] 9.1.1.
> 
> We should file an LWG issue about this.  Would you like to do it?

You mean a LWG to clarify the wording of P3663, such that
pair{n+1, n+1} is invalid?

I'm happy to help, though personally, I thought that the
formulation using first_ and last_ along with the condition:

   0 <= first_ <= last_ <= n

was simple and clear. Also made it immediately obvious that
pair<size_t, size_t>{5, 3} is invalid. (I think it still is
invalid but the reason is less easy to check, IMO.)

The easiest way seems to repeat the block (8.4.9.1) for
(8.4.10).

   (10.4) - if S is a specialization of strided_slice:
   (10.4.1) + if s.offset <= x
   (10.4.2) + if s.extent <= x
   (10.4.3) + if s.offset + s.extent <= x

(where x is the k-th extent of `e`.) I think (10.4.2) is
redundant and it feels clumsy because it overlaps with:

   (10.2) the k-th interval of e contains the submdspan slice
    range of s for the kth extent of e;

Alternatively, something like:
   (10.4) - if the slice range of s is empty then:
   (10.4.1-3) as above.

> 
>> 6. I'd like to suggest adding "canonical" to "valid submdspan slice":
> [...]
> Saying "valid canonical" would incorrectly imply that something can be
> valid but not canonical.

Understood, and that makes sense. Intuitively, I think of the two
terms "valid" and "canonical" as orthogonal. Something can be
canonical, but not valid and the other way around.

Consider, `exts = extents(3, 5)` then both
   auto s1 = pair{1, 3};
   int s2 = 2;

are *intutively* valid (as in they can be passed to `submdspan`),
non-canonical, slices of the `k-th` extent (k = 0, 1).
For example the term could be defined as:

   `s` is a valid slice of the k-th extent if
   canonical-slice<IndexType>(s) is a valid canonical slice
   of the k-th exent.

Then the precondition for submdspan_mapping is:

   For each k, slices...[k] is a valid canonical slice for the k-th
   extent.

Whereas submdspan and submdspan_canonocial_slices can simply write:

   For each k, slices...[k] is a valid slice for the k-th extent.

I don't have a strong preference. Therefore, if the argument wasn't
convincing, I'm happy to not "protest" further.



More information about the Libstdc++ mailing list