Functions in Lua

Beginner ~30 min read

Functions are reusable blocks of code that perform specific tasks. They're fundamental to writing clean, organized, and maintainable code. Lua treats functions as first-class values, meaning they can be stored in variables, passed as arguments, and returned from other functions. This makes Lua incredibly powerful for functional programming. Let's explore everything about functions!

Defining Functions

There are several ways to define functions in Lua:

Basic Function Definition

function greet()
    print("Hello, World!")
end

greet()  -- Call the function

Function as Variable

local greet = function()
    print("Hello, World!")
end

greet()  -- Same result

Best Practice: Always use local for function variables to avoid polluting the global namespace:

local function greet()
    print("Hello!")
end

-- Function Basics in Lua

-- Simple function definition
local function greet()
    print("Hello, Lua!")
end

greet()  -- Call the function

-- Function with parameters
local function greetPerson(name)
    print("Hello, " .. name .. "!")
end

greetPerson("Alice")
greetPerson("Bob")

-- Function with return value
local function add(a, b)
    return a + b
end

local result = add(5, 3)
print("5 + 3 =", result)

-- Function with multiple return values
local function getMinMax(a, b, c)
    local min = math.min(a, b, c)
    local max = math.max(a, b, c)
    return min, max
end

local minimum, maximum = getMinMax(10, 5, 15)
print("Min:", minimum, "Max:", maximum)

-- Function without return (returns nil)
local function sayHello()
    print("Hello!")
    -- No return statement
end

local value = sayHello()
print("Return value:", value)  -- nil

-- Local vs global functions
local function localFunc()
    print("I'm local")
end

function globalFunc()  -- No 'local' keyword
    print("I'm global (avoid this!)")
end

localFunc()
globalFunc()

-- Function stored in variable
local myFunc = function(x)
    return x * 2
end

print("Double 5:", myFunc(5))

Output

Click Run to execute your code

Function Parameters

Functions can accept input through parameters:

local function greet(name)
    print("Hello, " .. name .. "!")
end

greet("Alice")  -- Hello, Alice!
greet("Bob")    -- Hello, Bob!

Multiple Parameters

local function add(a, b)
    return a + b
end

local result = add(5, 3)
print(result)  -- 8

Default Parameters

Lua doesn't have built-in default parameters, but you can use or:

local function greet(name)
    name = name or "Guest"  -- Default to "Guest" if nil
    print("Hello, " .. name)
end

greet()         -- Hello, Guest
greet("Alice")  -- Hello, Alice

-- Function Parameters and Arguments

-- Default parameter values (using 'or')
local function greet(name)
    name = name or "Guest"  -- Default to "Guest" if nil
    print("Hello, " .. name)
end

greet("Alice")
greet()  -- Uses default

-- Multiple parameters
local function calculateArea(length, width)
    return length * width
end

print("Area:", calculateArea(5, 3))

-- Optional parameters
local function createUser(name, age, city)
    age = age or 18
    city = city or "Unknown"
    
    print("Name:", name)
    print("Age:", age)
    print("City:", city)
end

createUser("Alice", 25, "NYC")
createUser("Bob", 30)
createUser("Charlie")

-- Passing tables as parameters
local function printPerson(person)
    print("Name:", person.name)
    print("Age:", person.age)
end

local user = {name = "Alice", age = 25}
printPerson(user)

-- Modifying parameters (pass by value for primitives)
local function tryToModify(x)
    x = x + 10
    print("Inside function:", x)
end

local num = 5
tryToModify(num)
print("Outside function:", num)  -- Still 5!

-- Modifying tables (pass by reference)
local function modifyTable(t)
    t.value = 100
end

local myTable = {value = 10}
print("Before:", myTable.value)
modifyTable(myTable)
print("After:", myTable.value)  -- Changed!

-- Named arguments pattern (using tables)
local function createProfile(options)
    local name = options.name or "Unknown"
    local age = options.age or 0
    local email = options.email or "none"
    
    print(string.format("Profile: %s, %d, %s", name, age, email))
end

