Resolving UnionAlls with a single concrete instance in struct declarations

[brainandforce]

This is something I’ve encountered far too often, and it’s one of my biggest gripes with Julia. @Tamas_Papp explained it best:

@Tamas_Papp

To be concrete, let me give an example. The other day a student asked me for help with optimizing a calculation. Since it involved lots of small matrices, I immediately suggested using StaticArrays.SMatrix. The student then did something not unlike this MWE:

using StaticArrays

struct Foo{T,N}
    bar::SMatrix{N,N,T}
end

Now, seasoned Julia users can spot the problem quickly, which is easy to demo with

julia> baz(foo::Foo) = sum(foo.bar)
baz (generic function with 1 method)

julia> foo = Foo(SMatrix{3,3}(zeros(3,3)))
Foo{Float64, 3}([0.0 0.0 0.0; 0.0 0.0 0.0; 0.0 0.0 0.0])

julia> @code_warntype baz(foo)
MethodInstance for baz(::Foo{Float64, 3})
  from baz(foo::Foo) @ Main REPL[10]:1
Arguments
  #self#::Core.Const(Main.baz)
  foo::Foo{Float64, 3}
Body::Any
1 ─ %1 = Main.sum::Core.Const(sum)
│   %2 = Base.getproperty(foo, :bar)::SMatrix{3, 3, Float64}
│   %3 = (%1)(%2)::Any
└──      return %3

The problem is that SMatrix{3,3,Float64} is not a concrete type, it is SMatrix{3,3,Float64,9}.

I’ve encountered issues with this in the past with CliffordNumbers.jl: subtypes of AbstractCliffordNumber{Q,T} need an extra type parameter (for instance, KVector{K,Q,T,L}) where L is the length of the backing NTuple{L,T}. For this type, L = binomial(dimension(Q), K), so it’s not particularly simple arithmetic.

There’s good reason not to allow arbitrary computation in the type system, but this either becomes a pitfall for new Julia programmers, or an annoyance for those who have to leak type parameters when building a struct out of types like these.

Can there be a mechanism for the Julia compiler to resolve almost concrete types in struct declarations like SMatrix{N,N,T}, which only have a single concrete instance, to avoid the type instability and performance hit? Perhaps some sort of function, like

Base.resolve_to_concrete_type(::Type{SMatrix{M,N,T}}) = SMatrix{M,N,T,M*N}

function Base.resolve_to_concrete_type(::Type{KVector{K,Q,T}}) where {K,Q,T}
    return KVector{K,Q,T,binomial(dimension(Q), K)}
end

which a user can opt into to cover cases like this?

[Benny]

@brainandforce

SMatrix{N,N,T}, which only have a single concrete instance

Assuming you meant one instantiable concrete subtype, that’s entirely enforced by the implementation flagging or fixing an incomplete or inappropriate type like SMatrix{2,2,Int,3}, not the language itself. If we circumvent those methods with type piracy or the below hack, we can actually instantiate those inappropriate types:

julia> x = eval(Expr(:new, SMatrix{2,2,Int,6}, Tuple(1:6)))
2×2 SMatrix{2, 2, Int64, 6} with indices SOneTo(2)×SOneTo(2):
 1  3
 2  4

julia> eachindex(x), x[5], x[6]
(SOneTo(4), 5, 6)

In the general case, new constructor methods can make more reasonable exceptions to obvious computed types and thus make omitted type parameters not redundant after all. This essentially amounts to “arbitrary computation in the type system,” brittle and dangerous for a dynamic language.