Type Challenges: 00008-medium-readonly-2 Solution

// answer 1
type MyReadonly2<T, K extends keyof T = keyof T> = Readonly<Pick<T, K>> & Omit<T, K>

// answer 2
type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [Key1 in keyof T as Key1 extends K ? Key1 : never]: T[Key1];
} & {
  [Key2 in keyof T as Key2 extends K ? never : Key2]: T[Key2];
}

Solution by AlexBraunMagic #36907

type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [P in K]: T[P]
} & {
  [P in Exclude<keyof T, K>]: T[P]
}

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

type cases = [
  Expect<Alike<MyReadonly2<Todo1>, Readonly<Todo1>>>,
  Expect<Alike<MyReadonly2<Todo1, 'title' | 'description'>, Expected>>,
  Expect<Alike<MyReadonly2<Todo2, 'title' | 'description'>, Expected>>,
  Expect<Alike<MyReadonly2<Todo2, 'description' >, Expected>>,
]

// @ts-expect-error
type error = MyReadonly2<Todo1, 'title' | 'invalid'>

interface Todo1 {
  title: string
  description?: string
  completed: boolean
}

interface Todo2 {
  readonly title: string
  description?: string
  completed: boolean
}

interface Expected {
  readonly title: string
  readonly description?: string
  completed: boolean
}

Solution by AnastasiaSv #36880

type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [P in keyof T as P extends K ? P : never]: T[P]
} & {
  [P in keyof T as P extends K ? never : P]: T[P]
}

Solution by liyunguang-d #36834

type MyReadonly2<T, Keys extends keyof T = keyof T> = {
  readonly [K in Keys]: T[K]
} & {
  [K in keyof T as K extends Keys ? never: K]: T[K]
}

Solution by duynhanf #36776

type MyReadonly2<T, K extends keyof T = keyof T> =  Omit<T, K> & {
  readonly [I in keyof T]: T[I]
}

Solution by tungulin #36724

// 여기 풀이를 입력하세요
type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [key in K]: T[key]
} & Omit<T, K>

Solution by seungdeok #36697

type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [P in K]: T[P]
} & {[U in keyof T as U extends K ? never : U] : T[U]}

Solution by wiJeeXu #36664

type MyReadonly2<T, K extends keyof T = keyof T> = { readonly [P in K]: T[P] } & { [P in Exclude<keyof T, K>]: T[P] }

Solution by ChemieAi #36561

type MyReadonly2<T, K = keyof T > =  
{ readonly [Key in keyof T as Key extends K ? Key : never]: T[Key]} 
  & {[Key in keyof T as Key extends K ? never : Key ]: T[Key]}

Solution by badri-derakhshan #36529

type MyReadonly2<T, K extends keyof T = keyof T> = { readonly [P in K]: T[P] } & { [P in Exclude<keyof T, K>]: T[P] }

Solution by asylbekduldiev #36328

// 你的答案
type MyReadonly2<T, K extends keyof T  =  keyof T> = {
  readonly [key in keyof T as key extends K? key: never]: T[key]
} & {
  [key in keyof T as key extends K? never: key]: T[key]
}

Solution by leafBoat-dev #36295

// 你的答案
type Merge<T> = {
  [P in keyof T]: T[P]
}
type MyReadonly2<T extends object, K extends keyof T = never> = [K] extends [never] ? 
  { readonly[P in keyof T] : T[P]}
  :Merge<{ readonly[P in keyof T as P extends K ? P : never] :  T[P]}&{ [P in keyof T as P extends K ? never : P] :  T[P]}>
//虽然方式很笨拙，不管没出西现报错就好

Solution by 352623635 #36166

type MyReadonly2<T, K extends keyof T = keyof T> =
      {readonly [Prop in keyof T as Prop extends K ? Prop : never]: T[Prop]}
    & {[Prop in keyof T as Prop extends K ? never : Prop]: T[Prop]}

