Kotlin语法（十九）-内联函数（Inline Functions）

         参考原文： http://kotlinlang.org/docs/reference/inline-functions.html
 

         使用高阶函数造成一些运行时问题：每一个函数都是一个对象，它会持有一个闭包；即在函数体中可以访问这些变量。内存分配（包括函数对象和类）及虚拟调用都会作为运行开销。

         通过内联Lambda表达式方式，可以减少这种开销。如“lock()”函数，可以容易使用在使用位置内联相关函数，考虑下面使用方式：

fun <T> lock(lock: Lock, body: () -> T): T {
lock.lock()
try {
return body()
}
finally {
lock.unlock()
}
}

//
lock(l) { foo() }

         

        这种使用方式，会创建一个函数对象作为参数并使用它，编译器会生成下面的代码：
l.lock()
try {
foo()
}
finally {
l.unlock()
}

 

         内联函数，需要在函数前面使用“

inline

”修饰：
inline fun lock<T>(lock: Lock, body: () -> T): T {
// ...
}

         

         使用“

inline

”会影响函数本身及传入的Lambda表达式参数，它们都会嵌入到它们的调用位置。

         内联方式会增加生成的代码，需要合理的使用它（不要内联一个复杂功能的大函数），可以提高性能，尤其在循环中。

 

     非内联（noinline）

         有时，只需要将内联函数的部分参数使用内联Lambda，其他的参数不需要内联，可以使用“

noinline

”关键字修饰：

inline fun foo(inlined: () -> Unit, noinline notInlined: () -> Unit) {
// ...
}

 

         内联Lamdbd表达式（Inlinable lambdas）只能在内联函数中或作为内联函数的参数，而非内联表达式在所有中操作，如储存到字段，传递等。

        

         注：若一个内联函数没有任何的内联参数，并且也没有具体化类型参数（reified type parameters），编译器会抛出一个警告，提示内联函数没有实际意义（若认为内联定义时又必要的，也可以忽略该警告）。

 

     非局部返回（Non-local returns）

         在kotlin中，使用一个默认的无限制的“return”，会返回对应的函数或匿名函数。若需要返回一个Lambda，需要使用标签；由于Lambda不能直接返回一个封闭的函数，在Lambda中不允许直接使用单独的return。
fun foo() {
ordinaryFunction { //普通函数
return // ERROR: can not make `foo` return here
}
}

 

         但是，若函数表达式是内联的，“return”是可以直接使用的：

fun foo() {
inlineFunction {
return // OK: the lambda is inlined
}
}

 

         这类返回（位于Lambda中，但退出的是外层的封闭函数）称之为非局部返回（non-local returns）。如：
fun hasZeros(ints: List<Int>): Boolean {
ints.forEach {
if (it == 0) return true // returns from hasZeros
}
return false
}

 

         注：一些内联函数，不是直接在函数体中使用lambda参数，而是通过其他执行上下文，如具体对象或嵌套函数等。这种情况下，不能在Lambda中使用非局部返回。为了表明该种情况，可以在参数前使用“

crossinline

”关键字修饰标识。
inline fun f(crossinline body: () -> Unit) {
val f = object: Runnable {
override fun run() = body()
}
// ...
}

         “break”和“continue”还不能再内联Lambd中使用；但在考虑支持他们。

 

     具体化类型参数（Reified type parameters）

         有时候，需要使用一个类型作为参数，如：
fun <T> TreeNode.findParentOfType(clazz: Class<T>): T? {
var p = parent
while (p != null && !clazz.isInstance(p)) {
p = p?.parent
}
@Suppress("UNCHECKED_CAST")
return p as T
}

 

         如，假设爬上一颗“tree”，使用反射去检测一个节点是否是某类型。下面方式可以实现，但不是最优方式：
myTree.findParentOfType(MyTreeNodeType::class.java)
 

         实际上，只需要将一个类型传递给该函数；如像这种方式：
myTree.findParentOfType<MyTreeNodeType>()         为了支持这种方式，内联函数支持具体化类型参数（reified type parameters），实现方式：
inline fun <reified T> TreeNode.findParentOfType(): T? {
var p = parent
while (p != null && p !is T) {
p = p?.parent
}
return p as T
}

 

         类型参数使用“reified”关键字修饰，就可以在函数体中访问，其他基本跟一般的类一样。若函数为内联函数，不再需要反射方式，如“！is”，“as”操作符都可以使用。可以使用下面方式使用：

myTree.findParentOfType<MyTreeNodeType>()

 

         尽管反射在很多情况下不需要，但还是可以在具体化类型参数上使用它。

inline fun <reified T> membersOf() = T::class.members

fun main(s: Array<String>) {
println(membersOf<StringBuilder>().joinToString("\n"))
}

 

         注：普通函数（非内联函数），不能包含具体化类型参数；若一个类型没有运行时表示（run-time representation）（如非具体化类型参数（non-reified type parameter）或虚拟类型，比如“Nothing”）不能作为一个具体化类型参数的实参。