Canaux d’erreurs et de dépendances
Erreurs typées et environnement
Canaux d’erreurs et de dépendances 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.
Deux canaux puissants
Au-delà de la valeur de réussite, ZIO[R, E, A] suit un canal d’erreur typée E et un canal de dépendances R. Les deux apparaissent dans le type, ce qui rend les échecs et les exigences explicites dès la compilation.
Erreurs typées
Modélisez les échecs propres au domaine sous forme de hiérarchie scellée et placez-la dans E. Le compilateur vous obligera alors à traiter exactement ces cas.
import zio._
sealed trait AppError
case object NotFound extends AppError
case object Forbidden extends AppError
val lookup: IO[AppError, String] = ZIO.fail(NotFound)Récupérer les erreurs avec catchAll
catchAll gère toutes les erreurs dans E en fournissant un nouvel effet. Après cette opération, le canal d'erreur peut devenir Nothing si l'erreur a été entièrement gérée.
import zio._
val safe: UIO[String] =
ZIO.fail("boom").catchAll(e => ZIO.succeed(s"recovered: $e"))catchSome et orElse
catchSome récupère uniquement les erreurs correspondantes. orElse utilise un autre effet comme solution de repli en cas d'échec.
import zio._
val prog = ZIO.fail("x").orElse(ZIO.succeed("fallback"))Either et fold
either transforme ZIO[R, E, A] en ZIO[R, Nothing, Either[E, A]]. fold traite l'erreur et la réussite pour produire une seule valeur.
import zio._
val label: UIO[String] =
ZIO.fail(404).fold(e => s"err $e", v => s"ok $v")Défauts et échecs
ZIO distingue les échecs (typés, attendus et présents dans E) des défauts (exceptions inattendues). ZIO.die lève un défaut ; les défauts ne font pas partie du type E et représentent des bogues.
L'environnement R
Le canal R déclare les services dont un effet a besoin. Accédez à un service avec ZIO.service ; le besoin reste présent dans R tant qu'il n'est pas fourni.
import zio._
trait Logger { def log(s: String): UIO[Unit] }
val prog: ZIO[Logger, Nothing, Unit] =
ZIO.serviceWithZIO[Logger](_.log("hello"))Définir un service
Un service est un trait associé à un ZLayer qui le construit. Les couches décrivent comment construire les dépendances et peuvent elles-mêmes dépendre d'autres couches.
import zio._
case class ConsoleLogger() extends Logger {
def log(s: String): UIO[Unit] = ZIO.succeed(println(s))
}
object ConsoleLogger {
val layer: ULayer[Logger] = ZLayer.succeed(ConsoleLogger())
}
trait Logger { def log(s: String): UIO[Unit] }Fournir les dépendances
provide (ou provideLayer) satisfait le besoin R et transforme ZIO[Logger, E, A] en ZIO[Any, E, A], prêt à être exécuté.
import zio._
val runnable: UIO[Unit] =
ZIO.serviceWithZIO[Logger](_.log("hi"))
.provide(ConsoleLogger.layer)
trait Logger { def log(s: String): UIO[Unit] }
object ConsoleLogger { val layer: ULayer[Logger] = ??? }Composer des couches
Les couches se composent horizontalement avec ++ (pour les combiner) et verticalement avec >>> (pour transmettre la sortie d'une couche comme entrée d'une autre), afin de construire un graphe complet de dépendances.
import zio._
// val appLayer = configLayer ++ (dbLayer >>> repoLayer)Référence Scala classique
En guise de comparaison, voici un programme Scala autonome avec une gestion manuelle des erreurs. ZIO encode la même erreur dans le type et injecte les dépendances au moyen de couches.
object Main {
def main(args: Array[String]): Unit = {
val result: Either[String, Int] = Left("NotFound")
val msg = result.fold(e => s"err $e", v => s"ok $v")
println(msg)
}
}Vérification rapide
Que fait la méthode provide sur un ZIO[Logger, E, A] ?
Récapitulatif
Vous avez travaillé avec les deux canaux supplémentaires :
- Erreurs :
Etypé,catchAll,orElse,fold, défauts et échecs - Dépendances :
R, services,ZLayer,provide, composition de couches
Ensuite : exécuter des applications ZIO.
Apprends Scala avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 39
- Leçons
- 143
Questions Fréquemment Posées
La leçon « Canaux d’erreurs et de dépendances » est-elle gratuite ?
Oui — le texte complet de « Canaux d’erreurs et de dépendances » 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 « Canaux d’erreurs et de dépendances » ?
Erreurs typées et environnement 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 « Canaux d’erreurs et de dépendances » ?
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.
Toutes les leçons de ce cours
- L’effet ZIO
- Composer ZIO
- Canaux d’erreurs et de dépendances
- Exécuter des applications ZIO