Встроенные функции

noinline

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

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

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

Нелокальные возвраты

В Kotlin вы можете использовать только обычный, неквалифицированный return для выхода из именованной функции или анонимной функции. Чтобы выйти из лямбда-выражения, используйте метку. Голый return запрещён внутри лямбда-выражения, потому что лямбда-выражение не может сделать окружающую функцию return.

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
}

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

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

Параметры типа с реификацией

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

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 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"))
}

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

Встроенные свойства

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

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

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

Вы также можете аннотировать всё свойство, что пометит оба его аксессора как inline:

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

В месте вызова встроенные аксессоры встраиваются как обычные встроенные функции.

Ограничения для встроенных функций публичного API

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

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

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

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