Solution by karazyabko #36037

type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [P in K]: T[P];
} & {
  [P in keyof T as P extends K ? never : P]: T[P];
};

Solution by Young2un #35703

type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [P in K]: T[P];
} & Omit<T, K>;

Solution by gangnamssal #35506

// your answers
type MyReadonly2<T extends {}, K extends keyof T = keyof T> = T & { readonly [P in K]: T[P] };

Solution by Sathiyapramod #35456

type MyReadonly2<T, K = keyof T> = Omit<T, K & keyof T> & {
  readonly [k in keyof T as k extends K ? k : never]: T[k]
}

Solution by wendao-liu #35174

type MyReadonly2<T, P extends keyof T> = {
	readonly [K in P]: T[K];
} & {
	[K in keyof T as K extends P ? never : K]: T[K];
}

Solution by ClarityOfMind #35041

type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [key in K]: T[key];
} & {
  [key in keyof Omit<T, K>]: T[key];
}

Solution by dominikmatt #35009

type MyReadonly2<T, K extends keyof T> = {
 readonly [P in K]: T[P]
} & {
  [P in Exclude<keyof T, K>]: T[P];
};

Solution by raeyoung-kim #34997

type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [key in K]: T[key]
} & {
  [key in keyof T as key extends K ? never: key]: T[key]
}

Solution by 56aiden90 #34909

type MyReadonly2<T, K extends keyof T = keyof T> ={ readonly [key in K]: T[key] } & { [R in keyof T as R extends K ? never : R]: T[R] }

Solution by floatDreamWithSong #34872

type MyReadonly2<T, K extends keyof T = keyof T> = { readonly [Key in keyof Pick<T, K>]: T[Key] } & { [Key in keyof Omit<T, K>]: T[Key] }

Solution by eunsukimme #34825

// your answers
type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [P in K]: T[P];
} & {
  [P in keyof T as P extends K ? never : P]: T[P];
};

Solution by zeyuanHong0 #34774

// 你的答案
type MyOmit<T extends Record<string, any>, K> = {
  [key in keyof T as key extends K ? never : key]: T[key]
}
type MyPick<T extends Record<string, any>, K> = {
  [key in keyof T as key extends K ? key : never]: T[key]
}
type ToReadonly<T extends Record<string, any>> = {
  readonly [key in keyof T]: T[key]
}

type IsRq<T, U> = (<P>() => P extends T ? 1 : 2) extends (<P>() => P extends U ? 1 : 2) ? true : false

type MyReadonly2<T extends Record<string, any>, K extends keyof T | undefined = undefined> = IsRq<K, undefined> extends true ? ToReadonly<T> : ToReadonly<MyPick<T, K>> & MyOmit<T, K>

Solution by softkilllengxiaoning #34734


type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [P in K]: T[P];
} & {
  [P in keyof T as P extends K ? never : P]: T[P];
}

Solution by dev-jaemin #34630

type MyReadonly2<T, K extends keyof T = keyof T> = 
{
  readonly [key in K] : T[key]
} & {
  [P in keyof T as P extends K ? never : P] : T[P]
}
// K extends keyof T = keyof T, use "=" here mean that assign K with default value keyof T

Solution by binhdv155127 #34602

type MyReadonly2<T extends Record<string, any>, K extends keyof T = keyof T> = { [P in keyof T as (P extends K ? never : P)]: T[P] } & { readonly [P in keyof T]: T[P] }
// your answers

Solution by Rustamaha #34589

type MyReadonly2<T, K extends keyof T = keyof T> = Omit<T, K> & {
  readonly [U in K]: T[U]
} & Omit<T, K>

Solution by Yunjaejo #34588

type MyReadonly2<T, K extends keyof T = keyof T> = {
   [P in keyof T as P extends K ? never : P]: T[P]
} & {
  readonly [P in K]: T[P]
}

Solution by devshinthant #34560