Higher-order function: какво е, характеристики и примери в Kotlin

Какво е higher-order function?

Higher-order function — е функция, която притежава поне една от две характеристики: приемане на друга функция като аргумент или връщане на функция като резултат. В математиката такива функции се наричат функционали или оператори. В програмирането те се появяват в Lisp през 1958 г. и стават задължителна част от всички съвременни езици — JavaScript, Python, Swift, Kotlin, Scala и Haskell. Higher-order function позволява абстрахиране от конкретна операция и предаване на поведение като стойност.

Ключовата разлика между higher-order function и обикновена функция — наличието на параметър с функционален тип или върната функционална стойност. В Kotlin функционалният тип се записва като (ParamType) -> ReturnType. Например типът (Int) -> String означава функция, която приема Int и връща String. Типът () -> Unit обозначава функция без параметри, която не връща полезна стойност. Именно тази типова система прави higher-order functions типобезопасни.

Противоположността на higher-order function — first-class function (функция от първи клас). First-class function означава, че функцията може да се използва като всяка друга стойност: да се присвои на променлива, да се съхранява в колекция, да се предава като аргумент. Higher-order function е функция, която използва first-class functions за приемане или връщане. Kotlin поддържа и двете концепции на ниво език без допълнителни библиотеки.

Как работи higher-order function в Kotlin?

В Kotlin всяка функция, която има поне един параметър, деклариран с функционален тип, или чийто връщан тип е функционален, автоматично се счита за higher-order function. Компилаторът не изисква специална анотация — достатъчно е да посочите (T) -> R в сигнатурата. При извикване на такава функция като аргумент се предава или ламбда израз, или препратка към съществуваща функция чрез ::, или функционална стойност, съхранена в променлива.

fun operate(a: Int, b: Int, op: (Int, Int) -> Int): Int {
    return op(a, b)
}

fun main() {
    val sum = operate(10, 20) { x, y -> x + y }
    println(sum) // 30
}

В листинга функцията operate приема две цели числа и параметъра op от тип (Int, Int) -> Int. Тялото на функцията в един ред извиква предадената операция. В main извикването operate предава ламбда { x, y -> x + y } — Kotlin я поставя след скобите благодарение на синтаксиса trailing lambda. Ако ламбдата беше последният аргумент, тя можеше да бъде изнесена изцяло извън скобите, което повишава четимостта на веригите от извиквания.

Под капака Kotlin компилира higher-order function чрез интерфейса Function (Function2 за два параметъра). Всяка ламбда се превръща в анонимен клас, имплементиращ съответния интерфейс FunctionN. Това означава, че създаването на ламбда води до заделяне на обект за всяка операция. За намаляване на натоварването Kotlin поддържа inline функции, които вмъкват тялото на higher-order function на мястото на извикване, елиминирайки създаването на анонимен клас.

Функции като параметри: предаване на поведение

Предаването на функция като аргумент — най-честият модел на използване на higher-order function. Вместо да създава йерархия от класове с полиморфен метод, програмистът предава необходимото поведение директно на мястото на използване. Това имплементира принципа Отворено/Затворено (Open/Closed Principle) без наследяване: нова операция се добавя като нова ламбда, а не като нов подклас.

За nullable функции Kotlin използва типа ((T) -> R)? с въпросителен знак след скобите. Такава функция може да бъде извикана само след проверка за null или чрез оператора ?.invoke(). Сигнатурата на higher-order function ясно показва, че предаването на функция не е задължително — извикващият код може да пропусне аргумента. Това е полезно за callback-и и обработвачи на събития с опционално поведение.

fun <T> List<T>.customFilter(
    predicate: (T) -> Boolean
): List<T> {
    val result = mutableListOf<T>()
    for (item in this) {
        if (predicate(item)) result.add(item)
    }
    return result
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val even = numbers.customFilter { it % 2 == 0 }
    println(even) // [2, 4]
}

Функцията-разширение customFilter приема параметъра predicate от функционален тип (T) -> Boolean. Вътре в цикъла тя извиква predicate за всеки елемент и събира подходящите. Извикването в main предава ламбда { it % 2 == 0 }, където it е имплицитното име на единствения параметър на ламбдата. Благодарение на higher-order function логиката на филтриране е напълно отделена от механизма за обхождане на колекцията.

Функции като върнати стойности

Higher-order function може да върне функция — такъв модел се нарича фабрика за функции или генератор на поведение. Върнатата функция може да улови (closure) променливи от външния обхват на видимост, запазвайки ги между извикванията. Това позволява създаването на конфигурируеми обработвачи и специализирани операции на базата на общи шаблони.

При връщане на функция Kotlin извежда върнатия функционален тип ((T) -> R)? от сигнатурата. Компилаторът проверява, че всички return изрази в тялото връщат съвместими функционални стойности. Уловените променливи се съхраняват в обекта на ламбдата и са достъпни, докато съществува препратка към нея. Това е мощен механизъм, но изисква внимание при управлението на паметта.

fun makeMultiplier(factor: Int): (Int) -> Int {
    return { x -> x * factor }
}

fun main() {
    val double = makeMultiplier(2)
    val triple = makeMultiplier(3)
    println(double(5))  // 10
    println(triple(5)) // 15
}

Функцията makeMultiplier приема factor и връща ламбда { x -> x * factor }, където factor е уловен от външния обхват (closure). При всяко извикване на makeMultiplier се създава нова функция със собствена стойност на factor. Променливите double и triple съхраняват върнатите функции и могат да бъдат извиквани многократно. Този модел се използва широко в конфигурирането на HTTP клиенти, декоратори и междинен софтуер.

Higher-order function с ламбда: примери

Комбинираното използване на higher-order function и ламбда позволява изграждане на изразителни вериги от операции без междинни променливи. Стандартната библиотека на Kotlin съдържа десетки higher-order functions: let, run, apply, also, filter, map, flatMap, fold, reduce, forEach, groupBy и други. Всяка от тях приема ламбда и с нейна помощ извършва трансформация на данни.

data class User(val name: String, val age: Int)

fun main() {
    val users = listOf(
        User("Alice", 25),
        User("Bob", 17),
        User("Charlie", 30)
    )

    val result = users
        .filter { it.age >= 18 }
        .map { it.name.uppercase() }
        .sorted()
    println(result) // [АЛИСА, ЧАРЛИ]
}

В примера верига от три higher-order functions обработва списък от потребители. filter приема предикат, оставяйки само пълнолетни потребители. map преобразува всеки потребител в име, изписано с главни букви. sorted сортира резултата възходящо. Всяка операция приема ламбда, а Kotlin осигурява типова безопасност на всички етапи. Без higher-order function ще трябва да се напише цикъл с if, временни списъци и ръчно сортиране.