Scala for Backend Engineering & Functional Programming · Pelajaran

Pola Type Class

Polimorfisme ad hoc.

Pola Type Class 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 menambahkan perilaku ke berbagai tipe tanpa memodifikasinya. Ini merupakan bentuk polimorfisme ad hoc: operasi yang sama dapat bekerja pada banyak tipe yang tidak berhubungan, dan kompilator memilihnya berdasarkan tipe.

Pola ini berasal dari Haskell dan banyak digunakan dalam pustaka Scala seperti Cats.

Masalah yang Diselesaikannya

Pewarisan memaksa perilaku dimasukkan ke dalam tipe saat tipe tersebut didefinisikan. Namun, Anda sering kali tidak dapat mengubah suatu tipe karena tipe itu berada di dalam pustaka, atau Anda menginginkan perilaku yang berbeda dalam konteks yang berbeda. Kelas tipe memungkinkan Anda melampirkan perilaku secara eksternal.

Langkah 1: Mendefinisikan Trait

Kelas tipe adalah trait yang diparameterkan oleh suatu tipe. Di sini, Show[A] menjelaskan cara merender A apa pun menjadi String.

trait Show[A] {
  def show(value: A): String
}

@main def run(): Unit = {
  println("Show trait defined")
}

Langkah 2: Menyediakan Instans

Untuk setiap tipe konkret yang ingin Anda dukung, buat instance dari trait tersebut. Inilah yang disebut instans kelas tipe.

trait Show[A] { def show(value: A): String }

object Main {
  val intShow: Show[Int] = (v: Int) => s"Int($v)"
  val strShow: Show[String] = (v: String) => s"Str($v)"

  def main(args: Array[String]): Unit = {
    println(intShow.show(7))
    println(strShow.show("hi"))
  }
}

Langkah 3: Menggunakan Instans

Sebuah fungsi menerima instans sebagai parameter. Fungsi render yang sama dapat bekerja untuk tipe apa pun yang memiliki instans Show.

trait Show[A] { def show(value: A): String }

object Main {
  def render[A](value: A, s: Show[A]): String = s.show(value)

  val intShow: Show[Int] = (v: Int) => s"<$v>"

  def main(args: Array[String]): Unit = {
    println(render(99, intShow))
  }
}

Menjadikannya Implisit

Meneruskan instans secara manual cukup merepotkan. Menandai instans dan parameter dengan implicit (atau using di Scala 3) memungkinkan kompilator menyediakannya secara otomatis.

trait Show[A] { def show(value: A): String }

object Main {
  implicit val intShow: Show[Int] = (v: Int) => s"<$v>"

  def render[A](value: A)(implicit s: Show[A]): String = s.show(value)

  def main(args: Array[String]): Unit = {
    println(render(42))
  }
}

Polimorfisme Ad Hoc

Nama fungsi yang sama memilih implementasi yang berbeda berdasarkan tipe argumennya. Inilah polimorfisme ad hoc, yang berbeda dari polimorfisme subtipe (pewarisan) dan polimorfisme parametrik (generik).

trait Show[A] { def show(value: A): String }

object Main {
  implicit val intShow: Show[Int] = (v: Int) => s"int:$v"
  implicit val boolShow: Show[Boolean] = (v: Boolean) => s"bool:$v"

  def render[A](value: A)(implicit s: Show[A]): String = s.show(value)

  def main(args: Array[String]): Unit = {
    println(render(5))
    println(render(true))
  }
}

Bekerja dengan Tipe Kustom

Kekuatan sebenarnya terletak pada kemampuan menambahkan perilaku ke tipe Anda sendiri secara rapi, sambil menjaga kelas data tetap bebas dari urusan pemformatan.

trait Show[A] { def show(value: A): String }

case class User(name: String, age: Int)

object Main {
  implicit val userShow: Show[User] = (u: User) => s"${u.name} (${u.age})"

  def render[A](value: A)(implicit s: Show[A]): String = s.show(value)

  def main(args: Array[String]): Unit = {
    println(render(User("Ada", 36)))
  }
}

Kelas Tipe vs Antarmuka

Antarmuka mengikat perilaku pada definisi tipe, sedangkan kelas tipe memisahkan keduanya.

Anda dapat menambahkan instans kelas tipe untuk tipe yang tidak Anda miliki.
Anda dapat memiliki beberapa instans untuk konteks yang berbeda.
Perilaku dipilih oleh kompilator di lokasi pemanggilan.

Tiga Komponen

Setiap kelas tipe memiliki tiga bagian:

Trait (operasi abstrak).
Instans (implementasi untuk setiap tipe).
Antarmuka (fungsi yang memerlukan instans).

Anda akan mempelajari masing-masing bagian dalam pelajaran berikutnya.

Contoh Mini Lengkap

Menggabungkan pola ini melalui fungsi generik yang menggunakan instans implisit.

trait Show[A] { def show(value: A): String }

object Main {
  implicit val intShow: Show[Int] = (v: Int) => s"#$v"
  implicit val strShow: Show[String] = (v: String) => '"' + v + '"'

  def printAll[A](xs: List[A])(implicit s: Show[A]): Unit =
    xs.foreach(x => println(s.show(x)))

  def main(args: Array[String]): Unit = {
    printAll(List(1, 2, 3))
    printAll(List("a", "b"))
  }
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang pola kelas tipe.

Rangkuman

Anda telah mempelajari pola kelas tipe:

trait berparameter menjelaskan sebuah operasi.
Instans mengimplementasikannya untuk setiap tipe.
Parameter implicit memungkinkan kompilator menyediakan instans.
Pola ini menghasilkan polimorfisme ad hoc dan memungkinkan Anda memperluas tipe yang tidak Anda miliki.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pola Type Class” gratis?

Ya — teks lengkap “Pola Type Class” 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 “Pola Type Class”?

Polimorfisme ad hoc. 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 “Pola Type Class” 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