There's currently no way to specify bounds requiring constants in types to be well-formed

[varkor]

When we have a const expression with a generic parameter in it, we cannot be sure that the const expression is valid for all the values that the generic parameter might take.

fn foo<const N: usize>() {
	let _: [u8; { /* some expression involving N */ }] = ...;
	// ^ this type may not be well-formed, because the length may result in an error
}

If we do not force the caller of the function to specify that the expression must be well-formed, we may get post-monomorphisation errors, as we can only determine that the expression is well-formed after substituting the concrete values for the generic parameters. We therefore need some way to specify such a bound. This is currently not possible.

This was discussed in #66962 (comment), #66962 (comment), #68388 (comment).

@eddyb suggested the syntax where [u8; { /* some expression involving N */ }]:, though it is not clear whether this would be appropriate. This needs some discussion and careful consideration of the WF implications.

[eddyb]

Note that the syntax where SomeType:, is already supported (empty bound list), and has been checked for WF-ness for a while now (e.g. where Vec<str>:, errors instead of being ignored).

However, where [(); N+N]:, currently tries to prove N+N can be evaluated the same way writing [(); N+N] in the body does, instead of requiring it of the caller of the function (which would be the useful behavior here).

I'm worried that while this may be a pragmatic way to write "this must const-eval successfully" bounds, it would go against WF principles to use it as such.

cc @rust-lang/wg-traits

[Evrey]

Suggesting new syntax, how about just adding this to the language?

where (bool_expr)

// E.g.:
struct Arr<T, const N: usize>
where T: Sized,
      (N <= (usize::max_value() / size_of::<T>())),
{
    data: [T; N],
}

Being mandatorily wrapped in brackets should be good enough to not need any special restrictions around the syntax for expressions evaluating to bool.

we may get post-monomorphisation errors

As long as ill-formed types error out, that's pretty much Good Enough™. Sure, proper bounds to error out early are much nicer, though. Note that this does require the compiler to check whether or not the bounds make sense at all. I.e. this should not compile, even if you don't use the type:

struct Arr<T, const N: usize>
where T: Sized,
      (N == 0),
{
    data: [T; {32 / N}], // D:
}

Edit: To clarify, in case someone fears O(scary) bool exprs… You are able to do just as scary things with where [T; {usize_expr}]:.