Lambda Syntax

Setiap lambda Kotlin memiliki anatomi yang sama: daftar parameter, tanda panah ->, dan body berisi satu atau lebih ekspresi. Pemahaman anatomi ini penting karena banyak kode Kotlin modern memakai lambda untuk transformasi koleksi, callback, dan DSL. Pada chapter ini kita akan membedah setiap bagian sintaks lambda secara terpisah, melihat bagaimana body multi-statement bekerja, dan memahami aturan bahwa ekspresi terakhir selalu menjadi nilai kembalian. Kita juga akan melihat kapan kompilator memerlukan tipe parameter eksplisit.

Anatomi Lambda #

Bentuk paling sederhana dari lambda Kotlin adalah { parameter -> body }. Tanda panah -> memisahkan daftar parameter dari body lambda. Bila lambda tidak memiliki parameter, kita dapat menulis { body } tanpa panah.

//         parameter    body
//           ↓ ↓        ↓
val sum = { a: Int, b: Int -> a + b }

Body lambda dapat berisi satu ekspresi tunggal atau beberapa statement. Bila body berisi lebih dari satu statement, ekspresi terakhir menjadi nilai kembalian. Tidak ada keyword return eksplisit dalam lambda biasa.

Body Multi-Statement dan Ekspresi Terakhir #

Saat body lambda memuat beberapa statement, kita dapat menulis variabel lokal, melakukan perhitungan bertahap, dan menutup body dengan ekspresi yang menjadi hasil akhir. Pola ini umum dipakai saat transformasi memerlukan langkah perantara.

// lambda_syntax.kt
// Anatomi sintaks lambda: parameter, arrow, body, return value.

fun main() {
    // Lambda dengan dua parameter dan satu ekspresi.
    val tambah: (Int, Int) -> Int = { a, b -> a + b }
    println("Tambah 3 + 5 = ${tambah(3, 5)}")

    // Lambda dengan body multi-statement.
    // Ekspresi terakhir menjadi nilai kembalian.
    val proses: (Int) -> String = { angka ->
        val doubled = angka * 2
        val label = "angka=$angka, doubled=$doubled"
        label
    }
    println(proses(10))

    // Lambda tanpa parameter eksplisit menggunakan it.
    val sapa: (String) -> String = { "Halo, $it!" }
    println(sapa("Siti"))

    // Lambda dengan tipe parameter eksplisit (berguna saat tipe tidak disimpulkan).
    val hitung: (Int, Int, String) -> String = { a: Int, b: Int, op: String ->
        when (op) {
            "+" -> "${a + b}"
            "-" -> "${a - b}"
            else -> "tidak dikenal"
        }
    }
    println("Hasil 7 + 2 = ${hitung(7, 2, "+")}")
    println("Hasil 7 - 2 = ${hitung(7, 2, "-")}")

    // Lambda tanpa parameter, mengembalikan nilai dari blok terakhir.
    val pesanSapaan: () -> String = {
        val nama = "Budi"
        val tahun = 2026
        "Selamat datang $nama di tahun $tahun"
    }
    println(pesanSapaan())
}

Output yang Dihasilkan:

Tambah 3 + 5 = 8
angka=10, doubled=20
Halo, Siti!
Hasil 7 + 2 = 9
Hasil 7 - 2 = 5
Selamat datang Budi di tahun 2026

Mari kita telaah baris-baris kode di atas:

1. Baris 6 (val tambah = { a, b -> a + b }): lambda dengan dua parameter a dan b. Kompilator menyimpulkan tipe dari anotasi function type (Int, Int) -> Int pada variabel.
2. Baris 11-16 (val proses): body multi-statement. Baris val doubled = angka * 2 dan val label = ... adalah statement perantara. Baris terakhir label (tanpa val) menjadi nilai kembalian lambda.
3. Baris 19 (val sapa = { "Halo, $it!" }): lambda dengan satu parameter implisit it. Saat hanya ada satu parameter, Kotlin menyembunyikan nama parameter dan menyediakan identifier it.
4. Baris 22-29 (val hitung): lambda dengan tiga parameter dan tipe eksplisit a: Int, b: Int, op: String. Tipe eksplisit diperlukan saat kompilator tidak punya konteks untuk menyimpulkan.
5. Baris 32-36 (val pesanSapaan): lambda tanpa parameter bertipe () -> String. Body berisi dua val lokal dan ditutup dengan ekspresi string yang menjadi nilai kembalian.

Tipe Parameter Eksplisit vs Implisit #

Kompilator Kotlin menyimpulkan tipe parameter lambda dari konteks — biasanya dari tipe function type pada variabel atau dari signature function yang menerima lambda. Saat konteks tidak cukup, kita wajib menuliskan tipe parameter secara eksplisit seperti { a: Int, b: Int -> a + b }.

Ekspresi Terakhir sebagai Kembalian #

Aturan kunci lambda Kotlin: ekspresi terakhir selalu menjadi nilai kembalian. Tidak ada keyword return dalam lambda biasa — return di dalam lambda akan keluar dari function terluar yang membungkusnya. Untuk mendapat perilaku return lokal, gunakan anonymous function yang akan kita bahas pada chapter Anonymous Functions.

Referensi Lanjutan #

• Higher-order functions and lambdas — panduan resmi sintaks lambda: parameter, arrow, body
• Inline functions — mekanisme inlining lambda oleh kompilator

Penutup #

Sintaks lambda cukup ringkas tetapi memiliki aturan yang harus dipatuhi: tanda panah -> memisahkan parameter dari body, ekspresi terakhir menjadi nilai kembalian, dan tipe parameter dapat dihilangkan bila kompilator punya konteks. Dengan dasar ini, kita siap mempelajari trailing lambda — sintaks khusus yang membuat kode Kotlin terasa sangat natural saat melewatkan lambda sebagai argumen terakhir.