பாரபட்சமான யூனியன் என்றால் என்ன மற்றும் அது ஏன் சக்திশாலி?

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` வருதல் ஒவ்வொரு வழக்கையும் கையாள நிர்ப்பந்திக்கிறது — புதிய status சேர்த்தால் கம்பைலர் ஒவ்வொரு switch இரைக்கிறது.

## ஏன் இது முக்கியம்

பாரபட்சமான யூனியன்கள் கோட்(loading/success/error), நிகழ்வுகள்/செயல்கள் (Redux reducers), மற்றும் "பல வடிவங்களில் ஒன்று" தரவு மாதிரி செய்ய வழக்கமான வழி ஆகும்.

எவை சட்டவிரோத நிலைகளை சாத்தியமற்றதாக்குகின்றன மற்றும் `never` தந்திரம் மூலம், நீங்கள் compile-time exhaustiveness சரிபார்ப்பு பெறுகிறீர்கள் — loose `boolean`/optional-field மாதிரிக்கு மேல் ஒரு বெரிய பாதுகாப்பு வெற்றி.