Why is it impossible to subtype a struct

struct MyStruct
    x::Int
    y::Int
end

struct MySubStruct <: MyStruct
    z::Int
end

When working with Julia, you may come across a situation where you want to create a subtype of a struct. However, you may find that it is impossible to do so. In this article, we will explore three different ways to solve this problem.

Option 1: Using Abstract Types

One way to solve this problem is by using abstract types. Instead of directly subtyping the struct, we can create an abstract type and then subtype that abstract type.

abstract type MyAbstractStruct end

struct MyStruct <: MyAbstractStruct
    x::Int
    y::Int
end

struct MySubStruct <: MyAbstractStruct
    z::Int
end

By using abstract types, we can now create a subtype of the struct without any issues.

Option 2: Using Composition

Another way to solve this problem is by using composition. Instead of directly subtyping the struct, we can create a new struct that contains an instance of the original struct.

struct MyStruct
    x::Int
    y::Int
end

struct MySubStruct
    my_struct::MyStruct
    z::Int
end

By using composition, we can now create a new struct that includes the original struct as a field, allowing us to achieve the desired behavior.

Option 3: Using Traits

The third way to solve this problem is by using traits. Traits allow us to define a set of behaviors that can be shared across different types.

struct MyStruct
    x::Int
    y::Int
end

struct MySubStruct
    my_struct::MyStruct
    z::Int
end

trait MyTrait
    x::Int
    y::Int
end

Base.@kwdef struct MyStruct2 <: MyTrait
    x::Int = 0
    y::Int = 0
end

Base.@kwdef struct MySubStruct2 <: MyTrait
    my_struct::MyStruct2 = MyStruct2()
    z::Int = 0
end

By using traits, we can define a set of behaviors that can be shared across different types, allowing us to achieve the desired behavior.

After exploring these three options, it is clear that using abstract types is the best solution. It provides a clean and concise way to create subtypes of a struct without any limitations. Abstract types also allow for better code organization and maintainability. Therefore, using abstract types is the recommended approach when subtyping a struct in Julia.