Conas a oibríonn tagairt chineáil?

Question

Accepted Answer

**Type inference** is TypeScript figuring out types automatically from context, so you don't have to annotate everything. It infers from initial values, return statements, and usage.

```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 }
```

## Inference in functions and 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
```

This **contextual typing** is why callbacks rarely need parameter annotations — TypeScript knows `map` on a `number[]` passes a `number`.

## 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` infers the *literal* type because it can never change; `let` widens to the general type. This matters for unions:

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

## When to annotate anyway

- Function parameters (can't be inferred).
- When inference is too wide/narrow (e.g. you want `string` not the literal).
- Empty containers: `const xs = []` infers `any[]` — annotate as `number[]`.

## Cén fáth a bhfuil sé tábhachtach

Inference keeps TypeScript code nearly as concise as JavaScript while staying fully typed.

Understanding *when* it kicks in (and when it widens) lets you annotate only where it actually helps.