Higher-order function: apa itu, fitur dan contoh di Kotlin

Apa itu higher-order function?

Higher-order function — adalah fungsi yang memiliki setidaknya satu dari dua karakteristik: menerima fungsi lain sebagai argumen atau mengembalikan fungsi sebagai hasil. Dalam matematika, fungsi semacam itu disebut fungsional atau operator. Dalam pemrograman, mereka muncul di Lisp pada tahun 1958 dan menjadi bagian wajib dari semua bahasa modern — JavaScript, Python, Swift, Kotlin, Scala, dan Haskell. Higher-order function memungkinkan abstraksi dari operasi tertentu dan melewatkan perilaku sebagai nilai.

Perbedaan utama antara higher-order function dan fungsi biasa — adanya parameter dengan tipe fungsional atau nilai fungsional yang dikembalikan. Di Kotlin, tipe fungsional ditulis sebagai (ParamType) -> ReturnType. Misalnya, tipe (Int) -> String berarti fungsi yang menerima Int dan mengembalikan String. Tipe () -> Unit menunjukkan fungsi tanpa parameter yang tidak mengembalikan nilai yang berguna. Sistem tipe inilah yang membuat higher-order functions aman tipe.

Kebalikan dari higher-order function — first-class function (fungsi kelas satu). First-class function berarti fungsi dapat digunakan seperti nilai lainnya: ditugaskan ke variabel, disimpan dalam koleksi, dilewatkan sebagai argumen. Higher-order function adalah fungsi yang menggunakan first-class functions untuk menerima atau mengembalikan. Kotlin mendukung kedua konsep di tingkat bahasa tanpa pustaka tambahan.

Bagaimana cara kerja higher-order function di Kotlin?

Di Kotlin, setiap fungsi yang memiliki setidaknya satu parameter dideklarasikan dengan tipe fungsional atau tipe kembaliannya fungsional, secara otomatis dianggap sebagai higher-order function. Kompilator tidak memerlukan anotasi khusus — cukup dengan menentukan (T) -> R dalam tanda tangan. Saat memanggil fungsi seperti itu, sebagai argumen dilewatkan baik ekspresi lambda, atau referensi ke fungsi yang ada melalui ::, atau nilai fungsional yang disimpan dalam variabel.

fun operate(a: Int, b: Int, op: (Int, Int) -> Int): Int {
    return op(a, b)
}

fun main() {
    val sum = operate(10, 20) { x, y -> x + y }
    println(sum) // 30
}

Dalam daftar, fungsi operate menerima dua bilangan bulat dan parameter op bertipe (Int, Int) -> Int. Badan fungsi dalam satu baris memanggil operasi yang dilewatkan. Di main, panggilan operate melewatkan lambda { x, y -> x + y } — Kotlin menempatkannya setelah tanda kurung berkat sintaks trailing lambda. Jika lambda adalah argumen terakhir, ia dapat sepenuhnya ditempatkan di luar tanda kurung, yang meningkatkan keterbacaan rantai panggilan.

Di balik layar, Kotlin mengkompilasi higher-order function melalui antarmuka Function (Function2 untuk dua parameter). Setiap lambda diubah menjadi kelas anonim yang mengimplementasikan antarmuka FunctionN yang sesuai. Ini berarti membuat lambda memerlukan alokasi objek untuk setiap operasi. Untuk mengurangi overhead, Kotlin mendukung fungsi inline, yang menyisipkan badan higher-order function di tempat panggilan, menghilangkan pembuatan kelas anonim.

Fungsi sebagai parameter: melewatkan perilaku

Melewatkan fungsi sebagai argumen — pola paling umum dalam menggunakan higher-order function. Alih-alih membuat hierarki kelas dengan metode polimorfik, programmer melewatkan perilaku yang diperlukan langsung ke titik penggunaan. Ini mengimplementasikan Prinsip Terbuka/Tertutup (Open/Closed Principle) tanpa pewarisan: operasi baru ditambahkan sebagai lambda baru, bukan sebagai subkelas baru.

