X'inhu user-defined type guard?

Question

Accepted Answer

A **user-defined type guard** hija funzjoni li t-return type tagħha hija **type predicate** (`x is T`). Meta tirritorna `true`, il-compiler inaqqas l-argument għal `T` fil-kodiċi li jikkjamat — li jagħtik il-possibbiltà li tinkapsola checks tal-runtime personalizzati.

```ts
interface Cat { meow(): void; }
interface Dog { bark(): void; }

// the magic is the return type `pet is Cat`, not just `boolean`
function isCat(pet: Cat | Dog): pet is Cat {
  return "meow" in pet;
}

function speak(pet: Cat | Dog) {
  if (isCat(pet)) {
    pet.meow(); // ✅ narrowed to Cat
  } else {
    pet.bark(); // ✅ narrowed to Dog
  }
}
```

Bidla l-predicate `pet is Cat`, `isCat` li tirritorna `boolean` ma tkun *mhux* tnaqqas `pet` — il-compiler xorta kien jara `Cat | Dog` ġewwa l-`if`. Il-predicate hija dik li tgħallmu.

## Validazzjoni ta' data esterna mhux magħrufa

```ts
interface User { id: number; name: string; }

function isUser(x: unknown): x is User {
  return (
    typeof x === "object" && x !== null &&
    typeof (x as any).id === "number" &&
    typeof (x as any).name === "string"
  );
}

const data: unknown = await res.json();
if (isUser(data)) data.name; // ✅ safely typed as User
```

## Tweġiba

Il-compiler **jittfiena** fil-predicate tiegħek — jekk il-lojika tal-body hija ħażina, inti tikseb narrowing mhux sikur. Għal forom kumplessi, validator ta' schema (zod) jiġġenera guards korretti għalik.

## Għaliex hu importanti

Type guards ilaqqaak tibdel checks arbitrarji tal-runtime fi funzjonijiet ta' narrowing riusabbli — essenzjali għall-validazzjoni ta' data `unknown` f'API/boundaries u għad-distinzjoni ta' membri ta' union meta check sempliċi `typeof`/`in` mhuwiex biżżejjed għalih innifsu.