Julia abstract types vs union of types

When working with Julia, you may come across situations where you need to define types that can have multiple subtypes. In such cases, you have two options: using abstract types or using unions of types. In this article, we will explore both options and discuss their pros and cons.

Using Abstract Types

Abstract types in Julia allow you to define a common interface for a group of related types. They can be used as a way to organize and categorize types, providing a high-level view of the hierarchy. To define an abstract type, you can use the abstract type keyword followed by the name of the type.

abstract type Animal end

struct Dog <: Animal
    name::String
    age::Int
end

struct Cat <: Animal
    name::String
    color::String
end

In the example above, we define an abstract type Animal and two concrete subtypes Dog and Cat. The Dog subtype has two fields: name and age, while the Cat subtype has name and color fields.

Using abstract types allows you to write generic code that can operate on any subtype of the abstract type. For example, you can define a function that takes an Animal as an argument and performs some common operations:

function make_sound(animal::Animal)
    if animal isa Dog
        println("Woof!")
    elseif animal isa Cat
        println("Meow!")
    end
end

By using the isa keyword, you can check the type of the argument and perform different actions based on the subtype. This allows you to write more generic and reusable code.

Using Unions of Types

Unions of types in Julia allow you to define a type that can have multiple possible subtypes. To define a union type, you can use the Union keyword followed by the list of possible subtypes.

struct Dog
    name::String
    age::Int
end

struct Cat
    name::String
    color::String
end

function make_sound(animal::Union{Dog, Cat})
    if animal isa Dog
        println("Woof!")
    elseif animal isa Cat
        println("Meow!")
    end
end

In the example above, we define two concrete types Dog and Cat. The make_sound function takes an argument of type Union{Dog, Cat}, which means it can accept either a Dog or a Cat as input.

Using unions of types allows you to be more flexible in defining the possible subtypes. You can easily add or remove subtypes from the union without modifying the function signature. However, this flexibility comes at the cost of losing the high-level view provided by abstract types.

Which Option is Better?

The choice between using abstract types and unions of types depends on the specific requirements of your code. If you have a clear hierarchy of types and want to enforce a common interface, abstract types are a good choice. They provide a high-level view of the types and allow you to write more generic code.

On the other hand, if you need more flexibility in defining the possible subtypes and want to avoid modifying function signatures, unions of types are a better option. They allow you to define a type that can have multiple subtypes without the need for a strict hierarchy.

In conclusion, both abstract types and unions of types have their own advantages and disadvantages. The choice between them depends on the specific needs of your code. Consider the hierarchy of your types and the flexibility required when making a decision.