Higher-order function: ano ito, mga katangian at halimbawa sa Kotlin

Ano ang higher-order function?

Higher-order function — ay isang function na may hindi bababa sa isa sa dalawang katangian: pagtanggap ng isa pang function bilang argumento o pagbabalik ng function bilang resulta. Sa matematika, ang mga naturang function ay tinatawag na functional o operator. Sa programming, lumitaw sila sa Lisp noong 1958 at naging obligadong bahagi ng lahat ng modernong wika — JavaScript, Python, Swift, Kotlin, Scala at Haskell. Ang Higher-order function ay nagpapahintulot sa abstraksyon mula sa isang partikular na operasyon at pagpasa ng pag-uugali bilang halaga.

Ang pangunahing pagkakaiba sa pagitan ng higher-order function at ordinaryong function — ang pagkakaroon ng parameter na may functional na uri o ibinalik na functional na halaga. Sa Kotlin, ang functional na uri ay isinusulat bilang (ParamType) -> ReturnType. Halimbawa, ang uri (Int) -> String ay nangangahulugang function na tumatanggap ng Int at nagbabalik ng String. Ang uri () -> Unit ay nagpapahiwatig ng function na walang parameter na hindi nagbabalik ng kapaki-pakinabang na halaga. Ang sistemang ito ng uri ang gumagawa ng higher-order functions na ligtas sa uri.

Ang kabaligtaran ng higher-order function — first-class function (first-class na function). Ang First-class function ay nangangahulugan na ang isang function ay maaaring gamitin tulad ng anumang iba pang halaga: italaga sa variable, itago sa koleksyon, ipasa bilang argumento. Ang Higher-order function ay isang function na gumagamit ng first-class functions para tumanggap o magbalik. Sinusuportahan ng Kotlin ang parehong konsepto sa antas ng wika nang walang karagdagang mga library.

Paano gumagana ang higher-order function sa Kotlin?

Sa Kotlin, bawat function na may hindi bababa sa isang parameter na idineklara na may functional na uri o ang ibinalik na uri ay functional, ay awtomatikong itinuturing na higher-order function. Ang kompayler ay hindi nangangailangan ng espesyal na anotasyon — sapat na upang tukuyin ang (T) -> R sa lagda. Kapag tumatawag ng naturang function, bilang argumento ay ipinapasa alinman sa lambda expression, o referensya sa umiiral na function sa pamamagitan ng ::, o functional na halaga na naka-imbak sa variable.

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
}

Sa listahan, ang function na operate ay tumatanggap ng dalawang integer at parameter op ng uri (Int, Int) -> Int. Ang katawan ng function sa isang linya ay tumatawag sa ipinasa na operasyon. Sa main, ang tawag na operate ay nagpapasa ng lambda { x, y -> x + y } — inilalagay ito ng Kotlin pagkatapos ng mga panaklong dahil sa trailing lambda syntax. Kung ang lambda ay huling argumento, maaari itong ganap na ilagay sa labas ng mga panaklong, na nagpapataas ng pagiging madaling mabasa ng mga chain ng tawag.

Sa ilalim ng hood, ang Kotlin ay nagkokompile ng higher-order function sa pamamagitan ng Function interface (Function2 para sa dalawang parameter). Bawat lambda ay ginagawang anonymous class na nag-iimplementa ng kaukulang FunctionN interface. Ito ay nangangahulugan na ang paglikha ng lambda ay nangangailangan ng alokasyon ng bagay para sa bawat operasyon. Upang mabawasan ang overhead, sinusuportahan ng Kotlin ang inline function, na naglalagay ng katawan ng higher-order function sa lugar ng tawag, inaalis ang paggawa ng anonymous class.

Mga function bilang parameter: pagpasa ng pag-uugali

Ang pagpasa ng function bilang argumento — ang pinakakaraniwang pattern ng paggamit ng higher-order function. Sa halip na lumikha ng hierarchy ng mga klase na may polymorphic na pamamaraan, ang programmer ay nagpapasa ng kinakailangang pag-uugali nang direkta sa punto ng paggamit. Ito ay nag-iimplementa ng Open/Closed Principle nang walang pamana: ang bagong operasyon ay idinaragdag bilang bagong lambda, hindi bilang bagong subclass.

