0Pricing
Scala for Backend Engineering & Functional Programming · Pelajaran

Pengantar Functor & Applicative

Pahami konsep Functor untuk memetakan konteks dan Applicative untuk menggabungkan konteks yang independen.

Pengantar Functor & Applicative adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 1 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.

Melampaui Nilai Sederhana

Selamat datang di pembahasan yang lebih mendalam tentang pemrograman fungsional! Di Scala, kita sering bekerja dengan nilai yang bukan sekadar nilai "biasa", melainkan dibungkus dalam suatu "konteks".

Bayangkan Option yang mungkin berisi suatu nilai atau tidak, atau List yang berisi banyak nilai. Bagaimana cara kita bekerja dengan nilai-nilai ini tanpa terus-menerus memeriksa keberadaannya atau melakukan perulangan?

Nilai dalam Kotak: Konteks

Apa yang dimaksud dengan "konteks"? Kira-kira, konteks seperti wadah yang menambahkan makna atau perilaku pada suatu nilai. Contoh umum di Scala adalah:

  • Option[T]: Nilai yang mungkin ada (Some(T)) atau tidak ada (None).
  • List[T]: Kumpulan yang berisi nol atau lebih nilai.
  • Future[T]: Nilai yang akan tersedia pada suatu waktu di masa mendatang.

Funktor dan Aplikatif adalah alat yang ampuh untuk berinteraksi dengan nilai yang berada *di dalam* konteks-konteks ini.

Funktor: Melakukan Transformasi di Dalam

Funktor adalah tipe yang mengetahui cara menerapkan fungsi pada nilai yang berada *di dalam* konteksnya, tanpa mengubah konteks itu sendiri.

Bayangkan Anda mengubah isi sebuah kotak tanpa mengubah kotaknya. Operasi inti Funktor adalah map.

Contoh Funktor: Option

Tipe Option adalah contoh Funktor klasik. Metode map-nya menerapkan fungsi hanya jika Option berisi Some. Jika berisi None, fungsi tidak pernah dipanggil dan None dikembalikan.

Cobalah menjalankan contoh ini:

object Main {
  def main(args: Array[String]): Unit = {
    val maybeNum = Some(5)
    val mappedNum = maybeNum.map(x => x * 2)
    println(s"Mapped Some: $mappedNum") // Some(10)

    val noNum: Option[Int] = None
    val mappedNoNum = noNum.map(x => x * 2)
    println(s"Mapped None: $mappedNoNum") // None
  }
}

Contoh Funktor: List

Demikian pula, List juga merupakan Funktor. Metode map-nya menerapkan fungsi pada setiap elemen dalam list, lalu menghasilkan list baru yang berisi elemen-elemen yang telah diubah.

Dengan begitu, Anda dapat mengubah semua item tanpa menulis perulangan secara eksplisit!

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3)
    val doubled = numbers.map(x => x * 2)
    println(s"Doubled list: $doubled") // List(2, 4, 6)

    val emptyList = List.empty[Int]
    val mappedEmpty = emptyList.map(x => x * 2)
    println(s"Mapped empty: $mappedEmpty") // List()
  }
}

Kekuatan `map`

Mengapa Funktor penting?

  • Abstraksi: Funktor menyembunyikan detail tentang cara menerapkan fungsi pada nilai dalam suatu konteks. Anda tidak perlu menggunakan if (option.isDefined) atau for (item <- list).
  • Dapat dikomposisikan: Anda dapat merangkai beberapa pemanggilan map untuk melakukan serangkaian transformasi dengan rapi.
  • Keamanan: Untuk tipe seperti Option, map menangani ketiadaan nilai dengan baik.

Aplikatif: Lebih dari Sekadar `map`

Aplikatif adalah konsep yang lebih kuat yang dibangun di atas Funktor. Funktor memungkinkan Anda menerapkan fungsi biasa pada nilai dalam suatu konteks, sedangkan Aplikatif memungkinkan Anda menerapkan fungsi yang *juga berada di dalam konteks* pada nilai *dalam suatu konteks*.

Aplikatif sangat berguna untuk menggabungkan beberapa nilai kontekstual yang *saling independen*.

Mengangkat Nilai ke dalam Konteks

Salah satu fitur utama Aplikatif adalah kemampuan untuk "mengangkat" nilai biasa ke dalam konteks paling sederhana. Dalam pustaka standar Scala, Anda biasanya melakukannya dengan langsung membentuk konteks tersebut.

Misalnya, untuk menempatkan Int ke dalam konteks Option, Anda dapat menggunakan Some(value).

object Main {
  def main(args: Array[String]): Unit = {
    val value = 10
    val inOptionContext = Some(value) // Lifting 10 into Option
    println(s"Lifted to Option: $inOptionContext") // Some(10)

    val anotherValue = "Hello"
    val inListContext = List(anotherValue) // Lifting "Hello" into List
    println(s"Lifted to List: $inListContext") // List(Hello)
  }
}

Menggabungkan Konteks yang Saling Independen

Aplikatif sangat unggul dalam menggabungkan beberapa nilai kontekstual yang saling independen. Misalnya, jika Anda memiliki dua Option dan ingin menjumlahkan isinya, Aplikatif memungkinkan Anda melakukannya dengan baik.

Perulangan for Scala sering kali dapat menyatakan pola Aplikatif dengan cara yang elegan, terutama untuk tipe seperti Option dan List.

object Main {
  def main(args: Array[String]): Unit = {
    val maybeX = Some(5)
    val maybeY = Some(10)

    // Combine maybeX and maybeY to sum their values
    val result = for {
      x <- maybeX
      y <- maybeY
    } yield x + y

    println(s"Combined result: $result") // Some(15)

    val maybeZ: Option[Int] = None
    val resultWithError = for {
      x <- maybeX
      z <- maybeZ
    } yield x + z

    println(s"Result with None: $resultWithError") // None
  }
}

Pemeriksaan Singkat: Funktor

Uji pemahaman Anda tentang Funktor!

Tinjauan Funktor & Aplikatif

Dalam pelajaran ini, kita telah membahas:

  • Konteks: Nilai yang dibungkus dalam wadah seperti Option atau List.
  • Funktor: Tipe yang memungkinkan Anda melakukan map terhadap fungsi pada nilai di dalam konteks, sehingga nilainya berubah tanpa mengubah konteksnya.
  • Aplikatif: Lebih kuat daripada Funktor, karena memungkinkan Anda "mengangkat" nilai ke dalam konteks dan menggabungkan beberapa nilai kontekstual yang *saling independen*.

Konsep-konsep ini merupakan dasar penting untuk pola pemrograman fungsional yang lebih lanjut!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pengantar Functor & Applicative” gratis?

Ya — teks lengkap “Pengantar Functor & Applicative” 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 “Pengantar Functor & Applicative”?

Pahami konsep Functor untuk memetakan konteks dan Applicative untuk menggabungkan konteks yang independen. 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 1 dari 3.

Berapa lama pelajaran “Pengantar Functor & Applicative” 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

  1. Pengantar Functor & Applicative
  2. Memahami Monad di Scala
  3. Menjelajahi Cats dan ZIO
← Kembali ke Scala for Backend Engineering & Functional Programming