La monade IO
Effets purs
La monade IO est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 2 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.
Qu’est-ce que IO ?
IO[A] de Cats Effect est une description d’un calcul qui, lorsqu’il est exécuté, peut produire des effets de bord et une valeur de type A. Il s’agit d’une valeur pure : rien ne se produit tant que vous ne l’exécutez pas.
Différer les effets de bord
Enveloppez un effet de bord avec IO(...) ou IO.delay(...). Le corps n’est pas exécuté lors de la création de l’IO, mais uniquement lorsqu’il est exécuté.
import cats.effect.IO
val program: IO[Unit] = IO(println("Hello, IO!"))
// Nothing printed yet — program is just a descriptionTransparence référentielle
Comme IO est paresseux, vous pouvez remplacer une valeur IO par sa définition sans modifier le comportement. Cette transparence référentielle facilite le raisonnement sur le code avec effets et sa réorganisation.
Valeurs pures
Utilisez IO.pure pour élever une valeur déjà calculée. Ne placez pas d’effets de bord dans pure : son évaluation est immédiate. Utilisez IO.delay ou IO(...) pour les effets.
import cats.effect.IO
val p: IO[Int] = IO.pure(42)
// 42 is computed already; pure just wraps itmap et as
map transforme le résultat d’un IO. as le remplace par une constante. Aucun des deux n’exécute l’effet : ils construisent une description plus complète.
import cats.effect.IO
val len: IO[Int] = IO("hello").map(_.length)
val done: IO[String] = IO(println("ran")).as("done")Exécuter avec IOApp
Pour exécuter un programme IO, étendez IOApp et implémentez run en retournant un IO[ExitCode]. L’environnement d’exécution l’évalue sur un ordonnanceur fondé sur des fibres.
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
Pour les programmes sans arguments ni codes de sortie personnalisés, étendez IOApp.Simple et fournissez un 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 fournit IO.println pour afficher facilement une valeur sous forme d’effet. Il retourne IO[Unit] et n’affiche la valeur que lors de l’exécution.
import cats.effect.IO
val greet: IO[Unit] = IO.println("effectful output")Capture des exceptions
Si l’effet encapsulé lève une exception, l’échec est capturé à l’intérieur de IO au lieu de s’échapper. Le IO devient une valeur en échec que vous pourrez traiter ultérieurement.
import cats.effect.IO
val boom: IO[Int] = IO(throw new RuntimeException("fail"))
// Creating boom does NOT throw; running it wouldComparaison avec Scala classique
Sans type d’effet, les effets de bord s’exécutent immédiatement et sont difficiles à composer. IO les diffère ; ainsi, un programme Scala autonome affiche immédiatement son résultat, tandis qu’avec IO, l’affichage serait différé.
object Main {
def main(args: Array[String]): Unit = {
val eager = println("runs now") // executed immediately
println("second line")
}
}Pourquoi utiliser IO ?
IO vous apporte :
- Pureté — les effets sont des valeurs
- Composabilité — construisez des programmes à partir de petits éléments
- Sécurité — les erreurs et les ressources sont suivies
- Concurrence — des fibres légères
Vérification rapide
Quand l’effet de bord contenu dans IO(println("hi")) s’exécute-t-il réellement ?
Récapitulatif
La monade IO modélise les effets sous forme de valeurs pures et paresseuses :
IO(...)/IO.delaydiffèrent les effetsIO.pureencapsule les valeurs calculéesIOApp/IOApp.Simpleexécutent les programmes- Les exceptions sont capturées, et non levées immédiatement
Ensuite : composer plusieurs actions IO.
Questions Fréquemment Posées
La leçon « La monade IO » est-elle gratuite ?
Oui — le texte complet de « La monade 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 « La monade IO » ?
Effets purs 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 2 sur 4.
Combien de temps prend la leçon « La monade 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.