Scala for Backend Engineering & Functional Programming · Pelajaran

Type Class Cats

Functor, Monad, dan lainnya.

Type Class Cats adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. 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 4 pelajaran total.

Apa Itu Kelas Tipe?

Kelas tipe adalah pola untuk polimorfisme ad hoc. Pola ini memungkinkan Anda menambahkan perilaku ke suatu tipe tanpa memodifikasinya. Cats adalah pustaka Scala yang menyediakan hierarki kelas tipe yang kaya untuk pemrograman fungsional.

Functor — hal yang dapat Anda terapkan map
Applicative — menggabungkan efek yang independen
Monad — mengurutkan efek yang saling bergantung

Functor: map

Functor[F] menyediakan map. Kode ini mengubah nilai di dalam suatu konteks tanpa mengubah struktur konteks tersebut.

import cats.Functor
import cats.instances.option._

val f = Functor[Option].map(Some(2))(_ + 1)
println(f) // Some(3)

Hukum Functor

Functor yang mematuhi hukum harus mengikuti dua hukum berikut:

Identitas: fa.map(x => x) == fa
Komposisi: fa.map(f).map(g) == fa.map(f.andThen(g))

Jaminan ini memungkinkan Anda melakukan refaktor pada rangkaian map dengan aman.

Applicative: pure dan ap

Applicative[F] memperluas Functor dan menambahkan pure (mengangkat nilai ke dalam konteks) serta kemampuan untuk menggabungkan nilai-nilai independen dengan mapN.

import cats.Applicative
import cats.instances.option._

val lifted = Applicative[Option].pure(42)
println(lifted) // Some(42)

Menggabungkan dengan mapN

Sintaks mapN menggabungkan beberapa nilai yang menghasilkan efek dan saling independen menjadi satu, dengan menerapkan fungsi setelah semuanya tersedia.

import cats.syntax.apply._
import cats.instances.option._

val result = (Option(1), Option(2), Option(3)).mapN(_ + _ + _)
println(result) // Some(6)

Monad: flatMap

Monad[F] memperluas Applicative dan menambahkan flatMap, yang mengurutkan komputasi bergantung. Setiap langkah dapat bergantung pada hasil langkah sebelumnya.

import cats.Monad
import cats.instances.option._

val m = Monad[Option].flatMap(Some(3))(x => Some(x * 10))
println(m) // Some(30)

Hukum Monad

Monad harus mengikuti tiga hukum:

Identitas kiri: pure(a).flatMap(f) == f(a)
Identitas kanan: m.flatMap(pure) == m
Asosiativitas: flatMap bertingkat dapat dikelompokkan ulang

Semigrup dan Monoid

Semigroup[A] mendefinisikan combine (asosiatif). Monoid[A] menambahkan elemen identitas empty. Keduanya menjadi dasar pelipatan dan akumulasi.

import cats.syntax.semigroup._
import cats.instances.int._
import cats.instances.string._

println(3 |+| 4)       // 7
println("foo" |+| "bar") // foobar

Foldable

Foldable[F] mengabstraksikan pelipatan pada suatu struktur. Jika digabungkan dengan Monoid, combineAll mengurangi koleksi menjadi satu nilai.

import cats.Foldable
import cats.instances.list._
import cats.instances.int._

val total = Foldable[List].combineAll(List(1, 2, 3, 4))
println(total) // 10

Traverse

Traverse[F] memungkinkan Anda memetakan setiap elemen ke suatu efek dan mengumpulkan hasilnya, dengan mengubah List[F[A]] menjadi F[List[A]].

import cats.syntax.traverse._
import cats.instances.list._
import cats.instances.option._

val r = List(1, 2, 3).traverse(x => Option(x * 2))
println(r) // Some(List(2, 4, 6))

Mengapa Kelas Tipe Penting

Kelas tipe memungkinkan Anda menulis kode yang bekerja untuk sembarang tipe yang menyediakan perilaku yang diperlukan. Fungsi yang dibatasi oleh Monad[F] dapat digunakan untuk Option, List, IO, dan lainnya — tulis sekali, gunakan kembali di mana saja.

import cats.Monad
import cats.syntax.flatMap._
import cats.syntax.functor._

def twice[F[_]: Monad, A](fa: F[A])(f: A => A): F[A] =
  fa.flatMap(a => Monad[F].pure(f(f(a))))

Pemeriksaan Singkat

Kelas tipe mana yang menambahkan flatMap untuk mengurutkan komputasi yang saling bergantung?

Rangkuman

Anda telah mempelajari hierarki kelas tipe Cats inti:

Functor — map
Applicative — pure dan mapN
Monad — flatMap
Semigroup/Monoid — combine/empty
Foldable/Traverse — melipat dan mengumpulkan efek

Selanjutnya, Anda akan mempelajari monad IO untuk memodelkan efek secara murni.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Type Class Cats” gratis?

Ya — teks lengkap “Type Class Cats” 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 4 pelajaran total.

Apa yang akan aku pelajari di “Type Class Cats”?

Functor, Monad, dan lainnya. 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 4.

Berapa lama pelajaran “Type Class Cats” 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