type AsyncState<T> =
| { status: 'idle' }
| { status: 'loading' }
| { status: 'success'; data: T }
| { status: 'error'; error: Error };
function renderState<T>(state: AsyncState<T>): string {
switch (state.status) {
case 'idle':
return 'Apasă butonul pentru start';
case 'loading':
return 'Se încarcă...';
case 'success':
return `Date încărcate: ${JSON.stringify(state.data)}`;
case 'error':
return `Eroare: ${state.error.message}`;
default: {
// Dacă adaugi un nou status în AsyncState și uiți de el,
// compilatorul va da eroare exact aici:
const _exhaustiveCheck: never = state;
return _exhaustiveCheck;
}
}
}Am refactorizat acum câteva luni checkout-ul dintr-o aplicație cu vreo 14k tranzacții pe lună și am dat afară 8 flag-uri boolean care se băteau cap în cap. În locul lor am pus un discriminated union simplu. Dacă încă folosești isLoading, isError, isSuccess și data pe același obiect de state, articolul ăsta o să-ți scutească niște nopți albe.
Iluzia stărilor independente
Cu toții am scris interfețe de genul ăsta la început de drum:
interface RequestState {
isLoading: boolean;
isError: boolean;
data: User | null;
error: Error | null;
}
La prima vedere pare curat. În practică, tipul ăsta permite 16 combinații teoretice. Ce înseamnă când isLoading este true, dar isError este și el true, iar data are deja o valoare veche? Frontend-ul începe să clipească, spinner-ul rămâne blocat peste mesajul de eroare, iar tu bagi încă un if (!isLoading && !isError) ca să peticești problema.
Faci asta de trei ori și codul devine de neatins. Problema nu e logica ta din UI, ci modelarea stării: permiți compilatorului să accepte stări care în lumea reală nu ar trebui să existe niciodată.
Cum funcționează de fapt un discriminated union
Secretul stă într-o singură proprietate comună de tip literal, adesea numită status, type sau kind. Când TypeScript vede acea proprietate comună într-o uniune de tipuri, deduce automat restul proprietăților din ramura respectivă pe măsură ce verifici valoarea.
Dacă status === 'success', TypeScript știe sigur că data există și că nu este null. Nu mai ai nevoie de optional chaining (state.data?.name), nici de non-null assertion (state.data!.name). Dacă încerci să accesezi state.error pe ramura de succes, compilatorul îți dă peste degete direct în editor.
Pattern-ul strălucește în trei locuri mari:
- Răspunsuri de rețea / API client: tratezi
loading,successșifailurefără ambiguități. - Redux / useReducer actions: clasicul
{ type: 'ADD_TODO', payload: ... }este fix un discriminated union. - Mini state machines: când un pas din checkout depinde strict de finalizarea pasului anterior (ex:
AddressSelected->PaymentMethodChosen->ProcessingPayment).
Exhaustiveness checking: plasa de siguranță
Cel mai mare avantaj apare când modifici codul peste 6 luni. Dacă adaugi un nou status, cum ar fi 'requires_2fa', vrei ca aplicația să refuze compilarea până când nu tratezi noul caz peste tot.
Folosind tipul never pe ramura default dintr-un switch, forțezi compilatorul să verifice dacă ai acoperit toate ramurile posibile. Dacă uiți una, TypeScript aruncă eroare de build: nu poți atribui tipul neacoperit la never. Am prins zeci de bug-uri în CI/CD doar datorită acestei linii de cod.
Unde scârțâie: trade-off-ul sincer
Discriminated unions sunt geniale pentru stări discrete, dar devin enervante când ai nevoie de stări hibride legitime.
Un exemplu clasic: stale-while-revalidate (cum face TanStack Query sau SWR). Vrei să arăți datele vechi pe ecran în timp ce faci refetch în fundal. Dacă starea ta este strict { status: 'loading' }, pierzi accesul la data. Ca să rezolvi asta, ajungi să creezi stări intermediare precum { status: 'revalidating', previousData: T }, iar tipurile încep să se umfle.
De asemenea, dacă mapezi formulare mari cu 20 de câmpuri editabile independent, nu încerca să faci o uniune pentru fiecare câmp modificat. O să scrii boilerplate până la pensie. Acolo un simplu dicționar sau un obiect plat rămâne soluția corectă.
Voi cum gestionați revalidările în fundal când folosiți pattern-ul ăsta: preferați să păstrați datele opționale pe starea de loading sau mapați explicit o stare separată?