Signature matching for unbound type parameters in `Type`

[MilesCranmer]

Consider the following example:

julia> specializing_typeof(::T) where {T} = T;

julia> specializing_typeof(::Type{T}) where {T} = Type{T};

julia> specializing_typeof((Type{T} where {T}).body)
ERROR: UndefVarError: `T` not defined in static parameter matching
Suggestion: run Test.detect_unbound_args to detect method arguments that do not fully constrain a type parameter.
Stacktrace:

I don't understand why it matches the second signature and hits an error, when the first signature is actually a valid match for it. For example, if I didn't have the second method, I get

julia> specializing_typeof(::T) where {T} = T;

julia> specializing_typeof((Type{T} where {T}).body)
DataType

which seems right to me.

Is this behavior expected?

(On 1.11.5; I'm assuming it is also seen in other versions)

[nsajko]

Seems like the expected behavior to me.

why it matches the second signature and hits an error, when the first signature is actually a valid match for it.

Because Type is, as a strict subtype, more specific than Any.

[nsajko]

Oh, are you saying that the call should dispatch to the first method because the method static parameter is not defined for the second method? Not sure if that's possible 🤷

[MilesCranmer]

Yes exactly

[adienes]

seems like a poor precedent to me

foo(arg) = return "this is the correct value!"

foo(arg::Int) = throw(1)

then foo(1) throws, but foo(1::Any) does what we want. should the program choose to call the wrong method because of that? I would say certainly not.

[MilesCranmer]

@adienes I think you are misinterpreting the issue. It's very subtle! Please re-open.

[nsajko]

To summarize, my interpretation is that @MilesCranmer is requesting for method static parameter matching to affect dispatch. That makes me feel weird, as my mental model is that dispatch happens first, which is what @adienes is getting at, I think.

Questions that might be relevant:

• Are there any existing examples of method static parameter matching affecting dispatch?

• Are there any other counterexamples to the "dispatch happens first" rule?

[adienes]

it's certainly possible I'm misunderstanding and I apologize for the premature close

however I'd love to learn more about why this is a good idea, as I'm not sure I see it yet. for example of a consequence:

julia> slowlength(x) = sum(one(typeof(x)) for _ in x)

julia> slowlength(x::NTuple{N, T}) where {N, T} = N * one(T)

would you suggest slowlength(()) fall back to the Any method here? or is the request only concerning DataType. my mental model of "what method will get called" would have to get significantly more complicated if the rule extends much more beyond "construct the tuple of types of the argument values and look for the most specific match" than it absolutely has to