Inline-функции

noinline

Если вы не хотите, чтобы все лямбда-выражения, переданные inline-функции, встраивались, пометьте некоторые параметры функции модификатором noinline:

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

Встраиваемые лямбда-выражения можно вызывать только внутри inline-функций или передавать в качестве встраиваемых аргументов. С лямбда-выражениями noinline, однако, можно делать всё что угодно, в том числе сохранять их в полях или передавать дальше.

Нелокальные выражения перехода

fun ordinaryFunction(block: () -> Unit) {
    println("hi!")
}
//sampleStart
fun foo() {
    ordinaryFunction {
        return // ERROR: cannot make `foo` return here
    }
}
//sampleEnd
fun main() {
    foo()
}

inline fun inlined(block: () -> Unit) {
    println("hi!")
}
//sampleStart
fun foo() {
    inlined {
        return // OK: the lambda is inlined
    }
}
//sampleEnd
fun main() {
    foo()
}

fun hasZeros(ints: List<Int>): Boolean {
    ints.forEach {
        if (it == 0) return true // returns from hasZeros
    }
    return false
}

inline fun f(crossinline body: () -> Unit) {
    val f = object: Runnable {
        override fun run() = body()
    }
    // ...
}

fun processList(elements: List<Int>): Boolean {
    for (element in elements) {
        val variable = element.nullableMethod() ?: run {
            log.warning("Element is null or invalid, continuing...")
            continue
        }
        if (variable == 0) return true
    }
    return false
}

Параметры типа с reified

Иногда требуется получить доступ к типу, переданному в качестве параметра:

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?
}

Здесь вы поднимаетесь по дереву и используете рефлексию, чтобы проверить, имеет ли узел определённый тип. Всё хорошо, но место вызова выглядит не очень изящно:

treeNode.findParentOfType(MyTreeNode::class.java)

Лучше было бы просто передать тип этой функции. Её можно вызвать следующим образом:

treeNode.findParentOfType<MyTreeNode>()

Для этого inline-функции поддерживают параметры типа с reified, поэтому можно написать что-то вроде этого:

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>().

Хотя во многих случаях рефлексия может не понадобиться, её всё же можно использовать с параметром типа с reified:

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

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

Обычные функции (не помеченные как inline) не могут иметь параметры с reified. Тип, не имеющий представления во время выполнения (например, параметр типа без reified или фиктивный тип, такой как Nothing), нельзя использовать в качестве аргумента для параметра типа с reified.

Inline-свойства

Модификатор inline можно использовать для методов доступа к свойствам, у которых нет полей хранения. Можно аннотировать отдельные методы доступа к свойствам:

val foo: Foo
    inline get() = Foo()

var bar: Bar
    get() = ...
    inline set(v) { ... }

Можно также аннотировать свойство целиком, пометив оба его метода доступа как inline:

inline var bar: Bar
    get() = ...
    set(v) { ... }

В месте вызова встроенные методы доступа встраиваются так же, как обычные inline-функции.

Ограничения для inline-функций публичного API

Если inline-функция имеет модификатор public или protected, но не является частью объявления private или internal, она считается частью публичного API модуля. Её можно вызывать из других модулей, и в таких местах вызова она также встраивается.

Это создаёт определённый риск бинарной несовместимости: если модуль, объявляющий inline-функцию, изменится, а вызывающий модуль после этого изменения не будет перекомпилирован.

Чтобы исключить риск такой несовместимости, возникающей из-за изменения непубличного API модуля, inline-функциям публичного API запрещено использовать в телах объявления, не входящие в публичный API, то есть объявления private и internal и их части.

Объявление internal можно аннотировать с помощью @PublishedApi, что позволяет использовать его в inline-функциях публичного API. Если inline-функция internal помечена как @PublishedApi, её тело также проверяется, как если бы оно было публичным.