How would you type incompatible constructors?

[Hedwig7s]

It's common for subclasses to have incompatible constructors as they might require more information. As the constructor isn't available on the instance it can be incompatible without causing issues
Example:

class ParentClass {
    name: string;

    constructor(name: string) {
        this.name = name;
        console.log("Parent constructor: " + name);
    }

    greet(): void {
        console.log("Hello, my name is " + this.name);
    }
}

class ChildClass extends ParentClass {
    age: number;

    constructor(name: string, age: number) {
        super(name);
        this.age = age;
        console.log("Child constructor: " + name + ", " + age);
    }

    greetWithAge(): void {
        console.log("Hello, my name is " + this.name + " and I am " + this.age + " years old");
    }
}

In lua however since there are no classes the constructor is just a normal function
In base Lua you can do something similar just fine

local ParentClass = {}
ParentClass.__index = ParentClass

function ParentClass:new(name)
   local instance = setmetatable({}, { __index = self })
   instance.name = name
   print("Parent constructor: " .. name)
   return instance
end

function ParentClass:greet()
   print("Hello, my name is " .. self.name)
end

local ChildClass = setmetatable({}, { __index = ParentClass })
ChildClass.__index = ChildClass

function ChildClass:new(name, age)
   local instance = ParentClass.new(self, name)
   instance.age = age
   print("Child constructor: " .. name .. ", " .. age)
   return instance
end

function ChildClass:greetWithAge()
   print("Hello, my name is " .. self.name .. " and I am " .. self.age .. " years old")
end

However in teal, as the constructors are incompatible and they are treated as regular methods, this just isn't possible

local interface Parent 
    name: string
    metamethod __index: ParentMT
end
local interface ParentMT
    new: function(self: ParentMT, name: string): Parent
    greet: function(self: Parent)
    __index: ParentMT
end

local ParentClass: ParentMT = {}
ParentClass.__index = ParentClass

function ParentClass:new(name:string): Parent
    local instance: Parent = setmetatable({}, {__index = self})
    instance.name = name
    print("Parent constructor: " .. name)
    return instance
end
function ParentClass.greet(self:Parent) 
    print("Hello, my name is " .. self.name)
end

local interface ChildMT is ParentMT
    new: function(self: ChildMT, name: string, age: number): Child -- Incompatible
    greetWithAge: function(self: Child)
    __index: ChildMT
end
local interface Child is Parent
    age: number
    metamethod __index: ChildMT
end

local ChildClass = setmetatable({}, { __index = ParentClass })
ChildClass.__index = ChildClass

function ChildClass:new(name: string, age:number): Child
    --local instance = ParentClass.new(self, name) -- Error: Called method as regular function
    local super = ParentClass.new
    local instance = super(self, name) as Child -- Would work if new was compatible
    instance.age = age
    print("Child constructor: " .. name .. ", " .. age)
    return instance
end
function ChildClass.greetWithAge(self:Child)
    print("Hello, my name is " .. self.name .. " and I am " .. self.age .. " years old")
end

Is there a way to type this correctly? Do I have to do inheritence Rust style? Do I seperate the constructor from the metatable?

[Hedwig7s]

Did some testing and composition does in fact resolve the issue, although it's a completely different OOP model and probably isn't the best solution considering standard Lua practices

local interface Parent 
    name: string
    metamethod __index: ParentMT
end

local interface ParentMT
    new: function(self: ParentMT, name: string): Parent
    greet: function(self: Parent)
    __index: ParentMT
end

local ParentClass: ParentMT = {}
ParentClass.__index = ParentClass

function ParentClass:new(name: string): Parent
    local instance: Parent = setmetatable({}, {__index = self})
    instance.name = name
    print("Parent constructor: " .. name)
    return instance
end

function ParentClass.greet(self: Parent)
    print("Hello, my name is " .. self.name)
end

local interface Child
    parent: Parent
    age: number
    metamethod __index: ChildMT
end

local interface ChildMT
    new: function(self: ChildMT, name: string, age: number): Child
    greet: function(self: Child)
    greetWithAge: function(self: Child)
    __index: ChildMT
end

local ChildClass: ChildMT = {}
ChildClass.__index = ChildClass

function ChildClass:new(name: string, age: number): Child
    local instance: Child = setmetatable({}, {__index = self})
    instance.parent = ParentClass:new(name)
    instance.age = age
    print("Child constructor: " .. name .. ", " .. age)
    return instance
end

function ChildClass.greet(self: Child) -- Optional, could just call child.parent:greet()
    ParentClass.greet(self.parent)
end

function ChildClass.greetWithAge(self: Child)
    print("Hello, my name is " .. self.parent.name .. " and I am " .. self.age .. " years old")
end

[Hedwig7s]

Polymorphism could also work although I value my sanity