Generics are one of TypeScript's most powerful features. Learn how to write flexible, reusable, and type-safe code with advanced generic patterns including conditional types, mapped types, and infer.

# Mastering TypeScript Generics: Beyond the Basics TypeScript generics allow you to write functions, classes, and interfaces that work with any data type while still enforcing type safety. Most developers know the basic `Array<T>` or `Promise<T>`, but the real power lies deeper. ## Conditional Types Conditional types let you express non-uniform type mappings: ```typescript type IsArray<T> = T extends any[] ? true : false; type A = IsArray<string[]>; // true type B = IsArray<string>; // false ``` ## The `infer` Keyword `infer` lets you extract types from within conditional type checks: ```typescript type UnpackPromise<T> = T extends Promise<infer U> ? U : T; type Resolved = UnpackPromise<Promise<string>>; // string ``` ## Mapped Types Transform every property of an existing type: ```typescript type Nullable<T> = { [K in keyof T]: T[K] | null; }; ``` ## Practical Example: A Type-Safe API Fetcher ```typescript async function fetchData<T>(url: string): Promise<T> { const res = await fetch(url); if (!res.ok) throw new Error(`HTTP ${res.status}`); return res.json() as Promise<T>; } const user = await fetchData<{ id: number; name: string }>("/api/user/1"); // user.id and user.name are fully typed ``` ## Key Takeaways - Use conditional types for type-level branching logic. - Use `infer` to extract inner types from complex structures. - Use mapped types to derive new types from existing ones. - Generic constraints (`extends`) narrow what types are accepted. Generics are the gateway to writing truly reusable TypeScript code. Invest time mastering them and your type definitions will become expressive, self-documenting contracts.