constructor

constructor

Constructors can be defined using the constructor keyword.

import basics
import random

pragma ignore_unused

struct Person (name String, uid int) {
    constructor(name String){
        this.name = name
        this.uid = randomInt(100)
    }
}

func toString(person Person) String {
    return person.name + " : id=" + person.uid
}

func main {
    randomize()

    john Person("John")                               // constructed (living on stack)

    james *Person = new Person("John")                // constructed (living on heap)
    defer delete james

    print("Constructed people:")
    print(john)
    print(*james)

    // --------- vs ---------

    uninitialized_guy Person = undef                  // undefined (living on stack)

    uninitialized_heap_guy *Person = new undef Person // undefined (living on heap)
    defer delete uninitialized_heap_guy

    unconstructed_guy Person                          // zero-initialized (living on stack)

    unconstructed_heap_guy *Person = new Person       // zero-initialized (living on heap)
    defer delete unconstructed_heap_guy

    print("Unconstructed people")
    print(unconstructed_guy)
    print(*unconstructed_heap_guy)

    print("Uninitialized people")
    print("(cannot print these, since their names would be garbage memory)")
}

You can also define multiple constructors on the same type.

struct Thing (a, b, c String) {
    constructor(value String){
        this.a = value
        this.b = value
        this.c = value
    }

    constructor(int value){
        this.a = toString(value)
        this.b = toString(value + 1)
        this.c = toString(value + 2)
    }

    constructor(a String = "a", b String = "b", c String = "c"){
        this.a = a
        this.b = b
        this.c = c
    }
}

The primary use case of constructors is to construct values on their creation. You can easily invoke constructors on value creation by using parentheses immediately after. For example:

import basics

struct Thing (value double, owner String) {
    constructor(initial_value double){
        this.value = initial_value
        this.owner = "nobody"
    }
}

func main {
    one Thing(1.0)
    two *Thing = new Thing(2.0)

    defer {
        two.__defer__() // destroy
        delete two      // delete
    }

    print(one.value)
    print(two.value)
}

You can also call a constructor like any other method, using value.__constructor__(arg1, arg2, argN). However, you are responsible for making sure the memory of the value is zero-initialized before-hand, since constructors are allowed to assume zero-initialization.

import basics

struct MyInteger (value int) {
    constructor(){
        this.value = 12435
    }
}

func main {
    my_integer MyInteger
    my_integer.__constructor__()

    // which is equivalent to

    /*
    my_integer MyInteger()
    */

    // -----------------------------

    print(my_integer.value)
}

Calling __constructor__ on memory that is not zero-initialized is type-dependant. Types are NOT REQUIRED to be able to be constructed on non zero-initialized memory. If uncertain, zero-initialize the memory before manual construction using something like memset(memory, 0, size_in_bytes)!

import basics

struct Person (name String, level int) {
    constructor(name String){
        this.name = name
        this.level = 1
    }
}

func main(){
    // Example of manually constructing values from garbage memory

    count usize = 100
    raw_memory *Person = new undef Person * count // equivalent to `malloc(sizeof Person * count)`

    repeat count {
        person *Person = &raw_memory[idx]

        memset(person, 0, sizeof Person)
        person.__constructor__("Abby")
    }

    each Person in [raw_memory, count] {
        printf("[%d] Hello %S\n", idx, it.name)
    }

    defer {
        each Person in [raw_memory, count], it.__defer__() // destroy each person (necessary because it contains `String` and so is not POD (plain-old-data))
        delete raw_memory                                  // equivalent to `free(raw_memory)`
    }
}

When defined on Classes

Constructors have an additional behavior when defined on classes. They are responsible for initializing the __vtable__ field used for dynamic dispatch.

This is why instances of classes must be constructed before using dynamic dispatch.

class MyClass () {
    constructor {}

    virtual func doTheThing {}
}

func main {
    one MyClass()
    one.doTheThing() // ok - `one` is constructed

    two *MyClass = new MyClass()
    defer delete two
    two.doTheThing() // ok - the value pointed to by `two` is constructed

    three MyClass
    three.doTheThing()  // this will crash!!! The value `three` must be constructed in order to use dynamic dispatch!!!
}