Scala for Backend Engineering & Functional Programming · Pelajaran

Monad IO

Efek murni.

Monad IO adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 2 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 IO?

IO[A] dari Cats Effect adalah deskripsi komputasi yang, ketika dijalankan, dapat melakukan efek samping dan menghasilkan nilai bertipe A. Ini adalah nilai murni — tidak ada yang terjadi sampai Anda menjalankannya.

Menunda Efek Samping

Bungkus efek samping dengan IO(...) atau IO.delay(...). Isi efek tidak dieksekusi saat IO dibuat — efek tersebut hanya dieksekusi saat dijalankan.

import cats.effect.IO

val program: IO[Unit] = IO(println("Hello, IO!"))
// Nothing printed yet — program is just a description

Transparansi Referensial

Karena IO bersifat malas, Anda dapat mengganti nilai IO dengan definisinya tanpa mengubah perilaku. Transparansi referensial ini membuat kode yang menghasilkan efek lebih mudah dipahami dan direfaktor.

Nilai Murni

Gunakan IO.pure untuk mengangkat nilai yang sudah dihitung. Jangan masukkan efek samping ke dalam pure — kode tersebut mengevaluasi argumen secara langsung. Gunakan IO.delay atau IO(...) untuk efek.

import cats.effect.IO

val p: IO[Int] = IO.pure(42)
// 42 is computed already; pure just wraps it

map dan as

map mengubah hasil dari suatu IO. as menggantinya dengan nilai konstan. Keduanya tidak menjalankan efek — keduanya membangun deskripsi yang lebih besar.

import cats.effect.IO

val len: IO[Int] = IO("hello").map(_.length)
val done: IO[String] = IO(println("ran")).as("done")

Menjalankan dengan IOApp

Untuk mengeksekusi program IO, perluas IOApp dan implementasikan run, dengan mengembalikan IO[ExitCode]. Lingkungan waktu jalan mengevaluasinya pada penjadwal berbasis fiber.

import cats.effect.{IO, IOApp, ExitCode}

object Main extends IOApp {
  def run(args: List[String]): IO[ExitCode] =
    IO(println("Running!")).as(ExitCode.Success)
}

IOApp.Simple

Untuk program tanpa argumen atau kode keluar khusus, perluas IOApp.Simple dan sediakan run: IO[Unit].

import cats.effect.{IO, IOApp}

object Hello extends IOApp.Simple {
  def run: IO[Unit] = IO.println("Hello, world!")
}

IO.println

Cats Effect menyediakan IO.println sebagai operasi pencetakan yang menghasilkan efek dan praktis. Kode ini mengembalikan IO[Unit] dan hanya mencetak saat dijalankan.

import cats.effect.IO

val greet: IO[Unit] = IO.println("effectful output")

Menangkap Pengecualian

Jika efek yang dibungkus melempar pengecualian, kegagalan tersebut ditangkap di dalam IO, bukan dibiarkan keluar. IO menjadi nilai yang gagal dan dapat Anda tangani nanti.

import cats.effect.IO

val boom: IO[Int] = IO(throw new RuntimeException("fail"))
// Creating boom does NOT throw; running it would

Perbandingan dengan Scala Biasa

Tanpa tipe efek, efek samping berjalan segera dan sulit dikomposisikan. IO menundanya, sehingga program Scala mandiri mencetak secara langsung, sedangkan IO menundanya.

object Main {
  def main(args: Array[String]): Unit = {
    val eager = println("runs now") // executed immediately
    println("second line")
  }
}

Mengapa Menggunakan IO?

IO memberi Anda:

Kemurnian — efek merupakan nilai
Komposabilitas — bangun program dari bagian-bagian kecil
Keamanan — kesalahan dan sumber daya dilacak
Konkurensi — fiber yang ringan

Pemeriksaan Singkat

Kapan efek samping di dalam IO(println("hi")) benar-benar dijalankan?

Rangkuman

Monad IO memodelkan efek sebagai nilai murni yang dievaluasi secara malas:

IO(...) / IO.delay menunda efek
IO.pure membungkus nilai yang sudah dihitung
IOApp / IOApp.Simple menjalankan program
Pengecualian ditangkap, bukan dilempar secara langsung

Selanjutnya: mengomposisikan beberapa tindakan IO.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Monad IO” gratis?

Ya — teks lengkap “Monad IO” 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 “Monad IO”?

Efek murni. 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 4.

Berapa lama pelajaran “Monad IO” 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