Composer des effets
Enchaîner et combiner des effets avec pipe et des générateurs.
Composer des effets est une leçon TypeScript Academy 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 TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.
Composer des effets
Les effets sont des valeurs ; vous construisez donc des programmes en les composant. Les outils principaux sont Effect.pipe, Effect.map, Effect.flatMap et la syntaxe fondée sur les générateurs Effect.gen.
pipe : faire circuler dans des fonctions
pipe fait passer un effet dans une série de transformations de gauche à droite, ce qui évite les imbrications profondes.
import { Effect, pipe } from "effect";
const program = pipe(
Effect.succeed(2),
Effect.map((n) => n + 1),
Effect.map((n) => n * 10)
);
// Effect<number, never, never> producing 30map : transformer la valeur de réussite
Effect.map applique une fonction pure à la valeur de réussite, sans modifier les canaux d’erreur et d’exigences.
import { Effect } from "effect";
const doubled = Effect.map(Effect.succeed(21), (n) => n * 2);
// Effect<number, never, never>flatMap : enchaîner des effets
Lorsque l’étape suivante est elle-même un effet, utilisez flatMap (également appelé chain). Cette opération exécute le premier effet, puis transmet sa valeur à une fonction qui renvoie un autre effet.
import { Effect, pipe } from "effect";
const getId = Effect.succeed(1);
const loadUser = (id: number) => Effect.succeed({ id, name: "Ada" });
const program = pipe(getId, Effect.flatMap(loadUser));
// Effect<{ id: number; name: string }, never, never>map ou flatMap
Utilisez map lorsque votre fonction renvoie une valeur simple ; utilisez flatMap lorsqu’elle renvoie un effet. Utiliser map avec une fonction qui renvoie un effet vous laisse avec un effet imbriqué.
Les canaux s’accumulent
Lorsque vous enchaînez des effets, leurs types d’erreur s’unissent et leurs exigences s’unissent également. Le type composé reflète tout ce qui peut échouer et tout ce qui est nécessaire.
// Effect<A, E1, R1> then Effect<B, E2, R2>
// => Effect<B, E1 | E2, R1 | R2>Effect.gen : syntaxe des générateurs
Effect.gen vous permet d’écrire du code d’effets séquentiels qui se lit comme async/await, en utilisant yield* pour déballer chaque effet.
import { Effect } from "effect";
const program = Effect.gen(function* () {
const id = yield* Effect.succeed(1);
const user = yield* Effect.succeed({ id, name: "Ada" });
return user.name;
});
// Effect<string, never, never>gen ou pipe
gen est plus clair pour les flux linéaires comportant plusieurs étapes et des variables intermédiaires ; pipe est idéal pour les courtes chaînes de transformations. Ils s’utilisent librement ensemble.
Combiner des effets indépendants
Effect.all exécute plusieurs effets et rassemble leurs résultats, en accumulant les erreurs et les exigences de chacun.
import { Effect } from "effect";
const both = Effect.all([Effect.succeed(1), Effect.succeed("x")]);
// Effect<[number, string], never, never>Toujours paresseux
Tout cela ne fait que décrire le programme. Rien ne s’exécute tant que vous ne le lancez pas à la frontière avec Effect.runPromise ou Effect.runSync.
import { Effect } from "effect";
// const result = await Effect.runPromise(program);Pourquoi c'est important
La composition rend les effets pratiques : vous assemblez de petites pièces typées pour créer de grands programmes, tandis que le compilateur suit chaque erreur et chaque dépendance. map, flatMap, pipe et gen sont les verbes du quotidien dans le code utilisant cette bibliothèque.
Vérification rapide
Vérifiez votre compréhension de la composition des effets.
Récapitulatif
Vous composez les effets avec map (transformer les valeurs de réussite), flatMap (enchaîner les étapes qui renvoient des effets), pipe (faire passer une valeur à travers des transformations) et Effect.gen (une syntaxe de générateur semblable à l'attente). Les canaux d'erreurs et d'exigences s'élargissent pour réunir toutes les possibilités, et rien ne s'exécute tant que vous ne l'exécutez pas à la périphérie.
Questions Fréquemment Posées
La leçon « Composer des effets » est-elle gratuite ?
Oui — le texte complet de « Composer des effets » 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 « Composer des effets » ?
Enchaîner et combiner des effets avec pipe et des générateurs. 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 3 sur 4.
Combien de temps prend la leçon « Composer des effets » ?
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