(Solved) Luabind Lua Classes Static/nonstatic?

Hm, don’t know if this is for beginners… Anyway, is there a concept like static vs. nonstatic (like Java etc. have it) in luabind lua classes? If so, how do I write this, syntactically?

I thought I would write a static method like this:

function MyClass:myLittleStaticMethod(params)  

vs. a nonstatic one:

function myLittleNonstaticMethod(params)  

but turns out to be wrong…

(I’d love to see some real documentation on these things. I mean real stuff, not some very basic examples.
There are more questions: what about abstract classes, interfaces, … How do I do all this in LUA?)

The colon is just a shortcut. These two functions are identical

t = {};  
function t:foo(bar) end  
function t.foo(self, bar) end  

When you call a function using the colon syntax, you implicitly supply the table left of the colon as the first argument to the function. The following two function calls are identical:

t.foo(t, "baz");  

So you’re not going to have any luck creating a static method with it.

In fact, Lua doesn’t have classes or anything of the sort. Instead it has fancy tricks with meta tables.

But, Renoise uses this:


Basically, LuaBind helps create the bindings between C++ (Renoise) and Lua (the API) and it comes with a rudimentary OO-system.

Hope this helps.

Thanks, I see. I didn’t imagine LuaBind ‘Lua Classes’ are that rudimentary… :(
This explains why I couldn’t find any information - because what I was looking for plainly doesn’t exist. :lol:

Ok, seems I need to have a closer look at those tables.

Man, in the mid 90’s it had been so hard (for me) to understand OOP, today it’s hard to do anything decent without it.

You can fake something like this using tables.

Save as FakeClass.lua:

local FAKECLASS = {}  
FAKECLASS.public_var = "public value"  
private_var = "private value"  
function FAKECLASS.public_func()  
 print("public function called...")  
function private_func()  
 print("private function called...")  
return FAKECLASS  

Save as FakeClassTest.lua:

local fake_class = require("FakeClass")  

Output looks similar to this:

[public_func] => function: 00000000092EFAC0  
[public_var] => public value  
public function called...  
private function called...  
private value  
public value  

Static functions and properties in Renoises classes are possible too:

class "MyClass"  
MyClass.message = ""  
function MyClass:__init()  
 self.message = ""  
function MyClass:print()  
function MyClass.sprint()  
obj1 = MyClass()  
obj1.message = "foo"  
obj2 = MyClass()  
obj2.message = "bar"  
MyClass.message = "muh"  
obj1:print() --> "foo"  
obj2:print() --> "bar"  
obj1.sprint() --> "muh"  
obj2.sprint() --> "muh"  

MyClass, the class definition, is simply a table, so you can add any properties to it as well.

There is no such thing like “abstract classes” in Lua, because Lua is dynamically typed. The compiler does not, actually can not enforce an object to implement a specific interface. But you can check types at runtime and inherit classes from other classes, and thus also mimic interface and strict typing behavior in various ways.

So an interface in Lua is more a “convention” which is applied or tested during runtime.

The more Lua native approach to OO actually would be prototype based programming.
But how exactly you want to use Lua is up to you, depends on which OO approaches you like, and probably more important: which ones you are used to.

Thank you guys, this is very helpful, will check those things out.

Yeah, I’m used to the convenience of Java and C++/Qt, my fault. ;)