Scala for Backend Engineering & Functional Programming · Pelajaran

Memahami Monad di Scala

Pahami Monad dengan lebih jelas dan pelajari cara Monad memungkinkan komposisi berurutan dari komputasi secara fungsional.

Memahami Monad di Scala adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 2 dari 3. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Scala for Backend Engineering & Functional Programming, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Scala for Backend Engineering & Functional Programming mencakup 3 pelajaran total.

Apa Itu Monad?

Monad adalah konsep dasar dalam pemrograman fungsional dan sering dianggap sebagai konsep tingkat lanjut. Jangan khawatir, kita akan menguraikannya agar mudah dipahami!

Pada intinya, monad adalah pola desain yang membantu Anda mengurutkan komputasi yang melibatkan sebuah "konteks". Anggaplah monad sebagai cara untuk mengelola efek samping atau menangani nilai yang mungkin tidak ada dalam struktur yang dapat diprediksi.

Merangkai Operasi Kontekstual

Bayangkan Anda memiliki nilai yang mungkin ada atau tidak, seperti Option[Int]. Jika Anda ingin melakukan beberapa operasi terhadapnya, tetapi hanya ketika nilainya ada, bagaimana cara melakukannya dengan rapi?

Pernyataan if yang bersarang akan segera menjadi rumit. Monad menyediakan cara yang rapi dan berurutan untuk merangkai operasi tersebut, serta meneruskan "konteks" (seperti ada atau tidaknya nilai) secara otomatis.

Kekuatan `flatMap`

Operasi terpenting untuk memahami monad adalah flatMap.

Operasi ini menerima fungsi yang mengembalikan nilai "kontekstual" lain (seperti Option atau List).
Operasi ini menerapkan fungsi tersebut pada nilai yang berada di dalam konteks saat ini.
Jika konteksnya kosong (misalnya, None), flatMap cukup meneruskan kekosongan tersebut tanpa menerapkan fungsi.

Dengan demikian, Anda dapat merangkai operasi dengan baik sambil menangani kemungkinan kegagalan atau nilai yang hilang di sepanjang proses.

`Option` dan `flatMap`

Tipe Option di Scala adalah contoh Monad yang sempurna. Sebuah Option dapat berupa Some(value) atau None.

Saat menggunakan flatMap pada Option:

Jika nilainya Some(value), fungsi yang Anda berikan diterapkan pada value, lalu hasilnya (berupa Option lain) digunakan.
Jika nilainya None, fungsi tidak pernah dipanggil dan None langsung dikembalikan.

Hal ini memastikan operasi Anda hanya berjalan ketika suatu nilai benar-benar ada.

`flatMap` dengan `Option`

Mari kita lihat cara kerja flatMap dengan Option. Kode ini mencoba mengurai string menjadi bilangan bulat, lalu menggandakannya, tetapi hanya jika kedua langkah tersebut berhasil.

object Main {
  def parseToInt(s: String): Option[Int] =
    try {
      Some(s.toInt)
    } catch {
      case _: NumberFormatException => None
    }

  def main(args: Array[String]): Unit = {
    val result1 = parseToInt("10").flatMap(x => Some(x * 2))
    val result2 = parseToInt("hello").flatMap(x => Some(x * 2))

    println(s"Result 1: $result1")
    println(s"Result 2: $result2")
  }
}

`List` dan `flatMap`

Tipe Scala umum lainnya yang berperilaku sebagai Monad adalah List.

Saat menggunakan flatMap pada List:

Fungsi yang diberikan diterapkan pada setiap elemen list.
Fungsi tersebut harus mengembalikan List baru untuk setiap elemen.
Semua list hasil kemudian digabungkan menjadi satu list yang diratakan.

Hal ini berguna untuk mengubah dan menggabungkan list data.

`flatMap` dengan `List`

Berikut cara kerja flatMap dengan List. Perhatikan bagaimana hasil penerapan fungsi yang mengembalikan list untuk setiap item "diratakan".

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3)

    // For each number, create a list of that number and its double
    val result = numbers.flatMap(n => List(n, n * 2))

    println(s"Original: $numbers")
    println(s"FlatMapped: $result")

    val words = List("hello", "world")
    val chars = words.flatMap(_.toList) // Get all characters

    println(s"Words: $words")
    println(s"Chars: $chars")
  }
}

