Mutable

In this medium-level challenge, you'll implement the generic Mutable<T> which removes the readonly modifier from all properties in T, making them mutable.

interface Todo {
readonly title: string
readonly description: string
readonly completed: boolean
}
 
type MutableTodo = Mutable<Todo> // { title: string; description: string; completed: boolean; }
 

interface Todo1 {
  title: string
  description: string
  completed: boolean
  meta: {
    author: string
  }
}

type List = [1, 2, 3]

type cases = [
  Expect<Equal<Mutable<Readonly<Todo1>>, Todo1>>,
  Expect<Equal<Mutable<Readonly<List>>, List>>,
]

type errors = [
  // @ts-expect-error
  Mutable<'string'>,
  // @ts-expect-error
  Mutable<0>,
]

Detailed Explanation

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

How it works:

• The type constrains T to object to ensure only object and array types are accepted (rejecting primitives like string or number, as shown in the error test cases)
• It uses a mapped type that iterates over every key K in T with keyof T
• The -readonly modifier prefix removes the readonly attribute from each property, which is the inverse of adding readonly (or +readonly)
• The value type T[K] is preserved as-is, meaning this is a shallow operation -- nested objects retain their original readonly status
• This works for both object types and tuple/array types, since mapped types over tuples preserve the tuple structure

An alternative using the built-in Readonly for context:

// Readonly adds the modifier:
type Readonly<T> = { readonly [K in keyof T]: T[K] };
// Mutable removes it (the exact inverse):
type Mutable<T extends object> = { -readonly [K in keyof T]: T[K] };

This challenge helps you understand the readonly modifier and mapped type modifier removal syntax, and how to apply these concepts in real-world scenarios.