Julia Types Guide — Type Hierarchy, Abstract and Parametric Types

In this tutorial, you will learn about Julia Types Guide. We cover key concepts, practical examples, and best practices to help you master this topic.

Julia's type system is organized as a hierarchy with abstract types at the top (Number, Any) and concrete types at the leaves (Int64, Float64), with parametric types enabling generic code.

Type Hierarchy

# Abstract types
abstract type Animal end
abstract type Bird <: Animal end
abstract type Mammal <: Animal end

# Concrete types
struct Dog <: Mammal
    name::String
    age::Int
end

struct Cat <: Mammal
    name::String
    whiskers::Bool
end

Parametric Types

# Type parameter
struct Pair{T, U}
    first::T
    second::U
end

p = Pair{Int, String}(1, "one")
println(p.first)  # 1

Type Annotations

function describe(x::Int)
    "Integer: $x"
end

function describe(x::Float64)
    "Float: $x"
end

function describe(x::String)
    "String: $x"
end

Common Mistakes

1. Performance type instability

A variable whose type can change prevents JIT optimization. Always write type-stable code: s = 0.0 not s = 0.

2. Using :: incorrectly

x::Int asserts the type (runtime check). function f(x::Int) declares the type (dispatch).

FAQ

{{< faq question="What is the difference between abstract and concrete types?" >}} Abstract types (Number, Any) form the hierarchy. Concrete types (Int64, Float64) cannot be subclassed and have actual data layout. {{< /faq >}}

{{< faq question="What is Union type?" >}} Union{Int, Nothing} means the value can be either Int or Nothing. Useful for optional values.

{{< /faq >}}

{{< faq question="What are parametric types?" >}} Types that take parameters: Vector{Int}, Dict{String, Float64}. Like generics in other languages. {{< /faq >}}

What's Next

Now learn about multiple dispatch -- Julia's defining feature.