What is a mapped type, and how would you implement your own Readonly or Partial using one?

A strong answer covers: A mapped type iterates over keyof T and applies a transformation to each property, producing a new object type; Readonly /Partial are exactly this: { readonly [K in keyof T]: T[K] } and { [K in keyof T]?: T[K] }; Modifiers can be removed with a minus prefix (-readonly, -?), which is how Required is implemented.

Lesson 14 of 80

Mapped Types

The mechanism the utility types lesson's Partial, Pick, and Readonly are actually built from — a way to generate a new object type by transforming every property of an existing one.

13 min read

Check your understanding

Every option explains itself — why the right one is right, and why each wrong one is wrong. Miss one and it comes back later on a spaced-repetition schedule.

Question 1 of 2

How would you implement your own version of the built-in Partial<T> utility type?

type MyPartial<T> = { [K in keyof T]?: T[K] }Partial<T> can only be used via the built-in utility, it can't be reimplementedtype MyPartial<T> = T | undefined

Stuck? Ask the AI tutor

Hints without spoilers, and a plain explanation of why a wrong answer was wrong — answered only from this lesson. Free account, no card.

Interview questions on Mapped Types

What interviewers actually ask about this, and what a strong answer has to cover.

What is a mapped type, and how would you implement your own Readonly<T> or Partial<T> using one?

A strong answer covers

A mapped type iterates over keyof T and applies a transformation to each property, producing a new object type
Readonly<T>/Partial<T> are exactly this: { readonly [K in keyof T]: T[K] } and { [K in keyof T]?: T[K] }
Modifiers can be removed with a minus prefix (-readonly, -?), which is how Required<T> is implemented

Likely follow-ups

What is key remapping (the `as` clause inside a mapped type), and what's it useful for?
How would you build a utility type that only keeps the keys whose values are functions?
How do mapped types and conditional types combine in practice?

Practice these with the AI interviewer →

The plain-language idea

A mapped type walks every key of an existing type and produces a new type by applying the same transformation to each:

type User = { name: string; age: number };

type ReadonlyUser = { readonly [K in keyof User]: User[K] };
// { readonly name: string; readonly age: number }

type OptionalUser = { [K in keyof User]?: User[K] };
// { name?: string; age?: number }

keyof User gives you the union of User's keys ("name" | "age"); [K in keyof User] loops over that union, one member at a time, and User[K] looks up each property's type — building a brand-new object type, property by property.

Mapped types: looping over keys to build a new typeStep 1 of 3

type User = { name: string; age: number } — the original shape.

Modifiers can add or remove, not just apply

type Concrete<T> = { [K in keyof T]-?: T[K] };  // -? removes optionality
type Mutable<T> = { -readonly [K in keyof T]: T[K] };  // -readonly removes readonly

The - prefix on a modifier (-?, -readonly) strips that modifier instead of adding it — the inverse operations to Partial and Readonly, which is exactly how Required<T> is actually implemented.

What people usually miss

Watch out

keyof plus a mapped type is the standard way to build your own utility type the moment the built-in ones (Partial, Pick, Omit) don't quite fit your specific need.
Key remapping (as inside the brackets) lets you rename keys during the mapping: { [K in keyof T as `get${string & K}`]: () => T[K] } turns { name: string } into { getName: () => string } — generating getter method names from property names.
Mapped types combine naturally with conditional types (the next lesson) — filtering which keys survive the mapping based on their value's type is a very common real pattern.

Why this matters in interviews

"How would you implement your own version of Partial<T>?" is a real, common exercise, and mapped types are the honest, correct answer — showing you understand the mechanism the utility types lesson only showed the output of.