Specificity of function not clear

[lcnbr]

I have the following constructors

abstract type A end
abstract type B <: A end  
struct S<:B
  field1
  field2
end
struct R<:B
  field1
  field2
end

function (::Type{T})(f::T) where {T<: A} 
  @info "no copy"
  f
end

function (::Type{T})(f::B) where T <: B
  @info  "copy"
  T(f.field1,f.field2)  
end

Now if I execute

r=R(2,3)
S(r) #copy
R(r) #copy

I would expect that R(r) calls the first constructor but that is not the case. It seems to me that the first will always be more specific..
If anything I cannot find any info on the topic in the documentation. Maybe something needs clearing up in the diagonal types section..

[martinholters]

Note that this has nothing to do with constructors. The same specificity can be exercised with

julia> abstract type A end

julia> abstract type B <: A end

julia> struct S<:B end

julia> struct R<:B end

julia> foo(::Type{T}, x::T) where {T <: A} = 1
foo (generic function with 1 method)

julia> foo(::Type{T}, x::B) where {T <: B} = 2
foo (generic function with 2 methods)

julia> foo(S, R())
2

julia> foo(R, R())
2

To quote from https://docs.julialang.org/en/v1/devdocs/types/#Subtyping-and-method-sorting: "If a is a strict subtype of b, then it is automatically considered more specific. From there, type_morespecific employs some less formal rules."

Here we have two conflicting aspects: As B<:A, the second method should be more specific, but only the first method requires x::T, so that one should be more specific. The "less formal rule" here seems to be to favor the second method.

The fix/workaround would be to define

foo(::Type{T}, x::T) where {T <: B} = 3

or

function (::Type{T})(f::T) where {T<: B} 
  @info "no copy"
  f
end

for your case.

[lcnbr]

Hmm okay, thanks! Are these less formal rules documented somewhere then? Because to me at least, it should be opposite specificity..

[jakobnissen]

Duplicate of #23740, I think

[jakobnissen]

Interestingly:

julia> f(::Vector{<:Integer}, ::Int) = 1
f (generic function with 1 method)

julia> f(::Vector{Int}, ::Integer) = 2
f (generic function with 2 methods)

julia> f([1], 1)
ERROR: MethodError: f(::Vector{Int64}, ::Int64) is ambiguous.

I would imagine this should behave the same, but apparently not.

[vtjnash]

More-specific first ignores TypeVar. It sees that the first case requires both args to be <:A and in the second case to be <:B. Since B is more specific than A, it is the more-specific method.