Generics

This function works on anything and tells you nothing:

function first(items: any[]): any { return items[0]; }

A type parameter keeps the connection between what went in and what comes out:

function first<T>(items: T[]): T | undefined {
  return items[0];
}

const n = first([1, 2, 3]);       // number | undefined
const s = first(["a", "b"]);      // string | undefined

T is not a type; it is a slot the caller fills, usually without noticing, because TypeScript infers it from the argument.

Constraints

Inside the function you may only do what every possible T allows, which is almost nothing. extends narrows what a caller may pass, and in return lets you use it:

function longest<T extends { length: number }>(a: T, b: T): T {
  return a.length >= b.length ? a : b;
}

longest("abc", "de");       // fine: strings have length
longest([1, 2], [3]);       // fine: arrays have length

Try it

1// One entry per key; a later item with the same key replaces an earlier one.2function indexBy<T, K extends string>(items: T[], key: (item: T) => K): Record<K, T> {3  const out = {} as Record<K, T>;4  for (const item of items) {5    out[key(item)] = item;6  }7  return out;8}9 10export function run(): string[] {11  const people = [12    { login: "nino", name: "Nino Beridze", country: "GE" },13    { login: "luka", name: "Luka Meladze", country: "DE" },14  ];15  const byLogin = indexBy(people, (p) => p.login);16  // byLogin.nino is known to be one of those objects, not any.17  return [byLogin.nino.name, byLogin.luka.country];18}

The utility types worth knowing

• Partial<T> — every property optional. A patch object.
• Required<T> — the opposite.
• Pick<T, K> / Omit<T, K> — a subset of the properties.
• Record<K, V> — an object with keys K and values V.
• ReturnType<F> — what a function type returns.

They are all declared in TypeScript's own library files, built from generics plus the mapped and conditional types a later lesson covers. Nothing here is magic.

Where a generic signature can lie

indexBy above returns Record<K, T>, and K was inferred as string — so the type promises an entry for every string key. Ask for one that does not exist:

1function indexBy<T, K extends string>(items: T[], key: (item: T) => K): Record<K, T> {2  const out = {} as Record<K, T>;3  for (const item of items) {4    out[key(item)] = item;5  }6  return out;7}8 9export function run(): string[] {10  const people = [11    { login: "nino", name: "Nino Beridze" },12    { login: "luka", name: "Luka Meladze" },13  ];14  const byLogin = indexBy(people, (p) => p.login);15  // Record<string, ...> promises an entry for every string key. There is none for ana.16  const ana = byLogin["ana"];17  const answer: string[] = [typeof ana];18  try {19    answer.push(ana.name);20  } catch (e) {21    answer.push(String(e));22  }23  return answer;24}

The type says T; the value is undefined. The {} as Record<K, T> inside the function was the first lie, and indexing a Record with any string is the second. The noUncheckedIndexedAccess compiler flag (not part of strict) makes every such index read T | undefined, which forces the check.

Common mistakes

• A type parameter used once. function log<T>(x: T): void gains nothing over x: unknown. A type parameter earns its place by linking two positions — an input to an output, or two inputs to each other.
• Constraining too little, then casting. Writing <T> and then (item as any).length inside throws the check away; T extends { length: number } keeps it.
• Trusting Record<string, X> lookups. As above, a missing key comes back undefined while the type says X.

What interviewers ask

• What does T extends { length: number } mean? A constraint: callers may only pass types with a numeric , and in return the body may use .