The Type System and Abstract Types

Every value in Julia has exactly one type, and every type in Julia participates in a single-rooted hierarchy where Any sits at the top as the supertype of all types. Types are split into abstract types, which exist purely to organize the hierarchy and cannot be instantiated (you can never create a value whose type is literally Real or Number), and concrete types, which are the leaves of the tree and can actually be instantiated — Float64, Int64, and String are all concrete. The subtype operator <: expresses these relationships, so Float64 <: AbstractFloat <: Real <: Number <: Any all hold true, and functions like supertype(Float64) and subtypes(Real) let you inspect the hierarchy interactively.

You declare an abstract type with abstract type Animal end, and then attach concrete or further-abstract types to it using the <: subtyping syntax, as in struct Dog <: Animal name::String end and struct Cat <: Animal name::String end. This hierarchy exists purely for organizing dispatch and reasoning about code — Animal itself carries no fields and can't be constructed — but it lets you write functions like function speak(a::Animal) that accept any current or future subtype of Animal, and use isa(fido, Animal) or fido isa Dog to check membership in the hierarchy at runtime.

Multiple dispatch means a function call's implementation is chosen based on the types of all its arguments, not just one privileged 'receiver' as in classical single-dispatch object orientation — calling collide(a, b) can select a different method depending on whether (a, b) is (Circle, Circle), (Circle, Rectangle), or (Rectangle, Rectangle). Julia resolves this at each call by finding the most specific applicable method among all methods defined for that function name, and calling methods(f) lists every method currently defined for a generic function f; when two methods are equally specific for a given call and neither is more specific than the other, Julia raises a MethodError for ambiguity rather than guessing.

A function is type-stable when the type of its return value can be inferred from the types of its inputs alone, without depending on runtime values — this lets Julia's compiler generate specialized machine code ahead of time instead of falling back to slow, boxed, dynamically-dispatched operations. The macro @code_warntype prints the compiler's inferred types for a function, highlighting any Any or Union types in red as a warning sign of instability; a common cause is a container like Vector{Any} (or an abstract-typed struct field) forcing every element access to be dynamically typed, and a common fix is ensuring containers and fields use concrete, consistent element types.