Removing modifiers with minus in Typescript - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of removing readonly modifier with minus

What is the type of MutablePerson after removing the readonly modifier from Person?

Typescript

type Person = {
  readonly name: string;
  readonly age: number;
};

type MutablePerson = {
  -readonly [K in keyof Person]: Person[K];
};

const p: MutablePerson = { name: "Alice", age: 30 };
p.name = "Bob";

console.log(p.name);

A Compilation error

B Alice

C TypeError at runtime

D Bob

💡 Hint

Removing the readonly modifier allows properties to be changed.

The minus sign before readonly removes the readonly modifier, so the property 'name' can be reassigned. The console.log prints the updated value 'Bob'.

❓ Predict Output

intermediate

Effect of removing optional modifier with minus

What is the type of RequiredUser after removing the optional modifier from User?

Typescript

type User = {
  id: number;
  name?: string;
};

type RequiredUser = {
  -? [K in keyof User]: User[K];
};

const user: RequiredUser = { id: 1, name: "John" };
console.log(user.name);

A John

B Compilation error: Property 'name' is missing

C undefined

D TypeError at runtime

💡 Hint

Removing the optional modifier makes the property required.

The minus sign before ? removes the optional modifier, so 'name' must be present. The code assigns 'John' and logs it.

🔧 Debug

advanced

Why does this code cause a compilation error?

Consider this code snippet using minus modifiers. Which option explains the cause of the error?

Typescript

type Flags = {
  readonly active?: boolean;
};

type MutableFlags = {
  -readonly -? [K in keyof Flags]: Flags[K];
};

const flags: MutableFlags = {};
console.log(flags.active);

A Minus modifiers only work on methods, not properties

B Cannot remove both readonly and optional modifiers at once

C Removing optional modifier requires property to be present, but object is empty

D TypeScript does not support mapped types with multiple modifiers

💡 Hint

Check if the object satisfies the required properties after removing optional.

Removing the optional modifier makes 'active' required, but the object is empty, causing a compilation error.

🧠 Conceptual

advanced

Understanding combined minus modifiers in mapped types

What is the effect of the following mapped type?

type T = { readonly a?: number };
type U = { -readonly -? [K in keyof T]: T[K] };

A Properties in U are mutable and required

B Properties in U are readonly and optional

C Properties in U are mutable and optional

D Properties in U are readonly and required

💡 Hint

Minus removes modifiers from properties.

The minus signs remove readonly and optional modifiers, so properties become mutable and required.

📝 Syntax

expert

Which option causes a syntax error when removing modifiers?

Which of the following mapped type definitions is syntactically invalid in TypeScript when trying to remove modifiers?

A type A = { -readonly [K in keyof T]: T[K] };

B type D = { -readonly? [K in keyof T]: T[K] };

C type C = { -readonly -? [K in keyof T]: T[K] };

D type B = { -? [K in keyof T]: T[K] };

💡 Hint

Check the correct syntax for removing modifiers with minus.

Option B is invalid because '-readonly?' is not valid syntax; modifiers must be removed separately with '-' before each modifier.

Practice

1.

What does the minus sign - do in TypeScript mapped types when used with modifiers like readonly or ??

easy

A. It renames the properties by adding a prefix.

B. It removes the specified modifier from the properties.

C. It duplicates the properties with the modifier.

D. It adds the specified modifier to the properties.

Solution

1. Step 1: Understand mapped types modifiers

   In TypeScript, modifiers like readonly and ? control property mutability and optionality.

2. Step 2: Role of minus sign in mapped types

   Using - before a modifier removes that modifier from the properties in the new type.

3. Final Answer:

   It removes the specified modifier from the properties. -> Option B

4. Quick Check:

   Minus sign removes modifiers [OK]

Hint: Minus sign removes modifiers like readonly or optional [OK]

Common Mistakes:

• Thinking minus adds modifiers instead of removing
• Confusing minus with negation in values
• Assuming minus duplicates properties

2.

Which of the following is the correct syntax to remove the readonly modifier from all properties of type T in a mapped type?

type Mutable<T> = {

  [P in keyof T]: T[P]

}

easy

