Luau Function Overloading

FrontHD · August 22, 2020, 12:44pm

As a Roblox developer, it is currently too hard to create multiple functions that take unique type signatures with the same name.

If Roblox is able to address this issue, it would improve my development experience, because I would be able to make simpler modules, functions, scripts, etc.

Egregious Example

As we all know, most of the functions we use (CFrame.new(6 methods), ColorSequence.new(3 methods), etc.), has multiple methods of constructing a value:

When constructing a CFrame, we can choose to have either:

Empty, just a 0, 0, 0 CFrame
1 Vector3 (position)
3 numbers as a Vector3 position
2 Vector3 (position, lookAt)
5th method I don’t really understand (Probably something to do with position and rotation)
A method to construct a CFrame with all the “matrixes”

Now, what I suggest, is to add a feature, where you can make a constructor that takes unique combinations of arguments, as multiple methods. Basically, function overloading.

function foobar(a: number, b: Vector3): string
    return "I got a number and a Vector3!"
end

-- As of now, this just prints an error, telling us that we overwrote a function.
function foobar(a: Vector3): string
    return "I got a Vector3!"
end

function foobar(a: nil): string
    return "I got nothing. :("
end

print(foobar(Vector3.new(5, 15, 7))) -- "I got a Vector3!"
print(foobar(7, Vector3.new(62, 13, 5))) -- "I got a number and a Vector3!"
print(foobar()) -- "I got nothing. :("

This is in fact possible with a normal function, but this isn’t very feasible to do so.

function foobar(a, b)
    if typeof(a) == "number" and typeof(b) == "Vector3" then
        return "I got a number and a Vector3!"
    elseif typeof(a) == "Vector3" then
        return "I got a Vector3!"
    end
    return "I got nothing. :("
end

print(foobar(Vector3.new(5, 15, 7))) -- "I got a Vector3!"
print(foobar(7, Vector3.new(62, 13, 5))) -- "I got a number and a Vector3!"
print(foobar()) -- "I got nothing. :("

Module Example

local module = {}

function module:GetSomething(a: Vector3): Vector3
    return a * Vector3.new(5, 2, 1.5)
end

function module:GetSomething(a: number): string
    return "Your number is " .. tostring(a) .. "."
end

function module:GetSomething(a: nil): string
    return "I think you forgot to insert an argument..."
end

return module

Use cases:

Simpler, yet more effective modules
Easier organization in scripting

Here’s a wiki page more about function overloading.

nooneisback · August 22, 2020, 4:01pm

The issue here is that everything in Lua is treated like an object, even functions. This might cause a lot of confusion and unintentional behavior as Lua stores only one object per variable, while your suggestion means storing multiple functions in one.

I feel like overloading should be part of the initial function declaration, explicitly showing that it is done on the object, not the variable.

function foobar (a:number)
    print("nubmer",a)
overload (a:string)
    print("string",a)
end

Obviously it seems weird, but less so than your example.

Halalaluyafail3 · August 22, 2020, 4:25pm

One problem is that declaring a function over a variable is already valid

local function f(a:number)
    return a*2
end
function f(a:string)
    return a..a
end
function f(a:boolean)
    return not a
end

Would this use the new overload system or would it continue to function the same?

nooneisback:

I feel like overloading should be part of the initial function declaration, explicitly showing that it is done on the object, not the variable.
function foobar (a:number)
    print("nubmer",a)
overload (a:string)
    print("string",a)
end
Obviously it seems weird, but less so than your example.

Would overload be a keyword?
It would be difficult if not impossible to disambiguate this if it wasn’t

type t = {f:number,typeof:(t,string) -> any}
local s = "abc"
local overload = print
local function f(a:t)
    do return a.f end
overload(a:typeof(s))
    do return a..s end
end

Would this be an overload or would this call overload with all results of calling method typeof on a with arguments s (like how it is currently)?

Dekkonot · August 22, 2020, 4:38pm

Function overloading is a good way to confuse yourself; I don’t personally want it.

The example you listed, CFrame.new, is a particularly egregious one. It’s impossible to know what it’s doing at a glance. What does CFrame.new(x, y, z) do? You have to go check where these variables are defined to be able to know.

