Object Oriented Programming

wiki

Learning Material

• ObjectOrientationTutorial - tutorial on OOP with classes.
• InheritanceTutorial - tutorial on OOP using inheritance[2] with classes and prototypes.
• [Chapter on OOP] from [PiL] - a comprehensive view of OOP in Lua by the language's chief-architect.
• ObjectOrientationClosureApproach - alternative approach to OOP.

Related Discussions

• ColonForMethodCall - discussion about the use of colon (:) instead of period (.) for methods calls.
• ObjectBenchmarkTests - performance evaluation of different approaches to access objects members.

Feature Implementations

• SimpleLuaClasses - classes with constructors.
• LuaClassesWithMetatable - classes with constructor and copy operations.
• ClassesAndMethodsExample - classes with constructors and simple inheritance.
• ObjectProperties - getters/setters that look like table field accesses (like properties in C#).
• ProxyBasedEncapsulation - encapsulation of objects via proxy tables.
• ClassesAsConstructorClosures - a flexible way of implementing classes with type testing.

Older Lua Versions

• ClassesAndMethods - classes using tagmethods of Lua 4.0.
• ClassesAndMethodsWithEventtable - classes using metatables of a pre-release version of Lua 5.0.

Feature Modules

• [lclass] - Barebones Lua with Classes (73 SLOC), inspired by Lua's lightweight design, features:
  • constructor/initialization
  • simple inheritance
• YetAnotherClassImplementation - support for classes with:
  • constructor/initialization
  • simple inheritance
  • virtual methods
  • access control to inherited attributes
  • type casting
• MultipleInheritanceClasses - support for classes with:
  • constructor/initialization
  • multiple inheritance
  • shared derivation (like C++ virtual)
  • handling of ambiguities and inherited attributes
• ObjectLua - support for object prototyping and classes with:
  • constructor/initialization
  • simple inheritance
  • mandatory root class Object
  • access to the originally inherited implementation in overridden methods through function super, similarly to Java and Python classes
• KlassModule - support for classes with:
  • constructors and destructors
  • simple prototype-based inheritance
  • isA method
  • works with Lua 5.2
• [LOOP] - light-weight modules that incrementally support:
  • loop.base classes with constructor/initialization support
  • loop.simple classes with simple inheritance
  • loop.multiple classes with multiple inheritance
  • loop.cached classes with inheritance that copies members from superclasses (faster method resolution and inheritance of metamethods)
  • loop.scoped classes with private and protected access to members
• [lua-Coat] - port of [Coat] (a light-weight OO model of Perl5) that supports:
  • constructor/initialization
  • multiple inheritance
  • method modifiers
  • introspection operations
  • attribute checking
  • additional support for roles and type declarations
• [MiddleClass] - single file module (~100 LoC) that supports classes with:
  • constructor/initialization
  • simple inheritance
  • mandatory root class Object
  • basic mixins support (copying methods)
  • getter/setter construction facilities
  • additional lib [MiddleClass-extras] with mixins that improve upon the basic functionality.
• [OWL] - single file module that provides a class implementation with the following features:
  • constructor/initialization (can also be overridden on a per-instance basis).
  • multi-level inheritance (all the way to top-level super class).
  • easy-to-use with two primary functions: class() and instance()
  • common OOP methods: is_a(), kind_of(), and instance_of().
  • private class table (inherited by sub-classes, but not by instance objects).
  • easily implement basic metamethods via add_property_callback() method.
  • several samples and documentation included
  • compatible with Corona SDK (provides display object classes), as well as non-Corona projects.
• [30log] - single file module. It features:
  • named and unnamed classes
  • constructor/initialization
  • default values for properties
  • single inheritance
  • basic support for mixins
• [lupy] - single file module(~50 sloc, ~2 kb). It's a Python-style class implementation with several Ruby features:
  • constructor/initialization
  • single inheritance
  • basic mixins support
  • missing methods handler
  • monkey patching support
  • lexical scope based encapsulation
  • inheritance tree based type testing
  • namespace and inner class support
• [classy] - single file module (~460 sloc, ~14 kb) with:
  • constructor/initialization (efficient, necessary data precomputed during class definition)
  • multiple inheritance (method lookups in width-first search order)
  • efficient method calls (method lookup precomputed during class definition)
  • monkey patching support (updates to base classes propagate to derived classes)
  • multi methods (functions with more than one polymorphic parameter)

Sample Implementations

• PointAndComplex - classes for points and complex numbers (uses SimpleLuaClasses).
• [LOOP Library] - class library with various OO implementations (uses [LOOP] modules):
  • data strucutures (ex. memoization cache).
  • debugging utilities (ex. pretty-priting, logging).
  • serialization utilities (ex. streams).
  • coroutine-based multithreading utilities (ex. timers, cooperative sockets, etc.).
  • and other OO utilities (ex.: wrappers, publishers).

See Also

• SampleCode