Normalise upper bound of T in Foo{T} where T to Foo's upper bound

[jakobnissen]

@andreasnoack mentioned this on Slack:

julia> (Complex{T} where T) <: Complex
false

The annoying part is that in Complex, the upper bound for the TypVar is Real, but in Complex{T} where T, the upper bound is simply Any. But since it's not possible to instantiate e.g. Complex{String}:

julia> Complex{String}
ERROR: TypeError: in Complex, in T, expected T<:Real, got Type{String}
Stacktrace:
 [1] top-level scope at REPL[17]:1

Then the extent of the two types Complex{T} where {T <: Any} is the same as Complex{T} where {T <: Real}. So Julia might as well normalise it to Complex{T} where {T <: Real}. Similarly for e.g. Complex{<:Number}.

[jakobnissen]

Similar issues are

julia> Set{<:Int} == Union{Set{Int}, Set{Union{}}}
false

julia> (Complex{T} where {Int <: T <: Int}) == Complex{Int}
false

Maybe it' not feasible to normalize types by their extent in this way?

[mbauman]

This is effectively a proposed fix for #6383

[JeffBezanson]

julia> Set{<:Int} == Union{Set{Int}, Set{Union{}}}
false

This does not seem feasible. In fact I don't even think it's desirable to convert one of these into the other.

julia> (Complex{T} where {Int <: T <: Int}) == Complex{Int}
false

This is much more possible. EDIT: this gives true on master, as well as on versions <= 1.2.

[martinholters]

Concerning the original issue, doing that consistently is more tricky than one might expect at first glance. Consider Tuple{Foo{T}, Bar{T}} where T. Here, we would then like to automatically derive the upper bound of T as the intersection of the upper bounds imposed by Foo and Bar respectively. But currently, our type intersection code is allowed to be imprecise in some cases, which we probably don't want to expose at this level. Further, we cannot even express all intersections in our type system (e.g. between Type{<:Integer} and DataType). So should we only derive the upper bound automatically in sufficiently simple cases, e.g. the variable occurs only once? Or would that be too surprising?

[andreasnoack]

This came up when I tried to add a noop convert method next to https://github.com/JuliaStats/Distributions.jl/blob/6f7a80aad5b7373fa6da6589639a60a9a6636461/src/univariate/discrete/discretenonparametric.jl#L42-L43 for the case when type parameters matched. Specifically, I added

convert(::Type{DiscreteNonParametric{T,P,Ts,Ps}}, d::DiscreteNonParametric{T,P,Ts,Ps}) where {T,P,Ts,Ps} = d

but this method couldn't be reached. With an instance d::DiscreteNonParametric then methods(convert, Tuple{Type{typeof(d)}, typeof(d)}) would only show the existing method

convert(::Type{DiscreteNonParametric{T,P,Ts,Ps}}, d::DiscreteNonParametric) where {T,P,Ts,Ps} =
    DiscreteNonParametric{T,P,Ts,Ps}(convert(Ts, support(d)), convert(Ps, probs(d)), check_args=false)

I then noticed that methods(convert, Tuple{Type{typeof(d)}, DiscreteNonParametric}) did show the new method but that methods(convert, Tuple{Type{typeof(d)}, Any}), i.e.

julia> Base.convert(::Type{DiscreteNonParametric{T,P,Ts,Ps}}, d::DiscreteNonParametric{T,P,Ts,Ps}) where {T,P,Ts,Ps} = d

julia> methods(convert, Tuple{Type{typeof(d)}, DiscreteNonParametric})
# 1 method for generic function "convert":
[1] convert(::Type{DiscreteNonParametric{T,P,Ts,Ps}}, d::DiscreteNonParametric) where {T, P, Ts, Ps} in Distributions at /Users/andreasnoack/.julia/packages/Distributions/dTXqn/src/univariate/discrete/discretenonparametric.jl:42

julia> methods(convert, Tuple{Type{typeof(d)}, Any})
# 4 methods for generic function "convert":
[1] convert(::Type{DiscreteNonParametric{T,P,Ts,Ps}}, d::DiscreteNonParametric) where {T, P, Ts, Ps} in Distributions at /Users/andreasnoack/.julia/packages/Distributions/dTXqn/src/univariate/discrete/discretenonparametric.jl:42
[2] convert(::Type{DiscreteNonParametric{Int64,P,Base.OneTo{Int64},Ps}}, x::AbstractArray{var"#s47",1} where var"#s47"<:Real) where {P<:Real, Ps<:AbstractArray{P,1}} in Distributions at /Users/andreasnoack/.julia/packages/Distributions/dTXqn/src/univariate/discrete/categorical.jl:47
[3] convert(::Type{DiscreteNonParametric{T,P,Ts,Ps}}, d::DiscreteNonParametric{T,P,Ts,Ps}) where {T, P, Ts, Ps} in Main at REPL[5]:1
[4] convert(::Type{T}, x::T) where T in Base at essentials.jl:171

The struct definition has bounds on the type parameters

struct DiscreteNonParametric{T<:Real,P<:Real,Ts<:AbstractVector{T},Ps<:AbstractVector{P}}

and if I add similar bounds in the convert method definition then the method is reachable.

julia> Base.convert(::Type{DiscreteNonParametric{T,P,Ts,Ps}}, d::DiscreteNonParametric{T,P,Ts,Ps}) where {T<:Real,P<:Real,Ts<:AbstractVector{T},Ps<:AbstractVector{P}} = d

julia> methods(convert, Tuple{Type{typeof(d)}, typeof(d)})
# 1 method for generic function "convert":
[1] convert(::Type{DiscreteNonParametric{T,P,Ts,Ps}}, d::DiscreteNonParametric{T,P,Ts,Ps}) where {T<:Real, P<:Real, Ts<:AbstractArray{T,1}, Ps<:AbstractArray{P,1}} in Main at REPL[5]:1

This behavior is pretty tricky.

[vtjnash]

Duplicate of #6383