Why are these different?

[Fizzlemizz]

I'm sure I'm missing something obvious but using the code below, pressing the f1 button returns

LeftButton, nil

Pressing the f2 button returns:

table: 0000000043259BB0, LeftButton

Why the difference?

local _, Settings = ...

function Settings:TestClick(p1, p2)
	print(tostring(p1) .. ", " .. tostring(p2))
end
function Settings:CreateOptions()
	local f = CreateFrame("Frame")
	f:SetSize(10, 80)
	f:ClearAllPoints()
	f:SetPoint("CENTER", UIParent)
	f.test = CreateFrame("Button", "Test_Button", f, "UIPanelButtonTemplate")
	f.test:SetScript("OnClick", function(self, button)
		if self.clickextra then
			self.clickextra(self, button)
		end
	end)
	f.test.clickextra = Settings.TestClick
	f.test:ClearAllPoints()
	f.test:SetPoint("CENTER")
	return f
end

local function Test2Click(p1, p2)
	print(tostring(p1) .. ", " .. tostring(p2))
end
local function CreateOpts()
	local f = CreateFrame("Frame")
	f:SetSize(10, 80)
	f:ClearAllPoints()
	f:SetPoint("CENTER", UIParent, 0, -40)
	f.test = CreateFrame("Button", "Test_Button", f, "UIPanelButtonTemplate")
	f.test:SetScript("OnClick", function(self, button)
		if self.clickextra then
			self.clickextra(self, button)
		end
	end)
	f.test.clickextra = Test2Click
	f.test:ClearAllPoints()
	f.test:SetPoint("CENTER")
	return f
end

local f1 = Settings:CreateOptions()
local f2 = CreateOpts()

Edit: and changing

self.clickextra(self, button) to self.clickextra(1, self, button)

in Settings:CreateOptions() produces the same result as pressing f2.

[SDPhantom]

You might try this:

local function Test2Click(self, p1, p2)

This is because the first function is defined as a method, takes the first arg and assigns it to the local self. The second and third args go to p1 and p2 respectively. This normal function definition doesn't shift the args like that and causes the anomaly you witnessed. To compensate for this, you need to explicitly define self as the first arg.

[Gethe]

Originally Posted by Fizzlemizz I'm sure I'm missing something obvious but using the code below, pressing the f1 button returns Pressing the f2 button returns: Why the difference? <snip> Edit: and changing in Settings:CreateOptions() produces the same result as pressing f2.

The colon notation used in Settings:TestClick absorbs the first arg given as self. If you add

self:GetName(),

as the first arg to the Settings:TestClick print call, it will return:

Test_Button LeftButton, nil

With your edit, the above will return with this error:

1x MyFirstAddOn\code.lua:7: attempt to index local 'self' (a number value)
MyFirstAddOn\code.lua:7: in function `clickextra'
MyFirstAddOn\code.lua:17: in function <MyFirstAddOn\code.lua:15>

Locals:
self = Test_Button {
 0 = <userdata>
 clickextra = <function> defined @MyFirstAddOn\code.lua:6
 Right = <unnamed> {
 }
 Middle = <unnamed> {
 }
 Left = <unnamed> {
 }
}
button = "LeftButton"

In Test2Click, p1 is technically 'self'. Even though it's not named that, the reference still gets passed to the first arg.

ps: print() will automaticly tostring() each arg.

[Fizzlemizz]

I've learned something new today, thank you both.

Lua is an intersting beast full of surprises, both good and bad this one, not so much on the good side .

Edit: on second thought, a lightbulb moment so the surprise swings very much back to the good side.

[Oppugno]

Although it has already been said this is the formal reason why it is happening:

Originally Posted by Lua 5.1 Reference Manual The colon syntax is used for defining methods, that is, functions that have an implicit extra parameter self. Thus, the statement function t.a.b.c:f (params) body end is syntactic sugar for t.a.b.c.f = function (self, params) body end

As you would think this also applies when calling functions.

These two functions are identical

function Table.Print(self)
    print(self)
end
 
function Table:Print()
    print(self)
end

The second one uses the colon notation and thus 'self' is implicitly the table in which it is defined.

These two function calls are also identical, in their resulting outputs.

Table:Print()
Table.Print(Table)

When using the dot notation you explicitly define what the 'self' variable will be by calling the function with that passed as the first argument.

Note that the 'self' variable does not need be the table in which the function is defined in.

Table.Print("Orange")

Will work equally well. However, this time outputting "Orange" instead of the table reference.

P.S. It seems Fizzlemizz got what they needed while I was typing this up. Leaving it here for anyone that stumbles upon it.

[Seerah]

Originally Posted by Gethe ps: print() will automaticly tostring() each arg.

It will also print any number of arguments passed to it. No need to create a string and concatenate it all together.

print(p1, p2)