Lambda: ano ito, syntax at paggamit sa Kotlin

Ano ang lambda?

Lambda (lambda expression) — ay isang anonymous na function na tinukoy bilang isang expression, hindi isang deklarasyon. Ang termino ay nagmula sa lambda calculus ni Alonzo Church (1936). Sa programming, ang lambda ay kumakatawan sa isang bloke ng code na maaaring ipasa bilang halaga, iimbak sa isang variable, at tawagan sa ibang pagkakataon. Sa Kotlin, ang lambda ay palaging nakapaloob sa mga kulot na panaklong { }, ang mga argumento ay pinaghihiwalay mula sa katawan ng arrow ->.

Ang lambda ay naiiba sa isang ordinaryong function sa kawalan ng pangalan at keyword na fun. Ito ay nagpapahintulot sa pagdeklara ng pag-uugali nang direkta sa punto ng paggamit, nang hindi nadudumihan ang code ng mga karagdagang deklarasyon. Ang Kotlin compiler ay kumukuha ng mga uri ng argumento mula sa konteksto, kaya sa maraming kaso ang mga uri ay maaaring tanggalin. Ang lambda ay syntactic sugar sa ibabaw ng functional na uri (T) -> R: bawat lambda ay may katumbas na functional na uri.

Ang pangunahing gamit ng mga lambda sa Kotlin ay ang pagpasa sa mga higher-order function. Ang standard library ay gumagamit ng mga lambda kahit saan: filter { it > 0 }, map { it.uppercase() }, forEach { println(it) }. Ginagamit din ang mga lambda para sa paglikha ng mga event listener, callback, configurator ng bagay sa pamamagitan ng apply at run, na ginagawang mas deklaratibo ang code kumpara sa mga anonymous na klase.

Syntax ng mga lambda expression sa Kotlin

Ang kumpletong anyo ng lambda expression sa Kotlin: { mga argumento -> katawan_ng_lambda }. Ang mga argumento ay nakalista na may kuwit, sinusundan ng arrow at katawan — isa o higit pang mga expression. Kung ang katawan ay naglalaman ng maraming linya, ang huling expression ay magiging halaga ng pagbabalik. Kung ang function ay tumatanggap ng lambda bilang huling argumento, maaari itong ilagay sa labas ng mga panaklong ng tawag.

val sum: (Int, Int) -> Int = { a, b -> a + b }

// Mga uri na nakuha mula sa konteksto
val sumShort = { a: Int, b: Int -> a + b }

// Tawag sa lambda
val result = sum(5, 3)  // 8
println(result)

Ang variable na sum ay idineklara na may tahasang functional na uri (Int, Int) -> Int at sinimulan ng lambda { a, b -> a + b }. Para sa sumShort, ang mga uri ay tinukoy sa loob ng lambda at ang uri ng variable ay na-extract. Ang parehong variant ay katumbas. Ang pagtawag sa lambda ay hindi naiiba sa pagtawag sa ordinaryong function — ginagamit ang syntax na sum(5, 3). Ang lambda na walang argumento ay isinusulat bilang { body }, na may isang argumento — { it -> it * 2 } o simpleng { it * 2 }.

Implicit na pangalang it at pagtanggal ng mga argumento

Kapag ang lambda ay tumatanggap ng eksaktong isang argumento, ang Kotlin ay nagbibigay ng implicit na pangalang it. Tinatanggal nito ang pangangailangang ideklara ang argumento sa kaliwang bahagi. Ang programmer ay nagsusulat lamang ng katawan ng lambda, gamit ang it upang ma-access ang nag-iisang parameter. Ang ganitong syntax ay lalong maginhawa sa mga chain ng pagproseso ng koleksyon, kung saan ang it ay tumutukoy sa kasalukuyang elemento.

val numbers = listOf(1, 2, 3, 4, 5)

// Tahasang pangalan ng parameter
val squaredExplicit = numbers.map { n -> n * n }

// Implicit na it
val squared = numbers.map { it * it }

// Pagsala gamit ang it
val even = numbers.filter { it % 2 == 0 }

println(squared) // [1, 4, 9, 16, 25]

Sa halimbawang map { it * it } ginagamit ang it sa halip na deklarasyong n ->. Awtomatikong itinatalaga ng Kotlin ang it para sa nag-iisang parameter ng lambda. Kung ang lambda ay tumatanggap ng dalawa o higit pang mga argumento, ang it ay hindi nalikha — lahat ng parameter ay dapat na tahasang ideklara. Para sa mas mahusay na pagbasa ng mga nested na lambda, inirerekomenda na bigyan ang mga parameter ng makabuluhang pangalan at gamitin ang it sa maiikling isang-linya na predicate.

Trailing lambda at multi-line na lambda

Trailing lambda (pangwakas na lambda) — isang syntactic na feature ng Kotlin na nagpapahintulot na ilagay ang huling argumento-lambda sa labas ng mga bilog na panaklong ng tawag ng function. Ginagawa nitong katulad ang code sa mga built-in na construct ng wika. Kung ang lambda ay ang nag-iisang argumento, ang mga panaklong ay maaaring ganap na tanggalin. Ang pamamaraang ito ay aktibong ginagamit sa standard library at DSL.

// Karaniwang tawag
thread(block = {
    println("Kamusta mula sa thread")
})

// Bersyong trailing lambda
thread {
    println("Kamusta mula sa thread")
}

// repeat na may trailing lambda
repeat(3) { index ->
    println("Iterasyon $index")
}

// run na may multi-line na lambda
val config = run {
    val host = "localhost"
    val port = 8080
    "$host:$port"
}

Ang function na thread ay tumatanggap ng Runnable bilang huling argumento. Dahil sa trailing lambda, ang lambda ay maaaring ipasa sa labas ng mga panaklong, na biswal na kahawig ng isang bloke ng code. Ang function na repeat ay tumatanggap ng bilang ng mga iteration at isang lambda na may index. run — isang halimbawa ng higher-order function kung saan ang multi-line na lambda ay kinakalkula ang halaga na ibinalik ng huling expression. Ang mga panaklong sa paligid ng run() ay maaaring tanggalin kung ang lambda ay ang nag-iisang argumento.

Pagkuha ng mga variable (closure) sa mga lambda

Pagkuha ng mga variable (closure) — kakayahan ng lambda na ma-access ang mga variable na idineklara sa panlabas na saklaw. Sa Kotlin, ang lambda ay maaaring magbasa at magbago ng mga var variable, pati na rin magbasa ng mga val variable mula sa nakapaligid na konteksto. Ang mga nakuhang variable ay iniimbak kasama ng lambda sa buong siklo ng buhay nito, na nagpapahintulot sa paglikha ng mga function na may estado.

fun makeCounter(): () -> Int {
    var count = 0
    return {
        count++  // bilang ng mga nakuha
    }
}

fun main() {
    val counter = makeCounter()
    println(counter()) // 0
    println(counter()) // 1
    println(counter()) // 2
}

Ang function na makeCounter ay nagdedeklara ng lokal na variable na count at nagbabalik ng lambda { count++ }. Bagaman natapos na ng makeCounter ang trabaho nito, ang ibinalik na lambda ay nagpapanatili ng referensya sa count sa pamamagitan ng closure. Bawat tawag sa counter() ay nagdaragdag at nagbabalik ng kasalukuyang halaga. Ang mekanismong closure ay nasa pundasyon ng currying, mga pabrika ng function, at memoization. Mahalagang tandaan na ang pagkuha ng mga nababagong variable ay maaaring humantong sa hindi inaasahang pag-uugali sa parallel na pagpapatupad.