Para sa nullable function, ginagamit ng Kotlin ang uri ((T) -> R)? na may tandang pananong pagkatapos ng mga panaklong. Ang naturang function ay maaari lamang tawagan pagkatapos ng null check o sa pamamagitan ng operator ?.invoke(). Ang lagda ng higher-order function ay malinaw na nagpapahiwatig na ang pagpasa ng function ay hindi obligado — ang tumatawag na code ay maaaring alisin ang argumento. Ito ay kapaki-pakinabang para sa mga callback at event handler na may opsyonal na pag-uugali.

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]
}

Ang extension function na customFilter ay tumatanggap ng parameter predicate ng functional na uri (T) -> Boolean. Sa loob ng loop, tinatawag nito ang predicate para sa bawat elemento at kinokolekta ang mga tumutugma. Ang tawag sa main ay nagpapasa ng lambda { it % 2 == 0 }, kung saan ang it ay ang implicit na pangalan ng nag-iisang parameter ng lambda. Dahil sa higher-order function, ang logic ng pag-filter ay ganap na nahiwalay mula sa mekanismo ng pag-ikot ng koleksyon.

Mga function bilang mga ibinalik na halaga

Ang Higher-order function ay maaaring magbalik ng function — ang naturang pattern ay tinatawag na pabrika ng function o generator ng pag-uugali. Ang ibinalik na function ay maaaring kumuha (closure) ng mga variable mula sa panlabas na saklaw ng visibility, pinapanatili ang mga ito sa pagitan ng mga tawag. Ito ay nagpapahintulot sa paglikha ng mga nako-configure na handler at espesyalisadong operasyon batay sa pangkalahatang mga template.

Kapag nagbabalik ng function, ang Kotlin ay nagdeduce ng ibinalik na functional na uri ((T) -> R)? mula sa lagda. Ang kompayler ay nagsusuri na ang lahat ng return expression sa katawan ay nagbabalik ng mga katugmang functional na halaga. Ang mga nakuha na variable ay naka-imbak sa lambda object at naa-access hangga't may referensya dito. Ito ay isang makapangyarihang mekanismo, ngunit nangangailangan ng pansin sa pamamahala ng memorya.

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
}

Ang function na makeMultiplier ay tumatanggap ng factor at nagbabalik ng lambda { x -> x * factor }, kung saan ang factor ay nakuha mula sa panlabas na saklaw (closure). Sa bawat tawag ng makeMultiplier, isang bagong function ang nilikha na may sariling halaga ng factor. Ang mga variable na double at triple ay nag-iimbak ng mga ibinalik na function at maaaring tawagin nang maraming beses. Ang pattern na ito ay malawakang ginagamit sa pagsasaayos ng mga HTTP client, dekorador, at middleware.

Higher-order function na may lambda: mga halimbawa

Ang pinagsamang paggamit ng higher-order function at lambda ay nagpapahintulot sa pagbuo ng mga ekspresibong chain ng operasyon nang walang intermediate na mga variable. Ang standard library ng Kotlin ay naglalaman ng dose-dosenang higher-order functions: let, run, apply, also, filter, map, flatMap, fold, reduce, forEach, groupBy at iba pa. Bawat isa sa kanila ay tumatanggap ng lambda at nagsasagawa ng pagbabago ng data sa tulong nito.

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]
}

Sa halimbawa, isang chain ng tatlong higher-order functions ang nagpoproseso ng listahan ng mga gumagamit. filter ay tumatanggap ng predicate, nag-iiwan lamang ng mga nasa hustong gulang. map ay nagbabago ng bawat gumagamit sa pangalan na nakasulat sa malalaking titik. sorted ay nag-aayos ng resulta nang pataas. Bawat operasyon ay tumatanggap ng lambda, at tinitiyak ng Kotlin ang kaligtasan ng uri sa lahat ng yugto. Kung walang higher-order function, kailangang sumulat ng loop na may if, pansamantalang listahan at manu-manong pag-uuri.