function(self)

local objectDef = { -- This is a table, but im going to set it up like an object template
  numb1 = 5,
  numb2 = 10,
  addition = function(self) -- this is where self comes into play, to reference the table this funciton exists in.
	print(self.numb2+self.numb1)
  end,
  subtraction = function(self)
	print(self.numb2-self.numb1)
  end
}
setmetatable(objectDef, {__call = function() -- this makes calling the table result in the following function being invoked, which basically returns a copy of the table.
	local retTable = {}
	for k,v in pairs(objectDef) do
	  retTable[k] = v
	end
	return retTable
  end
})
object = objectDef()
object:addition() --syntactic sugar way of writing object.addition(object)
--prints 15

tTable = {
  value = 10,
  multiply = function(selforwhateveryouwannacallit,v)
	return selforwhateveryouwannacallit.value*v
  end
}
print(tTable:multiply(10)) --prints 100

CometWolf, on 20 February 2014 - 01:36 PM said:

tTable = {
  value = 10,
  multiply = function(selforwhateveryouwannacallit,v)
	return selforwhateveryouwannacallit.value*v
  end
}
print(tTable:multiply(10)) --prints 100

doStuff({1, 2, 3}, 1)
--OR
123Table = {1, 2, 3}
123Table:doStuff(1)

123Table = {1, 2, 3, doStuff = function(self,v) for i=1,#self do print(self[i]*v) end end}
123Table:doStuff(1)

local object = {text = "Hello"}

function object:print (newText)
  print(self.text)

  self.text = newText or self.text
end

object:print("Test") -->> 'Hello'
object:print() -->> 'Test'

function object:print (newText)
  print(self.text)
  self.text = newText or self.text
end

function object.print (derpherp,newText)
  print(derpherp.text)
  derpherp.text = newText or derpherp.text
end

object.print(object,"Test")
object:print()

local tbl = {}
tbl.setA = function(self, a)
    self.a = a
end

tbl.setA(tbl, 3)
print(tbl.a) -- prints 3

tbl:setA(4)
print(tbl.a) -- prints 4

local tbl = {}
function tbl:setA(a)
    self.a = a
end
tbl:setA(3)
print(tbl.a) -- prints 3

function arg1:myFunction(arg2, arg3)
   arg1 = arg2 + arg3
end
AND/OR
function arg1:myFunction(arg2, arg3)
   arg1.answer = arg2 + arg3
end

function arg1:myFunction(arg2, arg3)
   self = arg2 + arg3
end
AND/OR
function arg1:myFunction(arg2, arg3)
   self.answer = arg2 + arg3
end

function arg1:myFunction(arg2, arg3)
   arg1 = arg2 + arg3
end

local functionTable = {
  func = function(arg1,arg2,arg3)
    print("arg1 is the table ".. arg1.name)
    print("arg2 is "..tostring(arg2))
    print("arg3 is "..tostring(arg3))
  end
}
local test = setmetatable(
  {
    name = "test"
    --the table which im changing the metatable, im creating a new one here instead of creating one and referencing it later
  },
  {
    --the metatable
    __index = functionTable --makes it check functionTable if the key dosen't exist
  }
)
--now the following will work
test:func("derp","herp")

CometWolf, on 15 March 2014 - 06:35 PM said:

a metatable is the action a table uses to perform specific operations. the __index metatable is the one used when you're looking up a key in the table that does not exist. Thus, the table could find your function in another table instead of itself, and be able to use that instead.

local functionTable = {
  func = function(arg1,arg2,arg3)
	print("arg1 is the table ".. arg1.name)
	print("arg2 is "..tostring(arg2))
	print("arg3 is "..tostring(arg3))
  end
}
local test = setmetatable(
  {
	name = "test"
	--the table which im changing the metatable, im creating a new one here instead of creating one and referencing it later
  },
  {
	--the metatable
	__index = functionTable --makes it check functionTable if the key dosen't exist
  }
)
--now the following will work
test:func("derp","herp")

read more here
http://www.lua.org/pil/13.html

funcs = {
    function func1(arg1, arg2, arg3)
	    print(arg1.arg4.." "..arg1.arg5.." "..arg1.arg6.." "..arg2.." "..arg3)
    end
}
vars = {
    arg4 = "I am an idiot!",
    arg5 = "I make awesome stuff that has no use!",
    arg6 = "blah blah blah!"
}
setmetatable(vars, {_index = funcs})
--So...
vars.func1("bla", "blay") --I am an idiot! I make awesome stuff that has no use! blah blah blah! bla blay
--OR
vars:func1("bla", "blay") --I am an idiot! I make awesome stuff that has no use! blah blah blah! bla blay
--Colon or period?

--this
vars:func1("bla", "blay")
--is the same as
vars.func1(vars,"bla","blay")

MrabEzreb, on 20 February 2014 - 01:59 PM said:

123Table = {1, 2, 3}

CometWolf, on 20 February 2014 - 02:03 PM said:

123Table = {1, 2, 3, doStuff = function(self,v) for i=1,#self do print(self[i]*v) end end}

Note however that you can't begine a variable name(table) with a number.

local foo = {}
function foo:bar( x,y )
  --# there are 3 arguments: self, x, and y
  --# `self` would be a reference to `foo` when invoked like foo:bar(5,5)
  --# however the function could still be invoked like foo.bar(foo,5,5) meaning that you could provide another table if you wished like foo.bar({}, 5, 5)
end

local foo = {}
function foo.bar( this, x, y )
  --# there are 3 arguments: this, x, and y
  --# `this` would be a reference to `foo` when invoked like foo:bar(5,5)
  --# the same rules apply to this function as do with the previous, the previous is just simply syntactical sugar
end

MrabEzreb, on 28 May 2014 - 08:32 PM said:

Just in case anyone would still answer now that i get the point of OOP, by doing
function table:func()
The function table.func() or table:func() would give the function an argument called "self" which would contain everything in "table", right?

local new = function()
  local window = {
	x = 1,
	y = 1,
	resize = function(x,y)
	  window.x = x
	  window.y = y
	end
  }
  return window
end

local screenWindow = window.create()

Do i have to define the object WITHIN the function, or could it be somewhere else in the api?

CometWolf, on 28 May 2014 - 11:10 PM said:

You could, but if you're not creating it within a function there's really no point, since it won't have it's own instance. You might aswell ditch the function altogether and store it directly in your api.

CometWolf, on 28 May 2014 - 11:33 PM said:

I responded to this

Do i have to define the object WITHIN the function, or could it be somewhere else in the api?

with

CometWolf, on 28 May 2014 - 11:10 PM said:

You could, but if you're not creating it within a function there's really no point, since it won't have it's own instance. You might aswell ditch the function altogether and store it directly in your api.

Where does the window API enter the picture?

CometWolf, on 28 May 2014 - 10:34 PM said:

It defines the object within the creation function, then defines the variables inside the object, before returning it. It's heavier computation wise, as the variables have to be defined for each object, but it's more newb friendly i suppose.

local new = function()
  local window = {
	x = 1,
	y = 1,
	resize = function(x,y)
	  window.x = x
	  window.y = y
	end
  }
  return window
end

newobj = new()

MrabEzreb, on 28 May 2014 - 09:48 PM said:

Okay. But how do things like the window api work?

CometWolf, on 28 May 2014 - 10:34 PM said:

It defines the object within the creation function, then defines the variables inside the object, before returning it. It's heavier computation wise, as the variables have to be defined for each object, but it's more newb friendly i suppose.

local new = function()
  local window = {
	x = 1,
	y = 1,
	resize = function(x,y)
	  window.x = x
	  window.y = y
	end
  }
  return window
end

funcs = {
  add = function( self, num )
   self.value = self.value + num
  end,
  subtract = function( self, num )
   self.value = self.value - num
  end,
}
function new( num )
  local t = {value = num}
  setmetatable(t, funcs)
  return t
end

function new( num )
  t = {
    value = num,
  }
  t.add = function( num )
   t.value = t.value + num
  end
  t.subtract = function( num )
   t.value = t.value - num
  end
  return t
end

function new(num)
  local t = {}
  t.value = num
  t.add = function(num)
    t.value = t.value + num
  end
  return t

Lyqyd, on 29 May 2014 - 04:03 AM said:

You can't reference t from within t.

function new(num)
  local t = {}
  t.value = num
  t.add = function(num)
    t.value = t.value + num
  end
  return t