lang-lua
Fornece padrões de engenharia de software em Lua. Cobre o uso de local variables, manipulação eficiente de tabelas, metamétodos/metatables, closures, concorrência cooperativa com coroutines, otimizaçã
SKILL.mdskills/languages/lang-lua/SKILL.md
GitHubHabilidade de IA: Engenharia de Lua (Lua Specialist)
Esta skill orienta a inteligência artificial a atuar como especialista na linguagem Lua (aplicável tanto a Lua padrão 5.1-5.4 quanto a LuaJIT), com foco em código performático, limpo, manutenível e idiomático. O objetivo é evitar armadilhas comuns de memória e desempenho que ocorrem na linguagem devido à sua simplicidade sintática.
🧭 Diretrizes de Desenvolvimento em Lua
Ao atuar nesta skill, aplique rigorosamente os seguintes padrões:
1. Escopo e Variáveis Locais
- Local por Padrão: Sempre declare variáveis com a palavra-chave
local. Variáveis globais são custosas no lookup, poluem o ambiente global (_G) e podem causar bugs silenciosos. - Cache de Globais: Se funções de bibliotecas globais (como
math.sin,table.insert,string.format) forem chamadas repetidamente dentro de loops ou funções de alta frequência, faça o cache delas localmente:local sin = math.sin local insert = table.insert
2. Manipulação Eficiente de Tabelas (Tables)
- Tabelas como Objetos Únicos: Tabelas em Lua são a única estrutura de dados estrutural. Elas representam tanto arrays quanto dicionários.
- Indexação: Lembre-se que arrays em Lua são tradicionalmente indexados a partir de 1 e não 0.
- Pré-alocação (LuaJIT): Se souber o tamanho final da tabela e estiver usando LuaJIT ou APIs específicas, utilize funções que pré-alocam memória para evitar redimensionamentos constantes.
- Evitar Criação Excessiva: Evite instanciar tabelas temporárias em loops de alta frequência para reduzir a pressão sobre o Garbage Collector (GC). Reutilize tabelas limpando seus campos.
3. Programação Orientada a Objetos com Metatables
- Protótipos com
__index: Implemente o padrão de protótipo em Lua utilizando metatables. A metatable define o comportamento da tabela sob operações especiais. - Estrutura de Classe Básica:
local Account = {} Account.__index = Account function Account.new(balance) local self = setmetatable({}, Account) self.balance = balance or 0 return self end function Account:deposit(amount) self.balance = self.balance + amount end
4. Concorrência Cooperativa (Coroutines)
- Estados Independentes: Use corrotinas para simular multithreading cooperativo ou para implementar geradores (generators).
- Ciclo de Vida: Entenda o fluxo entre
coroutine.create,coroutine.resume,coroutine.yieldecoroutine.status.
5. Integração com C/C++ e LuaJIT FFI
- Lua C API: Entenda como a pilha virtual de Lua gerencia a comunicação e troca de tipos com o código nativo.
- FFI (Foreign Function Interface): Em ambientes LuaJIT, prefira o uso do módulo
ffipara chamar funções C nativas sem o overhead de wrappers tradicionais.
🧰 Padrões de Código Recomendados
Implementação Clássica de Orientação a Objetos com Herança
-- Base Class
local Animal = {}
Animal.__index = Animal
function Animal.new(name)
local self = setmetatable({}, Animal)
self.name = name or "Unknown"
return self
end
function Animal:makeSound()
return "Some generic sound"
end
-- Derived Class
local Dog = setmetatable({}, Animal)
Dog.__index = Dog
function Dog.new(name, breed)
-- Call base constructor
local self = setmetatable(Animal.new(name), Dog)
self.breed = breed or "Mixed"
return self
end
-- Override method
function Dog:makeSound()
return "Woof! Woof!"
end
-- Usage
local myDog = Dog.new("Rex", "German Shepherd")
print(myDog.name) -- Output: Rex
print(myDog:makeSound()) -- Output: Woof! Woof!
Cache Dinâmico com Tabelas Fracas (Weak Tables)
Tabelas fracas ajudam a prevenir vazamentos de memória cacheando referências que podem ser coletadas se não houver outras referências a elas.
-- Table with weak values
local cache = {}
setmetatable(cache, { __mode = "v" }) -- 'k' for weak keys, 'v' for weak values
local function getCachedObject(id, generator)
local obj = cache[id]
if not obj then
obj = generator(id)
cache[id] = obj
end
return obj
end
Integração Eficiente via LuaJIT FFI
local ffi = require("ffi")
-- Declare C prototypes
ffi.cdef[[
int printf(const char *fmt, ...);
typedef struct { double x, y; } point_t;
]]
-- Call C functions directly
ffi.C.printf("Hello from C printf via LuaJIT FFI!\n")
-- Create C structures directly in memory
local point = ffi.new("point_t", 10.5, 20.2)
ffi.C.printf("Point coordinates: x=%f, y=%f\n", point.x, point.y)
🔒 Questões de Segurança e Práticas Seguras
- Sandbox Escaping: Ao executar scripts Lua fornecidos pelo usuário, restrinja o acesso a funções globais perigosas (
load,loadstring,require,os.execute,ioepackagemodules). - Tratamento de Metatables: Proteja metatabelas de objetos internos para evitar que códigos externos alterem comportamentos nativos da aplicação ou escalem privilégios.
- Estouros em LuaJIT / APIs C: Ao realizar integrações com C através da API do Lua, valide rigorosamente os limites da pilha do Lua para evitar corrupção da memória nativa do interpretador.