A. type Mutable<T> = { -readonly [P in keyof T]: T[P] }

B. type Mutable<T> = { readonly- [P in keyof T]: T[P] }

C. type Mutable<T> = { [P in keyof T]-: T[P] }

D. type Mutable<T> = { [P in keyof T]: -readonly T[P] }

Solution

1. Step 1: Syntax for removing readonly modifier

   In mapped types, -readonly placed before the property name removes the readonly modifier.

2. Step 2: Check each option

   type Mutable<T> = { -readonly [P in keyof T]: T[P] } correctly uses -readonly [P in keyof T]. Others misuse syntax or place minus incorrectly.

3. Final Answer:

   type Mutable<T> = { -readonly [P in keyof T]: T[P] } -> Option A

4. Quick Check:

   Minus before readonly removes it [OK]

Hint: Use -readonly before property in mapped type [OK]

Common Mistakes:

• Placing minus after readonly
• Putting minus inside property type
• Using minus without readonly keyword

3.

Given the following code, what is the type of Result?

type Original = { readonly a: number; b?: string; c: boolean };

type Result = { -readonly [K in keyof Original]-?: Original[K] };

medium

A. { readonly a: number; b?: string; c: boolean }

B. { readonly a: number; b: string; c: boolean }

C. { a: number; b?: string; c: boolean }

D. { a: number; b: string; c: boolean }

Solution

1. Step 1: Analyze modifiers removed

   The -readonly removes readonly from all properties. The -? removes optional modifier, making all properties required.

2. Step 2: Apply changes to Original type

   Property a loses readonly, b loses optional, so b becomes required string, c stays boolean required.

3. Final Answer:

   { a: number; b: string; c: boolean } -> Option D

4. Quick Check:

   Minus removes readonly and optional [OK]

Hint: Minus removes modifiers, so readonly and ? are gone [OK]

Common Mistakes:

• Forgetting that -? removes optional
• Assuming readonly stays
• Thinking optional remains

4.

Identify the error in this mapped type that tries to remove the ? optional modifier:

type RequiredProps<T> = { [P in keyof T]-?: T[P] }

Which statement is true?

medium

A. Minus sign cannot be used to remove optional modifiers.

B. Minus sign should be before the property name like -? [P in keyof T].

C. The syntax is correct; it removes the optional modifier.

D. The minus sign must be after the property name like [P in keyof T]? -.

Solution

1. Step 1: Check syntax for removing optional modifier

   In mapped types, placing -? immediately after the property name removes the optional modifier.

2. Step 2: Verify given code

   The code uses [P in keyof T]-?: T[P], which is correct syntax to remove optional.

3. Final Answer:

   The syntax is correct; it removes the optional modifier. -> Option C

4. Quick Check:

   Minus after property removes optional [OK]

Hint: Minus ? after property removes optional modifier [OK]

Common Mistakes:

• Placing minus before property name for optional
• Thinking minus can't remove optional
• Misplacing minus sign

5.

You have a type with some properties readonly and some optional:

type Data = { readonly id: number; name?: string; active: boolean };

Write a mapped type CleanData that removes both readonly and ? modifiers from all properties.

Which of these is correct?

hard

A. type CleanData = { -readonly [P in keyof Data]-?: Data[P] }

B. type CleanData = { [P in keyof Data]-readonly-?: Data[P] }

C. type CleanData = { [P in keyof Data]-readonly -?: Data[P] }

D. type CleanData = { -readonly -? [P in keyof Data]: Data[P] }

Solution

1. Step 1: Remove readonly modifier

   Use -readonly before the property name to remove readonly.

2. Step 2: Remove optional modifier

   Use -? immediately after the property name to remove optional.

3. Step 3: Combine both in mapped type

   Correct syntax is { -readonly [P in keyof Data]-?: Data[P] }.

4. Final Answer:

   type CleanData = { -readonly [P in keyof Data]-?: Data[P] } -> Option A

5. Quick Check:

   Minus readonly before and minus ? after property [OK]

Hint: Minus readonly before, minus ? after property name [OK]

Common Mistakes:

• Placing minus signs incorrectly
• Trying to put minus signs inside brackets
• Using spaces that break syntax