Функции высшего порядка и лямбда-выражения

Создание экземпляров типа функции

Существует несколько способов получения экземпляра типа функции:

• Используйте блок кода внутри лямбда-выражения в одном из следующих форматов:

  • a лямбда-выражение: { a, b -> a + b },

  • анонимная функция: fun(s: String): Int { return s.toIntOrNull() ?: 0 }

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

• Используйте ссылку на вызываемый объект существующего объявления:

  • глобальную, локальную, членскую или расширяющую функцию: ::isOdd, String::toInt,

  • глобальную, членскую или расширяющую свойство: List<Int>::size,

  • конструктор: ::Regex

  Это включает в себя связанные вызываемые ссылки, которые указывают на член конкретного экземпляра: foo::toString.

• Используйте экземпляры пользовательского класса, который реализует тип функции как интерфейс:

class IntTransformer: (Int) -> Int {
    override operator fun invoke(x: Int): Int = TODO()
}

val intFunction: (Int) -> Int = IntTransformer()

Компилятор может вывести типы функций для переменных, если имеется достаточная информация:

val a = { i: Int -> i + 1 } // The inferred type is (Int) -> Int

Нелитеральные значения типов функций с и без получателя взаимозаменяемы, поэтому получатель может выступать в качестве первого параметра, и наоборот. Например, значение типа (A, B) -> C может передаваться или присваиваться там, где ожидается значение типа A.(B) -> C, и наоборот:

fun main() {
    //sampleStart
    val repeatFun: String.(Int) -> String = { times -> this.repeat(times) }
    val twoParameters: (String, Int) -> String = repeatFun // OK
    
    fun runTransformation(f: (String, Int) -> String): String {
        return f("hello", 3)
    }
    val result = runTransformation(repeatFun) // OK
    //sampleEnd
    println("result = $result")
}

Вызов экземпляра типа функции

Значение типа функции может быть вызвано с помощью invoke(...) оператора: f.invoke(x) или просто f(x).

Если значение имеет тип получателя, объект получателя должен передаваться в качестве первого аргумента. Другой способ вызвать значение типа функции с получателем — добавить объект получателя перед ним, как если бы это была расширяющая функция: 1.foo(2).

Пример:

fun main() {
    //sampleStart
    val stringPlus: (String, String) -> String = String::plus
    val intPlus: Int.(Int) -> Int = Int::plus
    
    println(stringPlus.invoke("<-", "->"))
    println(stringPlus("Hello, ", "world!"))
    
    println(intPlus.invoke(1, 1))
    println(intPlus(1, 2))
    println(2.intPlus(3)) // extension-like call
    //sampleEnd
}

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

Иногда целесообразно использовать встроенные функции, которые обеспечивают гибкий контроль потока, для функций высшего порядка.

Синтаксис лямбда-выражений

Полная синтаксическая форма лямбда-выражений следующая:

val sum: (Int, Int) -> Int = { x: Int, y: Int -> x + y }

• Лямбда-выражение всегда заключено в фигурные скобки.

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

• Тело следует за ->.

• Если выведенный тип возвращаемого значения лямбды не Unit, последнее (или возможно единственное) выражение внутри тела лямбды обрабатывается как возвращаемое значение.

Если вы опустите все необязательные аннотации, то останется следующее:

val sum = { x: Int, y: Int -> x + y }

Передача последующих лямбда-выражений

Согласно соглашению Kotlin, если последний параметр функции является функцией, то лямбда-выражение, передаваемое в качестве соответствующего аргумента, может быть размещено вне скобок:

val product = items.fold(1) { acc, e -> acc * e }

Такой синтаксис также известен как последующая лямбда.

Если лямбда является единственным аргументом в этом вызове, скобки можно полностью опустить:

run { println("...") }

it: неявное имя одного параметра

Очень часто лямбда-выражение имеет только один параметр.

Если компилятор может разобрать сигнатуру без каких-либо параметров, параметр не нужно объявлять, и -> можно опустить. Параметр будет неявно объявлен под именем it:

ints.filter { it > 0 } // this literal is of type '(it: Int) -> Boolean'

Возвращение значения из лямбда-выражения

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

Следовательно, два следующих фрагмента эквивалентны:

ints.filter {
    val shouldFilter = it > 0
    shouldFilter
}

ints.filter {
    val shouldFilter = it > 0
    return@filter shouldFilter
}

Это соглашение, наряду с передачей лямбда-выражения вне скобок, позволяет использовать синтаксис в стиле LINQ:

strings.filter { it.length == 5 }.sortedBy { it }.map { it.uppercase() }

Подчеркивание для неиспользуемых переменных

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

map.forEach { (_, value) -> println("$value!") }

Деструктуризация в лямбда-выражениях

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

Анонимные функции

Синтаксис лямбда-выражений выше опускает один момент — возможность указать тип возвращаемого значения функции. В большинстве случаев это не нужно, так как тип возвращаемого значения может быть выведен автоматически. Однако, если вам нужно его явно указать, вы можете использовать альтернативный синтаксис: анонимную функцию.

fun(x: Int, y: Int): Int = x + y

Анонимная функция очень похожа на обычное объявление функции, за исключением того, что у нее нет имени. Ее тело может быть либо выражением (как показано выше), либо блоком:

fun(x: Int, y: Int): Int {
    return x + y
}

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

ints.filter(fun(item) = item > 0)

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

Другое различие между лямбда-выражениями и анонимными функциями заключается в поведении нелокальных возвратов. Оператор return без метки всегда возвращает из функции, объявленной с ключевым словом fun. Это означает, что return внутри лямбда-выражения вернёт из окружающей функции, а return внутри анонимной функции вернет из самой анонимной функции.

Замыкания

Лямбда-выражение или анонимная функция (а также локальная функция и объектное выражение) может получить доступ к своему замыканию, которое включает в себя переменные, объявленные во внешнем объёме. Переменные, захваченные в замыкании, могут быть изменены в лямбде:

var sum = 0
ints.filter { it > 0 }.forEach {
    sum += it
}
print(sum)

Литералы функций с получателем

Типы функций с получателем, такие как A.(B) -> C, могут быть созданы со специальной формой литералов функций — литералами функций с получателем.

Как упоминалось выше, Kotlin предоставляет возможность вызывать экземпляр типа функции с получателем, предоставляя объект-получатель.

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

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

Вот пример литерала функции с получателем вместе с его типом, где plus вызывается на объекте-получателе:

val sum: Int.(Int) -> Int = { other -> plus(other) }

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

val sum = fun Int.(other: Int): Int = this + other

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

class HTML {
    fun body() { ... }
}

fun html(init: HTML.() -> Unit): HTML {
    val html = HTML()  // create the receiver object
    html.init()        // pass the receiver object to the lambda
    return html
}

html {       // lambda with receiver begins here
    body()   // calling a method on the receiver object
}