Neglecting a parameter with a similar punctuation in Lua in a type declaration

[ProBaturay]

I often use a colon when defining a method instead of a dot with the type-checking engine. At first, I determine a table of functions with their types and pass on them. Here's an example of code for what I mean.

--!strict

type a = {
    func1 : (a, number) -> (number)
}

local b : a = {
    func1 = function(self, num : number) : number
        return num * 5
    end
}

print(b.func1(b, 3), b:func1(3))

Both calls return the same value, except for the writing format. As aforementioned, I use the 2nd method as usual. I can reckon without the self parameter by using a colon, which I think is done with ease rather than using a dot and the parameter itself. But the type declaration sometimes does not comply with the same situation as the parentheses used for the predicted-to-be-passed parameters. Since Lua uses the keyword "self" to handle the hidden parameters, I guess there would be no specific keyword for Luau to get around with it. I propose something like this syntax that would get you to understand the state.

-- Forking the above script

func1 : (number) ->> (number)

-- would behave the same as below

func1 : (a, number) -> (number)

Understandably, I usually forget to write the table into the parentheses and struggle with debugging the script. The "->>" will see through the job hiding the self-behaving parameter. It will automatically search for the table that the function was assigned for. Such functions that are stored outside of a table will not be capable to use "->>" such that:

type a = {
    func1 : (a, func2 : () -> ()) -> (number)
}

-- below is the self-behaving parameter equivalent

type a = {
    func1 : (func2 : () -> ()) ->> (number)
}

-- func2 is the function of func1, which is not a table, therefore cannot be used with ->>.

Please tell me whether there's anything I missed while glancing at the documents to get over it or if the idea itself is theoretically wrong. I appreciate any help!