Fungsi adalah bagian penting dalam pemrograman, termasuk di bahasa pemrograman Gleam. Dalam kehidupan sehari-hari, kita sering melakukan tugas-tugas yang berulang, seperti menyikat gigi setiap pagi dan malam, atau menyiapkan sarapan setiap hari. Nah, dalam pemrograman, fungsi memiliki peran yang mirip. Fungsi digunakan untuk mengemas serangkaian instruksi yang dapat dipanggil berulang kali, sehingga kita tidak perlu menulis kode yang sama berulang-ulang.
Table of Contents
Open Table of Contents
Fungsi Dasar
Bayangkan kamu sedang membantu ibu memasak di dapur. Ibu memintamu untuk memotong sayuran, seperti wortel dan kentang, menjadi potongan-potongan kecil. Nah, dalam pemrograman, tugas memotong sayuran ini bisa diibaratkan sebagai sebuah fungsi.
fn potong_sayuran(sayuran: String) -> List(String) {
// Kode untuk memotong sayuran menjadi potongan kecil
}
Fungsi potong_sayuran menerima satu argumen, yaitu sayuran, dan mengembalikan sebuah daftar potongan sayuran.
Fungsi Orde Tinggi (Higher order functions)
Sekarang, bayangkan ibu memintamu untuk memotong sayuran dengan ukuran yang berbeda-beda, tergantung pada jenis masakannya. Untuk sayur sop, sayuran dipotong agak besar, sedangkan untuk tumis, sayuran dipotong kecil-kecil.
Dalam pemrograman, kita bisa membuat fungsi yang menerima fungsi lain sebagai argumen. Inilah yang disebut fungsi orde tinggi.
fn olah_sayuran(sayuran: String, cara_potong: fn(String) -> List(String)) -> List(String) {
cara_potong(sayuran)
}
Fungsi olah_sayuran menerima dua argumen: sayuran dan cara_potong. Argumen cara_potong adalah sebuah fungsi yang menerima String dan mengembalikan List(String).
Fungsi Anonim
Terkadang, kita hanya perlu menggunakan sebuah fungsi sekali saja. Dalam kasus ini, kita bisa menggunakan fungsi anonim, yaitu fungsi tanpa nama.
olah_sayuran("Wortel", fn(s) {
// Kode untuk memotong sayuran
})
Di sini, kita langsung menuliskan fungsi anonim sebagai argumen kedua dari olah_sayuran.
Fungsi dengan Penangkapan (Function captures )
Saat memasak, terkadang kita perlu menggunakan bumbu yang sama untuk beberapa masakan. Misalnya, kita menggunakan garam untuk menambahkan rasa pada sayur sop dan tumis.
Dalam pemrograman, kita bisa membuat fungsi yang “menangkap” nilai dari lingkup luarnya. Ini disebut fungsi dengan penangkapan.
let garam = "secukupnya"
let tambah_garam = fn(masakan) { masakan <> " dengan garam " <> garam }
tambah_garam("Sayur sop") // "Sayur sop dengan garam secukupnya"
tambah_garam("Tumis kangkung") // "Tumis kangkung dengan garam secukupnya"
Fungsi tambah_garam menangkap nilai garam dari lingkup luarnya.
Fungsi Generik
Saat memasak, kita sering menggunakan teknik yang sama untuk mengolah bahan makanan yang berbeda. Misalnya, teknik menumis bisa digunakan untuk menumis bawang, cabai, atau sayuran.
Dalam pemrograman, kita bisa membuat fungsi generik yang dapat menerima argumen dengan tipe data yang berbeda-beda.
fn tumis(bahan: a) -> Tumisan(a) {
// Kode untuk menumis bahan
}
tumis(Bawang) // Tumisan(Bawang)
tumis(Cabai) // Tumisan(Cabai)
Fungsi tumis adalah fungsi generik yang dapat menerima argumen dengan tipe data apa pun.
Pipa dalam Fungsi
Saat memasak, kita sering melakukan serangkaian langkah secara berurutan. Misalnya, untuk membuat sayur sop, kita perlu mencuci sayuran, memotongnya, lalu memasaknya.
Dalam pemrograman Gleam, kita bisa menggunakan operator pipa |> untuk melakukan serangkaian operasi secara berurutan.
Sayuran
|> cuci
|> potong
|> masak
|> sajikan
Dengan operator pipa, kita bisa menuliskan kode dengan cara yang lebih mudah dibaca.
Argumen Berlabel
Saat memasak, kita sering perlu memperhatikan takaran bahan-bahan yang kita gunakan. Misalnya, untuk membuat kue, kita perlu menggunakan tepung, gula, dan telur dengan takaran yang tepat.
Dalam pemrograman Gleam, kita bisa menggunakan argumen berlabel untuk memperjelas maksud dari argumen yang kita berikan pada sebuah fungsi.
fn buat_kue(tepung: Int, gula gulaPasir: Int, telur: Int) {
// Kode untuk membuat kue
}
buat_kue(250, gulaPasir: 100, telur: 2)
Dengan argumen berlabel, kita bisa menuliskan argumen dengan urutan yang bebas dan lebih mudah dipahami.
Komentar Dokumentasi
Saat memasak, kita sering mengikuti resep yang tertulis. Resep ini berisi langkah-langkah dan penjelasan yang membantu kita memahami cara memasak suatu masakan.
Dalam pemrograman, kita bisa menuliskan dokumentasi untuk fungsi-fungsi yang kita buat agar lebih mudah dipahami oleh orang lain atau diri kita sendiri di masa mendatang.
/// Fungsi untuk membuat kue.
///
/// ## Contoh Penggunaan
///
/// ```gleam
/// buat_kue(250, gulaPasir: 100, telur: 2)
/// ```
///
fn buat_kue(tepung: Int, gula gulaPasir: Int, telur: Int) {
// Kode untuk membuat kue
}
Dengan komentar dokumentasi, kita bisa menjelaskan kegunaan dan cara menggunakan fungsi dengan lebih jelas.
Fungsi yang Sudah Usang (Deprecations)
Saat memasak, terkadang kita menemukan resep lama yang sudah tidak relevan lagi. Mungkin karena bahan-bahannya sudah diganti dengan yang lebih sehat, atau ada cara memasak yang lebih praktis.
Dalam pemrograman, kita juga bisa menandai fungsi-fungsi yang sudah tidak direkomendasikan untuk digunakan lagi.
@deprecated("Gunakan fungsi `buat_kue_sehat` sebagai gantinya.")
fn buat_kue_lama(tepung: Int, gulaPasir: Int, telur: Int) {
// Kode untuk membuat kue dengan resep lama
}
Dengan menandai fungsi sebagai usang (deprecated), kita memberi tahu pengguna bahwa fungsi tersebut sebaiknya tidak digunakan lagi dan menyarankan alternatifnya.
Nah, itulah pengenalan tentang fungsi dalam pemrograman Gleam. Dengan memahami konsep-konsep ini, kamu sudah selangkah lebih dekat untuk menjadi programmer yang andal. Teruslah belajar dan jangan takut untuk bereksperimen. Selamat belajar!