విభేదించిన యూనియన్ అంటే ఏమిటి మరియు అది ఎందుకు శక్తివంతమైనది?

Question

Accepted Answer

ఒక **విభేదించిన (టాగ్ చేసిన) యూనియన్** సాధారణ సాహిత్య ఫీల్డ్ — **విభేదకారి** — ను పంచుకునే అబ్జెక్ట్ రకాల యూనియన్, ఇది కంపైలర్ వేరియంట్‌లను వేరుచేయడానికి మరియు సురక్షితంగా సంకుచితం చేయడానికి ఉపయోగిస్తుంది.

```ts
type Result =
  | { status: "loading" }
  | { status: "success"; data: string }
  | { status: "error"; message: string };
```

ప్రతి సభ్యకు `status` సాహిత్య విలువ ఉంటుంది. దీన్ని తనిఖీ చేసినప్పుడు, ఇది ఖచ్చితంగా ఒక వేరియంట్‌కు సంకుచితం అవుతుంది, ఆ వేరియంట్ ఫీల్డ్‌లను అన్‌లాక్ చేస్తుంది:

```ts
function render(r: Result) {
  switch (r.status) {
    case "loading": return "...";
    case "success": return r.data;     // ✅ data exists only here
    case "error":   return r.message;  // ✅ message exists only here
  }
}
```

`loading` సందర్భంలో `r.data` ఇ ప్రయత్నించినట్లయితే, ఇది కంపైల్ ఎర్రర్ — టైప్ సిస్టమ్ చెల్లని కలయికలను *ప్రాతినిధ్యపరచలేనివిగా* చేస్తుంది.

## సంపూర్ణత తనిఖీ

```ts
function render2(r: Result): string {
  switch (r.status) {
    case "loading": return "...";
    case "success": return r.data;
    case "error":   return r.message;
    default:
      const _exhaustive: never = r; // ✅ if you add a variant and forget a case, this errors
      return _exhaustive;
  }
}
```

`never` కేటాయింపు ప్రతి సందర్భాన్ని నిర్వహించమని మిమ్మల్ని బలవంతం చేస్తుంది — కొత్త స్థితిని జోడించండి మరియు కంపైలర్ అన్ని స్విచ్‌లను నిర్దేశిస్తుంది అవసరమైన నవీకరణ చేయాలి.

## ఇది ఎందుకు ముఖ్యమైనది

విభేదించిన యూనియన్‌లు రాష్ట్రం (loading/success/error), ఇవెంట్‌లు/చర్యలు (Redux reducers), మరియు "అనేక ఆకారాలలో ఒకటి" డేటా మోడల్‌కు ఆదర్శవంత మార్గం.

వారు చట్టవిరుద్ధ రాష్ట్రాలను అసాధ్యమైనవిగా చేస్తారు మరియు `never` ట్రిక్‌తో, మీరు compile-time సంపూర్ణత చెక్킿ని పొందుతారు — loose `boolean`/optional-field మోడలింగ్‌కు విపరీతమైన భద్రత విజయం.