Higher-order function: nima, xususiyatlari va Kotlin'da misollar

Higher-order function nima?

Higher-order function — ikki xususiyatdan kamida bittasiga ega bo'lgan funksiya: boshqa funksiyani argument sifatida qabul qilish yoki natija sifatida funksiya qaytarish. Matematikada bunday funksiyalar funksional yoki operator deb ataladi. Dasturlashda ular 1958-yilda Lisp'da paydo bo'ldi va barcha zamonaviy tillarning — JavaScript, Python, Swift, Kotlin, Scala va Haskell'ning majburiy qismiga aylandi. Higher-order function muayyan operatsiyadan abstraksiyalash va xatti-harakatni qiymat sifatida uzatish imkonini beradi.

Higher-order function va oddiy funksiya o'rtasidagi asosiy farq — funksional tipdagi parametrning yoki qaytariladigan funksional qiymatning mavjudligi. Kotlin'da funksional tip (ParamType) -> ReturnType ko'rinishida yoziladi. Masalan, (Int) -> String tipi Int qabul qiladigan va String qaytaradigan funksiyani bildiradi. () -> Unit tipi parametrsiz, foydali qiymat qaytarmaydigan funksiyani bildiradi. Aynan shu tip tizimi higher-order function'larni tip-xavfsiz qiladi.

Higher-order function'ning teskarisi — first-class function (birinchi darajali funksiya). First-class function funksiyadan boshqa har qanday qiymat kabi foydalanish mumkinligini anglatadi: o'zgaruvchiga tayinlash, to'plamda saqlash, argument sifatida uzatish. Higher-order function — bu qabul qilish yoki qaytarish uchun first-class functions'dan foydalanadigan funksiya. Kotlin ikkala tushunchani til darajasida qo'shimcha kutubxonalarsiz qo'llab-quvvatlaydi.

Kotlin'da higher-order function qanday ishlaydi?

Kotlin'da funksional tipdagi kamida bitta parametri bo'lgan yoki qaytariladigan tipi funksional bo'lgan har bir funksiya avtomatik ravishda higher-order function hisoblanadi. Kompilyator maxsus annotatsiya talab qilmaydi — imzoda (T) -> R ko'rsatish kifoya. Bunday funksiyani chaqirganda argument sifatida yo lambda ifodasi, yo :: orqali mavjud funksiyaga havola, yo o'zgaruvchida saqlangan funksional qiymat uzatiladi.

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
}

Ro'yxatda operate funksiyasi ikkita butun son va (Int, Int) -> Int tipidagi op parametrini qabul qiladi. Funksiya tanasi bir satrda uzatilgan operatsiyani chaqiradi. main'da operate chaqiruvi { x, y -> x + y } lambdasini uzatadi — Kotlin trailing lambda sintaksisi tufayli uni qavslardan keyin joylashtiradi. Agar lambda oxirgi argument bo'lsa, uni to'liq qavslardan tashqariga chiqarish mumkin edi, bu chaqiruv zanjirlarining o'qilishini oshiradi.

Ichki tuzilmada Kotlin higher-order function'ni Function interfeysi (ikki parametr uchun Function2) orqali kompilyatsiya qiladi. Har bir lambda tegishli FunctionN interfeysini amalga oshiradigan anonim sinfga aylanadi. Bu lambda yaratish har bir operatsiya uchun obyekt ajratishga olib kelishini anglatadi. Yukni kamaytirish uchun Kotlin inline funksiyalarini qo'llab-quvvatlaydi, ular higher-order function tanasini chaqiruv joyiga joylashtirib, anonim sinf yaratilishini bartaraf qiladi.

Funksiyalar parametr sifatida: xatti-harakatni uzatish

Funksiyani argument sifatida uzatish — higher-order function'dan foydalanishning eng keng tarqalgan namunasi. Sinflar iyerarxiyasini yaratish o'rniga, dasturchi kerakli xatti-harakatni to'g'ridan-to'g'ri foydalanish nuqtasiga uzatadi. Bu merossiz Ochiq/Yopiq Prinsipini (Open/Closed Principle) amalga oshiradi: yangi operatsiya yangi alt sinf sifatida emas, balki yangi lambda sifatida qo'shiladi.

