Authors CurseForge

Colon notation is the same as dot notation *except* that when using colon notation, the reference to the frame/table (self) is passed automatically.

ie,
frame:SetValue(65)
is the same as
frame.SetValue(self, 65)

If using dot notation, you need to pass the reference to the frame as the first parameter of the function.

Quote from Seerah

ie,
frame:SetValue(65)
is the same as
frame.SetValue(self, 65)

More specifically, it's the same as frame.SetValue(frame,65) with the usual caveat about only evaluating the "frame" expression once, etc, etc.

Your error occurs in Slider.lua. You haven't shown us that file.

Look at the frame stack of the error.

Even if the error actually happens in Slider.lua, line 103, it's probably because the code tries to pass a nil value to :SetValue. So where does that value comes from ?

Moving up in the stack frame, we see that this value is returned by self:GetValue() at line 154 of Control.lua.

function Portfolio.Control.Update(self)
    self:SetValue(self:GetValue(), false, true)
end

So, for some reason you have to find if you want to fix the error, this self:GetValue() returns nil.

I'm not sure if I was misreading that other thread or what, but what I took away from the post that said your functions were polluting the global namespace was that you just needed to put the word "local" in their declarations. I'm not sure it was entirely necessary to attach them all to a table unless you wanted to pass that table around to other parts of your addon. I might be missing something, though...

Though, as a result of looking at the code, I have a question: if a method is declared as...

function Table:Method()

...but is called like...

Table.Method()

...what does that mean for the self parameter? Is that actually just hidden from the parameter list or is that variable and its value injected into the function's scope from the C side? If it's the former, not passing it just means it's empty, right? So, what if there are other parameters.

For example, this...

function RIA:OnEvent(event, ...)

...being used like this...

RIA.eventFrame:SetScript("OnEvent", RIA.OnEvent)

Wouldn't OnEvent be expecting, when called using dot notation, the first parameter to be self? So, wouldn't the event name actually get thrown into self?

Quote from Pelf

Though, as a result of looking at the code, I have a question: if a method is declared as...

function Table:Method()

...but is called like...

Table.Method()

...what does that mean for the self parameter?

It means that inside the function, self will be nil. This is probably a bug in the calling code, unless self isn't used at all in that function, in which case it doesn't matter.

There's no special correspondence between "declaration" and "call" syntax in Lua. (Functions aren't really "declared" as in imperative languages, there's no function signature here.) You can mix and match colon and non-colon styles when defining and calling functions, as long as the parameters match up.

So, what if there are other parameters.

For example, this...

function RIA:OnEvent(event, ...)

...being used like this...

RIA.eventFrame:SetScript("OnEvent", RIA.OnEvent)

Wouldn't OnEvent be expecting, when called using dot notation, the first parameter to be self?

Yes, but "self" as a magic keyword is going to change, obviously. Using colon notation when defining a function just means "there will be a hidden first parameter, and it will be called 'self'". It doesn't bind it to the containing table.

So, wouldn't the event name actually get thrown into self?

It depends on how OnEvent is called. In this case, it's by Blizzard, and their event handlers always take a frame reference as the first parameter, specifically to support colon notation. In the code here, a reference to 'eventFrame' will be passed as the first argument, and will be accessible as "self" inside

function RIA:OnEvent(event, ...)

This is why a lot of event handlers get declared as

local my_event_handler (frame, event, ...)  stuff end

with embedded local references to the data structures, so that there's zero possible confusion or misreading about "self".

I'm trying to reconcile these two:

There's no special correspondence between "declaration" and "call" syntax in Lua. (Functions aren't really "declared" as in imperative languages, there's no function signature here.)

Using colon notation when defining a function just means "there will be a hidden first parameter, and it will be called 'self'".

Two things:

1. function(param1, param2)
       --body
   end

That's a function declaration, isn't it? It's defining the parameter list. I can call it with no parameters [as ___()] and it just passes nil for each one, but I can't call it with more parameters than what it was originally "declared" as having and expect those extra values to be accessible. I'd have to put the vararg in there explicitly to be able to use it within the function scope (to make it a "vararg function", I think the error message says).

2. Your use of the phrasing "there will be" also seems to imply that something is "set" when code like the above is written.

So, given this...

local f = {}

function f.Dot(name)
	print(type(name))
end

function f:Colon()
	print(self == nil)
end

f:Dot("Johnny") -- this prints "table"
f.Colon() -- this prints "true"

...there is something "saved" at the point of declaration. The self keyword isn't something that magically becomes available within the function's scope. It's really there in the parameter list at the first position. The value "Johnny" disappears into the ether in the first call as there are no more parameters left.

Without having read the thread thoroughly; 'self' is only "magical" in a function definition defined using colon syntax. It is there defined without having been typed out by the programmer, and it's only magical in being defined automatically. Beyond that it's just a normal parameter. Furthermore, both f.Dot and f:Colon are for all intents and purposes regular functions. The fact that they are on a table does not change the behaviour of the functions at all; only that you can call such a function using the colon syntax.

These are essentially the same:

function onEvent(frame, event, ...)
end

aFrame:SetScript("OnEvent", onEvent)

function aTable:OnEvent(event, ...)
end

aFrame:SetScript("OnEvent", aTable.OnEvent)

Basically, you should consider that this:

local f = {}

function f.Dot(name)
	print(type(name))
end

function f:Colon()
	print(self == nil)
end

f:Dot("Johnny") -- this prints "table"
f.Colon() -- this prints "true"

Is strictly complied as this by Lua :

local f = {}

f.Dot = function(name)
	print(type(name))
end

f.Colon = function(self)
	print(self == nil)
end

f.Dot(f, "Johnny") -- this prints "table"
f.Colon() -- this prints "true"

foo:bar(...) is just a syntactic sugar for foo.bar(foo, ...).

Quote from Pelf

I'm trying to reconcile these two:

I mean "declaration" as in a language like C++, Java, etc. Lua doesn't have function prototypes or signatures.

The magic insertion of 'self' happens only when parsing a function being defined with the colon syntax. That's it. That's all. There's nothing else going on.

I haven't looked at the code you've posted, but I don't see what the confusion is here.

The confusion was only related to you telling me that there wasn't anything going on when a function was written down for the first time.

I think it's clear now that if a function is not either defined on a table with colon syntax or manually defined with its first parameter reserved for a frame, it cannot later be called that way.

Quote from Pelf

The confusion was only related to you telling me that there wasn't anything going on when a function was written down for the first time.

....?

I think it's clear now that if a function is not either defined on a table with colon syntax or manually defined with its first parameter reserved for a frame, it cannot later be called that way.

*blink*

Yes, you need to give names to parameters.