No automatic type promotion for parametric structs

[lungben]

See discussion in https://discourse.julialang.org/t/no-automatic-type-promotion-for-parametric-structs/62664/1

When using different (but convertible) types in a constructor, for "standard" structs the types get converted automatically, e.g.

struct Struct1
    x:: Float64
    y
end

s1b = Struct1(5, 1) # output: Struct1b(5.0, 1)

However, this is not done if the struct has a type parameter (even if this parameter is for a different field), instead I get a MethodError:

struct Struct2{T}
    x:: Float64
    y:: T
end

s2b = Struct2(5, 1) # MethodError, I would expect Struct2{Int64}(5.0, 1)

s2c = Struct2(5.0, 1) # this works, output: Struct2{Int64}(5.0, 1)

This behavior is confusing for me, I would expect that type promotion is also done for parametric structs. Or is there a good reason for it which I am not aware of?

[nandoconde]

(For the sake of completeness)

Description of the problem

This is because no automatic parametric constructors are created for parametric type.

State of the docs

As said in the mentioned Discourse thread, this is mildly discussed in Types, where it is said that an error is thrown when there is ambiguity, but there are counter-examples that prove that those automatic constructors could be provided by the compiler unambiguously.

Counter example (single parameter)

struct single_param{T}
r::Float64
s::T
end

In this case, the type could be easily extrapolated from the variables passed with a single parametric method.

# Current status
julia> prueba(3,9)
ERROR: MethodError: no method matching single_param(::Int64, ::Int64)
Closest candidates are:
  single_param(::Float64, ::T) where T at REPL[1]:2

# Proposal
julia> single_param(r, s::T) where {T} = single_param{T}(r, s)
single_param

# Future status
julia> single_param(3,9)
single_param{Int64}(3.0, 9)

julia> single_param(3,"4")
single_param{String}(3.0, "4")

Counter example (multi parameter)

struct multi_param{T, U}
q::Float64
r::T
s::U
end

Even in this case, the types could be extrapolated from the variables passed.

# Current status
julia> multi_param(3,9,"7")
ERROR: MethodError: no method matching multi_param(::Int64, ::Int64, ::String)
Closest candidates are:
  multi_param(::Float64, ::T, ::U) where {T, U} at REPL[8]:2

# Proposal
julia> multi_param(q, r::T, s::U) where {T, U} = multi_param{T, U}(q, r, s)
multi_param

# Future status
julia> multi_param(3,9,7im)
multi_param{Int64, Complex{Int64}}(3.0, 9, 0 + 7im)

julia> multi_param(3,9,"t")
multi_param{Int64, String}(3.0, 9, "t")

[jakobnissen]

I think this is a duplicate of #35053

[nandoconde]

Indeed. Also, it seems that yours is itself a duplicate of #17186.

Should we close this and redirect the discussion there?