Lambda adalah function literal: blok kode yang dapat diperlakukan sebagai nilai, disimpan dalam variabel, dan diteruskan sebagai argumen tanpa perlu nama. Di Kotlin, lambda berperan besar dalam pemrograman fungsional dan menjadi dasar banyak API standard library seperti map, filter, dan forEach. Pada chapter ini kita akan memahami cara mendeklarasikan lambda, menyimpannya dalam variabel bertipe function, dan memanggilnya baik secara langsung maupun melalui operator invoke. Pemahaman lambda ini menjadi fondasi untuk bab-bab selanjutnya tentang higher-order function, trailing lambda, dan scope functions.

Apa Itu Lambda Expression #

Lambda expression adalah sintaks ringkas untuk membuat function tanpa nama (anonymous function literal). Sintaksnya dibungkus kurung kurawal { ... } dan dapat langsung diikat ke variabel. Bentuk umumnya adalah { parameter -> body }, dan bila tidak ada parameter, kita dapat menulis { body } saja.

kotlin Bentuk umum lambda 
val sum: (Int, Int) -> Int = { a, b -> a + b }

Pada baris di atas, sum adalah variabel bertipe function (Int, Int) -> Int — yaitu function yang menerima dua Int dan mengembalikan Int. Lambda { a, b -> a + b } mengisi nilai variabel tersebut.

Mendeklarasikan dan Memanggil Lambda #

Lambda dapat dipanggil seperti function biasa menggunakan tanda kurung (), atau melalui operator invoke(). Kedua cara menghasilkan perilaku yang sama persis; pemilihan hanya soal gaya penulisan.

kotlin 
// lambda_expressions.kt
// Contoh dasar lambda expression di Kotlin.

fun main() {
    // Lambda disimpan dalam variabel bertipe function.
    val sum: (Int, Int) -> Int = { a, b -> a + b }

    // Pemanggilan langsung seperti function biasa.
    println("sum(1, 2) = ${sum(1, 2)}")

    // Pemanggilan via operator invoke().
    println("sum.invoke(3, 4) = ${sum.invoke(3, 4)}")

    // Lambda tanpa parameter — tipe () -> Unit.
    val sapa: () -> Unit = { println("Halo, Budi!") }
    sapa()

    // Lambda tanpa parameter yang mengembalikan nilai.
    val buatPesan: () -> String = { "Pesanan siap diproses" }
    println(buatPesan())

    // Lambda sebagai argumen function standard library.
    val daftar = listOf(10, 20, 30)
    val hasil = daftar.map { it * 2 }
    println("Hasil map: $hasil")

    // Type inference tanpa anotasi tipe eksplisit.
    val kuadrat = { n: Int -> n * n }
    println("Kuadrat 5 = ${kuadrat(5)}")
}

Output yang Dihasilkan:

text 
sum(1, 2) = 3
sum.invoke(3, 4) = 7
Halo, Budi!
Pesanan siap diproses
Hasil map: [20, 40, 60]
Kuadrat 5 = 25

Mari kita telaah baris-baris kode di atas:

  1. Baris 6 (val sum: (Int, Int) -> Int = { a, b -> a + b }): variabel sum bertipe function (Int, Int) -> Int. Lambda { a, b -> a + b } menerima dua parameter a dan b, lalu mengembalikan hasil a + b.
  2. Baris 9 (sum(1, 2)): pemanggilan langsung seperti function biasa. Kotlin mengeluarkan hasil 3.
  3. Baris 12 (sum.invoke(3, 4)): operator invoke() adalah cara eksplisit memanggil lambda. Hasilnya sama dengan sum(3, 4).
  4. Baris 15 (val sapa: () -> Unit = { println(...) }): lambda tanpa parameter bertipe () -> Unit. Tidak mengembalikan nilai.
  5. Baris 19 (val buatPesan: () -> String = { ... }): lambda tanpa parameter yang mengembalikan String. Ekspresi terakhir dalam body menjadi nilai kembalian.
  6. Baris 24 (daftar.map { it * 2 }): lambda { it * 2 } diteruskan sebagai argumen ke function map. Identifier it merujuk ke setiap elemen daftar.
  7. Baris 28 (val kuadrat = { n: Int -> n * n }): type inference menyimpulkan tipe (Int) -> Int dari tipe parameter n. Kita tidak perlu menuliskan tipe variabel secara eksplisit.

Tipe Function dan Inference #

Kotlin menggunakan function type seperti (Int, Int) -> Int untuk mendeskripsikan lambda. Tipe ini dapat dituliskan eksplisit atau disimpulkan kompilator dari body lambda. Saat kompilator tidak memiliki konteks yang cukup (misalnya lambda ditempatkan pada variabel tanpa anotasi tipe dan tanpa parameter bertipe), kita perlu menambahkan tipe pada parameter lambda seperti { n: Int -> n * n }.

Lambda dalam Standard Library #

Banyak function di standard library Kotlin menerima lambda sebagai argumen. Contoh paling umum adalah map, filter, forEach, groupBy, dan sortedBy. Setiap function ini mengiterasi koleksi dan menerapkan lambda yang kita berikan pada setiap elemen. Kita akan mendalami pola ini lebih jauh pada chapter Trailing Lambdas dan Higher-Order Functions.

Referensi Lanjutan #

Penutup #

Lambda adalah blok bangunan utama pemrograman fungsional di Kotlin. Dengan kemampuan menyimpan function dalam variabel, meneruskannya sebagai argumen, dan memanggilnya baik secara langsung maupun via invoke, lambda membuat kode koleksi dan callback menjadi ringkas. Selanjutnya, kita akan membedah anatomi sintaks lambda — parameter, arrow ->, body multi-statement, dan nilai kembalian — pada chapter Lambda Syntax.