Faster dynamical dispatch and efficient "optionals" for Julia
A Switch is a one-element container that may contain one of two possible types.
For instance, a Switch{Int, Float64} is a wrapper container around a number
which is either an Int or a Float64.
This type differs from Union{Int, Float64} in two important respects:
- It is a container, so its value needs to be fetched, mapped or broadcasted over (possibly with dot-call syntax).
- The
broadcastmethod is extended to use type-stable routines. Dynamic dispatch is determined by a simple binary branch, rather than the Julia's slower dynamic multiple dispatch algorithm.
Under broadcast and Julia's powerful dot-call syntax, it allows for some
powerful manipulations. The type automatically simplifies wherever possible, for
example:
x = Switch{Int, Float64}(1)
x .+ 1 # = Switch{Int, Float64}(2)
x .+ 1.0 # = 2.0 (it is a Float64 in either case)While the value inside a Switch x can be accessed via x[] this is not
type-stable and should be avoided in performance-sensitive situations.
Julia's in-built Nullable type is often semantically compared to a container
with either zero or one value. This is particularly useful when an object might
not exist, for instance a system resource may or may not be initialized or
available.
On the other hand, data scientists and others might like to deal with
data which exists in principle but is unknown. The Optional{T} container
is a single-element container that contains a single value::T, or else Unknown(T).
Unknown(T) represents an element of T which is unknown to the computer
program. Optional{T} is a simple typealias of Switch{T, Unknown{T}} and
therefore uses the same algorithms for speed and the same dot-call syntax for
convenience (like both Nullable and Switch, unwrapping the container to
access the value is mandatory).
One example of where the distinction between Nullable and Optional is in
performing three-valued logic, where for instance logic dictates that
true | Unknown(Bool) is always true. However, as the result of
false | Unknown(Bool) is unknown, we wrap both results in an
Optional{Bool} to provide type stability and speed.
On the other hand, broadcasting over a Nullable{Bool} is unable to result in
three-valued logic. If an empty (i.e. null) container is passed to broadcast, the
output must always be an empty (i.e. null) container. It follows that
broadcast(|, Nullable(true), Nullable{Bool}()) must equal Nullable{Bool}().
In many senses Optional is a compromise between Base.Nullable and the
DataArrays pacakge and its NA object. Like NA, users can extend function
methods for the Unknown type to facilitate correct propagation of Optional
broadcasts through your code. The fact that Unknown{T} is parameterized by a
type helps one to reason about the output of such specializations (for instance,
Unknown{Bool} must represent either true or false).
I thank Tim Holy for inspiration on performant dynamic dispatch.