Generic Functions & Methods

## The problem Some functions are genuinely shaped the same for every type they touch: return the first element of an array, wrap a value in an object, pass a value through a logger. Without type variables you have three bad options — write the function once per type, widen everything to `any`, or widen everything to `unknown`. A type parameter is the fourth option: declare a placeholder in the signature and let each call site fill it in. ## What `any` actually does `any` is not "some type I don't know". It is an instruction to the checker to stop checking. A value of type `any` is assignable to everything, everything is assignable to it, and every property access and call on it is allowed. So with ```ts function identityAny(x: any): any { return x; } const a = identityAny("hello"); a.toFixed(2); // compiles; throws at runtime a.whateverYouLike; // compiles too ``` the error is not reported at the function — it is reported nowhere. Worse, `any` is contagious: `a` is `any`, so anything derived from `a` is `any` as well, and the hole spreads outward through the code that consumes the result. ## What the type parameter does instead `function identity<T>(x: T): T` declares one type parameter, `T`, in the angle brackets after the function name. Inside the signature `T` is an ordinary type you can use in parameters, in the return type, and in annotations in the body. The key point is that `T` occurs twice: once on the parameter and once on the return type. That single repetition is the whole payload — it tells the checker that the return type is *the same type as the argument*, whatever that turns out to be. ```ts function identity<T>(x: T): T { return x; } const b = identity("hello"); // b: string const c = identity(42); // c: number // b.toFixed(2); // Error: Property 'toFixed' does not exist on type 'string' ``` The function body is also checked against `T`. Because `T` could be any type, `x.length` inside the body is an error — you have said nothing about what `T` supports, so the checker assumes nothing. That is a feature: the body is verified once, for all possible callers, rather than re-verified per call. ## Everything is erased TypeScript's whole type layer disappears during compilation. The emitted JavaScript for both versions is identical: ```js function identity(x) { return x; } ``` There is no per-type copy of the function (unlike C++ templates), no runtime type token, and no reflection. Consequences worth saying out loud in an interview: a generic function costs nothing at runtime; you cannot write `if (x instanceof T)` in the body, because `T` is not a value; and you cannot switch on `T` to pick behaviour. If the body genuinely needs to branch on the shape of the value, it has to test the *value* with a runtime check, not the type parameter. ## `unknown` is safe but forgetful `function identity(x: unknown): unknown` is type-safe in a way `any` is not — the checker refuses every operation on the result until you narrow it. But safety is not the same as precision. `unknown` throws the caller's information away, so every call site has to prove all over again what it already knew. A type parameter keeps that information: `identity("hi")` gives back a `string` with no narrowing, no assertion, and no ceremony. The rule of thumb: `unknown` for values whose type you truly do not know (parsed JSON, a caught error); a type parameter for values whose type the *caller* knows and you merely pass through. ## The call site Usually you write nothing extra — the checker works `T` out from the argument. You can also supply it explicitly with `identity<string>("hi")`, which is occasionally useful to pin down a wider type than the argument suggests or to make a signature's intent obvious at a call site. Explicit type arguments never change the emitted code; they only constrain what the checker accepts. ## What it does not buy you A type parameter is not validation. It does not check that the incoming value really is a `string`, because there is no runtime check to perform. It also does not create a relationship you did not write: if `T` appears only once in the whole signature, the function is not really generic in a useful way — the parameter is doing no linking work, and the honest signature is a concrete type or `unknown`.