Abstract types and hierarchies

Declare a non-instantiable node with abstract type Animal end. Concrete structs hang under it with struct Dog <: Animal; name::String; end. You never construct Animal() — only leaves.

supertype(Dog) and subtypes(Animal) walk the tree. Dog <: Animal is true; Animal <: Dog is false. Field types and method signatures should name the most general type that still keeps your contracts.

Union{Int, Nothing} (often aliased) is a type that accepts either member. Prefer a small Union over Any when the set of cases is closed. Nothing is the singleton for absence; missing is for statistical missingness — different types.

Dispatch sees the runtime type. A method speak(::Animal) is a fallback; speak(::Dog) wins for dogs because it is more specific. Abstract parents organize interfaces; concrete leaves carry data.

Misses: trying to Animal() construct an abstract type, writing Java-style extends instead of <:, or treating Union{} (empty union, bottom) as a bag of values.

abstract type Animal end

struct Dog <: Animal
    name::String
end

struct Cat <: Animal
    name::String
end

speak(::Dog) = "woof"
speak(::Cat) = "meow"
speak(::Animal) = "..."

MaybeInt = Union{Int, Nothing}

println(speak(Dog("Rex")))
println(Dog <: Animal)
println(3 isa MaybeInt)
println(nothing isa MaybeInt)