Closures in Lua

Intermediate ~30 min read

A closure is a function that captures and remembers variables from its surrounding scope, even after that scope has finished executing. Closures are one of Lua's most powerful features, enabling elegant solutions to complex problems. They're essential for creating private variables, factory functions, callbacks, and functional programming patterns. Let's explore how closures work and how to use them effectively!

What is a Closure?

A closure is created when a function accesses variables from an outer scope:

local function createCounter()
    local count = 0  -- This variable is "captured"
    
    return function()
        count = count + 1
        return count
    end
end

local counter = createCounter()
print(counter())  -- 1
print(counter())  -- 2
print(counter())  -- 3

Key Concept: The inner function "closes over" the count variable. Even though createCounter() has finished executing, the returned function still has access to count!

-- Closures in Lua

-- Basic closure - function accessing outer variable
local function makeCounter()
    local count = 0  -- Upvalue
    
    return function()
        count = count + 1
        return count
    end
end

local counter1 = makeCounter()
print(counter1())  -- 1
print(counter1())  -- 2
print(counter1())  -- 3

local counter2 = makeCounter()  -- New closure, new count
print(counter2())  -- 1
print(counter2())  -- 2

-- Closure with multiple functions sharing state
local function createAccount(initialBalance)
    local balance = initialBalance
    
    local function deposit(amount)
        balance = balance + amount
        return balance
    end
    
    local function withdraw(amount)
        if amount > balance then
            print("Insufficient funds!")
            return balance
        end
        balance = balance - amount
        return balance
    end
    
    local function getBalance()
        return balance
    end
    
    return {
        deposit = deposit,
        withdraw = withdraw,
        getBalance = getBalance
    }
end

local account = createAccount(100)
print("Balance:", account.getBalance())
print("After deposit:", account.deposit(50))
print("After withdraw:", account.withdraw(30))
print("Final balance:", account.getBalance())

-- Closure capturing loop variable
local function createMultipliers()
    local multipliers = {}
    
    for i = 1, 5 do
        multipliers[i] = function(x)
            return x * i  -- Captures current i
        end
    end
    
    return multipliers
end

local mults = createMultipliers()
print("3 * 2 =", mults[2](3))
print("3 * 4 =", mults[4](3))

-- Closure for memoization
local function memoize(func)
    local cache = {}
    
    return function(x)
        if cache[x] == nil then
            cache[x] = func(x)
        end
        return cache[x]
    end
end

local function slowSquare(x)
    print("Computing square of", x)
    return x * x
end

local fastSquare = memoize(slowSquare)
print(fastSquare(5))  -- Computes
print(fastSquare(5))  -- Uses cache
print(fastSquare(3))  -- Computes

Output

Click Run to execute your code

Lexical Scoping

Lua uses lexical scoping, meaning functions can access variables from their enclosing scopes:

local x = 10

local function outer()
    local y = 20
    
    local function inner()
        local z = 30
        print(x, y, z)  -- Can access all three!
    end
    
    inner()
end

outer()  -- 10  20  30

Tip: Variables captured by closures are called upvalues. Each closure maintains its own copy of upvalues, allowing multiple independent closures.

Private Variables

Closures enable true private variables in Lua:

local function createBankAccount(initialBalance)
    local balance = initialBalance  -- Private!
    
    return {
        deposit = function(amount)
            balance = balance + amount
            return balance
        end,
        
        withdraw = function(amount)
            if amount > balance then
                return nil, "Insufficient funds"
            end
            balance = balance - amount
            return balance
        end,
        
        getBalance = function()
            return balance
        end
    }
end

local account = createBankAccount(1000)
print(account.getBalance())  -- 1000
account.deposit(500)
print(account.getBalance())  -- 1500
-- print(balance)  -- Error: balance is not accessible!

-- Private Variables with Closures

-- Creating private state
local function createBankAccount(initialBalance)
    -- Private variables (not accessible from outside)
    local balance = initialBalance
    local transactions = {}
    
    -- Private function
    local function recordTransaction(type, amount)
        table.insert(transactions, {
            type = type,
            amount = amount,
            balance = balance
        })
    end
    
    -- Public interface
    return {
        deposit = function(amount)
            if amount <= 0 then
                return false, "Amount must be positive"
            end
            balance = balance + amount
            recordTransaction("deposit", amount)
            return true, balance
        end,
        
        withdraw = function(amount)
            if amount <= 0 then
                return false, "Amount must be positive"
            end
            if amount > balance then
                return false, "Insufficient funds"
            end
            balance = balance - amount
            recordTransaction("withdraw", amount)
            return true, balance
        end,
        
        getBalance = function()
            return balance
        end,
        
        getTransactionHistory = function()
            return transactions
        end
    }
end

local account = createBankAccount(1000)
print("Initial balance:", account.getBalance())

account.deposit(500)
print("After deposit:", account.getBalance())

account.withdraw(200)
print("After withdraw:", account.getBalance())

