Generics

Generics parameterize a function, class, or type over a type variable so the same code works for many types while preserving the exact type. function identity<T>(x: T): T returns whatever type it receives, so identity(5) is typed number. Unlike any, which erases the type, a generic keeps the link between input and output, staying fully type-safe.

Each is a mapped type over keyof T that flips one modifier. Partial<T> makes every property optional by adding ?, Required<T> removes optionality with -?, and Readonly<T> marks every property readonly. All three are shallow and all three are erased from the emitted JavaScript.

The compiler infers T from the call's arguments: it matches each argument's type against the parameter that mentions T and picks the best common candidate, so identity(5) gives T = number. If T appears in no parameter, it falls back to its default or unknown.

Be generic over the function type and rebuild the signature from it: (...args: Parameters<T>) => ReturnType<T>. Parameters<T> extracts the argument tuple, ReturnType<T> the result, so the cached version is checked exactly like the original.

A generic keeps the link between input and output: in first<T>(xs: T[]): T the compiler binds T at the call site and hands the same type back, so first(users) is a User. With any[] the link is cut — the result is any and goes unchecked.

Declare function toArray<T>(input: T | T[]): T[]. The compiler infers T from either branch — toArray(user) and toArray(users) both give User[]. Inside, Array.isArray(input) narrows the union, and no type argument is needed.

Use extends to require the type argument to be assignable to a given shape: function len<T extends { length: number }>(x: T) accepts only types that have a length, so x.length is allowed inside the body. The constraint narrows what callers may pass while still preserving the exact type. You can also constrain one parameter by another, e.g. <K extends keyof T> to index into T safely.

Pick<T, K> builds a type with only the keys K from T. Omit<T, K> builds a type with every key of T except K — it is literally Pick<T, Exclude<keyof T, K>>. Exclude<U, E> operates on a union, removing the members of U that are assignable to E. So Pick and Omit select or drop object properties, while Exclude filters union members.

A type parameter is inferable only if it occurs in a parameter. fetchOne<User>(url) has no User in its arguments, so the type argument is an unchecked claim about the response — a runtime schema belongs there. Elsewhere, let inference work.

They declare the variance the compiler would otherwise infer: out T means T appears only in outputs (covariant), in T only in inputs (contravariant), in out T is invariant. The annotation is checked against real usage; a mismatch errors.

Function parameters are contravariant: a handler for any Animal also handles the Dog it will receive, so the wider parameter is safe. A Dog-only handler would break on a Cat. strictFunctionTypes enforces this on function-typed properties.

Deliberate unsoundness, kept for compatibility. strictFunctionTypes makes function-typed properties contravariant but exempts method shorthand — else Array<Dog> would not be an Array<Animal>. Declare the member as a property to get the check.