Comporre gli effetti
Concateni e combini gli effetti con pipe e generatori.
Comporre gli effetti è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.
Comporre gli effetti
Gli effetti sono valori, quindi costruisce i programmi componendoli. Gli strumenti fondamentali sono Effect.pipe, Effect.map, Effect.flatMap e la sintassi Effect.gen basata sui generatori.
pipe: concatenare le funzioni
pipe fa passare un effetto attraverso una serie di trasformazioni da sinistra a destra, evitando annidamenti profondi.
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: trasformare il valore di successo
Effect.map applica una funzione pura al valore di successo, lasciando invariati i canali degli errori e dei requisiti.
import { Effect } from "effect";
const doubled = Effect.map(Effect.succeed(21), (n) => n * 2);
// Effect<number, never, never>flatMap: concatenare gli effetti
Quando il passaggio successivo è a sua volta un effetto, usi flatMap (chiamato anche chain). Esegue il primo effetto, quindi passa il suo valore a una funzione che restituisce un altro effetto.
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 e flatMap
Usi map quando la funzione restituisce un valore semplice; usi flatMap quando restituisce un effetto. Usare map con una funzione che restituisce un effetto produce un effetto annidato.
I canali si accumulano
Quando concatena gli effetti, i relativi tipi di errore vengono uniti in un'unione e lo stesso accade ai requisiti. Il tipo composto riflette tutto ciò che può fallire e tutto ciò che è necessario.
// Effect<A, E1, R1> then Effect<B, E2, R2>
// => Effect<B, E1 | E2, R1 | R2>Effect.gen: sintassi dei generatori
Effect.gen permette di scrivere codice sequenziale basato sugli effetti, leggibile come async/await, usando yield* per estrarre il valore da ciascun effetto.
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 e pipe
gen è più chiaro per flussi lineari composti da più passaggi con variabili intermedie; pipe è ideale per brevi catene di trasformazioni. Sono liberamente interoperabili.
Combinare effetti indipendenti
Effect.all esegue più effetti e raccoglie i relativi risultati, accumulando gli errori e i requisiti di tutti.
import { Effect } from "effect";
const both = Effect.all([Effect.succeed(1), Effect.succeed("x")]);
// Effect<[number, string], never, never>La valutazione resta differita
Tutto questo descrive soltanto il programma. Nulla viene eseguito finché non lo avvia al margine dell'applicazione con Effect.runPromise o Effect.runSync.
import { Effect } from "effect";
// const result = await Effect.runPromise(program);Perché è importante
La composizione è ciò che rende pratici gli effetti: si assemblano piccoli elementi tipizzati per creare programmi complessi, mentre il compilatore tiene traccia di ogni errore e dipendenza. map, flatMap, pipe e gen sono i verbi di uso quotidiano del codice Effect.
Verifica rapida
Verifichi la Sua comprensione della composizione degli effetti.
Riepilogo
Gli effetti si compongono con map (trasforma i valori restituiti con successo), flatMap (mette in sequenza passaggi che restituiscono effetti), pipe (fa passare un valore attraverso le trasformazioni) e Effect.gen (sintassi dei generatori simile a await). I canali degli errori e dei requisiti si accumulano come unioni e nulla viene eseguito finché non lo si esegue al confine dell'applicazione.
Domande Frequenti
La lezione «Comporre gli effetti» è gratuita?
Sì — il testo completo di «Comporre gli effetti» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.
Cosa imparerò in «Comporre gli effetti»?
Concateni e combini gli effetti con pipe e generatori. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare TypeScript Academy?
Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Comporre gli effetti»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?
Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Perché i sistemi degli effetti sono importanti
- Il tipo Effect
- Comporre gli effetti
- Canali degli errori e dipendenze