DSL과 Kotlin

Posted Sep 5, 2025

By Hye Jin Ryoo

12 min read

DSL과 Kotlin

DSL (Domain Specific Language)과 Kotlin: 도메인에 특화된 언어의 가능성

DSL(Domain Specific Language)은 특정 도메인(영역)에 특화되어 설계된 컴퓨터 언어입니다. 일반적인 목적의 프로그래밍 언어(General Purpose Language, GPL)와 달리, DSL은 특정 문제 해결이나 특정 작업 수행에 최적화되어 있어 해당 도메인의 전문가가 더 쉽고 효율적으로 코드를 이해하고 작성할 수 있도록 돕습니다. Kotlin은 이러한 DSL을 만들기에 매우 적합한 언어로 평가받고 있습니다.

1. DSL이란 무엇인가?

DSL은 크게 두 가지 형태로 나눌 수 있습니다.

외부 DSL (External DSL): 완전히 독립적인 문법과 파서를 가진 언어입니다. SQL, HTML, CSS, 정규표현식 등이 대표적인 예시입니다. 특정 도구 없이 독자적으로 해석되고 실행될 수 있습니다.
내부 DSL (Internal DSL): 기존의 일반적인 목적의 프로그래밍 언어의 문법을 활용하여 특정 도메인의 코드를 작성하는 방식입니다. 마치 새로운 언어처럼 보이지만, 실제로는 호스트 언어(여기서는 Kotlin)의 문법적 유연성을 통해 만들어진 코드 블록입니다. Gradle의 Groovy DSL, JUnit 5의 Kotlin DSL 등이 여기에 해당합니다.

Kotlin은 특히 내부 DSL을 구축하는 데 강력한 이점을 제공합니다.

2. Kotlin이 DSL 작성에 유리한 이유

Kotlin은 여러 언어 기능을 통해 간결하고 가독성 높은 내부 DSL을 만들 수 있도록 지원합니다.

확장 함수 (Extension Functions): 기존 클래스에 새로운 메서드를 추가하는 것처럼 동작하여, 객체의 문맥 내에서 도메인 관련 함수를 자연스럽게 호출할 수 있도록 합니다.
고차 함수 (Higher-Order Functions) 및 람다 (Lambdas): 함수를 인자로 받거나 함수를 반환할 수 있는 기능은 클로저(closure)와 함께 특정 코드 블록을 구성하는 데 유용합니다. 특히 “Trailing Lambda” 문법은 람다가 함수의 마지막 인자일 때 괄호 밖으로 빼낼 수 있어 더욱 자연스러운 문법을 만듭니다.
infix 함수: 두 개의 인자 사이에 함수 이름을 배치하여 a doSomething b와 같은 형태로 호출할 수 있게 합니다. 이는 특정 연산자처럼 보이게 하여 가독성을 높입니다.
타입 안전 빌더 (Type-Safe Builders): 람다 수신자(lambda with receiver)를 활용하여 특정 객체의 문맥 안에서만 유효한 함수 호출을 가능하게 합니다. 이는 빌더 패턴을 구현할 때 특히 강력하며, 자동 완성 및 컴파일 타임 검사를 통해 오타나 잘못된 사용을 방지합니다.

3. 간단한 DSL 예시: HTML 생성기

Kotlin의 DSL 작성 능력을 이해하기 위해 간단한 HTML 생성 DSL을 만들어 보겠습니다. 목표는 다음과 같은 Kotlin 코드가 HTML을 생성하도록 하는 것입니다.

  
html {
    head {
        title("My Page")
    }
    body {
        h1("Welcome to my site!")
        p {
            +"This is a paragraph. "
            a("https://kotlinlang.org") { +"Kotlin Official Site" }
        }
    }
}

이 코드가 최종적으로 다음과 같은 HTML을 출력하도록 만들 것입니다.

  
<html>
    <head>
        <title>My Page</title>
    </head>
    <body>
        <h1>Welcome to my site!</h1>
        <p>This is a paragraph. <a href="https://kotlinlang.org">Kotlin Official Site</a></p>
    </body>
</html>

` `

3.1. 기본 요소 정의

HTML 태그를 표현할 추상 클래스와 몇 가지 구체적인 태그 클래스를 정의합니다.

  
// 모든 HTML 요소를 대표하는 인터페이스
interface HtmlElement {
    fun render(builder: StringBuilder, indent: String)
}

// 텍스트 노드
class TextElement(val text: String) : HtmlElement {
    override fun render(builder: StringBuilder, indent: String) {
        builder.append(indent).append(text).append("\n")
    }
}

// 자식 요소를 가질 수 있는 태그의 추상 클래스
abstract class Tag(val name: String) : HtmlElement {
    val children = mutableListOf<HtmlElement>()
    val attributes = mutableMapOf<String, String>()

    protected fun <T : HtmlElement> doInit(element: T, init: T.() -> Unit): T {
        element.init()
        children.add(element)
        return element
    }

