Canaux d’erreur et dépendances
Suivre les erreurs typées et les dépendances injectées dans les effets.
Canaux d’erreur et dépendances est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 4 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 TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.
Canaux d'erreurs et dépendances
Deux canaux rendent cette bibliothèque puissante : le canal d'erreurs typées (E) et le canal d'exigences (R). Cette leçon vous montre comment échouer avec des erreurs typées et comment fournir des dépendances à l'aide de Context et Layer.
Échecs typés avec Effect.fail
Effect.fail place une valeur dans le canal d'erreurs. Les classes étiquetées facilitent la distinction entre les erreurs.
import { Effect } from "effect";
class NotFound { readonly _tag = "NotFound"; }
class Forbidden { readonly _tag = "Forbidden"; }
const load = Effect.fail(new NotFound());
// Effect<never, NotFound, never>Les erreurs s'unissent lors de la composition
Lorsque vous enchaînez des effets produisant des erreurs différentes, celles-ci sont réunies dans le canal E, dont le type répertorie ainsi tous les modes d'échec.
// Effect<A, NotFound, never> then Effect<B, Forbidden, never>
// => Effect<B, NotFound | Forbidden, never>Gérer les erreurs
Effect.catchAll ou catchTag gèrent les erreurs, en les supprimant du canal ou en les remplaçant. Gérer NotFound restreint le canal E.
import { Effect, pipe } from "effect";
const safe = pipe(
Effect.fail(new NotFound()),
Effect.catchTag("NotFound", () => Effect.succeed("default"))
);
// Effect<string, never, never> -- error handledRécupérer ou propager
Si vous ne gérez pas une erreur, elle reste dans E et se propage jusqu'à l'appelant, qui doit alors la gérer ou la propager à son tour. Le compilateur garantit qu'aucune erreur n'est perdue silencieusement.
Déclarer une dépendance
Un service est déclaré comme un Context.Tag. Les effets qui l'utilisent ajoutent ce service à leur canal R.
import { Context, Effect } from "effect";
class Random extends Context.Tag("Random")<
Random,
{ readonly next: Effect.Effect<number> }
>() {}
const program = Effect.gen(function* () {
const random = yield* Random;
return yield* random.next;
});
// Effect<number, never, Random>Les exigences apparaissent dans le type
Remarquez que le canal R contient maintenant Random. L'effet ne peut pas s'exécuter tant que cette exigence n'est pas satisfaite ; le compilateur l'impose.
Fournir avec une couche
Une Layer décrit comment construire un service. Fournir une couche satisfait l'exigence et la retire du canal R.
import { Effect, Layer } from "effect";
const RandomLive = Layer.succeed(Random, {
next: Effect.sync(() => Math.random()),
});
const runnable = Effect.provide(program, RandomLive);
// Effect<number, never, never> -- R clearedLes couches se composent
Les couches peuvent dépendre d'autres couches et se combiner pour construire un graphe complet de dépendances. La bibliothèque les agence dans le bon ordre en fonction de leurs types.
import { Layer } from "effect";
// Layer.merge(DatabaseLive, LoggerLive)
// Layer that provides both servicesTester en échangeant les couches
Comme les dépendances sont explicites, les tests fournissent une couche différente (par exemple, un Random déterministe) sans toucher au programme testé : c'est un avantage majeur du suivi des exigences.
import { Layer, Effect } from "effect";
const RandomTest = Layer.succeed(Random, {
next: Effect.succeed(0.5),
});
// Effect.provide(program, RandomTest) -> deterministicPourquoi c'est important
Les canaux d'erreurs et d'exigences transforment les suppositions invisibles en contrats vérifiés par le compilateur : chaque échec doit être géré ou déclaré, et chaque dépendance doit être fournie. C'est ce qui rend les grands programmes utilisant cette bibliothèque robustes et faciles à tester.
Vérification rapide
Vérifiez votre compréhension des canaux d'erreurs et des dépendances.
Récapitulatif
Le canal d'erreurs suit les échecs typés (Effect.fail, restreints par catchTag/catchAll) qui s'élargissent au fil de la composition, tandis que le canal d'exigences suit les services déclarés via Context.Tag et satisfaits par des Layer grâce à Effect.provide. Ensemble, ils permettent au compilateur de vérifier les échecs et les dépendances, et facilitent les tests par échange de couches.
Questions Fréquemment Posées
La leçon « Canaux d’erreur et dépendances » est-elle gratuite ?
Oui — le texte complet de « Canaux d’erreur et 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 TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Canaux d’erreur et dépendances » ?
Suivre les erreurs typées et les dépendances injectées dans les effets. Tu pratiques TypeScript Academy 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 TypeScript Academy ?
Aucune expérience préalable n'est requise. TypeScript Academy 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 4 sur 4.
Combien de temps prend la leçon « Canaux d’erreur et 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 TypeScript Academy ?
Oui. Chaque leçon TypeScript Academy 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
- Pourquoi les systèmes d’effets sont importants
- Le type Effect
- Composer des effets
- Canaux d’erreur et dépendances