Функциональные типы и лямбды в 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)

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

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

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