createProfile({name = "Alice", age = 25, email = "alice@example.com"})
createProfile({name = "Bob", age = 30})

Output

Click Run to execute your code

Return Values

Functions can return values using the return statement:

local function square(x)
    return x * x
end

local result = square(5)
print(result)  -- 25

Multiple Return Values

Lua functions can return multiple values—a unique and powerful feature!

local function divmod(a, b)
    local quotient = math.floor(a / b)
    local remainder = a % b
    return quotient, remainder
end

local q, r = divmod(17, 5)
print("Quotient:", q)   -- 3
print("Remainder:", r)  -- 2

Tip: Multiple return values are commonly used in Lua. Many standard library functions return multiple values, like string.find() which returns start and end positions.

-- Return Values in Lua

-- Single return value
local function square(x)
    return x * x
end

print("Square of 5:", square(5))

-- Multiple return values
local function divide(a, b)
    if b == 0 then
        return nil, "Division by zero!"
    end
    return a / b, "Success"
end

local result, message = divide(10, 2)
print("Result:", result, "Message:", message)

local result2, message2 = divide(10, 0)
print("Result:", result2, "Message:", message2)

-- Returning multiple values from calculations
local function getStats(numbers)
    local sum = 0
    local count = #numbers
    
    for i, num in ipairs(numbers) do
        sum = sum + num
    end
    
    local average = sum / count
    return sum, average, count
end

local total, avg, cnt = getStats({10, 20, 30, 40, 50})
print(string.format("Sum: %d, Average: %.1f, Count: %d", total, avg, cnt))

-- Returning tables
local function createPoint(x, y)
    return {x = x, y = y}
end

local point = createPoint(10, 20)
print("Point:", point.x, point.y)

-- Early return
local function checkAge(age)
    if age < 0 then
        return false, "Invalid age"
    end
    
    if age < 18 then
        return false, "Too young"
    end
    
    return true, "Valid age"
end

local valid, msg = checkAge(25)
print("Valid:", valid, "Message:", msg)

-- Ignoring return values
local function getThreeValues()
    return 1, 2, 3
end

local a = getThreeValues()  -- Only gets first value
print("a =", a)

local x, y = getThreeValues()  -- Gets first two
print("x =", x, "y =", y)

local p, q, r, s = getThreeValues()  -- Extra var is nil
print("p =", p, "q =", q, "r =", r, "s =", s)

-- Returning functions
local function createMultiplier(factor)
    return function(x)
        return x * factor
    end
end

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

print("Double 5:", double(5))
print("Triple 5:", triple(5))

Output

Click Run to execute your code

Variadic Functions

Functions can accept variable numbers of arguments using ...:

local function sum(...)
    local total = 0
    for i, v in ipairs({...}) do
        total = total + v
    end
    return total
end

print(sum(1, 2, 3))        -- 6
print(sum(10, 20, 30, 40)) -- 100

Accessing Variadic Arguments

local function printAll(...)
    local args = {...}  -- Pack into table
    for i, v in ipairs(args) do
        print(i, v)
    end
end

printAll("apple", "banana", "cherry")

Mixed Parameters

local function greetAll(greeting, ...)
    local names = {...}
    for i, name in ipairs(names) do
        print(greeting .. ", " .. name .. "!")
    end
end

greetAll("Hello", "Alice", "Bob", "Charlie")

-- Variadic Functions in Lua (using ...)

-- Basic variadic function
local function printAll(...)
    local args = {...}  -- Pack into table
    for i, v in ipairs(args) do
        print(i, v)
    end
end

print("=== Print All ===")
printAll("Hello", "World", 42, true)

-- Getting number of arguments
local function countArgs(...)
    return select("#", ...)
end

print("\n=== Count Args ===")
print("Number of args:", countArgs(1, 2, 3, 4, 5))
print("Number of args:", countArgs("a", "b"))

-- Sum all numbers
local function sum(...)
    local total = 0
    for i, v in ipairs({...}) do
        total = total + v
    end
    return total
end

