Trait definitions: type level vs instance level

[nsajko]

I think this is a matter of taste. Related thread:

Should I dispatch on singleton types or their instances?

When I am developing packages, I often come across the following problem. struct Step{T} end func(::Step{1}, x) = do something... func(::Step{2}, x) = do some different things... I am not sure should I use singleton types Type{Step{1}} and Type{Step{2}}, instead of singletons Step{1} and Step{2} to dispatch behaviors? func(::Type{Step{1}}, x) = do something... func(::Type{Step{2}}, x) = do some different things... Julia’s doc says instances should be used, is it a general rule or just for V…

@mrufsvold

my guess is that you can always get a type from an instance with typeof but it could be potentially quite expensive to get an instance from a type

Getting the instance of a singleton type is free. T.instance currently works, though it’s not documented or part of the public interface as far as I know. A guaranteed-to-work way is by relying on incomplete initialization:

struct Helper{T}
  v::T
  Helper{T}() where {T} = new{T}()
end
uninitialized_instance(::Type{T}) where {T} = Helper{T}().v

julia> uninitialized_instance(Nothing) == nothing
true

This is a bit roundabout, but could be abstracted into a tiny package easily. I actually wanted to register such a package, but then gave up because the functionality seemed overly trivial so I wasn’t sure that anyone would use the package.