In JavaScript, a function call implicitly passes this depending on the call site. In Lua there is a difference between a method call and a function being called from a namespace. This is accomplished through syntactic sugar.
In Lua:
Object:Move(1) is equivalent to Object.Move(Object, 1)
This function can be declared like so:
function Object:Move(Amount)
The syntactic sugar puts a self as the first parameter. You could do this yourself as well:
function Object.Move(self, Amount) (you could name self whatever you want this way)
That means method calls can be localized and called later if necessary because self is actually a parameter. local f = Object.Move f(Object). You can't do this in JS, but it isn't just that. There isn't a need to implicitly pass this into namespaces.
The other solution could be to wrap localized functions with an implicit this, but that would make each instance of a class have a unique version of each method.
I would recommend under the hood using a data oriented approach. Instances of classes wouldn't hold all their data next to each other, an instance of a class would just be an integer which is the index at which its data can be retrieved from a bunch of arrays that each hold a single member of each instance. This is smarter design because it is much more frequent that at one time you might iterate through a particular property of all instances and with the way CPU caching works you can load up the right array and use just that data, without fetching unnecessary data you aren't using for comparison. Ex:
Names = ["First", "Second"]
IDs = [1, 2]
new Class() // reference to index 0 in each of these arrays
new Class() // reference to index 1 in each of these arrays
In JavaScript, a function call implicitly passes
thisdepending on the call site. In Lua there is a difference between a method call and a function being called from a namespace. This is accomplished through syntactic sugar.In Lua:
Object:Move(1)is equivalent toObject.Move(Object, 1)This function can be declared like so:
function Object:Move(Amount)The syntactic sugar puts a
selfas the first parameter. You could do this yourself as well:function Object.Move(self, Amount)(you could name self whatever you want this way)That means method calls can be localized and called later if necessary because
selfis actually a parameter.local f = Object.Movef(Object). You can't do this in JS, but it isn't just that. There isn't a need to implicitly pass this into namespaces.The other solution could be to wrap localized functions with an implicit this, but that would make each instance of a class have a unique version of each method.
I would recommend under the hood using a data oriented approach. Instances of classes wouldn't hold all their data next to each other, an instance of a class would just be an integer which is the index at which its data can be retrieved from a bunch of arrays that each hold a single member of each instance. This is smarter design because it is much more frequent that at one time you might iterate through a particular property of all instances and with the way CPU caching works you can load up the right array and use just that data, without fetching unnecessary data you aren't using for comparison. Ex:
(Obviously this example is a simplification)
Thanks for all the advice! All of these are good points which I'll definitely have to consider when designing my language.