Lua Cheatsheet: Tables, Metatables and Coroutines Reference

# Install
brew install lua                    # macOS — stable Lua 5.4
brew install luajit                 # LuaJIT 2.1 — much faster, Lua 5.1 dialect
sudo apt install lua5.4             # Debian/Ubuntu

# Package manager
brew install luarocks
luarocks install --local penlight    # functional + OO utility kit
luarocks install --local luasocket
luarocks install --local cjson       # if not using built-in JSON

# Run
lua script.lua arg1 arg2
luajit script.lua                    # LuaJIT — same surface, faster

# REPL
lua

# Daily commands
lua -e 'print(_VERSION)'             # one-liner
lua -l mymod                         # load a module before running
luarocks list                        # installed rocks
stylua --check src/                  # formatter (rust-based, optional)
selene src/                          # linter (rust-based, optional)

-- Tables are the ONE composite type in Lua.
-- Arrays, hashes, namespaces, objects, modules — all tables.

-- Array-style (1-indexed!)
local fruits = { "apple", "banana", "cherry" }
print(fruits[1])                          -- apple
print(#fruits)                            -- length (3)

-- Hash-style
local user = { name = "Ada", age = 36 }
print(user.name)                          -- Ada
print(user["name"])                       -- same thing

-- Mixed (both at once)
local row = { 1, 2, 3, label = "primes", verified = true }

-- Iterate
for i, v in ipairs(fruits) do             -- arrays: stops at first nil
    print(i, v)
end

for k, v in pairs(user) do                -- any keys, any order
    print(k, v)
end

-- Insert / remove
table.insert(fruits, "date")              -- append
table.insert(fruits, 1, "apricot")        -- insert at index 1
table.remove(fruits, 2)                   -- remove index 2

-- Sort + concat
table.sort(fruits)
print(table.concat(fruits, ", "))

-- Shallow copy
local copy = { table.unpack(fruits) }     -- Lua 5.2+ (or `unpack` in 5.1/LuaJIT)

-- Metatables = the hook layer that powers OOP, operator overloading, defaults.

-- 1 · Class via __index — fallback for missing keys
local Vector = {}
Vector.__index = Vector                   -- when key missing on instance, look here

function Vector.new(x, y)
    return setmetatable({ x = x, y = y }, Vector)
end

function Vector:length()                  -- `:` injects `self`
    return math.sqrt(self.x^2 + self.y^2)
end

function Vector:__add(other)              -- v + w
    return Vector.new(self.x + other.x, self.y + other.y)
end

function Vector:__tostring()              -- print(v)
    return string.format("Vec(%g, %g)", self.x, self.y)
end

local v = Vector.new(3, 4)
print(v:length())                         -- 5.0
print(v + Vector.new(1, 1))               -- Vec(4, 5)

-- 2 · Default-valued table
local function defaults(defaults_tbl)
    return setmetatable({}, { __index = defaults_tbl })
end

local config = defaults{ port = 8080, tls = false }
config.tls = true
print(config.port, config.tls)            -- 8080  true

-- Save as: word_count.lua
-- Run    :  lua word_count.lua path/to/dir
--
-- Walk a directory, tally word frequencies across every .txt and .md file,
-- print the top 20. Pure stdlib + `io.popen` for portable directory walk.

local function each_file(root, ext_pat)
    local cmd = ('find %q -type f \\( -name "*.txt" -o -name "*.md" \\)'):format(root)
    local pipe = assert(io.popen(cmd, "r"))
    return function()
        local line = pipe:read("*l")
        if not line then pipe:close(); return nil end
        return line
    end
end

local function tokenize(line)
    return line:lower():gmatch("[%a']+")     -- letters + apostrophe
end

local function topn(map, n)
    local list = {}
    for word, count in pairs(map) do
        list[#list + 1] = { word = word, count = count }
    end
    table.sort(list, function(a, b) return a.count > b.count end)
    for i = 1, math.min(n, #list) do
        print(string.format("%6d  %s", list[i].count, list[i].word))
    end
end

local function main()
    local root = arg[1] or "."
    local counts = setmetatable({}, { __index = function() return 0 end })

    for path in each_file(root) do
        local f = io.open(path, "r")
        if f then
            for line in f:lines() do
                for w in tokenize(line) do
                    counts[w] = counts[w] + 1
                end
            end
            f:close()
        end
    end

    topn(counts, 20)
end

main()