print("\n=== Sum ===")
print("Sum:", sum(1, 2, 3, 4, 5))
print("Sum:", sum(10, 20, 30))

-- Mixed parameters and varargs
local function greetAll(greeting, ...)
    local names = {...}
    for i, name in ipairs(names) do
        print(greeting .. ", " .. name .. "!")
    end
end

print("\n=== Greet All ===")
greetAll("Hello", "Alice", "Bob", "Charlie")

-- Using select() to access specific arguments
local function getSecondArg(...)
    return select(2, ...)
end

print("\n=== Select ===")
print("Second arg:", getSecondArg("first", "second", "third"))

-- select() to get remaining arguments
local function skipFirst(...)
    return select(2, ...)
end

local a, b, c = skipFirst(1, 2, 3, 4)
print("After skipping first:", a, b, c)

-- Forwarding arguments
local function wrapper(...)
    print("Before call")
    local results = {sum(...)}
    print("After call")
    return table.unpack(results)
end

print("\n=== Wrapper ===")
print("Result:", wrapper(5, 10, 15))

-- Finding maximum
local function max(...)
    local args = {...}
    if #args == 0 then return nil end
    
    local maximum = args[1]
    for i = 2, #args do
        if args[i] > maximum then
            maximum = args[i]
        end
    end
    return maximum
end

print("\n=== Max ===")
print("Max:", max(10, 25, 5, 30, 15))

-- String concatenation
local function concat(separator, ...)
    local args = {...}
    return table.concat(args, separator)
end

print("\n=== Concat ===")
print(concat(", ", "apple", "banana", "cherry"))
print(concat(" - ", "one", "two", "three"))

-- Variadic with default values
local function createList(...)
    local list = {...}
    if #list == 0 then
        return {"default"}
    end
    return list
end

print("\n=== Create List ===")
local list1 = createList("a", "b", "c")
print("List 1:", table.concat(list1, ", "))

local list2 = createList()
print("List 2:", table.concat(list2, ", "))

Output

Click Run to execute your code

Functions as First-Class Values

In Lua, functions are values that can be stored and passed around:

Storing in Variables

local function add(a, b)
    return a + b
end

local operation = add  -- Store function in variable
print(operation(5, 3))  -- 8

Passing to Other Functions

local function apply(func, a, b)
    return func(a, b)
end

local function multiply(x, y)
    return x * y
end

local result = apply(multiply, 4, 5)
print(result)  -- 20

Returning Functions

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

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

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

-- Functions as First-Class Citizens in Lua

-- Functions can be assigned to variables
print("=== Functions as Variables ===")
local greet = function(name)
    return "Hello, " .. name
end

print(greet("Alice"))

-- Functions can be stored in tables
print("\n=== Functions in Tables ===")
local math_ops = {
    add = function(a, b) return a + b end,
    subtract = function(a, b) return a - b end,
    multiply = function(a, b) return a * b end,
    divide = function(a, b) return a / b end
}

print("5 + 3 =", math_ops.add(5, 3))
print("5 - 3 =", math_ops.subtract(5, 3))
print("5 * 3 =", math_ops.multiply(5, 3))
print("5 / 3 =", math_ops.divide(5, 3))

-- Functions can be passed as arguments
print("\n=== Functions as Arguments ===")
local function apply_operation(a, b, operation)
    return operation(a, b)
end

local function add(x, y) return x + y end
local function multiply(x, y) return x * y end

print("Apply add:", apply_operation(10, 5, add))
print("Apply multiply:", apply_operation(10, 5, multiply))

-- Functions can be returned from other functions
print("\n=== Functions Returning Functions ===")
local function create_multiplier(factor)
    return function(x)
        return x * factor
    end
end

local double = create_multiplier(2)
local triple = create_multiplier(3)

print("Double 5:", double(5))
print("Triple 5:", triple(5))

-- Anonymous functions
print("\n=== Anonymous Functions ===")
local numbers = {1, 2, 3, 4, 5}
local function map(arr, func)
    local result = {}
    for i, v in ipairs(arr) do
        result[i] = func(v)
    end
    return result
