1 DSL(domain-specific language)

1.1 DSL的定義

DSL被定義為處理特定領域問題而定義的計算機語言, 與其相對的是GPL(general-purpose language). 通常使用的C/C++, Java, Python都是GPL, 而像make, Gradle, 正則表達式都是DSL. DSL通常被分為內部DSL和外部DSL. 外部DSL是指獨立于其他語言的, 獨立實現編譯(或解釋)的領域專用語言; 而內部DSL通常是在其他語言的內部, 利用宿主語言的語法特性而實現的. gradle是內部DSL, 因為其是基于Groovy語言實現的, 而正則表達式是外部DSL, 因為其解釋是(基本)不依賴宿主語言的.

1.2 DSL的優勢

DSL為簡化問題提供了便捷的途徑. Gradle使用Groovy語言來做項目配置, 可擴展性大大增強, 能夠在配置中完成定義和動作兩方面的內容, 這些在基于XML的配置中是難以實現的. 事實上, 很多配置管理類的項目都完成了類似的事情. 在Web前端領域, 諸如gulp的打包工具, 依托Node.js也實現了配置的可執行性. 而宿主語言的DSL能力通常會讓這一思想更優雅地表現出來.

2 Kotlin語言中DSL的基礎

2.1 中綴記法

當一個函數滿足下列條件的時候, 能夠以中綴記法調用:

• 是成員函數或者擴展函數
• 有且僅有一個參數
• 使用infix關鍵字修飾

一個典型的中綴記法調用如下:

// Define extension to Int
infix fun Int.shl(x: Int): Int {
...
}
// call extension function using infix notation
1 shl 2
// is the same as
1.shl(2)

2.2 作為參數的函數

在Kotlin中, 實現了函數是一等公民的思想, 這是函數式編程語言的基本概念. 同時, Kotlin采用了類型推導的方式來標記函數的類型, 這和Haskell一類的語言是類似的. 相比于Java和C#語言中強類型的函數表達式類型, 這種類型推導的記法更加的清晰; 相比Python等弱類型語言, 類型推導能夠讓解釋器做更多的優化, 提供了更高的性能.
Kotlin也提供了一個相當有趣的語法, 如果函數調用的最后一個參數是函數, 那么該參數能夠夠寫到函數調用的外部:

// 寫在外部的lambda表達式, 通常這種調用是為了傳入一個回調函數
foo(1, "something") { it ->
    do_something(it)
}

再考慮Kotlin的另外一個特性, 僅有一個參數的lambda表達式的參數可以省略不寫, 那么代碼會更加的簡潔:

// lambda表達式中的it, 會被解釋為該lambda表達式的參數
foo(1, "something") {
    do_something(it)
}

2.3 擴展函數, function type with receiver

這是一種特殊的函數類型, 語法為T.() -> K, 代指執行T類型的成員方法, 返回K類型的值. 舉一個簡單的例子:

class Person {
    fun setName(name: String) { ... }
    fun setAge(age: Int) { ... }
}

fun person(foo: Person.() -> Unit): Person {
    val person = Person()
    html.foo()
    return p
}

var jack = person {
    this.setName("Jack")
    this.setAge(20)
}
// this 是可以忽略的
var bruce = person {
    setName("Bruce")
    setAge(21)
}

在調用傳入的函數時, 需要提供一個T類型的實例, 在執行完所有傳入的函數后, 返回該T類型的實例. 這種語法為Kotlin帶來了較強的DSL能力.

3 Type-Safe Builders

3.1 簡介

Builders是Groovy社區比較火的概念. Builders允許使用半聲明(semi-declarative)的方法定義數據, 這種方式十分適合用于XML的生成, UI組件的布局.
Kotlin可以為BUilder是提供類型檢查, 也支持動態類型的Builders.

一個簡單的Type-Safe Builder的示例(來自官方文檔):

fun result(args: Array<String>) =
    html {
        head {
            title {+"XML encoding with Kotlin"}
        }
        body {
            h1 {+"XML encoding with Kotlin"}
            p {+"this format can be used as an alternative markup to XML"}
            // an element with attributes and text content
            a() {+"Kotlin"}
            // mixed content
            p {
                +"This is some"
                b {+"mixed"}
                +"text. For more see the"
                a() {+"Kotlin"}
                +"project"
            }
            p {+"some text"}
            // content generated by
            p {
                for (arg in args)
                    +arg
            }
        }
    }

這個Builder可用于生成一段HTML文檔.

3.2 具體實現

本節以上述XML Builder說明建立Builder的一般方法.

