Functions in Lua
Functions in Lua are first-class values: they can be assigned to variables, stored inside tables, passed as arguments to other functions, and returned as results. The familiar function name(args) ... end syntax is really just sugar for assigning an anonymous function value, function(args) ... end, to the variable name.
Cricket analogy: A team's designated 'finisher' role, someone like MS Dhoni who can be handed the bat at any point in the innings, mirrors how Lua functions are first-class values: they can be assigned to variables, passed around, and called wherever needed.
Defining and Calling Functions
function greet() ... end is syntactic sugar for greet = function() ... end; both bind a function value to the name greet. Prefixing a definition with local, as in local function greet() ... end, scopes the function to the current block or file instead of creating a global, which is the recommended default since it avoids polluting the global namespace and resolves faster.
Cricket analogy: Declaring local function calculateStrikeRate(runs, balls) keeps that formula private to the current over's scorer, while a global function calculateStrikeRate(...) would be visible to every scorer on the broadcast, mirroring Lua's function scoping rules.
-- named function (sugar for add = function(...) ... end)
local function add(a, b)
return a + b
end
print(add(3, 4)) --> 7
-- functions are first-class values
local operations = {
add = function(a, b) return a + b end,
subtract = function(a, b) return a - b end,
}
print(operations.add(10, 5)) --> 15
print(operations["subtract"](10, 5)) --> 5
-- higher-order function: custom comparator
local players = {"Kohli", "Root", "Smith"}
table.sort(players, function(a, b) return a > b end) -- descending
-- method (colon) syntax
local Account = {}
Account.__index = Account
function Account.new(balance)
return setmetatable({balance = balance}, Account)
end
function Account:deposit(amount)
self.balance = self.balance + amount
end
local acc = Account.new(100)
acc:deposit(50) -- sugar for Account.deposit(acc, 50)
print(acc.balance) --> 150
-- recursion requires forward declaration for local functions
local function factorial(n)
if n <= 1 then return 1 end
return n * factorial(n - 1) -- OK: "local function" pre-declares the name
end
print(factorial(5)) --> 120Functions as First-Class Values
Because functions are ordinary values, Lua supports higher-order functions: functions that accept other functions as arguments or return them as results. The standard library leans on this heavily — table.sort(t, compareFn) accepts a custom comparator function so the sorting algorithm itself stays completely decoupled from how two elements are compared.
Cricket analogy: Passing a custom 'sort by strike rate' function into table.sort(players, byStrikeRate) is like a selector handing the coach a specific ranking criterion, the sort itself doesn't care how the comparison is defined, only that a function is supplied.
Because functions are ordinary values in Lua, you can store them in tables to build dispatch tables, pass them as callbacks to table.sort, pcall, or your own APIs, and even return them from other functions — this is the foundation that makes closures and modules work.
Methods and the Colon Syntax
When a function is meant to operate on a particular table (as an object-style method), Lua offers colon syntax as sugar: function obj:method(args) ... end is equivalent to function obj.method(self, args) ... end, and calling obj:method(x) automatically passes obj as the first argument, conventionally named self, so you don't have to repeat the object reference at every call site.
Cricket analogy: Calling player:bat() is shorthand for player.bat(player), the player object implicitly hands itself in as self, the way a captain refers to 'my innings' without re-stating their own name every time.
Scope: local vs global Functions
A local function is only visible within the block or file where it's declared, and, critically, the local function name() ... end form declares the name name as local *before* the function body is compiled, so the function can call itself recursively. Writing local name = function() ... name() ... end instead does not have this property: inside the body, name would resolve to an outer or global variable unless local name is declared on its own line first.
Cricket analogy: A local function is like a squad member who only plays in this one match, invisible to other teams' rosters, while forgetting to forward-declare a recursive local function factorial before referencing itself inside its own body is like naming a player before they've officially joined the squad.
local function f() ... f() ... end works for direct recursion because Lua special-cases this syntax to declare the local name *before* evaluating the function body. But writing local f = function() ... f() ... end does NOT work the same way — inside the body, f still refers to whatever f was in scope before this statement (an outer variable, a global, or nil), unless you declare local f on its own line first and assign the function to it in a separate statement.
- function name(args) ... end is sugar for name = function(args) ... end; both create a function value bound to a variable.
- Functions are first-class values in Lua: they can be stored in tables, passed as arguments, and returned from other functions.
- obj:method(args) is sugar for obj.method(obj, args); the colon implicitly passes the object as the first parameter, conventionally named self.
- Prefer local function over global functions to avoid polluting the global namespace and to enable faster variable lookups.
- local function f() ... end pre-declares f so the function can call itself recursively; a plain local f = function() ... end does not.
- Lua functions can take a variable number of arguments and return multiple values, covered separately for variadic functions.
Practice what you learned
1. What does `function greet() end` desugar to?
2. What does `obj:method(x)` translate to?
3. Why does `local function fact(n) ... fact(n-1) ... end` support recursion correctly?
4. Which statement about Lua functions is true?
5. What is the conventional name for the implicit first parameter in a colon-defined method?
Was this page helpful?
You May Also Like
Variadic Functions and Multiple Returns
Understand how Lua functions return multiple values, how variadic parameters (...) work with select and table.pack/unpack, and the truncation rules that trip up newcomers.
Closures in Lua
Understand how Lua closures capture upvalues by reference, how to use them for private state and per-iteration loop callbacks, and common closure-based patterns like memoization.
Conditionals in Lua
Learn how Lua's if/elseif/else statement works, why only nil and false are falsy, and how to replace long conditional chains with idiomatic and/or expressions or table-based dispatch.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics