Is UnionAll abstract? Is it bad for performance?

Sorry in advance if this is covered somewhere; I’m still a beginner.

I’m concerned about the two performance tips as they relate to UnionAll: 1) Avoid fields with abstract type and 2) Avoid containers with abstract type parameters. Let’s say we have some type:

mutable struct MyType{field_type1<:Abstract_field_type, field_type2<:Abstract_field_type}

Where there are a few possible concrete types of Abstract_field_type. Now I want to contain a MyType object in a different object or in a dictionary of MyType objects:

mutable struct container_struct
    b::Dict{Int64, MyType}

Now when I try to see if the values of the dict b are an abstract type, by setting container = container_struct(...) and printing: println(valtype(container.b).abstract), I get type UnionAll has no field abstract. Is a UnionAll abstract? Might this cause a performance hit? Or is UnionAll covered under this blogpost: when it says

But often, Union{Type1, Type2, ...} is nothing to worry about, because it causes little or no performance hit of any kind.

If this is a potential performance problem, how can I design things better? Thank you!

Yes, UnionAll is abstract.

if your container struct and dict only hold one particular subtype of that UnionAll you can do

mutable struct container_struct{T<:MyType}
    b::Dict{Int64, T}

Otherwise, you can just leave it as you have it if you need a hetrogenious container.
It’s not the end of the world.
We don’t have to scrape every last bit of peformance out.

You can put in function barriers where you need them