Hoe werkt type inference?

Question

Accepted Answer

**Type inference** is TypeScript die types automatisch uit context bepaalt, zodat je niet alles hoeft in te annoteren. Het leidt af uit beginwaarden, return-statements en gebruik.

```ts
let x = 10;          // inferred: number
let s = "hi";        // inferred: string
const arr = [1, 2];  // inferred: number[]
const obj = { a: 1, b: "x" }; // inferred: { a: number; b: string }
```

## Inferentie in functies en callbacks

```ts
function double(n: number) { return n * 2; } // return inferred as number

[1, 2, 3].map(n => n * 2); // `n` inferred as number from the array — no annotation needed
```

Deze **contextuele typing** is de reden waarom callbacks zelden parameteraantekeningen nodig hebben — TypeScript weet dat `map` op `number[]` een `number` doorgeeft.

## let vs const widening

```ts
let a = "hello";     // widened to string (let can be reassigned)
const b = "hello";   // narrowed to the literal type "hello"
```

`const` leidt het *letterlijke* type af omdat het nooit kan veranderen; `let` verbreit naar het algemene type. Dit is belangrijk voor unions:

```ts
const dir = "up";              // type "up"
let dir2 = "up";               // type string
```

## Wanneer toch annoteren

- Functieparameters (kunnen niet worden afgeleid).
- Wanneer inferentie te breed/smal is (bijv. je wilt `string` niet het letterlijke).
- Lege containers: `const xs = []` leidt `any[]` af — annoteer als `number[]`.

## Waarom het belangrijk is

Inferentie houdt TypeScript-code bijna even beknopt als JavaScript terwijl het volledig getypeerd blijft.

Begrijpen *wanneer* het van toepassing is (en wanneer het verbreit) stelt je in staat alleen te annoteren waar het echt helpt.