Composer IO
Enchaînement des effets
Composer IO est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.
Enchaînement avec flatMap
Puisque IO est une monade, vous composez les effets avec flatMap. Chaque étape s’exécute dans l’ordre, et une étape ultérieure peut utiliser le résultat d’une étape précédente.
import cats.effect.IO
val program: IO[Unit] =
IO("Alice").flatMap(name => IO.println(s"Hello, $name"))Compréhension for
Une compréhension for est transformée en flatMap/map et se lit comme un script impératif tout en restant pure.
import cats.effect.IO
val prog: IO[Unit] = for {
_ <- IO.println("What is your name?")
name <- IO("Bob")
_ <- IO.println(s"Hi $name")
} yield ()L’ordre est préservé
Les effets d’une compréhension for s’exécutent de haut en bas lorsque le programme est exécuté. La structure de votre code reflète l’ordre d’exécution.
Combinaison d’effets indépendants
Lorsque deux effets ne dépendent pas l’un de l’autre, utilisez mapN ou (a, b).tupled pour les combiner. Ils s’exécutent tout de même séquentiellement par défaut, mais leur indépendance est exprimée.
import cats.effect.IO
import cats.syntax.apply._
val combined: IO[Int] = (IO(2), IO(3)).mapN(_ + _)Exécution d’effets en parallèle
Utilisez parMapN (issu de cats.syntax.parallel) pour exécuter simultanément des effets indépendants sur des fibres distinctes et combiner leurs résultats.
import cats.effect.IO
import cats.syntax.parallel._
val par: IO[Int] = (IO(2), IO(3)).parMapN(_ + _)Ignorer les résultats
Utilisez *> pour exécuter un effet et conserver le deuxième résultat, ou <* pour conserver le premier. void ignore entièrement le résultat et produit un IO[Unit].
import cats.effect.IO
val r1: IO[Int] = IO.println("log") *> IO(42)
val r2: IO[Unit] = IO(99).voidRépéter des effets
replicateA(n) exécute un effet n fois et rassemble les résultats dans une liste. foreverM le répète indéfiniment.
import cats.effect.IO
val three: IO[List[Unit]] = IO.println("tick").replicateA(3)Parcourir une liste
Transformez une List[A] en un effet produisant une List[B] avec traverse. Chaque élément produit un IO, puis les résultats sont rassemblés.
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 est la version parallèle de traverse : l’effet de chaque élément s’exécute sur sa propre fibre, ce qui convient parfaitement aux entrées-sorties concurrentes, comme la récupération de nombreuses 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))Un programme composé
Ce programme lit une valeur, la double et affiche le résultat : le tout est composé de petites étapes IO dans une seule description.
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 ()
}Enchaînement en Scala classique
À titre de comparaison, voici une sortie séquentielle vers la console en Scala classique : elle est avide et impure, contrairement à la version IO différée ci-dessus.
object Main {
def main(args: Array[String]): Unit = {
val n = 21
val d = n * 2
println(s"Doubled: $d")
}
}Vérification rapide
Quelle méthode exécute simultanément deux effets indépendants et combine leurs résultats ?
Récapitulatif
Vous avez composé des programmes IO avec :
flatMapetforpour l’enchaînementmapN/parMapNpour les effets indépendants*>,<*,voidpour combiner ou ignorertraverse/parTraversepour les collections
Ensuite : gérer les erreurs dans IO.
Questions Fréquemment Posées
La leçon « Composer IO » est-elle gratuite ?
Oui — le texte complet de « Composer IO » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Composer IO » ?
Enchaînement des effets Tu pratiques Scala for Backend Engineering & Functional Programming avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Scala for Backend Engineering & Functional Programming ?
Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Composer IO » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Scala for Backend Engineering & Functional Programming ?
Oui. Chaque leçon Scala for Backend Engineering & Functional Programming inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.