`Type{T} where T` as function arguments sometimes do not invoke "method ambiguity" error

[frankwswang]

MWE (tested on Julia 1.11.5):

• This will not invoke the error:

julia> foo1(::Type{<:Real}, ::Type{<:Real}) = false
foo1 (generic function with 1 method)

julia> foo1(::Type{<:AbstractFloat}, ::Type{<:AbstractFloat}) = true
foo1 (generic function with 2 methods)

julia> foo1(::Type{Union{}}, ::Type{<:Real}) = 1
foo1 (generic function with 3 methods)

julia> foo1(Union{}, Float32)
1

• This will not invoke the error either:

julia> foo2(::Type{T1}, ::Type{T2}) where {T1<:Real, T2<:Real} = false
foo2 (generic function with 1 method)

julia> foo2(::Type{T1}, ::Type{T2}) where {T1<:AbstractFloat, T2<:AbstractFloat} = true
foo2 (generic function with 2 methods)

julia> foo2(::Type{Union{}}, ::Type{T2}) where {T2<:Real} = 1
foo2 (generic function with 3 methods)

julia> foo2(Union{}, Float32)
1

• This will invoke the error:

julia> foo3(::Type{T1}, ::Type{T2}) where {T1<:Real, T2<:Real} = false
foo3 (generic function with 1 method)

julia> foo3(::Type{T1}, ::Type{T2}) where {T1<:AbstractFloat, T2<:AbstractFloat} = true
foo3 (generic function with 2 methods)

julia> foo3(::Type{T1}, ::Type{T2}) where {T1<:Union{}, T2<:Real} = 1
foo3 (generic function with 3 methods)

julia> foo3(Union{}, Float32)
ERROR: MethodError: foo3(::Type{Union{}}, ::Type{Float32}) is ambiguous.

[Keno]

Assigning to @JeffBezanson to make a call on whether the specificity rule for Type{Union{}} should extend to Type{<:Union{}}, since they are type equal (and it seems a little odd that replacing one method by one with a type-equal signature would change specificity)

[vtjnash]

It is intentional. There's plenty of other reasons type-equal signatures won't have the same specificity

[frankwswang]

I don't know how to think about this. Note that this type of inconsistent behavior would not happen if I were to define my own container to dispatch on types:

julia> struct MyType{T}
           type::Type{T}
       end

julia> foo(::MyType{<:Real}, ::MyType{<:Real}) = false
foo (generic function with 1 method)

julia> foo(::MyType{<:AbstractFloat}, ::MyType{<:AbstractFloat}) = true
foo (generic function with 2 methods)

julia> foo(::MyType{Union{}}, ::MyType{<:Real}) = 1
foo (generic function with 3 methods)

julia> foo(MyType(Union{}), MyType(Float32))
ERROR: MethodError: foo(::MyType{Union{}}, ::MyType{Float32}) is ambiguous.

Currently, there are mentions of method specializations and method ambiguities individually, but not how the former might affect the latter. So, I had assumed that specialization only affects the performance, not the result of a piece of code.

If this behavior is to stay, I think there should at least be a section in the official documentation to clarify that for certain types of function arguments (e.g., Type in this case), different levels of specialization, even when they are type-equivalent, can still result in different dispatch behaviors. In other words, the multiple-dispatch system in Julia does not work the same way for every data type.