Функциональные типы и лямбды в Kotlin #

Васильев Андрей Михайлович, 2024

Версии презентации

• Интерактивная презентация
• Текстовая версия
• Раздел курса

Функции #

• В Kotlin функции являются объектами первого класса, т.е. их можно сохранять в переменные, получать в качестве аргументов и возвращать в качестве результатов фукнции
• Т.е. с функциями можно работать любым способом, доступным для других значений
• Функцию, помещённую в переменную можно вызвать как и обычную функцию, ()
• Для представления того, что значение является функцией необходимо описать её как функциональный тип: (Int) -> Int

fun doSome(value: Int, modifier: (Int) -> Int): Int {
    val result: Int = modifier(value)
    return result
}

Функциональный тип вызывается с помощью оператора invoke

• Либо явно: modifier.invoke(55)
• Либо неявно: modifier(33)

Функциональные типы #

• У всех функциональных типов есть список с типами параметров, заключённых в скобки, и возвращаемый тип, записываемый после стрелки (A, B) -> C
  • (Int, Double) -> String — функциональный тип, принимающий два числа и возвращающий строку
  • () -> Unit — функциональный тип, не принимающий никаких аргументов и ничего не возвращающий. Unit не может быть опущен
• Объявление функционального типа также может включать именованные параметры: (x: Int, y: Int) -> Point
• Чтобы указать, что функциональный тип может принимать null-значения, необходимо использовать круглые скобки: ((Int, Int) -> Int)?
• Вы также можете присвоить функциональному типу альтернативное имя, используя псевдонимы типов

  typealias ClickHandler = (Button, ClickEvent) -> Unit
  fun addClickHandler(handler: ClickHandler) { ... }

Создание функционального типа #

Если мы хотим создать новый блок кода, который можно сохранить (или передать):

• Используя лямбда-выражение: { a, b -> a + b}
• Используя анонимную функцию: fun(a: Int, b: Int): Int = a + b

В лямбда-выражении можно опустить типы, если компилятор сможет корректно их вывести относительно места их использования

val result = doSome(
    34,
    { num -> num + 42 },
)
println(result)

Помимо создания нового блока можно создать ссылку на существующую функцию

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

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

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

• Лямбда-выражение всегда заключено в скобки {...}
• Объявление параметров при таком синтаксисе происходит внутри этих скобок и может включать в себя аннотации типов
• Тело функции начинается после знака ->
• Тело может состоять из нескольких выражений как и обычная функция
• Если тип возвращаемого значения не Unit, то в качестве возвращаемого типа принимается последнее (а возможно и единственное) выражение внутри тела лямбды

Если вы вынесите все необязательные объявления, то, что останется, будет выглядеть следующим образом:

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

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

• Вы можете вернуть значение из лямбды явно, используя оператор return
• Либо неявно будет возвращено значение последнего выражения

Таким образом, два следующих фрагмента равнозначны:

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

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

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

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

return без метки совершит выход из функции, не из лямбда-выражения

Передача лямбды в качестве последнего параметра #

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

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

Такой синтаксис также известен как trailing lambda

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

run { println("...") }

Стандартная библиотека по работе с коллекциями предлагает много функций, которые предполагают работу с лямбда-выражениями

it — неявное имя единственного параметра #

• Очень часто лямбда-выражение имеет только один параметр
• Если компилятор способен самостоятельно определить сигнатуру, то объявление параметра можно опустить вместе с ->
• Параметр будет неявно объявлен под именем it

ints.filter { it > 0 } // этот литерал имеет тип '(it: Int) -> Boolean'

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

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

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

Замыкания #

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

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

Обычно можно встретить в функциях-генераторах:

typealias Modifier = (Int) -> Int
fun createNumberAdder(howMuch: Int): Modifier = {
    number + howMuch
}

Реализация функционального типа через классы #

• Функции-генераторы могут быть эффективно заменены классами, которые создают объекты, согласующиеся с функциональным типом
• В классе необходимо реализовать оператор invoke

typealias Modifier = (Int) -> Int

class NumberAdder(
    private val howMuch: Int,
): Modifier {
    override fun invoke(number: Int): Int {
        return number + howMuch
    }
}

val twoAdder = NumberAdder(2)
println(twoAdder(42)) // "44"

Функциональные (SAM) интерфейсы #

• Интерфейсы только с одним абстрактным методом называются функциональными интерфейсами или Single Abstract Method (SAM) интерфейсами
• Функциональный интерфейс может иметь несколько неабстрактных членов, но только один абстрактный

Чтобы объявить функциональный интерфейс, используйте модификатор fun.

fun interface KRunnable {
   fun invoke()
}

Классы, которые его реализуют, должны будут реализовать только одну функцию

Использование SAM-интерфейса #

Рассмотрим следующий SAM-интерфейс по манипулированию целыми числами

fun interface IntManipulator {
    fun manipulate(input: Int): Int
}

Реализуем этот интерфейс с помощью лямбда-выражения

val twoMultiplier = IntManipulator { it * 2 }

Реализуем этот интерфейс с помощью классов

class NumberMultiplier(private val multiplicator)
        : IntManipulator {
    override fun manipulate(input: Int) {
        return input * multiplicator
    }
}
val twoMultiplier = NumberMultiplier(2)

Функциональные интерфейсы и псевдонимы типов #

Функциональные интерфейсы и псевдонимы типов служат разным целям

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