LÖVE

Metatables [are] the final key to having full class functionality in Lua.

The method I’m describing is the only way to achieve class-like functionality.

-- character.lua

local function moveLeft (self)
    self.x = self.x - 1
end

local function moveRight (self)
    self.x = self.x + 1
end

return function (x, y)
    local instance = {}
    
    instance.x = x
    instance.y = y
    instance.moveLeft = moveLeft
    instance.moveRight = moveRight
    
    return instance
end

-- enemy.lua

local Character = require 'character'

local function attack (self)
    print(self.name .. ' attacks you!')
end

return function (x, y)
    local instance = Character(x, y) -- extends Character
    
    instance.name = 'an enemy'
    instance.attack = attack
    
    return instance
end

-- main.lua

local Enemy = require 'enemy'

local badGuy = Enemy(10, 10)
badGuy:moveLeft()
badGuy:attack()

ivan wrote:I've seen this approach written as:

Code: Select all

[/quote]

Yeah, I've seen this too; I think closures can be very useful for some things, but wouldn't recommend using them like this. The "self-ness" of objects is a major point of OOP, and that "self-ness" means you already have a place to store relevant state, it doesn't need to be stored in a closure.

Private members are the only real advantage, but they're not worth much in my opinion. Your code won't be as extensible as it would in most languages with "true" private members, because those languages will generally also have protected members, and you can easily change your private members to protected when you need to access them from a derived type.

[quote]It works well for certain things, but the performance is worse than metatables (especially for short-lived objects).[/quote]

I'd expect that to be true for the closure-based solution, but not necessarily for the closure-less solution. I'd expect the closure-less solution to be slightly heavier than metatables on object creation and slightly lighter on method resolution (although I think the difference would be very minor and wouldn't affect overall performance in a meaningful way). It would be interesting to compare the performance of all 3 solutions, though.