PricingLoginStart free
Scala til backendudvikling og funktionel programmering · Lektion

Komposition af IO

Sekventering af effekter

Lektion 3 af 413 trin

Komposition af IO er en gratis Scala til backendudvikling og funktionel programmering-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Scala til backendudvikling og funktionel programmering, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Scala til backendudvikling og funktionel programmering-kurset indeholder 4 lektioner i alt.

Sekvensering med flatMap

Fordi IO er en monade, sammensætter du effekter med flatMap. Hvert trin køres i rækkefølge, og et senere trin kan bruge resultatet fra et tidligere trin.

import cats.effect.IO

val program: IO[Unit] =
  IO("Alice").flatMap(name => IO.println(s"Hello, $name"))

for-comprehension

En for-comprehension omskrives til flatMap/map og læses som et imperativt script, samtidig med at den forbliver ren.

import cats.effect.IO

val prog: IO[Unit] = for {
  _    <- IO.println("What is your name?")
  name <- IO("Bob")
  _    <- IO.println(s"Hi $name")
} yield ()

Rækkefølgen bevares

Effekter i en for-comprehension køres fra top til bund, når programmet udføres. Kodens struktur afspejler udførelsesrækkefølgen.

Kombinering af uafhængige effekter

Når to effekter ikke afhænger af hinanden, skal du bruge mapN eller (a, b).tupled til at kombinere dem. De køres stadig sekventielt som standard, men udtrykker uafhængighed.

import cats.effect.IO
import cats.syntax.apply._

val combined: IO[Int] = (IO(2), IO(3)).mapN(_ + _)

Kørsel af effekter parallelt

Brug parMapN (fra cats.syntax.parallel) til at køre uafhængige effekter samtidigt på separate fibere og kombinere deres resultater.

import cats.effect.IO
import cats.syntax.parallel._

val par: IO[Int] = (IO(2), IO(3)).parMapN(_ + _)

Kassering af resultater

Brug *> til at køre en effekt og beholde det andet resultat, eller <* for at beholde det første. void kasserer resultatet helt og giver IO[Unit].

import cats.effect.IO

val r1: IO[Int]  = IO.println("log") *> IO(42)
val r2: IO[Unit] = IO(99).void

Gentagelse af effekter

replicateA(n) kører en effekt n gange og samler resultaterne i en liste. foreverM gentager den uden ende.

import cats.effect.IO

val three: IO[List[Unit]] = IO.println("tick").replicateA(3)

Gennemløb af en liste

Omdan en List[A] til en effekt over en List[B] med traverse. Hvert element producerer en IO, og resultaterne samles.

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 er den parallelle version af traverse — hvert elements effekt køres på sin egen fiber, hvilket er ideelt til samtidig I/O, f.eks. hentning af mange URL'er.

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))

Et sammensat program

Dette program læser en værdi, fordobler den og udskriver resultatet — alt sammen sammensat af små IO-trin i én beskrivelse.

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 ()
}

Sekvensering i almindelig Scala

Til sammenligning ser du her sekventielt konsoloutput i almindelig Scala — ivrigt og urent i modsætning til IO-versionen ovenfor, hvor det udskydes.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 21
    val d = n * 2
    println(s"Doubled: $d")
  }
}

Hurtigt tjek

Hvilken metode kører to uafhængige effekter samtidigt og kombinerer deres resultater?

Besvar den i den interaktive lektion

Opsummering

Du har sammensat IO-programmer med:

  • flatMap og for til sekvensering
  • mapN / parMapN til uafhængige effekter
  • *>, <*, void til kombinering og kassering
  • traverse / parTraverse til samlinger

Næste emne: håndtering af fejl i IO.

Gratis at komme i gang

Lær Scala med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
39
Lektioner
143
Start gratisSe hele kurset

Ofte stillede spørgsmål

Er lektionen “Komposition af IO” gratis?

Ja — hele teksten til “Komposition af IO” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Scala til backendudvikling og funktionel programmering-kurset, skal du opgradere til CoddyKit PRO. Scala til backendudvikling og funktionel programmering-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Komposition af IO”?

Sekventering af effekter Du øver dig i Scala til backendudvikling og funktionel programmering med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Scala til backendudvikling og funktionel programmering?

Der kræves ingen tidligere erfaring. Scala til backendudvikling og funktionel programmering på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Komposition af IO”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Scala til backendudvikling og funktionel programmering-lektion?

Ja. Alle Scala til backendudvikling og funktionel programmering-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. Cats-type classes
  2. IO-monaden
  3. Komposition af IO
  4. Fejlhåndtering i IO
← Tilbage til Scala til backendudvikling og funktionel programmering