Функциональное программирование в Kotlin: от А до Я — полное руководство

Функциональное программирование в Kotlin: от А до Я

Функциональное программирование (ФП) — это парадигма, которая рассматривает вычисления как вычисление математических функций и избегает изменения состояния и изменяемых данных. Kotlin, будучи мультипарадигмальным языком, предоставляет мощные инструменты для применения функционального подхода, не заставляя отказываться от привычного ООП. В этой статье мы разберем ключевые концепции ФП в Kotlin: от чистых функций и неизменяемости до продвинутых техник, таких как композиция и монады.

1. Основы функционального подхода: чистые функции и неизменяемость

Фундамент ФП строится на двух принципах: чистота функций и неизменяемость данных.

• Чистая функция — это функция, результат которой зависит только от переданных аргументов и которая не имеет побочных эффектов (не изменяет внешние переменные, не выводит в консоль, не обращается к БД).
• Неизменяемость означает, что данные не могут быть изменены после создания. Вместо изменения существующего объекта создается его новая копия с нужными изменениями.

Пример чистой и нечистой функции на Kotlin:

// Нечистая функция: имеет побочный эффект (вывод в консоль)
fun impureSum(a: Int, b: Int): Int {
    println("Сумма: ${a + b}") // побочный эффект
    return a + b
}

// Чистая функция: только вычисление
fun pureSum(a: Int, b: Int): Int = a + b

// Неизменяемость: использование val вместо var
data class User(val name: String, val age: Int) // val делает поля неизменяемыми
fun main() {
    val user = User("Alice", 30)
    // user.age = 31 // Ошибка компиляции!
    val olderUser = user.copy(age = 31) // создаем новую копию
}

Использование val и data class с copy() — это стандартный способ соблюдать неизменяемость в Kotlin.

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

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

Лямбда-выражения — это компактный способ создания анонимных функций. Синтаксис: { аргументы -> тело }.

// Функция высшего порядка: принимает функцию (Int, Int) -> Int
fun operateOnNumbers(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

fun main() {
    // Лямбда-выражения
    val sum: (Int, Int) -> Int = { x, y -> x + y }
    val multiply: (Int, Int) -> Int = { x, y -> x * y }

    println(operateOnNumbers(5, 3, sum))      // 8
    println(operateOnNumbers(5, 3, multiply)) // 15

    // Использование лямбды "на лету"
    println(operateOnNumbers(10, 2, { a, b -> a - b })) // 8

    // Если лямбда последний аргумент, можно вынести за скобки (trailing lambda)
    println(operateOnNumbers(10, 2) { a, b -> a / b }) // 5
}

Стандартная библиотека Kotlin активно использует функции высшего порядка: map, filter, reduce для коллекций.

val numbers = listOf(1, 2, 3, 4, 5)
val evenSquares = numbers
    .filter { it % 2 == 0 } // {2, 4}
    .map { it * it }        // {4, 16}
println(evenSquares) // [4, 16]

3. Композиция функций и каррирование

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

// Композиция двух функций
infix fun  ((B) -> C).compose(f: (A) -> B): (A) -> C = { a -> this(f(a)) }

fun main() {
    val toInt: (String) -> Int = { it.toInt() }
    val square: (Int) -> Int = { it * it }

    val squareOfString: (String) -> Int = square compose toInt
    println(squareOfString("5")) // 25
}

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

// Обычная функция двух аргументов
fun sum(a: Int, b: Int): Int = a + b

// Каррированная версия
fun curriedSum(a: Int): (Int) -> Int = { b -> a + b }

fun main() {
    val addFive = curriedSum(5) // частичное применение
    println(addFive(3)) // 8
    println(addFive(10)) // 15
}

Каррирование особенно полезно при работе с функциями высшего порядка и композицией.

4. Продвинутые концепции: рекурсия, монады и функциональные структуры данных

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

tailrec fun factorial(n: Int, acc: Int = 1): Int {
    return if (n <= 1) acc else factorial(n - 1, n * acc)
}

fun main() {
    println(factorial(5)) // 120
}

Монады — это абстракция, которая позволяет обрабатывать контекст (например, опциональные значения, ошибки, асинхронность) цепочкой чистых функций. В Kotlin ключевые монады встроены в язык: Nullable (монада Maybe), Result (монада Either), Sequence (ленивая коллекция).

// Монада Nullable (T?)
data class Address(val city: String)
data class Person(val name: String, val address: Address?)

fun getCity(person: