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

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

Solution by jhsung23 #36091

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

Solution by tungulin #36047

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

Solution by karazyabko #36023

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

Solution by KimKyuHoi #36011

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

Solution by krokerdile #35986

// your answers

/* _____________ Your Code Here _____________ */

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

/* _____________ 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 pytest5 #35897

{ readonly [P in keyof T]: T[P] }

Solution by dienphamvan #35881

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

Solution by Yunjaejo #35865

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

Solution by reonce #35817

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

Solution by naruto-823 #35783

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

Solution by hatbann #35757