프로그래밍 언어 실전 가이드
루아 입문 시리즈 #16: 루아 메타프로그래밍
devcomet
2025. 7. 4. 16:06
728x90
반응형
루아 메타프로그래밍의 메타테이블 고급 기법부터 DSL 구축, 코드 생성까지 실전 예제로 배우는 완벽 가이드입니다.
메타프로그래밍의 세계로 떠나는 여행
메타프로그래밍은 프로그램이 자기 자신을 수정하거나 다른 프로그램을 생성할 수 있게 해주는 강력한 기법입니다.
루아에서 메타프로그래밍은 언어의 유연성과 동적 특성을 활용하여 코드를 더욱 효율적이고 표현력 있게 만들어줍니다.
이번 시리즈에서는 메타테이블 고급 기법부터 시작하여 DSL 구축과 코드 생성까지 다루겠습니다.
메타테이블 고급 기법 마스터하기
메타테이블의 심화 이해
메타테이블은 루아 메타프로그래밍의 핵심 요소입니다.
기본적인 메타메서드들을 넘어서 고급 기법들을 살펴보겠습니다.
-- 고급 메타테이블 예제: 자동 초기화 테이블
local AutoTable = {}
AutoTable.__index = function(t, k)
local new_table = {}
setmetatable(new_table, AutoTable)
t[k] = new_table
return new_table
end
function createAutoTable()
local t = {}
setmetatable(t, AutoTable)
return t
end
-- 사용 예시
local data = createAutoTable()
data.user.profile.name = "John"
data.user.profile.age = 30메타테이블 체이닝과 상속
메타테이블을 활용한 객체 지향 프로그래밍에서 상속을 구현할 수 있습니다.
-- 부모 클래스 정의
local Animal = {}
Animal.__index = Animal
function Animal:new(name)
local obj = {name = name}
setmetatable(obj, self)
return obj
end
function Animal:speak()
print(self.name .. " makes a sound")
end
-- 자식 클래스 정의
local Dog = setmetatable({}, Animal)
Dog.__index = Dog
function Dog:new(name, breed)
local obj = Animal.new(self, name)
obj.breed = breed
setmetatable(obj, self)
return obj
end
function Dog:speak()
print(self.name .. " barks")
end
-- 사용 예시
local myDog = Dog:new("Max", "Golden Retriever")
myDog:speak() -- "Max barks"프록시 패턴과 가상 프로퍼티
메타테이블을 활용하여 프록시 패턴을 구현할 수 있습니다.
-- 프록시 패턴 구현
local function createProxy(target, handler)
local proxy = {}
local mt = {
__index = function(t, k)
if handler.get then
return handler.get(target, k)
end
return target[k]
end,
__newindex = function(t, k, v)
if handler.set then
handler.set(target, k, v)
else
target[k] = v
end
end
}
setmetatable(proxy, mt)
return proxy
end
-- 사용 예시: 로깅 프록시
local obj = {x = 10, y = 20}
local logProxy = createProxy(obj, {
get = function(target, key)
print("Getting property: " .. key)
return target[key]
end,
set = function(target, key, value)
print("Setting property: " .. key .. " = " .. value)
target[key] = value
end
})DSL 구축의 실전 가이드
도메인 특화 언어(DSL) 설계 원칙
DSL 구축은 특정 도메인의 문제를 해결하기 위한 맞춤형 언어를 만드는 것입니다.
루아의 문법적 유연성을 활용하면 읽기 쉽고 직관적인 DSL을 만들 수 있습니다.
-- HTML 생성 DSL 예제
local HTML = {}
function HTML.tag(tagName)
return function(content)
if type(content) == "table" then
local attributes = ""
local body = ""
for k, v in pairs(content) do
if type(k) == "string" then
attributes = attributes .. " " .. k .. '="' .. v .. '"'
else
body = body .. tostring(v)
end
end
return "<" .. tagName .. attributes .. ">" .. body .. "</" .. tagName .. ">"
else
return "<" .. tagName .. ">" .. tostring(content) .. "</" .. tagName .. ">"
end
end
end
-- 동적 태그 생성
local tags = {"div", "h1", "p", "span", "a"}
for _, tag in ipairs(tags) do
HTML[tag] = HTML.tag(tag)
end
-- 사용 예시
local html = HTML.div {
class = "container",
HTML.h1 "Welcome to Lua DSL",
HTML.p {
class = "description",
"This is a simple HTML DSL built with Lua"
}
}구성 파일 DSL 만들기
설정 파일을 위한 DSL을 구축해보겠습니다.
-- 설정 DSL 구현
local Config = {}
local currentConfig = {}
function Config.server(settings)
currentConfig.server = settings
return Config
end
function Config.database(settings)
currentConfig.database = settings
return Config
end
function Config.logging(settings)
currentConfig.logging = settings
return Config
end
function Config.build()
local result = currentConfig
currentConfig = {}
return result
end
-- 사용 예시
local config = Config
.server {
host = "localhost",
port = 8080,
ssl = true
}
.database {
host = "db.example.com",
name = "myapp",
pool_size = 10
}
.logging {
level = "INFO",
file = "app.log"
}
.build()쿼리 빌더 DSL 구현
데이터베이스 쿼리를 위한 DSL을 만들어보겠습니다.
-- 쿼리 빌더 DSL
local QueryBuilder = {}
QueryBuilder.__index = QueryBuilder
function QueryBuilder:new()
local obj = {
_select = {},
_from = "",
_where = {},
_joins = {},
_orderBy = {},
_limit = nil
}
setmetatable(obj, self)
return obj
end
function QueryBuilder:select(...)
local fields = {...}
for _, field in ipairs(fields) do
table.insert(self._select, field)
end
return self
end
function QueryBuilder:from(table)
self._from = table
return self
end
function QueryBuilder:where(condition)
table.insert(self._where, condition)
return self
end
function QueryBuilder:join(table, condition)
table.insert(self._joins, {type = "JOIN", table = table, condition = condition})
return self
end
function QueryBuilder:orderBy(field, direction)
table.insert(self._orderBy, {field = field, direction = direction or "ASC"})
return self
end
function QueryBuilder:limit(count)
self._limit = count
return self
end
function QueryBuilder:build()
local query = "SELECT " .. table.concat(self._select, ", ")
query = query .. " FROM " .. self._from
-- JOIN 절 추가
for _, join in ipairs(self._joins) do
query = query .. " " .. join.type .. " " .. join.table .. " ON " .. join.condition
end
-- WHERE 절 추가
if #self._where > 0 then
query = query .. " WHERE " .. table.concat(self._where, " AND ")
end
-- ORDER BY 절 추가
if #self._orderBy > 0 then
local orderFields = {}
for _, order in ipairs(self._orderBy) do
table.insert(orderFields, order.field .. " " .. order.direction)
end
query = query .. " ORDER BY " .. table.concat(orderFields, ", ")
end
-- LIMIT 절 추가
if self._limit then
query = query .. " LIMIT " .. self._limit
end
return query
end
-- 사용 예시
local query = QueryBuilder:new()
:select("users.name", "profiles.email")
:from("users")
:join("profiles", "users.id = profiles.user_id")
:where("users.active = 1")
:where("profiles.verified = 1")
:orderBy("users.created_at", "DESC")
:limit(10)
:build()코드 생성 기법과 템플릿 엔진
동적 코드 생성의 원리
코드 생성은 메타프로그래밍의 핵심 기능 중 하나입니다.
런타임에 코드를 생성하고 실행할 수 있는 능력은 매우 강력합니다.
-- 코드 생성 예제: 함수 팩토리
local function createAccessor(fieldName)
local getterCode = string.format([[
return function(obj)
return obj.%s
end
]], fieldName)
local setterCode = string.format([[
return function(obj, value)
obj.%s = value
end
]], fieldName)
local getter = load(getterCode)()
local setter = load(setterCode)()
return getter, setter
end
-- 사용 예시
local getName, setName = createAccessor("name")
local getAge, setAge = createAccessor("age")
local person = {}
setName(person, "John")
setAge(person, 30)
print(getName(person)) -- "John"
print(getAge(person)) -- 30템플릿 엔진 구현
간단한 템플릿 엔진을 구현해보겠습니다.
-- 템플릿 엔진 구현
local Template = {}
Template.__index = Template
function Template:new(templateString)
local obj = {
template = templateString,
compiled = nil
}
setmetatable(obj, self)
return obj
end
function Template:compile()
if self.compiled then
return self.compiled
end
local code = [[
local _output = {}
local function _write(s)
table.insert(_output, tostring(s))
end
local function _writeEscaped(s)
s = tostring(s)
s = s:gsub("&", "&")
s = s:gsub("<", "<")
s = s:gsub(">", ">")
s = s:gsub('"', """)
table.insert(_output, s)
end
]]
local template = self.template
local i = 1
while i <= #template do
local start, finish = template:find("{{", i)
if not start then
-- 남은 텍스트 추가
if i <= #template then
code = code .. "_write(" .. string.format("%q", template:sub(i)) .. ")\n"
end
break
end
-- 텍스트 부분 추가
if start > i then
code = code .. "_write(" .. string.format("%q", template:sub(i, start - 1)) .. ")\n"
end
-- 표현식 찾기
local exprStart = finish + 1
local exprEnd = template:find("}}", exprStart)
if not exprEnd then
error("Unclosed expression in template")
end
local expr = template:sub(exprStart, exprEnd - 1):match("^%s*(.-)%s*$")
-- 표현식 처리
if expr:sub(1, 1) == "=" then
-- 출력 표현식
code = code .. "_writeEscaped(" .. expr:sub(2) .. ")\n"
elseif expr:sub(1, 1) == "-" then
-- 원시 출력 표현식
code = code .. "_write(" .. expr:sub(2) .. ")\n"
else
-- 코드 블록
code = code .. expr .. "\n"
end
i = exprEnd + 2
end
code = code .. "return table.concat(_output)"
self.compiled = load(code)
return self.compiled
end
function Template:render(context)
local compiled = self:compile()
local env = {}
-- 컨텍스트 변수들을 환경에 추가
if context then
for k, v in pairs(context) do
env[k] = v
end
end
-- 표준 함수들 추가
env.pairs = pairs
env.ipairs = ipairs
env.tostring = tostring
env.tonumber = tonumber
env.table = table
env.string = string
env.math = math
-- 컴파일된 함수의 환경 설정
local old_env = getfenv(compiled)
setfenv(compiled, env)
local success, result = pcall(compiled)
-- 환경 복원
setfenv(compiled, old_env)
if not success then
error("Template rendering error: " .. result)
end
return result
end
-- 사용 예시
local template = Template:new([[
<html>
<head>
<title>{{= title }}</title>
</head>
<body>
<h1>{{= title }}</h1>
<ul>
{{ for i, item in ipairs(items) do }}
<li>{{= item.name }} - {{= item.price }}</li>
{{ end }}
</ul>
</body>
</html>
]])
local context = {
title = "Product List",
items = {
{name = "Apple", price = 1.20},
{name = "Banana", price = 0.80},
{name = "Orange", price = 1.50}
}
}
local html = template:render(context)
print(html)
고급 메타프로그래밍 패턴
어노테이션 시스템 구현
Java나 C#의 어노테이션과 같은 기능을 루아에서 구현해보겠습니다.
-- 어노테이션 시스템
local Annotations = {}
local annotationStorage = {}
function Annotations.define(name, handler)
Annotations[name] = function(target, ...)
local args = {...}
if not annotationStorage[target] then
annotationStorage[target] = {}
end
table.insert(annotationStorage[target], {
name = name,
args = args,
handler = handler
})
return target
end
end
function Annotations.process(target)
local annotations = annotationStorage[target]
if not annotations then
return
end
for _, annotation in ipairs(annotations) do
if annotation.handler then
annotation.handler(target, unpack(annotation.args))
end
end
end
-- 어노테이션 정의
Annotations.define("route", function(func, method, path)
func._route = {method = method, path = path}
end)
Annotations.define("validate", function(func, validator)
local originalFunc = func
func = function(...)
local args = {...}
if validator(args) then
return originalFunc(...)
else
error("Validation failed")
end
end
end)
-- 사용 예시
local function getUserHandler(userId)
return {id = userId, name = "John Doe"}
end
Annotations.route(getUserHandler, "GET", "/users/:id")
Annotations.process(getUserHandler)AOP(Aspect-Oriented Programming) 구현
관점 지향 프로그래밍을 루아에서 구현해보겠습니다.
-- AOP 구현
local AOP = {}
local aspects = {}
function AOP.before(pointcut, advice)
if not aspects[pointcut] then
aspects[pointcut] = {before = {}, after = {}, around = {}}
end
table.insert(aspects[pointcut].before, advice)
end
function AOP.after(pointcut, advice)
if not aspects[pointcut] then
aspects[pointcut] = {before = {}, after = {}, around = {}}
end
table.insert(aspects[pointcut].after, advice)
end
function AOP.around(pointcut, advice)
if not aspects[pointcut] then
aspects[pointcut] = {before = {}, after = {}, around = {}}
end
table.insert(aspects[pointcut].around, advice)
end
function AOP.weave(target, pointcut)
local aspectList = aspects[pointcut]
if not aspectList then
return target
end
return function(...)
local args = {...}
-- Before advice 실행
for _, advice in ipairs(aspectList.before) do
advice(args)
end
-- Around advice 또는 원본 함수 실행
local result
if #aspectList.around > 0 then
local proceed = function()
return target(unpack(args))
end
result = aspectList.around[1](proceed, args)
else
result = target(unpack(args))
end
-- After advice 실행
for _, advice in ipairs(aspectList.after) do
advice(args, result)
end
return result
end
end
-- 사용 예시
AOP.before("logging", function(args)
print("Before: " .. table.concat(args, ", "))
end)
AOP.after("logging", function(args, result)
print("After: result = " .. tostring(result))
end)
local function calculate(a, b)
return a + b
end
local wrappedCalculate = AOP.weave(calculate, "logging")
wrappedCalculate(5, 3) -- 로깅과 함께 실행성능 최적화와 메모리 관리
메타프로그래밍의 성능 고려사항
메타프로그래밍은 강력하지만 성능에 영향을 줄 수 있습니다.
적절한 최적화 기법을 사용하여 성능을 향상시킬 수 있습니다.
| 기법 | 장점 | 단점 | 사용 시점 |
|---|---|---|---|
| 컴파일 타임 생성 | 빠른 실행 속도 | 유연성 부족 | 정적 코드 생성 |
| 런타임 생성 | 높은 유연성 | 느린 실행 속도 | 동적 코드 생성 |
| 메모이제이션 | 반복 호출 최적화 | 메모리 사용량 증가 | 반복적인 계산 |
| 레이지 로딩 | 초기 로딩 시간 단축 | 첫 사용 시 지연 | 큰 모듈 로딩 |
-- 성능 최적화 예제: 메모이제이션
local function memoize(func)
local cache = {}
return function(...)
local key = table.concat({...}, ",")
if cache[key] == nil then
cache[key] = func(...)
end
return cache[key]
end
end
-- 레이지 로딩 구현
local function createLazyLoader(modulePath)
local module = nil
return function()
if not module then
module = require(modulePath)
end
return module
end
end
-- 사용 예시
local lazyMath = createLazyLoader("math")
local mathModule = lazyMath() -- 이때 실제로 로드됨가비지 컬렉션 최적화
메타프로그래밍에서 메모리 관리는 중요합니다.
-- 메모리 효율적인 객체 풀 구현
local ObjectPool = {}
ObjectPool.__index = ObjectPool
function ObjectPool:new(factory, reset)
local obj = {
factory = factory,
reset = reset or function() end,
pool = {}
}
setmetatable(obj, self)
return obj
end
function ObjectPool:get()
if #self.pool > 0 then
return table.remove(self.pool)
else
return self.factory()
end
end
function ObjectPool:release(obj)
self.reset(obj)
table.insert(self.pool, obj)
end
-- 사용 예시
local tablePool = ObjectPool:new(
function() return {} end,
function(t)
for k in pairs(t) do
t[k] = nil
end
end
)
local temp = tablePool:get()
temp.data = "some data"
-- 사용 후 반납
tablePool:release(temp)실전 프로젝트: 마이크로 ORM 구축
ORM 기본 구조 설계
메타프로그래밍을 활용하여 간단한 ORM을 구축해보겠습니다.
-- 마이크로 ORM 구현
local MicroORM = {}
MicroORM.__index = MicroORM
function MicroORM:new(config)
local obj = {
config = config,
models = {},
connection = nil
}
setmetatable(obj, self)
return obj
end
function MicroORM:model(name, schema)
local Model = {}
Model.__index = Model
Model._name = name
Model._schema = schema
Model._orm = self
function Model:new(data)
local instance = data or {}
setmetatable(instance, self)
return instance
end
function Model:save()
local fields = {}
local values = {}
local placeholders = {}
for field, _ in pairs(self._schema) do
if self[field] ~= nil then
table.insert(fields, field)
table.insert(values, self[field])
table.insert(placeholders, "?")
end
end
local sql = string.format("INSERT INTO %s (%s) VALUES (%s)",
self._name,
table.concat(fields, ", "),
table.concat(placeholders, ", ")
)
-- 실제로는 데이터베이스 연결을 통해 실행
print("Executing: " .. sql)
print("Values: " .. table.concat(values, ", "))
return self
end
function Model:find(id)
local sql = string.format("SELECT * FROM %s WHERE id = ?", self._name)
print("Executing: " .. sql .. " with id = " .. id)
-- 실제로는 데이터베이스에서 조회
local data = {id = id, name = "Sample Data"}
return self:new(data)
end
function Model:where(field, operator, value)
local QueryBuilder = {}
QueryBuilder.__index = QueryBuilder
function QueryBuilder:new(model)
local obj = {
model = model,
conditions = {}
}
setmetatable(obj, self)
return obj
end
function QueryBuilder:where(field, operator, value)
table.insert(self.conditions, {field = field, operator = operator, value = value})
return self
end
function QueryBuilder:get()
local whereClause = {}
for _, condition in ipairs(self.conditions) do
table.insert(whereClause, condition.field .. " " .. condition.operator .. " ?")
end
local sql = string.format("SELECT * FROM %s WHERE %s",
self.model._name,
table.concat(whereClause, " AND ")
)
print("Executing: " .. sql)
-- 실제로는 데이터베이스에서 조회
return {}
end
local query = QueryBuilder:new(self)
return query:where(field, operator, value)
end
self.models[name] = Model
return Model
end
-- 사용 예시
local orm = MicroORM:new({
host = "localhost",
database = "test"
})
local User = orm:model("users", {
id = "integer",
name = "string",
email = "string",
created_at = "datetime"
})
-- 사용
local user = User:new({
name = "John Doe",
email = "john@example.com"
})
user:save()
local foundUser = User:find(1)
local users = User:where("name", "=", "John"):get()관계형 데이터 처리
ORM에서 관계형 데이터를 처리하는 방법을 구현해보겠습니다.
-- 관계형 데이터 처리 확장
function MicroORM:hasMany(parentModel, childModel, foreignKey)
parentModel["get" .. childModel._name] = function(self)
return childModel:where(foreignKey, "=", self.id):get()
end
end
function MicroORM:belongsTo(childModel, parentModel, foreignKey)
childModel["get" .. parentModel._name] = function(self)
return parentModel:find(self[foreignKey])
end
end
-- 사용 예시
local Post = orm:model("posts", {
id = "integer",
title = "string",
content = "text",
user_id = "integer"
})
orm:hasMany(User, Post, "user_id")
orm:belongsTo(Post, User, "user_id")
-- 관계 사용
local user = User:find(1)
local posts = user:getposts()
local post = Post:find(1)
local author = post:getusers()디버깅과 에러 처리
메타프로그래밍 디버깅 기법
메타프로그래밍 코드를 디버깅하는 것은 도전적입니다.
적절한 디버깅 도구와 기법을 사용해야 합니다.
-- 디버깅 도구 구현
local Debug = {}
function Debug.trace(func, name)
return function(...)
print("Entering: " .. (name or "anonymous"))
local args = {...}
for i, arg in ipairs(args) do
print(" Arg " .. i .. ": " .. tostring(arg))
end
local result = func(...)
print("Exiting: " .. (name or "anonymous"))
print(" Result: " .. tostring(result))
return result
end
end
function Debug.inspect(obj, depth)
depth = depth or 0
local indent = string.rep(" ", depth)
if type(obj) == "table" then
print(indent .. "{")
for k, v in pairs(obj) do
print(indent .. " " .. tostring(k) .. ": ")
if type(v) == "table" and depth < 3 then
Debug.inspect(v, depth + 1)
else
print(indent .. " " .. tostring(v))
end
end
print(indent .. "}")
else
print(indent .. tostring(obj))
end
end
-- 사용 예시
local tracedFunction = Debug.trace(function(x, y)
return x + y
end, "add")
tracedFunction(5, 3)에러 처리 패턴
메타프로그래밍에서 발생할 수 있는 에러들을 처리하는 패턴을 살펴보겠습니다.
-- 에러 처리 패턴
local ErrorHandler = {}
function ErrorHandler.safe(func, errorHandler)
return function(...)
local success, result = pcall(func, ...)
if success then
return result
else
if errorHandler then
return errorHandler(result)
else
error("Safe execution failed: " .. result)
end
end
end
end
function ErrorHandler.retry(func, maxRetries, delay)
return function(...)
local args = {...}
local retries = 0
while retries < maxRetries do
local success, result = pcall(func, unpack(args))
if success then
return result
end
retries = retries + 1
if retries < maxRetries then
if delay then
-- 실제로는 sleep 함수가 필요
print("Retrying in " .. delay .. " seconds...")
end
end
end
error("Max retries exceeded")
end
end
-- 사용 예시
local safeFunction = ErrorHandler.safe(function(x)
if x < 0 then
error("Negative number not allowed")
end
return math.sqrt(x)
end, function(err)
print("Error occurred: " .. err)
return 0
end)
local result = safeFunction(-5) -- 에러가 발생하지만 0을 반환모범 사례와 주의사항
메타프로그래밍 모범 사례
메타프로그래밍을 효과적으로 사용하기 위한 모범 사례들을 정리했습니다.
-- 모범 사례 1: 명확한 네이밍
local function createValidator(rules)
local validator = {}
function validator:validate(data)
for field, rule in pairs(rules) do
if not self:validateField(data[field], rule) then
return false, "Validation failed for field: " .. field
end
end
return true
end
function validator:validateField(value, rule)
if rule.required and not value then
return false
end
if rule.type and type(value) ~= rule.type then
return false
end
if rule.min and value < rule.min then
return false
end
if rule.max and value > rule.max then
return false
end
return true
end
return validator
end
-- 모범 사례 2: 문서화와 주석
--[[
메타테이블 기반 프록시 패턴 구현
@param target 대상 객체
@param interceptor 인터셉터 함수들을 포함한 테이블
@return 프록시 객체
]]
local function createInterceptor(target, interceptor)
local proxy = {}
local mt = {
__index = function(t, k)
if interceptor.beforeGet then
interceptor.beforeGet(target, k)
end
local value = target[k]
if interceptor.afterGet then
value = interceptor.afterGet(target, k, value) or value
end
return value
end,
__newindex = function(t, k, v)
if interceptor.beforeSet then
v = interceptor.beforeSet(target, k, v) or v
end
target[k] = v
if interceptor.afterSet then
interceptor.afterSet(target, k, v)
end
end
}
setmetatable(proxy, mt)
return proxy
end주의사항과 함정
메타프로그래밍을 사용할 때 주의해야 할 점들을 살펴보겠습니다.
-- 주의사항 1: 메모리 누수 방지
local WeakTable = {}
WeakTable.__index = WeakTable
function WeakTable:new()
local obj = {
data = setmetatable({}, {__mode = "v"}) -- 값에 대한 약한 참조
}
setmetatable(obj, self)
return obj
end
function WeakTable:set(key, value)
self.data[key] = value
end
function WeakTable:get(key)
return self.data[key]
end
-- 주의사항 2: 재귀 참조 방지
local function safeToString(obj, seen)
seen = seen or {}
if seen[obj] then
return "<circular reference>"
end
if type(obj) == "table" then
seen[obj] = true
local result = "{"
local first = true
for k, v in pairs(obj) do
if not first then
result = result .. ", "
end
result = result .. tostring(k) .. ": " .. safeToString(v, seen)
first = false
end
result = result .. "}"
seen[obj] = nil
return result
else
return tostring(obj)
end
end
-- 주의사항 3: 성능 모니터링
local function createProfiler()
local profiler = {
calls = {},
startTime = {}
}
function profiler:start(name)
self.startTime[name] = os.clock()
end
function profiler:stop(name)
local endTime = os.clock()
local elapsed = endTime - (self.startTime[name] or endTime)
if not self.calls[name] then
self.calls[name] = {count = 0, totalTime = 0}
end
self.calls[name].count = self.calls[name].count + 1
self.calls[name].totalTime = self.calls[name].totalTime + elapsed
end
function profiler:report()
print("Performance Report:")
print("==================")
for name, stats in pairs(self.calls) do
local avgTime = stats.totalTime / stats.count
print(string.format("%s: %d calls, %.4f total, %.4f avg",
name, stats.count, stats.totalTime, avgTime))
end
end
return profiler
end
-- 사용 예시
local profiler = createProfiler()
local function wrappedFunction(func, name)
return function(...)
profiler:start(name)
local result = func(...)
profiler:stop(name)
return result
end
end실제 사용 사례와 라이브러리
유명 라이브러리에서의 메타프로그래밍
실제 루아 라이브러리들에서 메타프로그래밍이 어떻게 사용되는지 살펴보겠습니다.
-- OpenResty/ngx_lua 스타일 모듈 패턴
local _M = {}
_M._VERSION = '0.1.0'
local mt = { __index = _M }
function _M.new(self, config)
local instance = {
config = config or {},
state = {}
}
return setmetatable(instance, mt)
end
function _M.process(self, data)
-- 실제 처리 로직
return data
end
return _M
-- Penlight 라이브러리 스타일 체이닝
local Chain = {}
Chain.__index = Chain
function Chain:new(value)
local obj = {value = value}
setmetatable(obj, self)
return obj
end
function Chain:map(func)
local result = {}
for i, v in ipairs(self.value) do
result[i] = func(v)
end
return Chain:new(result)
end
function Chain:filter(predicate)
local result = {}
for _, v in ipairs(self.value) do
if predicate(v) then
table.insert(result, v)
end
end
return Chain:new(result)
end
function Chain:reduce(func, initial)
local acc = initial
for _, v in ipairs(self.value) do
acc = func(acc, v)
end
return acc
end
function Chain:value()
return self.value
end
-- 사용 예시
local numbers = {1, 2, 3, 4, 5}
local result = Chain:new(numbers)
:map(function(x) return x * 2 end)
:filter(function(x) return x > 5 end)
:reduce(function(acc, x) return acc + x end, 0)
print(result) -- 18게임 개발에서의 메타프로그래밍
게임 개발에서 메타프로그래밍을 활용하는 예시를 살펴보겠습니다.
-- 게임 엔티티 시스템
local Entity = {}
Entity.__index = Entity
function Entity:new(id)
local obj = {
id = id,
components = {},
systems = {}
}
setmetatable(obj, self)
return obj
end
function Entity:addComponent(componentType, data)
self.components[componentType] = data
return self
end
function Entity:getComponent(componentType)
return self.components[componentType]
end
function Entity:hasComponent(componentType)
return self.components[componentType] ~= nil
end
-- 컴포넌트 시스템
local ComponentSystem = {}
function ComponentSystem.createSystem(name, requiredComponents, updateFunc)
return {
name = name,
requiredComponents = requiredComponents,
update = updateFunc,
entities = {}
}
end
function ComponentSystem.addEntity(system, entity)
-- 필요한 컴포넌트가 모두 있는지 확인
for _, component in ipairs(system.requiredComponents) do
if not entity:hasComponent(component) then
return false
end
end
table.insert(system.entities, entity)
return true
end
function ComponentSystem.update(system, dt)
for _, entity in ipairs(system.entities) do
system.update(entity, dt)
end
end
-- 사용 예시
local player = Entity:new("player")
:addComponent("Position", {x = 0, y = 0})
:addComponent("Velocity", {x = 0, y = 0})
:addComponent("Renderable", {sprite = "player.png"})
local movementSystem = ComponentSystem.createSystem(
"Movement",
{"Position", "Velocity"},
function(entity, dt)
local pos = entity:getComponent("Position")
local vel = entity:getComponent("Velocity")
pos.x = pos.x + vel.x * dt
pos.y = pos.y + vel.y * dt
end
)
ComponentSystem.addEntity(movementSystem, player)
ComponentSystem.update(movementSystem, 0.016) -- 60 FPS미래 전망과 발전 방향
루아 메타프로그래밍의 미래
루아 메타프로그래밍은 계속해서 발전하고 있습니다.
새로운 패러다임과 기법들이 등장하고 있으며, 다른 언어들과의 상호 운용성도 개선되고 있습니다.
-- 미래 지향적 패턴: 함수형 메타프로그래밍
local FunctionalMeta = {}
function FunctionalMeta.curry(func, arity)
arity = arity or 2
return function(...)
local args = {...}
if #args >= arity then
return func(unpack(args))
else
return function(...)
local newArgs = {}
for _, arg in ipairs(args) do
table.insert(newArgs, arg)
end
for _, arg in ipairs({...}) do
table.insert(newArgs, arg)
end
return FunctionalMeta.curry(func, arity)(unpack(newArgs))
end
end
end
end
function FunctionalMeta.compose(...)
local functions = {...}
return function(value)
for i = #functions, 1, -1 do
value = functions[i](value)
end
return value
end
end
-- 사용 예시
local add = FunctionalMeta.curry(function(a, b) return a + b end)
local multiply = FunctionalMeta.curry(function(a, b) return a * b end)
local addFive = add(5)
local multiplyByTwo = multiply(2)
local composed = FunctionalMeta.compose(multiplyByTwo, addFive)
print(composed(10)) -- (10 + 5) * 2 = 30다른 언어와의 비교
루아 메타프로그래밍을 다른 언어들과 비교해보겠습니다.
| 언어 | 메타프로그래밍 방식 | 장점 | 단점 |
|---|---|---|---|
| 루아 | 메타테이블, 동적 코드 생성 | 간단하고 직관적 | 타입 안정성 부족 |
| 파이썬 | 데코레이터, 메타클래스 | 풍부한 라이브러리 | 복잡성 증가 |
| 자바스크립트 | 프로토타입, 프록시 | 웹 호환성 | 브라우저 의존성 |
| 리스프 | 매크로 | 강력한 매크로 시스템 | 학습 곡선 가파름 |
마치며
루아 메타프로그래밍은 코드의 표현력과 재사용성을 크게 향상시킬 수 있는 강력한 도구입니다.
메타테이블 고급 기법부터 DSL 구축, 코드 생성까지 다양한 기법들을 살펴보았습니다.
하지만 메타프로그래밍은 양날의 검과 같습니다.
적절히 사용하면 코드의 품질을 크게 향상시킬 수 있지만, 과도하게 사용하면 복잡성이 증가하고 유지보수가 어려워질 수 있습니다.
따라서 메타프로그래밍을 사용할 때는 항상 다음과 같은 원칙을 염두에 두어야 합니다:
- 명확성: 코드가 무엇을 하는지 명확해야 합니다
- 단순성: 복잡한 메타프로그래밍보다는 단순한 해결책을 선호합니다
- 테스트 가능성: 메타프로그래밍 코드도 충분히 테스트되어야 합니다
- 문서화: 메타프로그래밍 코드는 특히 잘 문서화되어야 합니다
다음 글에서는 더욱 고급 주제들을 다루어보겠습니다.
참고 자료
이전 글: 루아 입문 시리즈 #15: 루아 테스팅과 CI/CD
루아 입문 시리즈 #15: 루아 테스팅과 CI/CD
루아 개발 프로젝트의 품질을 보장하고 자동화된 배포 환경을 구축하기 위한 단위 테스트, 통합 테스트, CI/CD 파이프라인 구축 방법을 상세히 알아보겠습니다.루아 테스팅 개요루아 프로젝트의
notavoid.tistory.com
728x90
반응형