IO combineren
Effecten sequencen
IO combineren is een gratis Scala voor backend-engineering en functioneel programmeren-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Scala voor backend-engineering en functioneel programmeren. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Scala voor backend-engineering en functioneel programmeren bevat in totaal 4 lessen.
In volgorde uitvoeren met flatMap
Omdat IO een monad is, stel je effecten samen met flatMap. Elke stap wordt in volgorde uitgevoerd en een latere stap kan het resultaat van een eerdere stap gebruiken.
import cats.effect.IO
val program: IO[Unit] =
IO("Alice").flatMap(name => IO.println(s"Hello, $name"))for-comprehension
Een for-comprehension wordt omgezet in flatMap/map en leest als een imperatief script, terwijl de code zuiver blijft.
import cats.effect.IO
val prog: IO[Unit] = for {
_ <- IO.println("What is your name?")
name <- IO("Bob")
_ <- IO.println(s"Hi $name")
} yield ()De volgorde blijft behouden
Effecten in een for-comprehension worden van boven naar beneden uitgevoerd wanneer het programma wordt uitgevoerd. De structuur van je code weerspiegelt de uitvoeringsvolgorde.
Onafhankelijke effecten combineren
Wanneer twee effecten niet van elkaar afhankelijk zijn, gebruik je mapN of (a, b).tupled om ze te combineren. Standaard worden ze nog steeds sequentieel uitgevoerd, maar je drukt hun onafhankelijkheid uit.
import cats.effect.IO
import cats.syntax.apply._
val combined: IO[Int] = (IO(2), IO(3)).mapN(_ + _)Effecten parallel uitvoeren
Gebruik parMapN (uit cats.syntax.parallel) om onafhankelijke effecten gelijktijdig op afzonderlijke fibers uit te voeren en hun resultaten te combineren.
import cats.effect.IO
import cats.syntax.parallel._
val par: IO[Int] = (IO(2), IO(3)).parMapN(_ + _)Resultaten negeren
Gebruik *> om een effect uit te voeren en het tweede resultaat te behouden, of <* om het eerste te behouden. void negeert het resultaat volledig en levert IO[Unit] op.
import cats.effect.IO
val r1: IO[Int] = IO.println("log") *> IO(42)
val r2: IO[Unit] = IO(99).voidEffecten herhalen
replicateA(n) voert een effect n keer uit en verzamelt de resultaten in een lijst. foreverM herhaalt het effect onbeperkt.
import cats.effect.IO
val three: IO[List[Unit]] = IO.println("tick").replicateA(3)Een List doorlopen
Zet met traverse een List[A] om in een effect over een List[B]. Elk element levert een IO op en de resultaten worden verzameld.
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 is de parallelle versie van traverse — het effect van elk element wordt op zijn eigen fiber uitgevoerd, ideaal voor gelijktijdige I/O, zoals het ophalen van veel URL's.
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))Een samengesteld programma
Dit programma leest een waarde, verdubbelt deze en print het resultaat — allemaal samengesteld uit kleine IO-stappen in één beschrijving.
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 ()
}Sequentiële uitvoering in gewone Scala
Ter vergelijking zie je hier sequentiële console-uitvoer in gewone Scala — eager en onzuiver, in tegenstelling tot de uitgestelde IO-versie hierboven.
object Main {
def main(args: Array[String]): Unit = {
val n = 21
val d = n * 2
println(s"Doubled: $d")
}
}Korte controle
Welke methode voert twee onafhankelijke effecten gelijktijdig uit en combineert hun resultaten?
Samenvatting
Je hebt IO-programma's samengesteld met:
flatMapenforvoor uitvoering in volgordemapN/parMapNvoor onafhankelijke effecten*>,<*,voidvoor combineren en negerentraverse/parTraversevoor verzamelingen
Vervolgens: fouten binnen IO afhandelen.
Leer Scala met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 39
- Lessen
- 143
Veelgestelde vragen
Is de les “IO combineren” gratis?
Ja — de volledige tekst van “IO combineren” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Scala voor backend-engineering en functioneel programmeren wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Scala voor backend-engineering en functioneel programmeren bevat in totaal 4 lessen.
Wat leer ik in “IO combineren”?
Effecten sequencen Je oefent met Scala voor backend-engineering en functioneel programmeren door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Scala voor backend-engineering en functioneel programmeren te beginnen?
Ervaring vooraf is niet nodig. Scala voor backend-engineering en functioneel programmeren op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “IO combineren”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Scala voor backend-engineering en functioneel programmeren?
Ja. Elke les over Scala voor backend-engineering en functioneel programmeren bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Cats-typeclasses
- De IO-monad
- IO combineren
- Foutafhandeling in IO