How to use the composition pattern for OOP and also have it be typed at the same time without triggering a cyclic dependency error for Modules?

Help and Feedback Scripting Support
#1

I am trying to do this. I want to use the Composition pattern that is for Object Oriented Programming but also have it be typed at the same time without the cyclic dependency error that I keep getting since it may require requiring the Modules to get the type information. My question is is there a way to make it happen without triggering that cyclic dependency module error? In composition, objects are composed within objects. Here is an example:

tycoon.lua

local tycoon = {}
tycoon.__index = tycoon

function tycoon.new(model: Model)
    local self = setmetatable({}, tycoon)
    self.model = model
    self.door = require(script.door).new(self, model:FindFirstChild("Door"))
    return self
end

type tycoon = typeof(tycoon.new(table.unpack(...)))
export type Type = tycoon

return tycoon

door.lua

local tycoon = require(script.Parent)
local door = {}
door.__index = door

function door.new(tycoon: tycoon.Type, model: Model)
    local self = setmetatable({}, door)
    self.tycoon = tycoon
    self.model = model
    return self
end

function door.open(self: door)
    -- open animation plays
    self.open = true
end

function door.close(self: door)
    -- close animation plays
    self.open = false
end

function door.toggle(self: door, playerInteracting: Player)
    if not self.transitioning then
        if playerInteracting == self.tycoon.owner then
            self.transitioning = true
            if self.open then
                door:close()
            else
                door:open()
            end
            self.transitioning = false
        end
    end
end

type door = typeof(door.new(table.unpack(...)))

return door

This was from a tutorial and the OP said that it works for usage with VSCode and ROBLOX LSP but now I am using LUAU LSP to do it but it no longer works (ROBLOX LSP has been deprecated).
Can anyone test and report back? For reference, this is the original posted tutorial:

I would appreciate it, thanks!

#2

You can define a module before requiring it, which will break a false cycle. If your modules only contain functions which are not called at the time of require(), then this works.
Type annotations don’t do anything so I don’t really know how they work in Roblox. Presumably you can separate the types into their own modules to break the cycle.

1 Like
#3

I am trying to get type annotations so I have a form of autocompletion as well as IntelliSense. That is the whole purpose here. In this case, I cannot get the type annotations because it will result in cyclic dependency due to the nature of composition passing in objects into the parameter and then having to use require() to infer the type of the object when that object is passed into the parameter. Makes sense? You have any ideas on how this can be fixed? Thanks btw!

1 Like