type ViewState<T> =
| { status: 'idle' }
| { status: 'loading' }
| { status: 'success'; data: T }
| { status: 'error'; error: Error };
function renderUI(state: ViewState<string[]>) {
switch (state.status) {
case 'idle':
return 'Apasă butonul pentru încărcare';
case 'loading':
return 'Se încarcă datele...';
case 'success':
return `Avem ${state.data.length} elemente`;
case 'error':
return `Eroare: ${state.error.message}`;
default: {
// Asigură verificarea completă la compilare
const _exhaustiveCheck: never = state;
return _exhaustiveCheck;
}
}
}Am văzut prea multe codebase-uri unde starea unui ecran sau a unui request e modelată cu cinci booleeni separați: isLoading, isSuccess, isError, data și errorMessage. Rezultatul e mereu același: stări imposibile în UI, unde ai simultan isLoading: true și isError: true, iar componentele afișează un spinner peste un ecran roșu de eroare.
Discriminated unions (sau tagged unions) rezolvă fix problema asta forțând sistemul de tipuri să accepte doar stări logice valide.
Problema booleenilor independenți
La un checkout flow cu vreo 6 pași și în jur de 40k de tranzacții lunare, am moștenit un reducer React plin de flag-uri: isSubmitting, paymentPending, has3DSecureError, canRetry. Când userul dădea back din pagina băncii și apăsa iar pe Submit, doi booleeni se băteau cap în cap. Logica devenise un coșmar de if (isSubmitting && !paymentPending && !has3DSecureError).
Am aruncat toate flag-urile alea la gunoi și am rescris starea ca un union cu un singur câmp discriminator, de obicei numit status sau kind. O stare nu poate fi simultan în loading și în eroare. E fie una, fie alta.
Când discriminezi după status: 'error', TypeScript știe sigur că proprietatea error există. În schimb, dacă ești pe status: 'loading', compilatorul urlă la tine dacă încerci să citești data fără să verifici înainte. Scapi instant de defensive programming și de operatorul ?. pus la disperare peste tot.
Exhaustiveness checking: plasa de siguranță
Cel mai util truc când folosești acest pattern este verificarea exhaustivă folosind tipul never. Dacă ai un switch care procesează stările sau acțiunile dintr-un reducer, vrei să fii sigur că ai acoperit absolut toate cazurile posibile.
Când adaugi un caz nou în union, de exemplu status: 'requires_action', vrei ca build-ul să crape imediat în toate locurile unde n-ai tratat noul caz. Nu vrei să afli asta pe staging sau, mai rău, dintr-un tichet de la un client.
Trimiți valoarea pe ramura default într-o funcție helper sau o atribui unei variabile de tip never. Dacă vreun caz a fost omis, TypeScript dă eroare la compilare pentru că valoarea rămasă nu este asignabilă tipului never.
Trade-off-uri reale
Să fim sinceri: pattern-ul nu vine gratis. Scrii ceva mai mult boilerplate la definirea tipurilor inițiale. E nevoie de disciplină în echipă, fiindcă e mai comod pentru un junior să mai arunce un isModalOpen: boolean în interfață decât să gândească o stare finită.
De asemenea, dacă ai formulare mari cu zeci de câmpuri parțial completate, modelarea lor strictă cu discriminated unions poate deveni alambicată și redundantă. Pentru formulare clasice, o stare plată e deseori suficientă.
Dar pentru API responses, flow-uri de plată, mașini de stare sau acțiuni de Redux, pattern-ul ăsta mi-a salvat nenumărate ore de debugging. Câștigă detașat prin faptul că mută bug-urile de logică din runtime direct în timpul de compilare.
Voi cum gestionați stările complexe în frontend? Ați trecut complet pe discriminated unions sau vă bazați în continuare pe librării dedicate gen XState?