Untuk fungsi nullable, Kotlin menggunakan tipe ((T) -> R)? dengan tanda tanya setelah tanda kurung. Fungsi semacam itu hanya dapat dipanggil setelah pemeriksaan null atau melalui operator ?.invoke(). Tanda tangan higher-order function dengan jelas menunjukkan bahwa melewatkan fungsi tidak wajib — kode pemanggil dapat menghilangkan argumen. Ini berguna untuk callback dan penangan acara dengan perilaku opsional.

fun <T> List<T>.customFilter(
    predicate: (T) -> Boolean
): List<T> {
    val result = mutableListOf<T>()
    for (item in this) {
        if (predicate(item)) result.add(item)
    }
    return result
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val even = numbers.customFilter { it % 2 == 0 }
    println(even) // [2, 4]
}

Fungsi ekstensi customFilter menerima parameter predicate bertipe fungsional (T) -> Boolean. Di dalam perulangan, ia memanggil predicate untuk setiap elemen dan mengumpulkan yang cocok. Panggilan di main melewatkan lambda { it % 2 == 0 }, di mana it adalah nama implisit dari satu-satunya parameter lambda. Berkat higher-order function, logika pemfilteran sepenuhnya terpisah dari mekanisme penelusuran koleksi.

Fungsi sebagai nilai kembali

Higher-order function dapat mengembalikan fungsi — pola seperti itu disebut pabrik fungsi atau generator perilaku. Fungsi yang dikembalikan dapat menangkap (closure) variabel dari lingkup visibilitas eksternal, mempertahankannya di antara panggilan. Ini memungkinkan pembuatan penangan yang dapat dikonfigurasi dan operasi khusus berdasarkan template umum.

Saat mengembalikan fungsi, Kotlin menyimpulkan tipe fungsional kembali ((T) -> R)? dari tanda tangan. Kompilator memeriksa bahwa semua ekspresi return di badan mengembalikan nilai fungsional yang kompatibel. Variabel yang ditangkap disimpan dalam objek lambda dan dapat diakses selama referensi ke sana ada. Ini adalah mekanisme yang kuat, tetapi memerlukan perhatian dalam manajemen memori.

fun makeMultiplier(factor: Int): (Int) -> Int {
    return { x -> x * factor }
}

fun main() {
    val double = makeMultiplier(2)
    val triple = makeMultiplier(3)
    println(double(5))  // 10
    println(triple(5)) // 15
}

Fungsi makeMultiplier menerima factor dan mengembalikan lambda { x -> x * factor }, di mana factor ditangkap dari lingkup eksternal (closure). Setiap panggilan makeMultiplier membuat fungsi baru dengan nilai factor-nya sendiri. Variabel double dan triple menyimpan fungsi yang dikembalikan dan dapat dipanggil beberapa kali. Pola ini banyak digunakan dalam konfigurasi klien HTTP, dekorator, dan middleware.

Higher-order function dengan lambda: contoh

Penggunaan gabungan higher-order function dan lambda memungkinkan pembangunan rantai operasi ekspresif tanpa variabel perantara. Pustaka standar Kotlin berisi puluhan higher-order functions: let, run, apply, also, filter, map, flatMap, fold, reduce, forEach, groupBy dan lainnya. Masing-masing menerima lambda dan melakukan transformasi data dengannya.

data class User(val name: String, val age: Int)

fun main() {
    val users = listOf(
        User("Alice", 25),
        User("Bob", 17),
        User("Charlie", 30)
    )

    val result = users
        .filter { it.age >= 18 }
        .map { it.name.uppercase() }
        .sorted()
    println(result) // [ALICE, CHARLIE]
}

Dalam contoh, rantai tiga higher-order functions memproses daftar pengguna. filter menerima predikat, hanya menyisakan pengguna dewasa. map mengubah setiap pengguna menjadi nama dengan huruf kapital. sorted mengurutkan hasil secara menaik. Setiap operasi menerima lambda, dan Kotlin memastikan keamanan tipe di semua tahap. Tanpa higher-order function, harus ditulis perulangan dengan if, daftar sementara, dan pengurutan manual.