For example, in Scala: val x = if (some_condition) Employer else Employee
If Employer and Employee both derive from Person, then x will be of type Person. The run time uses dynamic dispatch to figure out how members are accessed from x.
If you want to constrain x, you need to specify the type explicitly.
In your example, the type of x is not (Employer \/ Employee), it is their shared superclass - Person. The analogous example would be if
val x = if (some_condition) Employer else Employee
succeeded even though Employer and Employee did not share a superclass. Very few languages use union types - Typed Racket comes to mind, and Algol apparently did too. class Person
end
class Employer < Person
end
class Employee < Person
end
x = some_condition ? Employer.new : Employee.new
# x is a Person+
This is not said in the "happy birthday" article (or anywhere else, IIRC).In the beginning we typed x as Employer | Employee. But, as the hierarchy grew bigger compile times became huge. Then we decided to let x be the lowest superclass of all the types in the union (and mark it with a "+", meaning: it's this class, or any subclass). This made compile times much faster, and in most (if not all) cases this is what you want when you assign different types under the same hierarchy to a variable.
What this does mean, though, is that the following won't compile:
# Yes, there are abstract classes in Crystal
abstract class Animal
end
class Dog < Animal
def talk
end
end
class Cat < Animal
def talk
end
end
class Mouse < Animal
end
x = foo ? Dog.new : Cat.new
x.talk # undefined method 'talk' for Mouse
That is, even though "x" is never assigned a Mouse, Crystal infers the type of "x" to be Animal+, so it really doesn't know which types are in and considers all cases.Again, this is most of the time something good: if you introduce a new class in your hierarchy you probably want it to respond to some same methods as the other classes in the hierarchy.
If you do:
a = [1, 'a', 1.5, "hello"]
you get Array(Int32 | Char | Float64 | String)
In a way, the Super+ type is a union type of all the subtypes of Super, including itself, but just with a shorter name.
You can always have a static analyzer tool (that works, because Crystal is compiled) that can pin-point all the locations of union types. You can then put some type restrictions wherever you need them, to know where the union types come from.
The idea is that you can start prototyping something that works and is quite fast, and later you can always improve the performance without ever having to write C code.
Also, the union of an int and float will probably be just float so it won't have any performance overhead.