Anonymous Functions

Anonymous function adalah alternatif lambda yang menggunakan keyword fun secara eksplisit. Berbeda dari lambda biasa, anonymous function memungkinkan kita menulis tipe kembalian secara eksplisit dan menggunakan keyword return yang berperilaku lokal terhadap function tersebut. Pada chapter ini kita akan membandingkan anonymous function dengan lambda, melihat kapan masing-masing lebih tepat, dan memahami perbedaan perilaku return yang krusial. Pemahaman ini penting untuk kode yang memerlukan kontrol alur eksplisit di dalam function literal.

Apa Itu Anonymous Function #

Anonymous function adalah function tanpa nama yang dideklarasikan dengan keyword fun. Sintaksnya mirip function biasa, hanya saja tidak ada nama function setelah fun.

// Lambda biasa
val a: (Int) -> Int = { x -> x * x }

// Anonymous function — tipe eksplisit
val b: (Int) -> Int = fun(x: Int): Int { return x * x }

// Anonymous function — ekspresi tunggal
val c: (Int) -> Int = fun(x: Int) = x * x

Ketiga bentuk di atas menghasilkan function dengan perilaku identik. Pilihan bergantung pada keterbacaan dan kebutuhan kontrol alur.

Contoh Anonymous Function #

Mari kita lihat anonymous function dalam berbagai skenario dan membandingkannya langsung dengan lambda biasa.

// anonymous_functions.kt
// Anonymous function: function literal dengan keyword `fun` eksplisit.

fun main() {
    // Lambda biasa.
    val lambdaKuadrat: (Int) -> Int = { x -> x * x }

    // Anonymous function dengan tipe kembalian eksplisit.
    val anonKuadrat: (Int) -> Int = fun(x: Int): Int { return x * x }

    // Anonymous function singkat (ekspresi tunggal).
    val anonKuadratSingkat: (Int) -> Int = fun(x: Int) = x * x

    println("Lambda kuadrat 4: ${lambdaKuadrat(4)}")
    println("Anon kuadrat 4: ${anonKuadrat(4)}")
    println("Anon singkat 4: ${anonKuadratSingkat(4)}")

    // Anonymous function dengan multi-statement body.
    val klasifikasi: (Int) -> String = fun(nilai: Int): String {
        return when {
            nilai < 0 -> "negatif"
            nilai == 0 -> "nol"
            else -> "positif"
        }
    }
    println("Klasifikasi -5: ${klasifikasi(-5)}")
    println("Klasifikasi  0: ${klasifikasi(0)}")
    println("Klasifikasi  7: ${klasifikasi(7)}")

    // Perbedaan return: anonymous function return dari dirinya sendiri,
    // lambda return dari function terluar.
    val daftar = listOf(1, 2, 3, 4, 5)
    val hasilAnon = daftar.filter(fun(n): Boolean { return n % 2 == 0 })
    println("Genap (anon): $hasilAnon")

    // Anonymous function sebagai argumen tanpa anotasi tipe.
    val hasilPanjang = daftar.map(fun(n) = n.toString().length)
    println("Panjang digit: $hasilPanjang")
}

Output yang Dihasilkan:

Lambda kuadrat 4: 16
Anon kuadrat 4: 16
Anon singkat 4: 16
Klasifikasi -5: negatif
Klasifikasi  0: nol
Klasifikasi  7: positif
Genap (anon): [2, 4]
Panjang digit: [1, 1, 1, 1, 1]

Mari kita telaah baris-baris kode di atas:

1. Baris 6 (val lambdaKuadrat = { x -> x * x }): lambda biasa. Body berisi ekspresi tunggal x * x yang menjadi nilai kembalian.
2. Baris 9 (fun(x: Int): Int { return x * x }): anonymous function dengan keyword fun, tipe parameter eksplisit x: Int, tipe kembalian Int, dan keyword return eksplisit di dalam body.
3. Baris 12 (fun(x: Int) = x * x): bentuk singkat anonymous function — ekspresi tunggal setelah =. Tipe kembalian disimpulkan dari ekspresi.
4. Baris 19-25 (fun(nilai: Int): String { ... }): anonymous function dengan multi-statement body. Keyword return mengembalikan hasil when secara eksplisit.
5. Baris 29 (daftar.filter(fun(n): Boolean { return n % 2 == 0 })): anonymous function sebagai argumen filter. Kita bisa tulis return di dalam — return hanya keluar dari anonymous function, bukan dari main.
6. Baris 32 (daftar.map(fun(n) = n.toString().length)): anonymous function singkat tanpa anotasi tipe kembalian. Tipe disimpulkan dari ekspresi n.toString().length menjadi Int.

Perbedaan return Lambda vs Anonymous Function #

Perbedaan paling mendasar antara lambda dan anonymous function adalah perilaku return:

Kapan Memakai Anonymous Function #

Anonymous function jarang dipakai untuk lambda satu baris karena lambda biasa lebih ringkas. Anonymous function cocok dipakai saat:

• Body kompleks dan memerlukan beberapa return awal (early return).
• Ingin menyatakan tipe kembalian secara eksplisit.
• Ingin menghindari jebakan non-local return pada lambda.

Referensi Lanjutan #

• Higher-order functions and lambdas — panduan resmi anonymous function sebagai alternatif lambda
• Inline functions — anonim function dan inlining

Penutup #

Anonymous function adalah alternatif lambda yang memberi kontrol eksplisit atas tipe kembalian dan perilaku return. Untuk lambda sederhana, lambda biasa tetap lebih ringkas dan menjadi pilihan default. Untuk function literal kompleks dengan banyak cabang return, anonymous function lebih aman dan lebih mudah dibaca. Selanjutnya, kita akan masuk ke topik higher-order function — function yang menerima atau mengembalikan function lain, yang menjadi inti pemrograman fungsional di Kotlin.