I am aware that Lua is case sensitive, but can Foo() just be used directly in conjunction with . and :

eg:

Code: [Select]

Foo():bar(42)Actually I'm not sure that looks valid...

It is valid, but keep in mind that it will create a new instance every time you use that.
It can be useful in certain specific cases, but not in general.

when you do foo = Foo(), that's similar to something like ball = Class() right?
It clicked for me when you said that Foo() was the class, and foo became the object.

Yes.
It is equivalent to ball = new Class() in other POO languages.

About creating new instances with Foo():bar(42),
does that have any other disadvantages, such as some sort of memory leak?

Only Memory Leaks (and maybe stupid beginner errors like "why my code doz not work" just because your creating a new object each time that has its own properties).

So clarification,

Code: [Select]

ball = class() -- creates a class called ball using the class function that is predefined
function ball:init(speed, size) -- initialises the class, it can be called by just ball() elsewhere in the code
   self.speed = spd -- these are added to the table, ball?
   self.size = size
end


Yes (and it's 'speed' not 'spd').

However, it's a general habit that classes definitions are first-letter-capitalized :
Ball = class()
function Ball:init(arg1, arg2) ... end

etc.

and instances of the classes, first-letter-lowercase :

myBall = Ball(5,10)

Ball = class()
Yeah I meant that as well, I forgot about that capitalised in that post. I already had these conventions in my current Lua project. Oops.

Also with instances of the classes, what if you want many instances using the same class,like at least 10? I've thought about using a table/list/array. Then I could call them by just referencing a particular value within the table.
Eg, using the function Ball:init(arg1, arg2)
Like this?
ballarray = {{3,4},{6,10},{4,11}...}


self.speed = spd
So this is not valid? does it have to be self.speed = speed, or self.speed = 0[a number], or self.speed = {}
EDIT: Oh I see the self.speed has to match the arguments.

function ball:init(speed, size)
   self.speed = speed
   self.size = size

I thought assigning any variable with a valid name would do ok...

Also thanks mannuri for explaining var.store() and math.eval()

PointClass.init(self, x, y)

What does the first argument (self) represent in relation to PointClass?
as compared to
PointClass:init(x, y)

for _, ball in ipairs(ball_tbl) do
I'm not 100% what in ipairs means as I've never had to use it. Also what does for _ mean? I'm more used to something like for x=sample, sample+9 do.

I know I'm getting closer to understanding everything...

Code: [Select]

PointClass.init(self, x, y)
What does the first argument (self) represent in relation to PointClass?
as compared to

Code: [Select]

PointClass:init(x, y)


Well, this wouldn't work. (the ":" would mean that the PointClass table (class definition !) is passed.)

For the first line of code you quoted, "self", there, is from the BallClass, not the PointClass. He's using PointClass.init (and not :init) because he specifies the object to be used for instanciation : the current (ball) self. As said before, ":" is just a shortcut for a.b(self)


Also, for pairs/ipairs : look here http://lua-users.org/wiki/ForTutorial

Ah, I'm making stupid mistakes again, I go back and look at it again and see that that line is within the function BallClass:init(x, y, radius)

Oh of course, I get what ipairs is now. Takes all the indices in numbered order (ones that can be ordered anyway), and has the indicies and keys from the table in pairs. Ok.

Oh wow I didn't know that _ could be used as a variable. Kinda like a wild card. Is it?

Spoiler For This question isn't so important, the more pressing stuff is below:

so can _ be used mixed like how you would search using * in other languages
Eg: you have variables bark, bork, berk
can you look for b_rk somehow?

No, "_" is just a valid char as a variable name such as _a, _foo, ________bar, foo_bar or even _ or _____, etc ...
Futhermore, "_" is in the Lua's culture (same in OCaml for example) a junk variable. It is then used when you know you don't want to use it.
But this doesn't mean it has a special meaning for the Lua's interpretor, for example this works :
local _o = 42
for _=1, _o do
 print(_, _+1, _o/_)
end


Quote

":" is just a shortcut for a.b(self)

So PointClass:init(x, y) is a shortcut for PointClass.init(PointClass, x, y)

I'm trying to work through in my mind the connections between all this stuff, and I still don't quite get it. I even drew a diagram, draft version, probably some mistake in there .
To describe what i'm not getting, it's the syntax that's getting me. I'm having trouble understanding the meaning of certain parts of the syntax lua classes use.

Yes ":" is a shortcut to "." + self, you understood that well.
Where you're going "too far" in the understanding is that you substitude "self" as the ClassName which is not always the case.
"self" is a dynamic variable, its meaning is determined at running time. Just remind that "self" refers to the first argument when using the ":" notation.
For example, these 3 calls are differents :
Toto = class()
function Toto:init()
  print(self)
end

Toto:init()     -- equivalent to Toto.init(Toto)
lol = Toto()   -- equivalent to Toto.init(temp) where "temp" will be stored in "lol"
lal = lol.init({}) -- here we force "self" to be "{}", an empty table


How does that translate to something in a table?

This is an intersting deep question. Jim will maybe better explain than me, but I'll try something :
In Lua, table have a "prototype" table that describe their content and how to access an element. This inner table is called "metatable".
You can get/set the metatables using getmetatable(tbl) or setmetatable(tbl, meta).
There are special elements of the metatable that changes the meaning of tbl[a] for example, or t1 + t2. It's like operator overloading.

Metatables in classes are used to transfert all the links to the functions from the "template" (the class) to the "instance" (the object) without copying them.
This means that when you're doing foo = Foo(), you end up with a new table (foo) that has the metatable of Foo (the class) that refers to every single function you defined in Foo (Foo.bar() for example).
Using the same principle, when doing Bar = class(Foo), you end up with a new table (Bar) that has the metatable of Foo (the parent class) that refers to every single function you defined in Foo. What's the difference then ? Foo() will also call Foo:init() after the copy (the constructor).