Aturan Monad (Disederhanakan)

Meskipun flatMap adalah operasi utama, Monad yang sebenarnya juga mematuhi beberapa hukum (aturan) untuk memastikan perilaku yang dapat diprediksi.

Sederhananya, suatu tipe bersifat monadik jika tipe tersebut:

Dapat "membungkus" suatu nilai (sering disebut pure atau unit).
Memiliki operasi flatMap yang merangkai komputasi dengan tetap mempertahankan konteks.

Hukum-hukum ini memastikan bahwa penyusunan operasi monadik tetap konsisten, terlepas dari cara Anda mengelompokkannya.

Monad dan For-Comprehension

for-comprehensions di Scala menyediakan gula sintaksis untuk bekerja dengan Monad (serta tipe lain seperti Funktor dan Aplikatif).

Fitur ini memungkinkan Anda menulis operasi berurutan pada nilai kontekstual dengan gaya yang jauh lebih mudah dibaca dan menyerupai kode imperatif.

Di balik layar, kompiler Scala menerjemahkan for-comprehensions menjadi serangkaian pemanggilan flatMap, map, dan filter.

`Option` dalam For-Comprehension

Contoh ini menunjukkan bagaimana for-comprehension dapat menyederhanakan rangkaian Option.flatMap dari sebelumnya. Contoh ini menangani kasus None secara otomatis.

object Main {
  def parseToInt(s: String): Option[Int] =
    try {
      Some(s.toInt)
    } catch {
      case _: NumberFormatException => None
    }

  def main(args: Array[String]): Unit = {
    val numStr1 = "10"
    val numStr2 = "5"
    val badStr = "abc"

    val result1 = for {
      a <- parseToInt(numStr1) // If parseToInt returns None, the whole for-comp becomes None
      b <- parseToInt(numStr2)
    } yield a + b

    val result2 = for {
      a <- parseToInt(numStr1)
      b <- parseToInt(badStr) // This will be None
    } yield a + b

    println(s"Sum 1: $result1") // Some(15)
    println(s"Sum 2: $result2") // None
  }
}

Tantangan Monad

Perhatikan kode Scala berikut.

val list1 = List(1, 2)
val list2 = List(10, 20)

val result = for {
  x <- list1
  y <- list2
} yield x * y

Monad: Pengurutan Kontekstual

Selamat! Anda telah mengambil langkah besar dalam memahami Monad.

Monad menyediakan pola yang ampuh untuk mengurutkan komputasi yang berjalan dalam suatu "konteks" (seperti Option untuk ada atau tidaknya nilai, dan List untuk banyak nilai).
Operasi utamanya adalah flatMap, yang menerapkan fungsi yang mengembalikan nilai kontekstual baru, sehingga konteks dapat dirangkai dan diratakan secara efektif.
for-comprehensions Scala adalah gula sintaksis yang sangat baik. Fitur ini langsung diterjemahkan menjadi pemanggilan flatMap (serta map/filter), sehingga kode monadik jauh lebih mudah dibaca.

Selanjutnya, kita akan membahas pustaka pemrograman fungsional populer seperti Cats dan ZIO, yang banyak menggunakan konsep monadik ini.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Memahami Monad di Scala” gratis?

Ya — teks lengkap “Memahami Monad di Scala” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Scala for Backend Engineering & Functional Programming, upgrade ke CoddyKit PRO. Kursus Scala for Backend Engineering & Functional Programming mencakup 3 pelajaran total.

Apa yang akan aku pelajari di “Memahami Monad di Scala”?

Pahami Monad dengan lebih jelas dan pelajari cara Monad memungkinkan komposisi berurutan dari komputasi secara fungsional. Kamu berlatih Scala for Backend Engineering & Functional Programming dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Scala for Backend Engineering & Functional Programming?

Tidak diperlukan pengalaman sebelumnya. Scala for Backend Engineering & Functional Programming di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 3.

Berapa lama pelajaran “Memahami Monad di Scala” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Scala for Backend Engineering & Functional Programming ini?

Ya. Setiap pelajaran Scala for Backend Engineering & Functional Programming menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Scala for Backend Engineering & Functional Programming