루아 입문 시리즈 #16: 루아 메타프로그래밍

루아 메타프로그래밍 입문 가이드 썸네일

 

루아 메타프로그래밍의 메타테이블 고급 기법부터 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을 만들 수 있습니다.

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("<", "&lt;")
            s = s:gsub(">", "&gt;")
            s = s:gsub('"', "&quot;")
            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

게임 개발에서의 메타프로그래밍

728x90

게임 개발에서 메타프로그래밍을 활용하는 예시를 살펴보겠습니다.

-- 게임 엔티티 시스템
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 구축, 코드 생성까지 다양한 기법들을 살펴보았습니다.

하지만 메타프로그래밍은 양날의 검과 같습니다.

적절히 사용하면 코드의 품질을 크게 향상시킬 수 있지만, 과도하게 사용하면 복잡성이 증가하고 유지보수가 어려워질 수 있습니다.

따라서 메타프로그래밍을 사용할 때는 항상 다음과 같은 원칙을 염두에 두어야 합니다:

1. 명확성: 코드가 무엇을 하는지 명확해야 합니다
2. 단순성: 복잡한 메타프로그래밍보다는 단순한 해결책을 선호합니다
3. 테스트 가능성: 메타프로그래밍 코드도 충분히 테스트되어야 합니다
4. 문서화: 메타프로그래밍 코드는 특히 잘 문서화되어야 합니다

다음 글에서는 더욱 고급 주제들을 다루어보겠습니다.

---

참고 자료

• 루아 공식 메뉴얼
• Programming in Lua
• 루아 위키
• OpenResty 문서

이전 글: 루아 입문 시리즈 #15: 루아 테스팅과 CI/CD

루아 입문 시리즈 #15: 루아 테스팅과 CI/CD