Generic Constraints & Default Type Parameters

The beginner course's firstElement<T> worked for any T, but plenty of generic functions only make sense for types that have something specific about them. Constraints narrow what T is allowed to be.

interface HasId {
  id: string;
}

function findById<T extends HasId>(items: T[], id: string): T | undefined {
  return items.find((item) => item.id === id);
}

interface Task extends HasId {
  title: string;
}

const tasks: Task[] = [{ id: '1', title: 'Write lesson' }];
findById(tasks, '1'); // ✅ Task has an id, so it satisfies HasId

findById([{ title: 'no id here' }], '1'); // ❌ compile error: missing id

T extends HasId doesn't mean inheritance the way a class extends does, it means "whatever T ends up being, it must have at least the shape of HasId." Inside the function, item.id is safe to access precisely because the constraint guarantees it exists, no matter which concrete type T turns out to be.

Constraining with keyof

A very common constraint ties a generic parameter to the keys of another generic parameter.

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const task = { id: '1', title: 'Write lesson', done: false };

getProperty(task, 'title'); // ✅ inferred as string
getProperty(task, 'nope');  // ❌ 'nope' isn't a key of task, compile error

K extends keyof T means "K can only be one of T's actual property names," so getProperty can never be called with a key that doesn't exist, and its return type (T[K]) is exactly the type of that specific property, not a generic unknown.

Default type parameters

Generics can also supply a default, used when the caller doesn't specify one explicitly.

interface ApiResponse<T = unknown> {
  status: number;
  data: T;
}

function ok(): ApiResponse {
  return { status: 200, data: null }; // T defaults to unknown here
}

function okWithTask(task: Task): ApiResponse<Task> {
  return { status: 200, data: task }; // T explicitly set to Task
}

T = unknown means ApiResponse (with no type argument at all) still compiles, falling back to unknown for data, while callers that care can still specify exactly what they're returning.