-- Try to access private variable (won't work!)
-- print(account.balance)  -- nil
-- print(account.transactions)  -- nil

-- Print transaction history
print("\nTransaction History:")
for i, trans in ipairs(account.getTransactionHistory()) do
    print(string.format("%d. %s: $%d (Balance: $%d)", 
        i, trans.type, trans.amount, trans.balance))
end

-- Creating a module with private state
local function createCounter()
    local count = 0
    local maxCount = 0
    
    return {
        increment = function()
            count = count + 1
            if count > maxCount then
                maxCount = count
            end
            return count
        end,
        
        decrement = function()
            count = count - 1
            return count
        end,
        
        reset = function()
            count = 0
            return count
        end,
        
        getValue = function()
            return count
        end,
        
        getMax = function()
            return maxCount
        end
    }
end

local counter = createCounter()
counter.increment()
counter.increment()
counter.increment()
print("Current:", counter.getValue())
print("Max reached:", counter.getMax())

counter.decrement()
counter.decrement()
print("After decrement:", counter.getValue())
print("Max still:", counter.getMax())

-- Object with private methods
local function createUser(username, password)
    -- Private function to hash password
    local function hashPassword(pwd)
        -- Simple hash (in real code, use proper hashing!)
        return "hashed_" .. pwd
    end
    
    local hashedPassword = hashPassword(password)
    
    return {
        getUsername = function()
            return username
        end,
        
        checkPassword = function(pwd)
            return hashPassword(pwd) == hashedPassword
        end,
        
        changePassword = function(oldPwd, newPwd)
            if not hashPassword(oldPwd) == hashedPassword then
                return false, "Incorrect password"
            end
            hashedPassword = hashPassword(newPwd)
            return true, "Password changed"
        end
    }
end

local user = createUser("alice", "secret123")
print("Username:", user.getUsername())
print("Check password:", user.checkPassword("secret123"))
print("Check wrong password:", user.checkPassword("wrong"))

Output

Click Run to execute your code

Factory Functions

Closures are perfect for creating factory functions that generate customized functions:

local function createMultiplier(factor)
    return function(x)
        return x * factor
    end
end

local double = createMultiplier(2)
local triple = createMultiplier(3)
local quadruple = createMultiplier(4)

print(double(5))     -- 10
print(triple(5))     -- 15
print(quadruple(5))  -- 20

More Factory Examples

-- Greeting factory
local function createGreeter(greeting)
    return function(name)
        return greeting .. ", " .. name .. "!"
    end
end

local sayHello = createGreeter("Hello")
local sayHi = createGreeter("Hi")

print(sayHello("Alice"))  -- Hello, Alice!
print(sayHi("Bob"))       -- Hi, Bob!

-- Validator factory
local function createValidator(min, max)
    return function(value)
        return value >= min and value <= max
    end
end

local isValidAge = createValidator(0, 120)
local isValidScore = createValidator(0, 100)

print(isValidAge(25))   -- true
print(isValidScore(150)) -- false

-- Function Factories with Closures

-- Simple factory - creating specialized functions
local function createAdder(n)
    return function(x)
        return x + n
    end
end

local add5 = createAdder(5)
local add10 = createAdder(10)

print("7 + 5 =", add5(7))
print("7 + 10 =", add10(7))

-- Factory with configuration
local function createGreeter(greeting)
    return function(name)
        return greeting .. ", " .. name .. "!"
    end
end

local sayHello = createGreeter("Hello")
local sayHi = createGreeter("Hi")
local sayHola = createGreeter("Hola")

print(sayHello("Alice"))
print(sayHi("Bob"))
print(sayHola("Carlos"))

-- Factory creating objects with methods
local function createPerson(name, age)
    local person = {}
    
    person.getName = function()
        return name
    end
    
    person.getAge = function()
        return age
    end
    
    person.haveBirthday = function()
        age = age + 1
        return age
    end
    
    person.introduce = function()
        return "Hi, I'm " .. name .. " and I'm " .. age .. " years old"
    end
    
    return person
end

local alice = createPerson("Alice", 25)
print(alice.introduce())
alice.haveBirthday()
print(alice.introduce())

-- Factory for validators
local function createRangeValidator(min, max)
    return function(value)
        return value >= min and value <= max
    end
end

local isValidAge = createRangeValidator(0, 120)
local isValidPercent = createRangeValidator(0, 100)

print("Is 25 valid age?", isValidAge(25))
print("Is 150 valid age?", isValidAge(150))
print("Is 75 valid percent?", isValidPercent(75))

-- Factory for formatters
local function createFormatter(prefix, suffix)
    return function(text)
        return prefix .. text .. suffix
    end
end

local bold = createFormatter("**", "**")
local italic = createFormatter("_", "_")
local code = createFormatter("`", "`")

print(bold("Important"))
print(italic("Emphasis"))
print(code("console.log()"))

-- Chaining factories
local function createMultiplier(factor)
    return function(x)
        return x * factor
    end
end

local double = createMultiplier(2)
local triple = createMultiplier(3)
local sextuple = function(x)
    return triple(double(x))
end

print("6 * 5 =", sextuple(5))

Output

Click Run to execute your code

Callbacks and Event Handlers

Closures are commonly used for callbacks that need to remember context:

local function createButton(label)
    local clickCount = 0
    
    return {
        onClick = function()
            clickCount = clickCount + 1
            print(label .. " clicked " .. clickCount .. " times")
        end
    }
end

local button1 = createButton("Submit")
local button2 = createButton("Cancel")

button1.onClick()  -- Submit clicked 1 times
button1.onClick()  -- Submit clicked 2 times
button2.onClick()  -- Cancel clicked 1 times

Custom Iterators

Closures enable powerful custom iterators:

local function range(from, to, step)
    step = step or 1
    local current = from - step
    
    return function()
        current = current + step
        if current <= to then
            return current
        end
    end
end

-- Use in for loop
for i in range(1, 10, 2) do
    print(i)  -- 1, 3, 5, 7, 9
end

-- Fibonacci iterator
local function fibonacci()
    local a, b = 0, 1
    return function()
        a, b = b, a + b
        return a
    end
end

local fib = fibonacci()
for i = 1, 10 do
    print(fib())  -- 1, 1, 2, 3, 5, 8, 13, 21, 34, 55
end