UndefVarError for a struct type parameter

[aplavin]

Not sure if that's the intended behaviour or not, but seems surprising:

julia> struct A{T}
               x::Vector{<:T}
       end

# ok:
julia> A([1, 2, 3])
A{Int64}([1, 2, 3])

# fails:
julia> A(Any[1, 2, 3])
ERROR: UndefVarError: T not defined

In my particular case, this code was a mistake anyway: I intended to write

struct A{T<:SomeSuperT}
    x::Vector{T}
end

instead. But maybe it is relevant in the wider context.

I'm using the latest julia release:

julia> versioninfo()
Julia Version 1.6.2
Commit 1b93d53fc4 (2021-07-14 15:36 UTC)
Platform Info:
  OS: Linux (x86_64-pc-linux-gnu)
  CPU: Intel(R) Core(TM) i7-8565U CPU @ 1.80GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-11.0.1 (ORCJIT, skylake)

[JeffBezanson]

As you can probably guess, this struct definition creates a default constructor similar to the following function:

f(::Vector{<:T}) where T = T

During dispatch, we try to pick a value for T, given the argument types. But that cannot always be done --- the types of the arguments don't always imply a unique value for T. And in edge cases, it can be non-obvious whether the algorithm that picks a value for T will succeed. In this case:

julia> f(Int[])
Int64

julia> f(Any[])
ERROR: UndefVarError: T not defined

So with a concrete element type we assume that type is what we should pick. But it's not well-defined, since technically T could be any type greater than Int. Arguably we could make Any work here, since only one type is >: Any (Any itself).

[aplavin]

It's not just an issue with Any, but with any abstract type: they all lead to T not defined. I don't know whether it makes sense to always infer T as the struct parameter, so that

julia> f(Int[])
Int64
julia> f(Any[])
Any
julia> f(Real[])
Real

But the current behavior is confusing: I thought that T declaration was missing somewhere in my struct definition, which turned out not to be the case. Maybe, this could be solved with a better error message without any changes to the result? I don't know if there are legitimate usecases of f(::Vector{<:T}) where T = T as opposed to f(::Vector{T}) where T = T.