Consider these semantically identical functions:

void foo(M)(M list) {
	static if (is(M : T[L], T, uint L)) {
		pragma(msg, "Length: " ~ L.to!string); // Length: 2
	}
}

void bar(M)(M list) if (is(M : T[L], T, uint L)) {
	pragma(msg, "Length: " ~ L.to!string); // undefined identifier 'L'
}

void main(string[] args) {
	int[2] list = [1, 2];
	foo(list);
	bar(list);
}

Although semantically the same, bar will fail.
This can of course be solved by changing the template arguments, but could lead to issues in more complex scenarios:

alias UnsignedType(T) = mixin(getUnsignedType!(T));

string getUnsignedType(T)() {
	static if (is(T == byte))
		return "ubyte";
	else static if (is(T == short))
		return "ushort";
	else static if (is(T == int))
		return "uint";
	else
		assert(0, "Type not supported: " ~ T.stringof);
}

auto foo(T)(T number) if (is(UnsignedType!T T2)) {
	alias T2 = UnsignedType!T; // still required
	return cast(T2) number;
}

void main(string[] args) {
	foo(1).writeln; // 1
	foo(-1).writeln; // 4294967295
}

Apart from these examples, depending on complexity, one might even think of a scenario in which a type returned inside the template condition should be matched against, in which case the body of the function would be required to contain a duplicate statement:
is(aliasMixin!M M2: T[L], T, uint L); (eg. when getUnsignedType returns a more complex type)

Given the above consideration, assuming this is not a bug (tested on both dmd & ldc), I believe identifiers introduced inside a template constraint should be visible inside the scope of the template.

On Wednesday, 21 September 2022 at 11:23:57 UTC, HuskyNator wrote:

Agreed, it's been bothering me as well. (It is a language design question, not a implementation bug.)

On Wednesday, 21 September 2022 at 11:23:57 UTC, HuskyNator wrote:

+1, this has annoyed me in the past too.

On Wednesday, 21 September 2022 at 11:23:57 UTC, HuskyNator wrote:

void foo(M)(M list) {
	static if (is(M : T[L], T, uint L)) {
		pragma(msg, "Length: " ~ L.to!string); // Length: 2
	}
}

void bar(M)(M list) if (is(M : T[L], T, uint L)) {
	pragma(msg, "Length: " ~ L.to!string); // undefined identifier 'L'
}

void main(string[] args) {
	int[2] list = [1, 2];
	foo(list);
	bar(list);
}

They are not semantically the same. The first can be instantiated with any type and conditionally makes an output (it is empty otherwise), the other says it cannot be instantiated unless the arguments have specific properties.

The first one is Design by Introspection (DbI), the second is a template with requirements.

alias UnsignedType(T) = mixin(getUnsignedType!(T));

string getUnsignedType(T)() {
	static if (is(T == byte))
		return "ubyte";
	else static if (is(T == short))
		return "ushort";
	else static if (is(T == int))
		return "uint";
	else
		assert(0, "Type not supported: " ~ T.stringof);
}

There are better ways than a string mixin to do this.
If for some reason std.traits.Unsigned is not for you, I’d do:

alias UnsignedType(T) = typeof({
    static if (is(T == byte)) return cast(ubyte)0;
    else static if (is(T == short)) return cast(ushort)0;
    else static if (is(T == int)) return cast(uint)0;
    else static assert(0, "Type not supported: " ~ T.stringof);
}());

auto foo(T)(T number) if (is(UnsignedType!T T2)) {
	alias T2 = UnsignedType!T; // still required
	return cast(T2) number;
}

void main(string[] args) {
	foo(1).writeln; // 1
	foo(-1).writeln; // 4294967295
}

Your suggestion is very much independent of the DbI vs constraints. You want identifiers defined in a constraint to be visible in the body of the template. This is possible in simple cases like yours, but what if the is check is nested or negated?

In your case,

void foo(M : T[L], T, uint L)(M list) { }

does the trick. It works unless you’d have a || concatenated static if condition:

void foo(M)(M list)
{
    static if (is(M : T[n], T, size_t n) || is(M : T[], T))
    {
        // on either way the condition is true, `T` is defined.
        pragma(msg, T);

        // Coming from second condition, `n` is undefined
        pragma(msg, is(typeof(n)));
    }
}

void main()
{
    int[3] xs = [1, 2, 3];
    foo(xs);
    foo([1, 2]);
}

In that case, you can still come very close with this:

void boo(M : T[n], T, size_t n)(M list) => boo_impl!T(list);
void boo(M : T[], T)(M list) if (!is(M : T[n], T, size_t n)) => boo_impl!T(list);
private void boo_impl(T, M)(M list)
{
    pragma(msg, T);
}

On Wednesday, 21 September 2022 at 12:18:19 UTC, Quirin Schroll wrote:

void foo(M)(M list) {
	static if (is(M : T[L], T, uint L)) {
		pragma(msg, "Length: " ~ L.to!string); // Length: 2
	}
}

void bar(M)(M list) if (is(M : T[L], T, uint L)) {
	pragma(msg, "Length: " ~ L.to!string); // undefined identifier 'L'
}

If you want the semantics to match exactly you can replace the static if with a static assert (or add else static assert(0);).

static if already handles these cases. I don't know exactly what the rules are (needs better documentation), but presumably they would work the same way for constraints.

void foo(M : T[L], T, uint L)(M list) { }

As I'm sure you're aware, there are cases where the desired constraint cannot be expressed using template specializations. For example:

auto fun(R)(R r)
    if (isInputRange!R && is(ElementType!R == T[], T))

On Wednesday, 21 September 2022 at 12:18:19 UTC, Quirin Schroll wrote:

I am aware of the differences when the if statement fails, though the intent remains the same.

I would presume it to work identically to its behavior inside a static if statement.

On Wednesday, 21 September 2022 at 12:32:38 UTC, Paul Backus wrote:

Apologies, I only read your comment now.

auto fun(R)(R r)
    if (isInputRange!R && is(ElementType!R == T[], T))

Thank you, this is indeed what I was aiming for :)

On Wednesday, 21 September 2022 at 11:23:57 UTC, HuskyNator wrote:

void bar(M)(M list) if (is(M : T[L], T, uint L)) {
	pragma(msg, "Length: " ~ L.to!string); // undefined identifier 'L'
}

This is in bugzilla:
https://issues.dlang.org/show_bug.cgi?id=6269