# Parametric inner constructor with `where {T}` of non-parametric type

#1

Consider the following type definition attempt, which tries to define a type that stores arrays of x- and y-locations of points:

``````julia> struct PointVector{T<:Real}
x::Vector{T}
y::Vector{T}
PointVector{T<:Real}(x, y) = new(x, y)
end

WARNING: deprecated syntax "inner constructor PointVector(...) around REPL[0]:4".
ERROR: syntax: function static parameter names not unique
``````

We realize that in defining the inner constructor, the old syntax (without `where`) does not work.

This is fine, because I like the new syntax with `where` and it works:

``````julia> struct PointVector{T<:Real}
x::Vector{T}
y::Vector{T}
PointVector{T}(x, y) where {T<:Real} = new(x, y)
end

julia> PointVector{Int64}([1,0], [0,1])
PointVector{Int64}([1, 0], [0, 1])
``````

Now, consider another example that attempts to define `PointVectorFloat64`, a version of `PointVector` that stores `x` and `y` only in `Vector{Float64}` type:

``````julia> struct PointVectorFloat64
x::Vector{Float64}
y::Vector{Float64}
PointVectorFloat64(x::Vector{T}, y::Vector{T}) where {T<:Real} = new(float.(x), float.(y))
end
ERROR: TypeError: Type{...} expression: expected UnionAll, got Type{PointVectorFloat64}
``````

The type definition intends to define an inner constructor that is callable only for vectors `x` and `y` with real entries. However, as can be seen in the above example, the new syntax with `where` does not work in defining the inner constructor.

On the other hand, the old syntax without `where` still works:

``````julia> struct PointVectorFloat64
x::Vector{Float64}
y::Vector{Float64}
PointVectorFloat64{T<:Real}(x::Vector{T}, y::Vector{T}) = new(float.(x), float.(y))
end

julia> PointVectorFloat64([1.0, 0.0], [0.0, 1.0])
PointVectorFloat64([1.0, 0.0], [0.0, 1.0])
``````

To summarize, it seems that a parametric inner constructor for a non-parametric type cannot be defined using the new syntax with `where`. Is there a way to define such an inner constructor using the new syntax?

#2

This should not work on 0.5 either. You are defining an inner parameter with an unused type parameter.

``````julia> immutable P{T}
P{T}() = new()
end
WARNING: static parameter T does not occur in signature for Type at REPL[1]:2.
The method will not be callable.
``````

Seems like a bug.

#3

Thanks for the clarification! Will issue a bug report.