LÖVE

zorg wrote: ↑Sat Dec 17, 2016 4:37 pm Not bad!

Though to be honest, when you said "uses modules currently", at first, i was worried you might've been using the lua module stuff, which has been deprecated since forever; glad it's not the case.

One thing though, in many other threads one specific line of code surfaced:

Code: Select all

local classOrWhatever = {}
classOrWhatever.__index = classOrWhatever

Now, some might say that this does absolutely nothing (apart from creating a circular reference), and on the whole, it doesn't; but it has exactly one use:

Code: Select all

local new = function(possiblyArgs) -- a constructor for object instances, or something similar
  local instance = setmetatable({}, classOrWhatever)
  return instance
end

Whether one would write the setmetatable call on a separate line from the local empty table creation or not is mostly irrelevant; it won't make any dents in code speed.

However, the __index metamethod is used to look up stuff from another table, if the table the metamethod is defined for doesn't have it.

The issue with the above way is that you're basically denying further lookups; if you don't plan on having "class" hierarchies, then it's fine, but i myself prefer to keep my options open, hence a slightly different code:

Code: Select all

local classOrWhatever = {}

-- define functions working on instances with self param or colon notation, whichever one finds more understandable.

local mtClassOrWhatever = {__index = classOrWhatever} -- The metatable that the instances used is defined separately from the table where funtions (and possibly class fields/variables) are located.

local new = function(possiblyArgs)
  local instance = {}
  setmetatable(instance, mtClassOrWhatever)
  return instance
end

return new -- either this, or you make the constructor part of the classOrWhatever table, and return that... you can also go further and have a __call metatable defined, which would call new when you'd do classOrWhatever() where you required this file.
end

This way, if i ever wanted these instances to look up a function from another class after it's not found in classOrWhatever, i could just set the metatable for that table to be the other class, which i'd require in this file.

Sorry if this is a bit much at once, but i thought i'd share my insights.

zorg wrote: ↑Sat Dec 17, 2016 4:37 pm Not bad!

Though to be honest, when you said "uses modules currently", at first, i was worried you might've been using the lua module stuff, which has been deprecated since forever; glad it's not the case.

One thing though, in many other threads one specific line of code surfaced:

Code: Select all

local classOrWhatever = {}
classOrWhatever.__index = classOrWhatever

Now, some might say that this does absolutely nothing (apart from creating a circular reference), and on the whole, it doesn't; but it has exactly one use:

Code: Select all

local new = function(possiblyArgs) -- a constructor for object instances, or something similar
  local instance = setmetatable({}, classOrWhatever)
  return instance
end

Whether one would write the setmetatable call on a separate line from the local empty table creation or not is mostly irrelevant; it won't make any dents in code speed.

However, the __index metamethod is used to look up stuff from another table, if the table the metamethod is defined for doesn't have it.

The issue with the above way is that you're basically denying further lookups; if you don't plan on having "class" hierarchies, then it's fine, but i myself prefer to keep my options open, hence a slightly different code:

Code: Select all

local classOrWhatever = {}

-- define functions working on instances with self param or colon notation, whichever one finds more understandable.

local mtClassOrWhatever = {__index = classOrWhatever} -- The metatable that the instances used is defined separately from the table where funtions (and possibly class fields/variables) are located.

local new = function(possiblyArgs)
  local instance = {}
  setmetatable(instance, mtClassOrWhatever)
  return instance
end

return new -- either this, or you make the constructor part of the classOrWhatever table, and return that... you can also go further and have a __call metatable defined, which would call new when you'd do classOrWhatever() where you required this file.
end

This way, if i ever wanted these instances to look up a function from another class after it's not found in classOrWhatever, i could just set the metatable for that table to be the other class, which i'd require in this file.

Sorry if this is a bit much at once, but i thought i'd share my insights.

local Base = {}
Base.__index = Base

function Base.new()
  local self = setmetatable({}, Base)
  self.bar = 2
  return self
end

function Base:foo()
  print(self:getBar())
end

function Base:getBar()
  -- (not something i would normally write but good for illustration)
  return self.bar
end

--

local Sub = setmetatable({}, Base)
Sub.__index = Sub

function Sub.new()
  local self = setmetatable(Base.new(), Sub)
  self.spam = 'eggs'
  return self
end

function Sub:foo()
  Base.foo(self)
  print('but also ' .. self.spam)
end

--

sub = Sub.new()
sub:getBar() -- 2
sub:foo() -- prints '2 but also eggs'

This is the way I've been doing it for a while, and I do prefer it because I think the metatable - 'instance' mapping should be one to many and not many to many.

zorg wrote: ↑Sat Feb 18, 2017 3:37 pm s-ol: Call it personal preference, but i just don't like mixing metatable stuff into the same table that i'd set itself as a metatable on.

zorg wrote:s-ol: Call it personal preference, but i just don't like mixing metatable stuff into the same table that i'd set itself as a metatable on.

local function new (t, ...) t = setmetatable({}, t) t:init(...) return t end
local Foo = { __call = new }
Foo.__index = Foo

zorg wrote: ↑Sun Feb 19, 2017 3:58 pm So basically, instances have their metatable be their own class' metatable, but the class metatable itself inherits from another class.
Also, the bigger reason i always want to define -one- variable that has {__index = something} in it is because if i do that in the constructor function, the metatables themselves will be different tables in memory, as opposed to re-using a single one.

Sharing the same mt between all my instances is the exact reasoning that makes me prefer this style.

local Foo = {}
local FooMeta = { __index = Foo }
local function new (_, ...) local t = setmetatable({}, FooMeta) t:init(...) return t end
setmetatable(Foo, { _call = new })

local function new (t, ...) t = setmetatable({}, t) t:init(...) return t end

local Vehicle = {}
Vehicle.__index = Vehicle
setmetatable(Vehicle, { __call = new })

local Bike = {}
Bike.__index = Bike
setmetatable(Bike, { __call = new, __index = Vehicle })