"id","perguntas","saidas"
"1","Como declaro uma função em Lua?","```lua
local function soma(a, b)
    return a + b
end

print(soma(3, 4))  -- 7
```
Em Lua, funções são valores de primeira classe. `local` torna a função local ao escopo atual, evitando poluir o ambiente global."
"2","Como percorro uma tabela em Lua?","```lua
local frutas = {'maçã', 'banana', 'uva'}

for i, v in ipairs(frutas) do
    print(i, v)
end

-- Tabela associativa
local pessoa = {nome='Ana', idade=25}
for k, v in pairs(pessoa) do
    print(k, v)
end
```
`ipairs` percorre tabelas numeradas (arrays); `pairs` percorre qualquer tabela, mas sem ordem garantida."
"3","Como crio uma classe/objeto em Lua?","```lua
local Conta = {}
Conta.__index = Conta

function Conta.new(saldo)
    local self = setmetatable({}, Conta)
    self.saldo = saldo or 0
    return self
end

function Conta:depositar(valor)
    self.saldo = self.saldo + valor
end

function Conta:sacar(valor)
    if valor > self.saldo then error('Saldo insuficiente') end
    self.saldo = self.saldo - valor
end

local c = Conta.new(100)
c:depositar(50)
c:sacar(30)
print(c.saldo)  -- 120
```
Lua não tem classes nativas; usamos metatables para simular orientação a objetos."
"4","Como leio entrada do usuário em Lua?","```lua
io.write('Qual seu nome? ')
local nome = io.read()
print('Olá, ' .. nome .. '!')
```
`io.read()` lê uma linha do stdin. `..` é o operador de concatenação em Lua."
"5","Como faço um loop while em Lua?","```lua
local i = 1
while i <= 5 do
    print('Iteração', i)
    i = i + 1
end
```
O loop continua enquanto a condição for verdadeira. Lua não tem `++`, então use `i = i + 1`."
"6","Como trabalho com arquivos em Lua?","```lua
-- Escrever
local f = io.open('dados.txt', 'w')
f:write('Linha 1\n')
f:write('Linha 2\n')
f:close()

-- Ler
local f = io.open('dados.txt', 'r')
for linha in f:lines() do
    print(linha)
end
f:close()
```
`io.open` aceita modos: 'r' (leitura), 'w' (escrita), 'a' (append), 'b' (binário)."
"7","Como trato erros em Lua?","```lua
local ok, err = pcall(function()
    error('Algo deu errado')
end)

if ok then
    print('Sucesso')
else
    print('Erro capturado:', err)
end
```
`pcall` (protected call) captura erros sem interromper o programa. Útil para código que pode falhar."
"8","Como uso coroutines em Lua?","```lua
local co = coroutine.create(function()
    for i = 1, 3 do
        coroutine.yield(i)
    end
end)

print(coroutine.resume(co))  -- true  1
print(coroutine.resume(co))  -- true  2
print(coroutine.resume(co))  -- true  3
print(coroutine.resume(co))  -- true  nil
```
Coroutines permitem execução pausável. `yield` pausa; `resume` retoma. Diferente de threads, são cooperativas."