通過2.3節的例子, 可以使用lambda表達式來表達層級關系和子節點:

fun html(init: HTML.() -> Unit): HTML {
    val html = HTML()
    html.init()
    return html
}

在HTML類中實現head, body成員方法, 將能夠實現html級別文檔的構造; 而head和body也可以用類似的方法去添加子元素. 為了實現添加子元素的功能, 定義一個通用函數:

protected fun <T : Element> initTag(tag: T, init: T.() -> Unit): T {
    tag.init()
    children.add(tag)
    return tag
}

此時, 可以很方便地實現head和body, 如下所示, 其中Head和Body是對應的類.

fun head(init: Head.() -> Unit) = initTag(Head(), init)
fun body(init: Body.() -> Unit) = initTag(Body(), init)

至此, 已經能夠處理所有的元素節點, 對于文本節點, 需要特別地對待. 示例代碼中, 使用+完成了文本到函數調用的轉換(花括號是lambda表達式, 其中的內容為函數調用, 只有通過函數調用并用某種方法接受該文本, 文本才能被添加到Builder中). 這個+是Kotlin中String類的一個前綴操作符unaryPlus, 其實現如下:

fun String.unaryPlus() {
    children.add(TextElement(this))
}

而帶屬性的節點需要額外的參數傳入屬性信息, 例如對于錨點節點, 可以如下實現:

fun a(href: String, init: A.() -> Unit) {
    val a = initTag(A(), init)
    a.href = href
}

至此, 一個樸素的XML生成器已經完成. 完整的代碼, 可以參考Kotlin 官網

4 DSL的應用

4.1 when語法的改良實現

此節內容來自知乎專欄 - Kotlin雜談(二) - 以DSL重新打造when

Kotlin使用when關鍵字代替了通常語言里的switch關鍵字, 并且提供了更強的特性. 但是其仍無法實現類似SQL中case表達式的模式, 即:

when {
    1 > 5 -> print("something") // OK
}
    
when (1) {
    > 5 -> print("something") // Error
}

問題的關鍵是在when(arg)表達式的內部, 無法引用arg. 可以通過類似3節中的構造方法來構造DSL解決這個問題, 判斷條件的結果作為判斷條件回調函數是否執行的依據.

fun <T: Comparable<T>> ewhen(target: T, tester: Tester<T>.() -> Unit) {
    val test = Tester(target)
    test.tester()
    test.funFiltered?.invoke() ?: return
}

tester是when下的一系列判斷, 根據執行tester的結果來可以選擇要執行的回調, 即funFiltered.

Tester類的實現: 原作者的代碼

class Tester<T: Comparable<T>>(val it: T) {
    var funFiltered: (() -> Unit)? = null

    infix fun Boolean.then(block: () -> Unit) {
        if (this && funFiltered == null)
            funFiltered = block
    }

    fun lt(arg: T) = it < arg
    fun gt(arg: T) = it > arg
    fun ge(arg: T) = it >= arg
    fun le(arg: T) = it <= arg
    fun eq(arg: T) = it == arg
    fun ne(arg: T) = it != arg
    fun ct(arg: Collection<T>) = it in arg
    fun ct(arg: String) = it as String in arg
    fun nc(arg: Collection<T>) = it !in arg
    fun nc(arg: String) = it as String !in arg
}

在Tester中, 如果保存一個funFiltered的列表, 將能夠實現瀑布式switch的效果.

4.2 一些賞心悅目的基于DSL的庫

本節來自知乎專欄 - Kotlin 一個很厲害的 DSL 寫法

4.2.1 Anko

Anko是Kotlin用于安卓界面布局的框架, 使用DSL的方式代替了Activity的XML配置.

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    verticalLayout {
        padding = dip(30)
        editText {
            hint = "Name"
            textSize = 24f
        }
        editText {
            hint = "Password"
            textSize = 24f
        }
        button("Login") {
            textSize = 26f
        }
    }
}

4.2.2 JavaFX DSL

class MyView : View() {
    private val persons = FXCollections.observableArrayList(
        Person(1, "Samantha Stuart", LocalDate.of(1981, 12, 4)),
        Person(2, "Tom Marks", LocalDate.of(2001, 1, 23)),
        Person(3, "Stuart Gills", LocalDate.of(1989, 5, 23)),
        Person(3, "Nicole Williams", LocalDate.of(1998, 8, 11))
    )
    override val root = tableview(persons) {
        column("ID", Person::id)
        column("Name", Person::name)
        column("Birthday", Person::birthday)
        column("Age", Person::age)
        columnResizePolicy = SmartResize.POLICY
    }
}