Menyusun IO
Mengurutkan efek.
Menyusun IO adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 3 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.
Mengurutkan dengan flatMap
Karena IO adalah monad, Anda mengomposisikan efek dengan flatMap. Setiap langkah berjalan secara berurutan, dan langkah berikutnya dapat menggunakan hasil dari langkah sebelumnya.
import cats.effect.IO
val program: IO[Unit] =
IO("Alice").flatMap(name => IO.println(s"Hello, $name"))Ekspresi for
Ekspresi for diubah menjadi flatMap/map dan terbaca seperti skrip imperatif, tetapi tetap murni.
import cats.effect.IO
val prog: IO[Unit] = for {
_ <- IO.println("What is your name?")
name <- IO("Bob")
_ <- IO.println(s"Hi $name")
} yield ()Urutan Dipertahankan
Efek dalam ekspresi for berjalan dari atas ke bawah saat program dieksekusi. Struktur kode Anda mencerminkan urutan eksekusi.
Menggabungkan Efek Independen
Jika dua efek tidak saling bergantung, gunakan mapN atau (a, b).tupled untuk menggabungkannya. Secara bawaan, keduanya tetap berjalan secara berurutan, tetapi menyatakan bahwa keduanya independen.
import cats.effect.IO
import cats.syntax.apply._
val combined: IO[Int] = (IO(2), IO(3)).mapN(_ + _)Menjalankan Efek secara Paralel
Gunakan parMapN (dari cats.syntax.parallel) untuk menjalankan efek independen secara serentak pada fiber terpisah dan menggabungkan hasilnya.
import cats.effect.IO
import cats.syntax.parallel._
val par: IO[Int] = (IO(2), IO(3)).parMapN(_ + _)Membuang Hasil
Gunakan *> untuk menjalankan suatu efek dan mempertahankan hasil kedua, atau <* untuk mempertahankan hasil pertama. void membuang hasil sepenuhnya dan menghasilkan IO[Unit].
import cats.effect.IO
val r1: IO[Int] = IO.println("log") *> IO(42)
val r2: IO[Unit] = IO(99).voidMengulangi Efek
replicateA(n) menjalankan suatu efek sebanyak n kali dan mengumpulkan hasilnya ke dalam daftar. foreverM mengulanginya tanpa batas.
import cats.effect.IO
val three: IO[List[Unit]] = IO.println("tick").replicateA(3)Melakukan Traverse pada List
Ubah List[A] menjadi efek atas List[B] dengan traverse. Setiap elemen menghasilkan sebuah IO, lalu hasilnya dikumpulkan.
import cats.effect.IO
import cats.syntax.traverse._
val names = List("a", "b", "c")
val prog: IO[List[Unit]] = names.traverse(n => IO.println(n))parTraverse
parTraverse adalah versi paralel dari traverse — efek setiap elemen berjalan pada fiber-nya sendiri, sehingga ideal untuk I/O serentak seperti mengambil banyak URL.
import cats.effect.IO
import cats.syntax.parallel._
val ids = List(1, 2, 3)
val prog: IO[List[Int]] = ids.parTraverse(id => IO(id * 10))Program yang Dikomposisikan
Program ini membaca sebuah nilai, menggandakannya, lalu mencetak hasilnya — semuanya dikomposisikan dari langkah-langkah IO kecil dalam satu deskripsi.
import cats.effect.{IO, IOApp}
object Doubler extends IOApp.Simple {
def run: IO[Unit] = for {
n <- IO(21)
d = n * 2
_ <- IO.println(s"Doubled: $d")
} yield ()
}Pengurutan Scala Biasa
Sebagai perbandingan, berikut keluaran konsol berurutan dalam Scala biasa — dievaluasi langsung dan tidak murni, berbeda dari versi IO yang ditunda di atas.
object Main {
def main(args: Array[String]): Unit = {
val n = 21
val d = n * 2
println(s"Doubled: $d")
}
}Pemeriksaan Singkat
Metode mana yang menjalankan dua efek independen secara serentak dan menggabungkan hasilnya?
Rangkuman
Anda telah mengomposisikan program IO dengan:
flatMapdanforuntuk pengurutanmapN/parMapNuntuk efek independen*>,<*,voiduntuk menggabungkan atau membuang hasiltraverse/parTraverseuntuk koleksi
Selanjutnya: menangani kesalahan di dalam IO.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Menyusun IO” gratis?
Ya — teks lengkap “Menyusun 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 “Menyusun IO”?
Mengurutkan efek. 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 3 dari 4.
Berapa lama pelajaran “Menyusun 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.