Lambda: apa itu, sintaksis dan penggunaan di Kotlin

Apa itu lambda?

Lambda (ekspresi lambda) — adalah fungsi anonim yang didefinisikan sebagai ekspresi, bukan deklarasi. Istilah ini berasal dari kalkulus lambda Alonzo Church (1936). Dalam pemrograman, lambda mewakili blok kode yang dapat diteruskan sebagai nilai, disimpan dalam variabel, dan dipanggil nanti. Di Kotlin, lambda selalu diapit oleh kurung kurawal { }, argumen dipisahkan dari tubuh oleh panah ->.

Lambda berbeda dari fungsi biasa dengan tidak adanya nama dan kata kunci fun. Hal ini memungkinkan deklarasi perilaku langsung di titik penggunaan, tanpa mengotori kode dengan deklarasi tambahan. Kompiler Kotlin menyimpulkan tipe argumen dari konteks, sehingga dalam banyak kasus tipe dapat dihilangkan. Lambda adalah gula sintaksis di atas tipe fungsional (T) -> R: setiap lambda memiliki tipe fungsional yang sesuai.

Penggunaan utama lambda di Kotlin adalah penerusan ke fungsi tingkat tinggi (higher-order functions). Pustaka standar menggunakan lambda di mana-mana: filter { it > 0 }, map { it.uppercase() }, forEach { println(it) }. Lambda juga digunakan untuk membuat pendengar peristiwa, callback, konfigurator objek melalui apply dan run, yang membuat kode lebih deklaratif dibandingkan dengan kelas anonim.

Sintaksis ekspresi lambda di Kotlin

Bentuk lengkap ekspresi lambda di Kotlin: { argumen -> tubuh_lambda }. Argumen didaftar dengan koma, diikuti oleh panah dan tubuh — satu atau lebih ekspresi. Jika tubuh berisi beberapa baris, ekspresi terakhir menjadi nilai yang dikembalikan. Jika fungsi menerima lambda sebagai argumen terakhir, lambda dapat ditempatkan di luar tanda kurung panggilan.

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

// Tipe yang disimpulkan dari konteks
val sumShort = { a: Int, b: Int -> a + b }

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

Variabel sum dideklarasikan dengan tipe fungsional eksplisit (Int, Int) -> Int dan diinisialisasi dengan lambda { a, b -> a + b }. Untuk sumShort, tipe ditentukan di dalam lambda dan tipe variabel disimpulkan. Kedua varian setara. Memanggil lambda tidak berbeda dengan memanggil fungsi biasa — menggunakan sintaksis sum(5, 3). Lambda tanpa argumen ditulis sebagai { body }, dengan satu argumen — { it -> it * 2 } atau cukup { it * 2 }.

Nama implisit it dan menghilangkan argumen

Ketika lambda menerima tepat satu argumen, Kotlin menyediakan nama implisit it. Ini menghilangkan kebutuhan untuk mendeklarasikan argumen di sisi kiri. Programmer hanya menulis tubuh lambda, menggunakan it untuk mengakses satu-satunya parameter. Sintaksis seperti ini sangat nyaman dalam rantai pemrosesan koleksi, di mana it menunjukkan elemen saat ini.

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

// Nama parameter eksplisit
val squaredExplicit = numbers.map { n -> n * n }

// it implisit
val squared = numbers.map { it * it }

// Pemfilteran dengan it
val even = numbers.filter { it % 2 == 0 }

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

Dalam contoh map { it * it } menggunakan it sebagai pengganti deklarasi n ->. Kotlin secara otomatis menetapkan it untuk satu-satunya parameter lambda. Jika lambda menerima dua atau lebih argumen, it tidak dibuat — semua parameter harus dideklarasikan secara eksplisit. Untuk keterbacaan lambda bersarang yang lebih baik, disarankan untuk memberikan nama yang bermakna pada parameter dan menggunakan it dalam predikat pendek satu baris.

Trailing lambda dan lambda multi-baris

Trailing lambda (lambda akhir) — fitur sintaksis Kotlin yang memungkinkan menempatkan argumen-lambda terakhir di luar tanda kurung bulat panggilan fungsi. Ini membuat kode mirip dengan konstruksi bahasa bawaan. Jika lambda adalah satu-satunya argumen, tanda kurung dapat dihilangkan sepenuhnya. Pendekatan ini digunakan secara aktif di pustaka standar dan DSL.

// Panggilan standar
thread(block = {
    println("Halo dari utas")
})

// Versi trailing lambda
thread {
    println("Halo dari utas")
}

// repeat dengan trailing lambda
repeat(3) { index ->
    println("Iterasi $index")
}

// run dengan lambda multi-baris
val config = run {
    val host = "localhost"
    val port = 8080
    "$host:$port"
}

Fungsi thread menerima Runnable sebagai argumen terakhir. Berkat trailing lambda, lambda dapat diteruskan di luar tanda kurung, yang secara visual menyerupai blok kode. Fungsi repeat menerima jumlah iterasi dan lambda dengan indeks. run — contoh fungsi tingkat tinggi di mana lambda multi-baris menghitung nilai yang dikembalikan oleh ekspresi terakhir. Tanda kurung di sekitar run() dapat dihilangkan jika lambda adalah satu-satunya argumen.

Penangkapan variabel (closure) dalam lambda

Penangkapan variabel (closure) — kemampuan lambda untuk mengakses variabel yang dideklarasikan di ruang lingkup eksternal. Di Kotlin, lambda dapat membaca dan memodifikasi variabel var, serta membaca variabel val dari konteks sekitarnya. Variabel yang ditangkap disimpan bersama lambda sepanjang siklus hidupnya, memungkinkan pembuatan fungsi dengan keadaan.

fun makeCounter(): () -> Int {
    var count = 0
    return {
        count++  // jumlah tangkapan
    }
}

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

Fungsi makeCounter mendeklarasikan variabel lokal count dan mengembalikan lambda { count++ }. Meskipun makeCounter telah selesai bekerja, lambda yang dikembalikan mempertahankan referensi ke count melalui penutupan (closure). Setiap panggilan counter() menambah dan mengembalikan nilai saat ini. Mekanisme closure mendasari currying, pabrik fungsi, dan memoization. Penting untuk diingat bahwa penangkapan variabel yang dapat diubah dapat menyebabkan perilaku tak terduga dalam eksekusi paralel.