    override fun render(builder: StringBuilder, indent: String) {
        builder.append(indent).append("<$name")
        attributes.forEach { (key, value) ->
            builder.append(" $key=\"$value\"")
        }
        builder.append(">\n")
        children.forEach { it.render(builder, "$indent  ") }
        builder.append(indent).append("</$name>\n")
    }

    // 텍스트를 추가하는 단항 연산자 오버로딩 (DSL 가독성 향상)
    operator fun String.unaryPlus() {
        children.add(TextElement(this))
    }
}

// 특정 태그 클래스들
class Html : Tag("html") {
    fun head(init: Head.() -> Unit) = doInit(Head(), init)
    fun body(init: Body.() -> Unit) = doInit(Body(), init)
}

class Head : Tag("head") {
    fun title(text: String) = doInit(Title(text)) {}
}

class Body : Tag("body") {
    fun h1(text: String) = doInit(H1(text)) {}
    fun p(init: P.() -> Unit) = doInit(P(), init)
    fun a(href: String, init: A.() -> Unit) = doInit(A(href), init)
}

class Title(text: String) : Tag("title") {
    init { +"$text" } // 텍스트를 직접 추가
    override fun render(builder: StringBuilder, indent: String) {
        // 자식 요소만 렌더링하도록 오버라이드
        builder.append(indent).append("<$name>")
        children.forEach { it.render(builder, "") } // 들여쓰기 없이 바로 출력
        builder.append("</$name>\n")
    }
}

class H1(text: String) : Tag("h1") {
    init { +"$text" }
}

class P : Tag("p")
class A(href: String) : Tag("a") {
    init {
        attributes["href"] = href
    }
}

3.2. DSL 엔트리 포인트 및 헬퍼 함수

이제 이 요소들을 조합하여 HTML을 생성할 수 있는 최상위 함수를 정의합니다.

  
// HTML DSL의 시작점
fun html(init: Html.() -> Unit): Html {
    val html = Html()
    html.init() // 람다 수신자를 통해 Html 객체 문맥 안에서 init 블록 실행
    return html
}

fun main() {
    val myHtml = html {
        head {
            title("My Page")
        }
        body {
            h1("Welcome to my site!")
            p {
                +"This is a paragraph. " // 단항 + 연산자 오버로딩 활용
                a("https://kotlinlang.org") { +"Kotlin Official Site" }
            }
        }
    }

    val stringBuilder = StringBuilder()
    myHtml.render(stringBuilder, "")
    println(stringBuilder.toString())
}

` ` 위 예시에서 html { ... }, head { ... }, body { ... } 등은 모두 람다 수신자(lambda with receiver)를 사용하여 특정 객체(Html, Head, Body 등)의 인스턴스에 대한 확장 함수처럼 작동합니다. 이로 인해 {} 블록 내에서 해당 객체의 멤버 함수나 프로퍼티를 마치 자신의 것처럼 호출할 수 있게 됩니다. String.unaryPlus() 확장 함수 오버로딩은 +"Text"와 같이 텍스트 노드를 추가하는 간결한 문법을 가능하게 합니다.

4. DSL의 장점과 고려사항

4.1. 장점

가독성 및 명확성: 도메인 전문가도 이해하기 쉬운 자연스러운 문법으로 코드를 작성할 수 있습니다.
생산성 향상: 특정 도메인의 반복적인 작업을 간결하게 표현할 수 있어 개발 속도가 향상됩니다.
유지보수 용이성: 도메인 지식이 코드에 직접 반영되므로 변경 사항이 발생했을 때 영향을 받는 부분을 파악하기 쉽습니다.
타입 안전성: Kotlin의 내부 DSL은 컴파일 타임에 타입 검사를 수행하므로, 외부 DSL보다 오류를 조기에 발견할 수 있습니다.

4.2. 고려사항

학습 곡선: DSL을 사용하는 사용자뿐만 아니라 DSL 자체를 설계하고 구현하는 개발자에게도 Kotlin의 고급 기능에 대한 이해가 요구됩니다.
과도한 사용 방지: 모든 상황에 DSL이 필요한 것은 아닙니다. 단순한 로직에는 일반적인 함수 호출이 더 명확할 수 있습니다.
디버깅의 복잡성: 내부 DSL은 결국 호스트 언어의 코드로 컴파일되므로, 문제가 발생했을 때 스택 트레이스를 이해하기 어려울 수 있습니다.
유지보수 비용: DSL 설계가 잘못되면 오히려 가독성을 해치고 유지보수를 어렵게 만들 수 있습니다.

결론

Kotlin은 확장 함수, 고차 함수, 람다 수신자 등 다양한 기능을 통해 강력하고 타입 안전한 내부 DSL을 구축할 수 있는 환경을 제공합니다. 이를 통해 특정 도메인의 문제를 더 간결하고 가독성 높게 표현할 수 있으며, 도메인 전문가와 개발자 간의 소통을 원활하게 돕는 효과적인 도구가 될 수 있습니다. 그러나 DSL의 설계와 구현에는 신중함이 요구되며, 그 활용 목적과 필요성을 명확히 인지하고 접근하는 것이 중요합니다.

일상, 공부, 언어

Develop Kotlin

This post is licensed under CC BY 4.0 by the author.