Wrong type-parameter bounds inside a type alias

[frankwswang]

MWE (tested on Julia 1.11.1):

julia> const MyDict{T, C<:AbstractDict{<:Array, <:Array{T}}} = C
AbstractDict{<:Array, <:Array{T}} where T

julia>  MyDict{Float64}
AbstractDict{<:Array, <:Array{Float64}}

julia> MyDict{T, Dict{Vector{Int}, Array{T, 2}}} where {T} # Should have been: `Dict{Vector{Int64}, Matrix{T}} where T`
AbstractDict{Dict{Vector{Int64}, Matrix{T}}, <:Array{T}} where T

julia> MyDict{Float64, Dict{Vector{Float64}, Array{Float64, 2}}} # Should have been: `Dict{Vector{Float64}, Matrix{Float64}`
ERROR: TypeError: in AbstractDict, in #s1, expected var"#s1"<:Array, got Type{Dict{Vector{Float64}, Matrix{Float64}}}

[oscardssmith]

reproduced on master.

[vtjnash]

Those look correct to me. You only have one UnionAll variable, so it should only accept one application, though if that application is a UnionAll variable, then the result can accept another one again

[oscardssmith]

isn't the TypeError a problem?

[frankwswang]

Those look correct to me. You only have one UnionAll variable, so it should only accept one application, though if that application is a UnionAll variable, then the result can accept another one again

How is it acceptable that a more specialized version of MyDict is not even the subtype of MyDict?

julia> (MyDict{T, Dict{Vector{Int}, Array{T, 2}}} where {T}) <: MyDict
false

Moreover, MyDict{T, Dict{Vector{Int}, Array{T, 2}}} where {T} <: C does not even meet its bound AbstractDict{<:Array, <:Array{T}} where {T}:

julia> bound = AbstractDict{<:Array, <:Array{T}} where {T}
AbstractDict{<:Array, <:Array{T}} where T

julia> (MyDict{T, Dict{Vector{Int}, Array{T, 2}}} where {T}) <: bound
false

[vtjnash]

Julia does not enforce type constraints applied to type aliases when making new type aliases from them

[frankwswang]

More problematic examples:

julia> const TypeofMyT{T, C<:Vector{T}} = Type{C}
Type{C} where {T, C<:Vector{T}}

julia> TypeofMyT{Integer, <:Vector{<:Real}}
Type{<:Vector{<:Real}}

which should have been TypeofMyT{Integer, <:Vector{Integer}} (or should not have been allowed, which is debateble) because

julia> Vector{Integer} <: Vector{<:Real}
true

julia> Vector{<:Real} <: Vector{Integer}
false

julia> TypeofMyT{Integer, <:Vector{<:Real}} <: TypeofMyT
false

julia> const MyT{T, C<:Vector{T}} = C
Vector (alias for Array{T, 1} where T)

It is already concerning that the compiler automatically converts MyT back to vector. Consequently, it does not even allow a specification of the second parameter:

julia> MyT{<:Any, Vector{Float64}}
ERROR: too many parameters for type Array

Just because there's a reason for such behavior does not automatically justify it. If you allow the user to rename a type legally with additional type parameters, you should support full feature and consistent type inference for all of these parameters or forbid such construction altogether. Calling this behavior "correct," IMHO, does not seem a convincing solution.

[frankwswang]

Julia does not enforce type constraints applied to type aliases when making new type aliases from them

What about this?

julia> const MyArray{N, T<:Real} = Array{T, N}
Array{T, N} where {N, T<:Real}

julia> MyArray{1}
Vector{T} where T<:Real (alias for Array{T, 1} where T<:Real)

julia> const MyArrArr{N, T<:MyArray{N, <:Integer}} = Array{T, N}
Array{T, N} where {N, T<:(Array{<:Integer, N})}

julia> MyArrArr{2, Vector{Int}}
ERROR: TypeError: in Array, in T, expected T<:(Matrix{<:Integer}), got Type{Vector{Int64}}

julia> MyArrArr{2, Matrix{Float64}}
ERROR: TypeError: in Array, in T, expected T<:(Matrix{<:Integer}), got Type{Matrix{Float64}}

julia> MyArrArr{2, Matrix{Int}}
Matrix{Matrix{Int64}} (alias for Array{Array{Int64, 2}, 2})

The type constraints seem to propagate properly in this scenario, no?