Hi all, I appreciate any help in making the following code type stable:

```
abstract type Something{T} end
Base.eltype(:: Something{T}) where T = T
mutable struct OneThing{T} <: Something{T}
α :: T
end
# HERE
mutable struct ManyThings{T} <: Something{T}
L :: Vector{Something}
end
# OR HERE
function ManyThings(L :: Vector{<: Something})
T = promote_type(eltype.(L)...)
ManyThings{T}(L)
end
function test()
A = OneThing(2.0)
B = OneThing(3)
S = ManyThings([A, B])
@code_warntype ManyThings([A, B])
end
test()
```

output:

```
┌ Info:
└ eltype(S) = Float64
Variables
#self#::Type{ManyThings}
L::Array{OneThing,1}
T::Any
Body::ManyThings{_A} where _A
1 ─ %1 = Base.broadcasted(Main.eltype, L)::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(eltype),Tuple{Array{OneThing,1}}}
│ %2 = Base.materialize(%1)::Any
│ (T = Core._apply(Main.promote_type, %2))
│ %4 = Core.apply_type(Main.ManyThings, T)::Type{ManyThings{_A}} where _A
│ %5 = (%4)(L)::ManyThings{_A} where _A
└── return %5
```

Thanks in advance.