Inheritance

In Asylum, structures can inherit data and functions from other structures. Inheritance can be complicated for new programmers, so read carefully.

Basic Inheritance

You can inherit from another struct by using : followed by the name of the struct to inherit from:

struct Tires {
    int count;
    int expectedPSI;
}

struct Vehicle {
    Color color;
    int year;
    str maker;
    str model;
}

struct Car : Vehicle {
    int trunkSpace;
    int year;
}

fn main()
{
    Car car = Car {
        bases.Tires: Tires {
            count: 4,
            expectedPSI: 32
        },
        bases.Vehicle: Vehicle {
            color: Color(0x7F, 0x84, 0x29),
            year: 2017,
            maker: "Toyota",
            model: "Camry"
        },
        trunkSpace: 21,
        year: 2022
    };
    println(car.year);
    println(car.bases.Vehicle.year); // Can specify exactly where variable is from.
    println(car.count); // Is inherited from Tires.
}

Output:

2022
2017
4

Note that what the struct inherits can be referenced done by using bases.STRUCTNAME.MEMBERNAME.

Function Inheritance

You can inherit functions similarly to members:

struct A {
    int val;
}

struct B : A {}
struct C : B {}

impl A {
    fn fun() -> int => val;
}

impl B {
    fn fun() -> int => 7;
}

impl C {
    fn fun() -> int => val;
}

fn main() {
    A a = A {
        val: 1
    };
    B b1 = B {
        bases.A: A {
            val: 2
        }
    };
    C c = C {
        bases.B: B {
            bases.A: A {
                val: 3
            }
        }
    };
    B& b2 -> c;
    println(a.fun());
    println(b1.fun());
    println(c.fun());
    println(b2.fun());
    println(b2.bases.A.fun());
}

Output:

1
7
3
7
3

There is a lot going on here, so let’s take it a step at a time:

1. We create a bunch of structures. Here, A has an int named val, B inherits A, and C inherits B.

2. We give each of our structures implementations with identically named functions named fun. For A and C, these just return the value stored in A. For B though, it just returns 7.

3. Since a is an A, it just returns the value stored. This is the same for c, since it’s a C. However, b1 is a B so returns 7.

4. The variable b2 is a reference to c. Since c is a C and C inherits from B, that means we have no problem treating c as a B. We could also treat it as an A as we wanted. But since we are treating it as a B, the function call fun returns 7.

5. If we just call A’s function from b2, we print its value like it would if b2 was an A.

Traits

These are essentially virtual functions. When implementing functions, what function is called is heavily dependent on what struct you are working with as you saw above. However, what if we wanted b2 to call C’s fun since we know it is really a C? A use case for this would be if we were implementing animals. We could have dogs, cats, etc. Ideally, we would want to just pass around an Animal and if it were a Dog it should bark, a Cat meow, etc. We can do this using traits:

trait Animal {
    fn noise() -> str => "";
    fn isMammal() -> bool;
}

struct Dog {};
struct Cat {};

impl Animal for Dog {
    fn noise() -> str => "Bark";
    fn isMammal() -> bool => true;
}

impl Animal for Cat {
    fn noise() -> str => "Meow";
    fn isMammal() -> bool => true;
}

fn main()
{
    Dog dog;
    Cat cat;
    Animal& dog2 -> dog;
    println(dog.noise());
    println(cat.noise());
    println(dog2.noise());
}

Output:

Bark
Meow
Bark

In the above example, the Animal trait has a function for getting the noise of the animal. It has a default implementation that returns an empty noise, while the function for determining if the animal is a mammal has no default and must be implemented for the structure to not be abstract (explained later). Note that if we were to use standard functions rather than traits, dog2.noise() would return an empty string.

Base Calling

Abstract Structures

The Diamond Problem

TODO!!!

Composition VS Inheritance

TODO!!!