はじめに

Kotlin の最大の強みの一つが DSL（Domain Specific Language） を簡潔に構築できることです。

本記事では、「受容者付き関数型（Function Type with Receiver）」を核に、
Gradle や Jetpack Compose のような宣言的・型安全なDSLを自作する方法を紹介します。

1. DSLとは何か

DSL（Domain Specific Language） とは、
特定のドメインや用途に特化した小さな言語です。

Kotlin は柔軟な関数型構文を持ち、
「宣言的・可読性の高い構文」を自然に表現できるため、
Gradle や kotlinx.html、Jetpack Compose のような DSL 実装に最適です。

例：Gradle 風の宣言

dependencies {
    implementation("org.jetbrains.kotlin:kotlin-stdlib")
}

2. 受容者付き関数型（Function Type with Receiver）

Kotlin DSLの根幹をなすのが「受容者付き関数型」です。

class Robot {
    fun forward(step: Int) = println("→ $step")
    fun turnRight() = println("↱ turn right")
}

fun robot(block: Robot.() -> Unit): Robot {
    return Robot().apply(block)
}

fun main() {
    robot {
        forward(3)
        turnRight()
        forward(1)
    }
}

Robot.() -> Unit は「Robot をレシーバに持つラムダ」。
block の中では this が暗黙的に Robot となり、
ドメイン語彙だけで表現できる。

3. `@DslMarker` によるスコープ衝突防止

複数のビルダーをネストすると、外側・内側のプロパティが混ざる危険があります。
これを防ぐために @DslMarker アノテーションを付与します。

@DslMarker
annotation class UiDsl

@UiDsl
class ScreenBuilder {
    var title = ""
    fun button(label: String) = println("button: $label")
}

@UiDsl
class AppBuilder {
    fun screen(block: ScreenBuilder.() -> Unit) {
        ScreenBuilder().apply(block)
    }
}

fun app(block: AppBuilder.() -> Unit) = AppBuilder().apply(block)

fun main() {
    app {
        screen {
            title = "Home"
            button("Start")
            // title = "Oops" ← 外のスコープのtitleを参照できない（安全！）
        }
    }
}

@DslMarker を付けると、同一DSL階層での
「スコープ混在（shadowing）」を防止でき、補完も安全に。

4. Kotlin 2.0 以降の context receiver

Kotlin 2.x では、複数レシーバを自然に扱える context receiver が導入されました。

例：DBセッションとトランザクションを同時スコープに持つ DSL

class DbSession { fun query(sql: String) = println("run: $sql") }
class Tx { fun commit() = println("commit") }

context(DbSession, Tx)
fun selectOne(sql: String) {
    query(sql)
    commit()
}

fun <R> withDb(block: context(DbSession, Tx) () -> R): R {
    val db = DbSession()
    val tx = Tx()
    return with(db, tx) { block(db, tx) }
}

fun main() {
    withDb {
        selectOne("SELECT * FROM users")
    }
}

context により：

両方の API (DbSession, Tx) に補完アクセス可能
型安全かつネスト不要

5. ビルダーパターンとの融合（典型構造）

DSL の多くは「Builder + apply + build()」構造で設計されます。

data class Button(val label: String)
data class Screen(val title: String, val buttons: List<Button>)

@DslMarker
annotation class ScreenDsl

@ScreenDsl
class ScreenBuilder {
    var title: String = "Untitled"
    private val buttons = mutableListOf<Button>()

    fun button(label: String) { buttons += Button(label) }
    fun build(): Screen = Screen(title, buttons)
}

fun screen(block: ScreenBuilder.() -> Unit): Screen =
    ScreenBuilder().apply(block).build()

fun main() {
    val s = screen {
        title = "Dashboard"
        button("OK")
        button("Cancel")
    }
    println(s)
}

出力：

Screen(title=Dashboard, buttons=[Button(label=OK), Button(label=Cancel)])

build() で不変化し、
DSL は可読性と再利用性の両立が可能になります。

6. operator / infix による構文糖衣

受容者付き関数型を operator と組み合わせると、
より自然言語的な構文にできます。

@JvmInline
value class Col(val name: String)

class Where {
    private val conds = mutableListOf<String>()
    infix fun Col.eq(value: Any) { conds += "$name = '$value'" }
    infix fun Col.gt(value: Any) { conds += "$name > '$value'" }
    fun build() = conds.joinToString(" AND ")
}

fun where(block: Where.() -> Unit): String =
    Where().apply(block).build()

fun main() {
    val cond = where {
        Col("age") gt 18
        Col("name") eq "Anna"
    }
    println(cond)
}

出力：

age > '18' AND name = 'Anna'

infix と @JvmInline による表現力強化は、SQL や HTML DSL に最適。

7. 設計パターンとベストプラクティス

パターン	概要
Type-safe builder	不変モデルを安全に構築（Gradle, kotlinx.html）
Scoped DSL	`@DslMarker` でスコープ境界を明確化
Functional Composition	`apply`, `run`, `also` で関数合成
Immutable Build Result	`build()` で確定モデルを返す
Context receiver	複数の文脈を安全に共有
Extension-based Expansion	`fun Builder.chart { ... }` で拡張可能

DSL は「読めるコード」こそ最優先。
過度な operator やネストは可読性を損なうため、
宣言的・直感的にすることが最重要。

まとめ

要素	キー概念
設計基盤	`T.() -> R`（受容者付き関数型）
安全性	`@DslMarker`
柔軟性	`context receiver`（Kotlin 2.x）
拡張性	`operator`, `infix`, `extension function`
不変性	`build()` パターン

Kotlin DSL は「構文を設計する」という、
APIデザインの最前線にある技術です。
GradleやComposeのように、
ドメイン知識をそのままコードに落とし込むための表現力が得られます。