nooneisback · August 22, 2020, 5:11pm

My main point was to avoid declaring a function twice, as them still keeping the previous behavior is very confusing.

What I find weird is what would happen if you were to set the overloaded function as a table’s value. How would that even work? Most languages that have overloading restrict it to class methods; meanwhile, here we have a new function being created which doesn’t actually create a new object, but extends an existing one. Yet, creating a function without overloading does create a new object.

overload would be a keyword and my main reasoning behind this was the same as else/elseif in case of if statements.

Scarious · September 4, 2020, 5:33am

I agree that function overloading should be supported with luau, especially given what we can do with it.

This is used rather often in OOP languages, and seeing as people like OOP in Roblox (it has its benefits, but should not be defaulted to in all cases), this would totally improve OOP as a whole. We could extend classes, setup certain methods as “do nothing” methods until they are finally edited by the class extending the initial class… and so on.

Also, given what we can currently do with luau, I fully support this.

C_Corpze · March 20, 2025, 11:01am

Bumping this because yes this do be useful indeed.

Luau now has type checking and may potentially also allow for type-based optimizations in byte/low-level instructions.

Static C/C+±like languages typically allow for some sort of function overloading.

This can be quite tricky to do in Lua(u) because it’s an interpreted language by default but I don’t think it is impossible.

Without type checking it should technically already be possible to overload functions based on the amount of arguments, e.g.

function do_thing(arg)
 ...
end

function do_thing(arg1, arg2)
 ...
end

function do_thing(arg1, arg2, arg3)
 ...
end

Now in this case, if I were to type something like this:

do_thing(5, true)

3 functions with the same name exist, however they all accept different amounts of arguments, Lua should technically be able to distinguish these 3 functions based on that.

Now with type checking this should also be possible with functions that accept different types of arguments.

The biggest problem with Lua(u) currently however is that…

functions are technically variables

Why is that a problem?
Weeeeeell…

function do_thing(arg)
 ...
end

function do_thing(arg1, arg2)
 ...
end

Currently if we were to write this, the first function would get deleted and overwritten with the new function, because Lua treats functions like variables.

This is a problem.

Changing this behavior in the VM / compiler would most likely take a lot of work.
And even if it’s somehow achieved,
it could also break potential code in existing games and codebases that still depend on the functions are variables behavior.

As much as I would love this feature, it’s almost impossible to implement unless some new keyword / behavior is invented without replacing / changing old and original behavior that existing code might already rely on.

But I still support this feature request.

galmeowing · March 20, 2025, 4:34pm

Function overloads are able to be typed, and this just seems like an unnecessary syntax addition that just makes the language less friendly to beginners + overloaded functions are vague as @Dekkonot said previously

(() -> ()) & ((boolean) -> ())

GetStyled · March 21, 2025, 1:31am

The issue with implementing function overloading is you remove backwards compatibility
Also since lua(u) doesnt have strict type checking its not likely going to be possible to have the option for overloaded functions with types without either (and or both) slowing down code by a significant amount or having ambiguous/unexpected calls.
As an alternative you might be able to use typescript and just use their transpiler to convert it into luau code or whatever it does (assuming they support overloading by function renaming or smthing like that) or what most people do is have a bunch of if then elseif statements inside of a function. Additionally you could just type your functions using &

local foo : (state : boolean) -> () & (name : string, state : boolean) -> function(state, name)
-- if statements here
end

Additionally if you want to go with a ^^^ approach you could always do a #vargs check using select("#", ...)
anyways TLDR unlikely and unrealistic to happen

BlueDeveloper24 · March 21, 2025, 6:18am

Just do

local bool function aFunction()
end)

nothing_1649 · March 21, 2025, 7:56am

i was thinking about this the other day and if it could be done and every thought came to the conclusion that the implementation effort just isn’t worth it, uniquely named functions are not only easier to read but are basically just the same thing you just have to use a different identifier for each signature

TheGrimDeathZombie · March 21, 2025, 12:19pm

As much as this sounds great in theory, it would really detract from the readability of any code that makes use of overloads. With an overload, you have to go to the original function to figure out what x or y combination of arguments does, but with clearly named and unique functions you can tell at a glance exactly what the code is doing.