Getting the base type in 0.6


#1

Given t = SomeType{Int64}, we used to be able to get SomeType via t.name.primary. That no longer works in 0.6. How should I do that? t.name still exists, but it’s a TypeName.

Alternatively, all I really want is, given an object of type SomeType{Int64}, to create a similar object of the same “base type”, but with a different instantiation of the parameter, eg. SomeType{Float64}.


#2

Also, what’s the “official name” for Nullable's relationship to Nullable{Int64}? Primary type?


#3

The right way to do this is usually to write a function that does the conversion you want, e.g.:

Base.float{T}(x::SomeType{T}) = SomeType{float(T}}(x)

Define a method for each SomeType you want to convert.

(For example, the similar function does this for array types.)


#4

You are not supposed to extract that to create a new type like that (see some discussion of this here).

You said you want a similar object of the same base type, well, the word similar should give you a hint

struct SomeType{T}
    field::T
end

# two possible definitions, but it would depend exactly on what you want
similar(::T, s::SomeType) where T<:SomeType = T(s.field)
similar(s::SomeType, T::Type) = SomeType{T}(s.field)

#5

A supertype or a typename (note however that the former is ambiguous and the latter is not a type).


#6

My use case is that I manipulate mathematical expressions such as Multiply(Variable(:x), 5), and my variable substitution algorithm might replace Variable(:x) with a number. If Multiply is parametric, I cannot use typeof(expr)(map(y->subst(y, substitutions), fieldsof(expr))...), because typeof(expr) is Multiply{Variable, Int}. It was convenient to have a generic way of traversing the tree and changing subtrees, without defining N trivial methods for my N function/predicate types, but I guess it’s no big deal.


#7

I don’t recommend traversing the tree, but the way to do it on 0.6 is Compat.TypeUtils.typename, and then possibly a .primary field access.