type MyReadonly<T> = { readonly [P in keyof T]: T[P] }

Solution by shaishabcoding #36838

type MyReadonly<T> = {
  readonly[P in keyof T]: T[P];
}  //Here we change from 'any' on this 

import type { Equal, Expect } from '@type-challenges/utils'

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

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

Solution by GormanProg123 #36813

type MyReadonly<T> = {
  readonly [key in keyof T]: T[key]
}

Solution by BernTheSeal #36808

// 你的答案
type MyReadonly<T> = {
  readonly [P in keyof T]: T[P];
};

Solution by Huiyong-Chen #36801

type MyReadonly<T> = {
  readonly [P in keyof T]: T[P]
}

/* _____________ Test Cases _____________ */
import type { Equal, Expect } from '@type-challenges/utils'

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

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

Solution by AnastasiaSv #36759

type MyReadonly = { readonly [P in keyof T]: T[P] }

Solution by Abdullah-Elsayed01 #36743

// type MyReadonly<T> = {
  readonly [K in keyof T]: T[K]
}

Solution by Mamdouhreda #36705

// 여기 풀이를 입력하세요
type MyReadonly<T> = {
  readonly [key in keyof T]: T[key]
}

Solution by seungdeok #36686

// your answers
type MyReadonly<T> = { readonly [key in keyof T]: T[key] }

Solution by desertby #36640

type MyReadonly<T> = {
  readonly [P in keyof T]: T[P]
}

Solution by kimdaeyeobbb #36635

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

Solution by wiJeeXu #36597

type MyReadonly<T> = {
  readonly [k in keyof T] : T[k]
}

Solution by ae-hyon #36587

// 你的答案
type MyReadonly<T> = {
  readonly [P in keyof T]: T[P]
}

Solution by MrSissel #36578

// your answers
type MyReadonly<T> = {
  readonly [key in keyof T]:T[key]
}

Solution by mola-fish #36573

type MyReadonly = { readonly [P in keyof T]: T[P] }

Solution by ChemieAi #36547

// 你的答案

type MyReadonly = { readonly [key in keyof T]: T[key] }

Solution by Rocco10086 #36534

type MyReadonly = { readonly [K in keyof T]: T[K] }

Solution by UsGitHu611 #36493

type MyReadonly<T> = {
  readonly [K in keyof T ] :T[K]
}

Solution by blueSky120 #36481

type MyReadonly<T> = {
  readonly [P in keyof T]: T[P];
};

Solution by alirezaprime #36409

// your answers
type MyReadonly<T> = {readonly [J in keyof T]: T[J]};

Solution by justBadProgrammer #36356

type MyReadonly<T> = {
  readonly [k in keyof T] : T[k]
}

Solution by tac-tac-go #36353

// 你的答案
type MyReadonly<T> = {
  readonly [key in keyof T]: T[key]
}

Solution by ATravelerGo #36337

type MyReadonly<T> = {
  readonly [K in keyof T]: T[K] 
}

Solution by 1Alex4949031 #36307

// your answers
type MyReadonly<T> = { readonly [P in keyof T]: T[P]; }

Solution by Jace254 #36264

// your answers

type MyReadonly = { readonly [k in keyof T]: T[k] }

Solution by lxy2222 #36199

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

Solution by tjd985 #36186

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

Solution by asylbekduldiev #36162

type MyReadonly<T> = {
  readonly [i in keyof T]: T[i]
}

Solution by AleksandrShcherbackov #36139

// 你的答案

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

Solution by louzhaoyan #36129

type MyReadonly<T> = {
  readonly [K in keyof T]: T[K]
}

Solution by EvgeniyKoch #36119