end

local squared = map(numbers, function(x) return x * x end)
print("Squared:", table.concat(squared, ", "))

-- Functions as table methods
print("\n=== Functions as Methods ===")
local calculator = {
    value = 0,
    add = function(self, n)
        self.value = self.value + n
        return self
    end,
    multiply = function(self, n)
        self.value = self.value * n
        return self
    end,
    get = function(self)
        return self.value
    end
}

calculator.value = 10
calculator:add(5):multiply(2)
print("Result:", calculator:get())

Output

Click Run to execute your code

Anonymous Functions

Functions without names, often used as callbacks:

-- Sort with custom comparator
local numbers = {5, 2, 8, 1, 9}
table.sort(numbers, function(a, b)
    return a > b  -- Sort descending
end)

-- Map function
local function map(array, func)
    local result = {}
    for i, v in ipairs(array) do
        result[i] = func(v)
    end
    return result
end

local doubled = map({1, 2, 3}, function(x)
    return x * 2
end)
-- doubled = {2, 4, 6}

Variable Scope

Variables in functions follow scoping rules:

local x = 10  -- Global to this file

local function test()
    local y = 20  -- Local to function
    print(x)      -- Can access outer x
    print(y)      -- Can access local y
end

test()
-- print(y)  -- Error: y is not accessible here

Scope Rules:

Local variables are only accessible within their block
Functions can access variables from outer scopes
Parameters are local to the function
Always use local to avoid global pollution

Practice Exercise

Try these function challenges:

-- Exercise: Functions
-- TODO: Complete the following exercises

-- 1. Create a function that calculates the area of a rectangle
local function calculateRectangleArea(length, width)
    -- your code here
end

print("Rectangle area:", calculateRectangleArea(5, 3))

-- 2. Create a function that checks if a number is even
local function isEven(number)
    -- your code here (hint: use % operator)
end

print("Is 4 even?", isEven(4))
print("Is 7 even?", isEven(7))

-- 3. Create a function that returns both sum and product of two numbers
local function sumAndProduct(a, b)
    -- your code here (return two values)
end

local s, p = sumAndProduct(5, 3)
print("Sum:", s, "Product:", p)

-- 4. Create a function that finds the maximum of three numbers
local function findMax(a, b, c)
    -- your code here
end

print("Max of 10, 25, 15:", findMax(10, 25, 15))

-- 5. Create a function that converts Celsius to Fahrenheit
-- Formula: F = C * 9/5 + 32
local function celsiusToFahrenheit(celsius)
    -- your code here
end

print("25°C in Fahrenheit:", celsiusToFahrenheit(25))

-- 6. Create a function that calculates factorial
-- factorial(5) = 5 * 4 * 3 * 2 * 1 = 120
local function factorial(n)
    -- your code here (use a loop or recursion)
end

print("Factorial of 5:", factorial(5))

-- 7. Create a function that counts vowels in a string
local function countVowels(str)
    -- your code here
    -- hint: use string.lower() and string.match()
end

print("Vowels in 'Hello World':", countVowels("Hello World"))

Output

Click Run to execute your code

Summary

In this lesson, you learned:

Defining functions with function keyword
Function parameters and default values
Returning single and multiple values
Variadic functions with ...
Functions as first-class values
Anonymous functions for callbacks
Variable scope in functions

What's Next?

You've mastered the basics of functions! Next, we'll explore closures —one of Lua's most powerful features. You'll learn how functions can "remember" their environment, enabling advanced patterns like private variables, factories, and decorators. Let's continue! 🚀

Previous Loops

Next Closures

Defining Functions

Basic Function Definition

Function as Variable

Function Parameters

Multiple Parameters

Default Parameters

Return Values

Multiple Return Values

Variadic Functions

Accessing Variadic Arguments

Mixed Parameters

Functions as First-Class Values

Storing in Variables

Passing to Other Functions

Returning Functions

Anonymous Functions

Variable Scope

Practice Exercise

Summary

What's Next?

Enjoying these tutorials?