在Kotlin中使用DSL

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(href = "http://kotlinlang.org") {+"Kotlin"}
            // mixed content
            p {
                +"This is some"
                b {+"mixed"}
                +"text. For more see the"
                a(href = "http://kotlinlang.org") {+"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
    }
}