Thanks Jameson and here the context:
# Initializes an array which has a's container but b's eltype
function f(a::AbstractVector, b::AbstractVector)
Eb = eltype(b) # this is type-stable
Ca = typeof(a).name.primary # this is not type-stable
return Ca(Eb, 5) # assumes Ca supports the normal Array
constructor
end
The last line would probably better use copy+convert but for that I
still need to make Ca{Eb,1}. Note that Ca is always a leaftype and I
don't want to climb the type hierarchy, so I think your remark about the
subtypes does not apply.
Here the typed code:
julia> @code_warntype f([1,2], [1.])
Variables:
a::Array{Int64,1}
b::Array{Float64,1}
Eb::Type{Float64}
Ca::Type{T} # <---
Body:
begin # none, line 3:
Eb = Float64 # line 4:
Ca =
(top(getfield))((top(getfield))(typeof(a::Array{Int64,1})::Type{Array{Int64,1}},:name)::TypeName,:primary)::Type{T}
# line 5:
return (Ca::Type{T})(Eb::Type{Float64},5)::Any
end::Any
Thanks!
On Tue, 2015-04-21 at 22:56, Jameson Nash <[email protected]> wrote:
> Your question presupposes that you can write useful generic code with the
> return result, but does not provide any context on your problem. When a
> similar question was asked previously on the mailing list, I recall
> pointing out that the code the author was attempting to write was not going
> to function as intended. Perhaps you can provide some more context?
>
> The observation that I am making is that you cannot arbitrarily pick apart
> a type and expect everything to line up afterwards. For example, it is
> possible to have the following:
> abstract AbstractTy{A,B}
> type Ty1 <: AbstractTy{Int, Float64} end
> type Ty2{B,A} <: AbstractTy{A,B} end
>
> So you can't generically reconstruct some arbitrary subtype by some generic
> rearrangement of its type parameters.
>
> On Tue, Apr 21, 2015 at 4:34 PM Mauro <[email protected]> wrote:
>
>> I have a parameterized type and want to get the primary-type. For
>> example, I got
>>
>> a = Array{Int,2}
>>
>> is there a type-stable way to get Array? This is non-type stable:
>>
>> f(t::Type) = t.name.primary
>>
>> as the inferred return type is Type.
>>
>> This does not work:
>>
>> f{T, S}(::Type{T{S...}}) = T
>>
>> Any ideas? Thanks, M
>>