Nullable funksiyalar uchun Kotlin qavslardan keyin so'roq belgisi bilan ((T) -> R)? tipidan foydalanadi. Bunday funksiyani faqat null tekshiruvidan so'ng yoki ?.invoke() operatori orqali chaqirish mumkin. Higher-order function imzosi funksiya uzatish majburiy emasligini aniq ko'rsatadi — chaqiruvchi kod argumentni tashlab ketishi mumkin. Bu ixtiyoriy xatti-harakatga ega callback va hodisa ishlovchilari uchun foydalidir.

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 kengaytma funksiyasi (T) -> Boolean funksional tipidagi predicate parametrini qabul qiladi. Sikl ichida har bir element uchun predicate'ni chaqiradi va mos keladiganlarni yig'adi. main'dagi chaqiruv { it % 2 == 0 } lambdasini uzatadi, bu yerda it lambda'ning yagona parametrining yashirin nomi. Higher-order function tufayli filtrlash mantig'i to'plamni aylanib o'tish mexanizmidan butunlay ajratilgan.

Funksiyalar qaytariladigan qiymatlar sifatida

Higher-order function funksiya qaytarishi mumkin — bunday namuna funksiya fabrikasi yoki xatti-harakat generatori deb ataladi. Qaytarilgan funksiya tashqi ko'rinish sohasidan o'zgaruvchilarni (closure) tortib olishi va ularni chaqiruvlar orasida saqlashi mumkin. Bu umumiy shablonlar asosida sozlanishi ishlovchilar va ixtisoslashgan operatsiyalar yaratish imkonini beradi.

Funksiyani qaytarishda Kotlin imzodan qaytariladigan funksional tipni ((T) -> R)? chiqaradi. Kompilyator tanadagi barcha return ifodalari mos funksional qiymatlarni qaytarishini tekshiradi. Tortib olingan o'zgaruvchilar lambda obyektida saqlanadi va unga havola mavjud ekan, foydalanish mumkin. Bu kuchli mexanizm, ammo xotira boshqaruviga e'tibor talab qiladi.

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 funksiyasi factor'ni qabul qiladi va { x -> x * factor } lambdasini qaytaradi, bu yerda factor tashqi sohadan (closure) tortib olingan. Har bir makeMultiplier chaqiruvida o'z factor qiymatiga ega yangi funksiya yaratiladi. double va triple o'zgaruvchilari qaytarilgan funksiyalarni saqlaydi va bir necha marta chaqirilishi mumkin. Bu namuna HTTP mijozlari konfiguratsiyasida, dekoratorlarda va middleware'da keng qo'llaniladi.

Higher-order function lambdalar bilan: misollar

Higher-order function va lambdalarning birgalikda ishlatilishi oraliq o'zgaruvchilarsiz ifodali operatsiyalar zanjirlarini qurish imkonini beradi. Kotlin'ning standart kutubxonasida o'nlab higher-order functions mavjud: let, run, apply, also, filter, map, flatMap, fold, reduce, forEach, groupBy va boshqalar. Ularning har biri lambda qabul qiladi va uning yordamida ma'lumotlar konvertatsiyasini amalga oshiradi.

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) // [ALICE, CHARLIE]
}

Misolda uchta higher-order functions zanjiri foydalanuvchilar ro'yxatini qayta ishlaydi. filter predikat qabul qiladi, faqat voyaga yetganlarni qoldiradi. map har bir foydalanuvchini katta harflar bilan yozilgan nomga aylantiradi. sorted natijani o'sish tartibida saralaydi. Har bir operatsiya lambda qabul qiladi va Kotlin barcha bosqichlarda tip xavfsizligini ta'minlaydi. Higher-order function'siz if, vaqtinchalik ro'yxatlar va qo'lda saralash bilan sikl yozish kerak bo'lardi.