Related, I wonder if the following two are effectively the same types: `Vector{T} where T<:Union{Float64,Int64}`

and `Union{Vector{Float64},Vector{Int64}}`

.

I know these two are different from `Vector{Union{Float64,Int64}}`

, which is a concrete type that can take both `Float64`

and `Int64`

as vector entries. Therefore, this is *not* a supertype of `Vector{Float64}`

, which can take only `Float64`

as entries:

```
julia> const T3 = Vector{Union{Float64,Int64}}
Array{Union{Float64, Int64},1}
julia> Vector{Float64}<:T3
false
```

On the other hand, the first two types are either a vector of `Float64`

, or a vector of `Int64`

. Therefore, they are both (abstract) supertypes of `Vector{Float64}`

:

```
julia> const T1 = Vector{T} where T<:Union{Float64,Int64}
Array{T,1} where T<:Union{Float64, Int64}
julia> const T2 = Union{Vector{Float64},Vector{Int64}}
Union{Array{Float64,1}, Array{Int64,1}}
julia> Vector{Float64}<:T1
true
julia> Vector{Float64}<:T2
true
```

However, they are different types:

```
julia> T1 == T2
false
```

Are there any practical differences between `T1`

and `T2`

? If there are, which one is more preferable in what situations? Or, are they effectively the same, so which one to use is just a matter of taste?