0Pricing
TypeScript Academy · Lesson

Modifiers in Mapped Types: readonly and ?

Add or remove modifiers with +/- in mapped types.

Modifiers in Mapped Types: readonly and ? is a free TypeScript Academy lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the TypeScript Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Welcome

Mapped types can add or remove `readonly` and optional (`?`) modifiers from properties using the `+` and `-` prefixes.

Adding Modifiers with +

The `+` prefix (implicit by default) adds a modifier to each property in the mapped type.
type Readonly<T> = { +readonly [K in keyof T]: T[K] }; // + is implicit
type Optional<T> = { [K in keyof T]+?: T[K] };

Removing readonly with -

Use `-readonly` to strip the readonly modifier from properties.
type Mutable<T> = { -readonly [K in keyof T]: T[K] };
const mutableUser: Mutable<Readonly<User>> = { id: 1, name: 'Alice' };
mutableUser.id = 2; // OK now

Removing ? with -

Use `-?` to remove the optional modifier, making all properties required.
type Required<T> = { [K in keyof T]-?: T[K] };
// Now all optional properties become required

Combining - and -?

You can combine both removals to create a mutable, required version of a type.
type Concrete<T> = { -readonly [K in keyof T]-?: T[K] };

Partial and Required Are Opposites

Partial adds `?` with +?. Required removes it with -?.
// From TypeScript lib:
type Partial<T> = { [K in keyof T]?: T[K] };   // adds ?
type Required<T> = { [K in keyof T]-?: T[K] };  // removes ?

Modifier Preservation by Default

Without explicit + or -, mapped types preserve existing modifiers from the source type.
interface User { readonly id: number; name?: string; }
type Copy<T> = { [K in keyof T]: T[K] };
type C = Copy<User>; // readonly id preserved, name? preserved

Practical Use: Patch Type

Create a Patch type that makes all properties optional and also removes readonly for updates.
type Patch<T> = { -readonly [K in keyof T]?: T[K] };

DeepReadonly

Apply readonly recursively with a conditional type inside the mapped type.
type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K]
};

DeepPartial

Similarly, apply ? recursively for a deeply optional type.
type DeepPartial<T> = {
  [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K]
};

Modifier Combinations Table

+readonly = add readonly. -readonly = remove readonly. +? = add optional. -? = remove optional. All four can be combined.

Quick Check

What does `{ [K in keyof T]-?: T[K] }` produce?

Recap

Use +/- prefixes before readonly and ? in mapped types to explicitly add or remove those modifiers. -? implements Required, -readonly implements Mutable. Combine both for complete mutability control.

Frequently asked questions

Is the “Modifiers in Mapped Types: readonly and ?” lesson free?

Yes — the full text of “Modifiers in Mapped Types: readonly and ?” is free to read here on the web, and the TypeScript Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the TypeScript Academy course, upgrade to CoddyKit PRO.

What will I learn in “Modifiers in Mapped Types: readonly and ?”?

Add or remove modifiers with +/- in mapped types. You practise TypeScript Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start TypeScript Academy?

No prior experience is required. TypeScript Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Modifiers in Mapped Types: readonly and ?” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this TypeScript Academy lesson?

Yes. Every TypeScript Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Mapped Types: Transforming Object Types
  2. Modifiers in Mapped Types: readonly and ?
  3. Template Literal Types: String Patterns
  4. Key Remapping with as in Mapped Types
← Back to TypeScript Academy