Mapped type for deep transformations in Typescript - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a deep readonly mapped type

What is the type of obj after applying the DeepReadonly mapped type to data?

Typescript

type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K]
};

const data = {
  name: "Alice",
  details: {
    age: 30,
    hobbies: ["reading", "hiking"]
  }
};

const obj: DeepReadonly<typeof data> = data;

// What happens if we try to assign obj.details.age = 31?

A TypeScript error: Property 'age' does not exist on type 'DeepReadonly<typeof data>'.

B Runtime error when assigning the value.

C TypeScript error: Cannot assign to 'age' because it is a read-only property.

D No error, assignment works normally.

💡 Hint

Think about what 'readonly' means in TypeScript and how it applies recursively.

The DeepReadonly type recursively marks all properties as readonly, including nested objects. So trying to assign a new value to obj.details.age causes a TypeScript compile-time error.

❓ Predict Output

intermediate

Output of a deep partial mapped type

Given the DeepPartial type below, what is the type of partialUser?

Typescript

type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P]
};

interface User {
  id: number;
  profile: {
    name: string;
    address: {
      city: string;
      zip: string;
    };
  };
}

const partialUser: DeepPartial<User> = {
  profile: {
    address: {
      city: "New York"
    }
  }
};

A partialUser can have any subset of User properties, including nested ones, all optional.

B partialUser must have all properties of User defined.

C partialUser can only omit top-level properties, nested properties are required.

D partialUser cannot omit any properties; all are required.

💡 Hint

Look at how the optional modifier and recursion are applied in the mapped type.

The DeepPartial type makes all properties optional recursively, so partialUser can have any subset of properties at any depth.

🔧 Debug

advanced

Identify the error in a deep required mapped type

The following DeepRequired type is intended to make all properties required recursively. Which option correctly identifies the error in the code?

Typescript

type DeepRequired<T> = {
  [P in keyof T]-?: T[P] extends object ? DeepRequired<T[P]> : T[P];
};

A It only works on top-level properties, not nested ones.

B It causes infinite recursion on types like arrays or functions because they are objects too.

C It does not remove optional modifiers from properties.

D It causes a syntax error due to missing semicolon.

💡 Hint

Consider what types extend object in TypeScript and how that affects recursion.

Since arrays and functions are also objects, the recursive condition causes infinite recursion or incorrect behavior. A better approach is to exclude arrays and functions from recursion.

📝 Syntax

advanced

Which mapped type syntax is correct for deep transformation?

Which option correctly defines a mapped type that recursively makes all properties readonly?

A type DeepReadonly<T> = { readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K] };

B type DeepReadonly<T> = { [K in keyof T]: readonly DeepReadonly<T[K]> };

C type DeepReadonly<T> = { readonly [K in keyof T]: DeepReadonly<T[K]> };

D type DeepReadonly<T> = { [K in keyof T]: T[K] extends object ? readonly DeepReadonly<T[K]> : T[K] };

💡 Hint

Remember to check the placement of 'readonly' and the conditional type.

Option A correctly places readonly before the property and uses a conditional type to recurse only on objects.

🚀 Application

expert

Create a mapped type to deeply transform all string properties to number

Which option defines a mapped type DeepStringToNumber that recursively changes all string properties to number, leaving other types unchanged?

A type DeepStringToNumber<T> = { [K in keyof T]: T[K] extends object ? DeepStringToNumber<T[K]> : number };

B type DeepStringToNumber<T> = { [K in keyof T]: T[K] extends object ? DeepStringToNumber<T[K]> : T[K] extends string ? number : T[K] };

C type DeepStringToNumber<T> = { [K in keyof T]: T[K] extends string ? number : T[K] };

D type DeepStringToNumber<T> = { [K in keyof T]: T[K] extends string ? number : T[K] extends object ? DeepStringToNumber<T[K]> : T[K] };

💡 Hint

Check the order of conditional checks to handle strings before objects or vice versa.

Option D correctly checks if the property is a string first, then if it is an object to recurse, otherwise leaves it unchanged.