Belajar Kotlin - Functional Programming & Lambdas

#Pendahuluan

Kotlin adalah bahasa yang menggabungkan OOP dan functional programming. Episode 7 fokus pada sisi fungsionalnya: lambda, anonymous functions, function references, dan scope functions yang menjadi ciri khas kode Kotlin modern.

Scope functions seperti let, run, apply, also, dan with mungkin terlihat ajaib di awal, tapi sebenarnya mereka hanya fungsi biasa dengan lambda yang menerima receiver. Memahami mereka berarti memahami setengah dari idiom kode Kotlin di production.

Setelah episode ini, kalian akan menulis transformasi data dengan gaya deklaratif dan memakai scope functions dengan sadar — bukan sekadar meniru dari StackOverflow.

#Lambda dan Anonymous Functions

#Sintaks Lambda

Lambda adalah blok fungsi yang bisa disimpan dalam variabel atau dilewatkan sebagai argumen. Bentuk umumnya: parameter di dalam kurung, lalu body setelah panah:

Lambda dasar

val tambah: (Int, Int) -> Int = { a, b -> a + b }
val sapa = { nama: String -> "Halo, $nama" }
 
println(tambah(3, 4))
println(sapa("Budi"))

Tipe lambda ditulis sebagai (Int, Int) -> Int — parameter di dalam kurung, tipe hasil setelah panah. Kotlin juga mengizinkan trailing lambda: jika lambda adalah argumen terakhir fungsi, kurung bisa dihilangkan, seperti yang sudah kalian lihat di filter { ... } pada episode 5.

#Anonymous Functions dan Function References

Anonymous function mirip lambda tapi memakai kata kunci fun dan memungkinkan return yang jelas:

Function reference

val angka = listOf(1, 2, 3, 4)
 
fun genap(n: Int): Boolean = n % 2 == 0
 
println(angka.filter(::genap))
println(angka.filter { it % 2 == 0 })

::genap adalah function reference — mengubah fungsi bernama menjadi nilai fungsi. Kedua baris menghasilkan hasil yang sama; yang pertama memakai reference, yang kedua memakai lambda. Function reference berguna untuk fungsi yang sudah ada dan ingin dipakai ulang.

#Scope Functions

#let dan run: Transformasi Nilai

let memakai nilai sebagai argumen lambda (it) dan mengembalikan hasil lambda — sempurna untuk memproses nilai nullable:

let untuk nilai nullable

val teks: String? = "hello"
val panjang = teks?.let { it.length } ?: 0
println(panjang) // 5

run mirip let tapi memakai receiver (this) alih-alih parameter, dan juga mengembalikan hasil lambda. Pola teks?.let { it.length } hanya mengeksekusi lambda jika teks bukan null — kombinasi yang sangat umum di kode produksi.

#apply dan also: Efek Samping dan Inisialisasi

apply mengembalikan receiver itu sendiri setelah menjalankan lambda dengan receiver this — sempurna untuk mengonfigurasi objek. also juga mengembalikan receiver, tapi lambda menerima it, cocok untuk log pencatatan:

apply dan also

class Pesanan {
    var id: String = ""
    var total: Int = 0
}
 
val p = Pesanan().apply {
    id = "ORD-001"
    total = 150000
}.also {
    println("Pesanan dibuat: ${it.id}")
}

apply memungkinkan menginisialisasi properties objek tanpa mengulangi nama objek, dan also menyelipkan efek samping seperti logging tanpa mengubah alur. Keduanya mengembalikan p yang sama.

#with dan Pilihan yang Tepat

with memakai receiver dan mengembalikan hasil lambda — berguna saat memanggil banyak method pada objek yang sama:

with untuk operasi berulang

val hasil = with(StringBuilder()) {
    append("A")
    append("B")
    toString()
}
println(hasil) // AB

Panduan pemilihan: pakai let untuk transformasi nilai nullable, apply untuk inisialisasi objek, also untuk efek samping, run dan with untuk komputasi dalam konteks receiver. Jangan berlebihan — jika lambda membuat kode sulit dibaca, pakai statement biasa.

#Immutability dan Transformasi Data

#Data Immutable sebagai Default

Kotlin mendorong immutability: val, collection read-only, dan data class dengan copy. Data immutable aman dibagikan antar thread, lebih mudah diprediksi, dan menjadi fondasi pemrograman fungsional:

Transformasi immutable

data class Item(val nama: String, val harga: Int)
 
val items = listOf(
    Item("Kopi", 15000),
    Item("Teh", 8000),
    Item("Susu", 12000),
)
 
val total = items
    .filter { it.harga > 10000 }
    .map { it.harga }
    .sum()

Rantai filter dan map tidak mengubah items — keduanya menghasilkan collection baru. Pola ini membuat data mengalir dari transformasi ke transformasi tanpa efek samping, dan hasilnya mudah diuji karena murni (pure function).

#Functional Idioms di Kotlin

#Menulis dengan Gaya Fungsional

Beberapa idiom yang sering dipakai di kode Kotlin fungsional:

• map dan filter untuk transformasi dan penyaringan tanpa loop manual.
• fold dan reduce untuk akumulasi nilai.
• Scope functions untuk inisialisasi dan efek samping yang terkontrol.
• Function reference untuk memakai ulang fungsi bernama.
• data class dengan copy untuk memperbarui data immutable.

#Kombinasi dengan Collection API

Functional idioms paling kuat saat digabung dengan collection API episode 5. Misalnya menghitung rata-rata harga item tertentu menjadi satu baris ekspresi. Latihan berulang akan membuat pola ini otomatis muncul saat kalian menulis kode.

#Penutup

Episode 7 membuka sisi fungsional Kotlin: lambda dengan trailing lambda syntax, anonymous functions dan function references, kelima scope functions dengan kegunaan masing-masing, serta kebiasaan immutability yang membuat kode lebih aman dan mudah diuji.

Inti yang harus dibawa pulang:

• Lambda disimpan sebagai nilai bertipe (Params) -> Hasil.
• Trailing lambda menghilangkan kurung pemanggil untuk argumen terakhir.
• ::namaFungsi membuat function reference untuk memakai ulang fungsi.
• let dan run mengembalikan hasil; apply dan also mengembalikan receiver.
• Pilih scope function sesuai niat: inisialisasi, transformasi, atau efek samping.
• Prefer val, collection read-only, dan copy untuk data immutable.

Di episode 8 selanjutnya kita akan membahas null-safe data handling — data classes dan destructuring declarations, sealed classes untuk state, Result type dan error handling idiomatis, serta serialisasi dengan kotlinx.serialization atau Jackson.