type Chainable<R = unknown> = {
  option<T extends string, V extends any>(key: T extends keyof R ? never : T, value: V): Chainable<Omit<R, T> & Record<T, V>>
  get(): R
}

Solution by eunsukimme #35121

type Chainable<T = {}> = {
  option<K extends string, V>(key: K, value: V): Chainable<Omit<T, K> & Record<K, V>>;
  get(): T;
};

Solution by 2njeong #35083

type Chainable<T = {}> = {
  option<K extends string, V>(key: string, value: any): Chainable<T & {[P in K]: V}>
  get(): T
}

Solution by raeyoung-kim #35013

// 你的答案
type Chainable<T = {}> = {
  option<K extends string, V>(key: K extends keyof T ? never : K, value: V): Chainable<{
    [P in K]: V
  } & {
    [P in keyof T as P extends K ? never : P]: T[P]
  }>
  get(): T
}

Solution by heyuelan #34689

declare const config: Chainable<Result>

interface Result {
  foo: number
  name: string
  bar: {
    value: string
  }
}

type Chainable<T> = {
  options: <Key extends keyof T>(key: Key, val: T[Key]) => Chainable<Omit<T, Key>>
  get: () => T
}

const result = config.options('foo', 12)
  .options('name', 'foo')
  .options('bar', { value: 'bar' })
  .get()

Solution by semet #34645

type Chainable<T extends Record<string, any> = {}> = {
  option<K extends string, V extends any>(key: K extends keyof T ? never : K, value: V ): K extends keyof T ? Chainable<{ [P in K]: V }> : Chainable<T & { [P in K]: V }>
  get(): T
}
// your answers

Solution by Rustamaha #34597

type Chainable<T = {}> = {
  option: <K extends string, V>(key: K extends keyof T ? never
    : K, value: V) => Chainable<Omit<T, K> & Record<K, V>>
  get: () => T
}

Solution by devshinthant #34564

type Chainable<T = {}> = {
  option<K extends PropertyKey, V>(
    key: K extends keyof T ? never : K, value: V
  ): Chainable<Omit<T, K> & {[P in K]: V}>
  get(): {
    [P in keyof T]: T[P]
  } 
}

Solution by ktim816 #34434

type Chainable<T extends Record<string, any> = {}> = {
  option: <K extends string, V>(key: K extends keyof T ? never : K, value: V) => K extends keyof T ? Chainable<Omit<T, K> & Record<K, V>> : Chainable<T & Record<K, V>>
  get: () => T
}

Solution by rookie-luochao #34391

I couldn't find my solution under the accepted ones and many solutions with many upvotes don't allow overriding key-value pairs as required by the third test case. Many other solutions seem overly complicated.

type Chainable<Current = {}> = {
  option<K extends string, V>(key: K, value: V): Chainable<Omit<Current, K> & { [ Key in K as `${Key}` ]: V }>
  get(): Current
}

Type mapping allows for the creation of object types by mapping over union types. K can be thought of as a union with only one member.

The as keyword allows for the creation of a key name based on the value provided for key.

Before extending the current object Current, we must Omit from it any existing entry with the same key.

Solution by watisnu #34362

문제 설명

체인 가능 옵션은 일반적으로 Javascript에서 사용됩니다. 하지만 TypeScript로 전환하면 제대로 구현할 수 있나요?

이 챌린지에서는 option(key, value)과 get() 두가지 함수를 제공하는 객체(또는 클래스) 타입을 구현해야 합니다. 현재 타입을 option으로 지정된 키와 값으로 확장할 수 있고 get으로 최종 결과를 가져올 수 있어야 합니다.

예시

declare const config: Chainable;

const result = config
	.option("foo", 123)
	.option("name", "type-challenges")
	.option("bar", { value: "Hello World" })
	.get();

// 결과는 다음과 같습니다:
interface Result {
	foo: number;
	name: string;
	bar: {
		value: string;
	};
}

문제를 해결하기 위해 js/ts 로직을 작성할 필요는 없습니다. 단지 타입 수준입니다.

key는 string만 허용하고 value는 무엇이든 될 수 있다고 가정합니다. 같은 key는 두 번 전달되지 않습니다.

풀이

options 메서드를 추가하여야

type Chainable<T = object> = {
	option: <K extends string, V>(
		key: K extends keyof T ? never : K,
		value: V
	) => Chainable<Omit<T, K> & Record<K, V>>;
	get: () => T;
};

<K extends string, V> 와 같은 부분은 ts에서 제네릭을 선언하는 부분입니다. 이 구문은 함수의 제네릭 타입 매개변수를 추가하여, 해당 함수가 다양한 타입에 대해 재사용 가능하도록 합니다. V는 어떤 타입이든 될 수 있습니다. 제약이 없기 때문에, 이 타입 매개변수는 함수가 호출될 때 어떤 타입으로도 설정될 수 있습니다. 제네릭 타입을 사용하는 이유는 제네릭을 사용하면 함수나 클래스가 다양한 타입에 대해 동작할 수 있기 때문입니다.

solution

/* _____________ 여기에 코드 입력 _____________ */

type Chainable<T = object> = {
	option: <K extends string, V>(
		key: K extends keyof T ? never : K,
		value: V
	) => Chainable<Omit<T, K> & Record<K, V>>;
	get: () => T;
};

/* _____________ 테스트 케이스 _____________ */
import type { Alike, Expect } from "@type-challenges/utils";

declare const a: Chainable;

const result1 = a
	.option("foo", 123)
	.option("bar", { value: "Hello World" })
	.option("name", "type-challenges")
	.get();

const result2 = a
	.option("name", "another name")
	// @ts-expect-error
	.option("name", "last name")
	.get();

const result3 = a
	.option("name", "another name")
	// @ts-expect-error
	.option("name", 123)
	.get();

type cases = [
	Expect<Alike<typeof result1, Expected1>>,
	Expect<Alike<typeof result2, Expected2>>,
	Expect<Alike<typeof result3, Expected3>>
];

type Expected1 = {
	foo: number;
	bar: {
		value: string;
	};
	name: string;
};

type Expected2 = {
	name: string;
};

type Expected3 = {
	name: number;
};

Solution by adultlee #34139

문제 설명

체인 가능 옵션은 일반적으로 Javascript에서 사용됩니다. 하지만 TypeScript로 전환하면 제대로 구현할 수 있나요?

이 챌린지에서는 option(key, value)과 get() 두가지 함수를 제공하는 객체(또는 클래스) 타입을 구현해야 합니다. 현재 타입을 option으로 지정된 키와 값으로 확장할 수 있고 get으로 최종 결과를 가져올 수 있어야 합니다.

예시

declare const config: Chainable;

const result = config
	.option("foo", 123)
	.option("name", "type-challenges")
	.option("bar", { value: "Hello World" })
	.get();

// 결과는 다음과 같습니다:
interface Result {
	foo: number;
	name: string;
	bar: {
		value: string;
	};
}

문제를 해결하기 위해 js/ts 로직을 작성할 필요는 없습니다. 단지 타입 수준입니다.

key는 string만 허용하고 value는 무엇이든 될 수 있다고 가정합니다. 같은 key는 두 번 전달되지 않습니다.

풀이

options 메서드를 추가하여야

type Chainable<T = object> = {
	option: <K extends string, V>(
		key: K extends keyof T ? never : K,
		value: V
	) => Chainable<Omit<T, K> & Record<K, V>>;
	get: () => T;
};

<K extends string, V> 와 같은 부분은 ts에서 제네릭을 선언하는 부분입니다. 이 구문은 함수의 제네릭 타입 매개변수를 추가하여, 해당 함수가 다양한 타입에 대해 재사용 가능하도록 합니다. V는 어떤 타입이든 될 수 있습니다. 제약이 없기 때문에, 이 타입 매개변수는 함수가 호출될 때 어떤 타입으로도 설정될 수 있습니다. 제네릭 타입을 사용하는 이유는 제네릭을 사용하면 함수나 클래스가 다양한 타입에 대해 동작할 수 있기 때문입니다.

solution

/* _____________ 여기에 코드 입력 _____________ */

type Chainable<T = object> = {
	option: <K extends string, V>(
		key: K extends keyof T ? never : K,
		value: V
	) => Chainable<Omit<T, K> & Record<K, V>>;
	get: () => T;
};

/* _____________ 테스트 케이스 _____________ */
import type { Alike, Expect } from "@type-challenges/utils";

declare const a: Chainable;

const result1 = a
	.option("foo", 123)
	.option("bar", { value: "Hello World" })
	.option("name", "type-challenges")
	.get();

const result2 = a
	.option("name", "another name")
	// @ts-expect-error
	.option("name", "last name")
	.get();

const result3 = a
	.option("name", "another name")
	// @ts-expect-error
	.option("name", 123)
	.get();

type cases = [
	Expect<Alike<typeof result1, Expected1>>,
	Expect<Alike<typeof result2, Expected2>>,
	Expect<Alike<typeof result3, Expected3>>
];

type Expected1 = {
	foo: number;
	bar: {
		value: string;
	};
	name: string;
};

type Expected2 = {
	name: string;
};

type Expected3 = {
	name: number;
};

Solution by adultlee #34138

type Chainable = {
  option<K extends string, T>(key: K, value: T): SaveType<{
    [k in K]: T;
  }>;
}
type SaveType<Keys extends Record<string, any>> = {
  option<K extends string, T>(key: Exclude<K | keyof Keys, keyof Keys>, value: T): SaveType<{ [k in K]: T } & {
    [t in keyof Keys as t extends K ? never : t]: Keys[t];
  }>
  get(): {
    [t in keyof Keys]: Keys[t];
  }
}

Solution by LeonCry #34055

type Chainable<T = {}> = {
  option: <K extends string, V>(key: K extends keyof T ? never : K, value: V) => Chainable<Omit<T, K> & Record<K, V>>
  get(): T
}

Solution by ouzexi #33988

type Chainable<R = object> = {
  option<K extends string, V>(
    key: Exclude<K, keyof R>, 
    value: V
  ): Chainable<Omit<R, K> & Record<K, V>>
  get(): R
}

Solution by notsecret32 #33890

type Chainable<T = {}> = {
  option: <K extends string, V>
  (key: K, value: V) => Chainable<Omit<T, K> & { [P in K]: V }>
  get: () => T
}

Solution by laplace1009 #33717

// 你的答案
type Chainable<T = {}> = {
  option<K extends string, V>(key: K extends keyof T ? never : K, value: V): Chainable<{
    [P in K]: V
  } & {
    [P in keyof T as P extends K ? never : P]: T[P]
  }>
  get(): T
}

Solution by heyuelan #33661

type Chainable<T = {}> = {
  option: <K extends string, V>(key: K, value: V) => Chainable<Omit<T, K> & Record<K, V>>
  get(): T
}

Solution by nupthale #33579

the answer is inspired from #598

type Chainable<U={}> = {
    option<TK extends string,TV>(k:Exclude<TK,keyof U>,v:TV):Chainable<U&{
        [P in Exclude<TK,keyof U>]: TV // double guarantee
    }>
    get():U
}

Solution by whatever8080 #33015

// 你的答案
type Chainable<T extends Record<string,any> = {}> = {
  option<K extends string,V extends any>(key: K extends keyof T?never: K, value: V): Chainable< {
    [key in keyof T as key extends K?never:key]:T[key]
  }& {
    [key in K]:V
  }>
  get(): T
}

Solution by walker-hzx #32934

// 解答をここに記入
type Chainable<T extends object = {}> = {
  option: <Key extends string, Value>(
    key: Key extends keyof T
      ? never
      : Key,
    value: Value
  ) => Chainable<Omit<T, Key> & Record<Key, Value>>;
  get: () => T;
}

『チェイン可能なオプション』を実現するためには、該当オブジェクトそのものを関数の返り値に設定する必要があるため、option関数の返り値はChainableとなる。
- オブジェクトにオプションを動的追加していくため、Chainableは型引数Tにオブジェクトを受け取り返り値で返却する。
- 同名オプションは1度しか追加できないようにするために、keyに渡された型引数Keyが現在のオブジェクトのキーに存在しているのかを判定。
- 上記で型定義しているため本来は問題ないはずだが、同名プロパティに2度オプション追加した場合後者のバリューに上書きされるので、Chainableから既存のキープロパティを削除したオブジェクトと新規バリューのプロパティをマージする。
追加したオプションをすべて返却させるため、get関数ではオブジェクトであるTをそのまま返り値として設定している。

Solution by Yasunori-aloha #32813

type Chainable<T = {}> = {
  option<K extends PropertyKey, V>(key: K extends keyof T ? never : K, value: V): Chainable<Omit<T, K> & Record<K, V>>
  get(): T
}

T = {} gives a default value so type arguments is not required
K needs to be a PropertyKey in order to be passed to Record, you can use string here since there is only string in test cases
K extends keyof T ? never : K: K is never type when key already exists in Chainable, any type except never itself can pass to never type
From test case 2 & 3 we know that same key needs to be overwritten, so we Omit the old key every time we merge the new key

const result2 = a
  .option('name', 'another name')
  // @ts-expect-error
  .option('name', 'last name')
  .get()

const result3 = a
  .option('name', 'another name')
  // @ts-expect-error
  .option('name', 123)
  .get()

type Expected2 = {
  name: string
}

type Expected3 = {
  name: number
}

I have a question though. Why overwrite duplicate key if you wants it to be an error?

Solution by MarvinXu #32713

interface Result {
  foo: number
  name: string
  bar: {
    value: string
  }
}

type Chainable = {
    option: (arg1: string, arg2: number | string | { value: string }) => Chainable
    get: () => Result
}

declare const config: Chainable

const result = config
  .option('foo', 123)
  .option('name', 'type-challenges')
  .option('bar', { value: 'Hello World' })
  .get()

Solution by ZhulinskiiDanil #32670

type Chainable<T = {}> = {
  option: <NewK extends string, NewV extends unknown>(
    key: NewK extends keyof T ? never : NewK, 
    value: NewV,
  ) => Chainable<Omit<T, NewK> & Record<NewK, NewV>>;
  get(): T;
}

没做出来，这题有点难。思考方向完全错了，没有想到递归，这不太应该。

NewK extends keyof T ? never : NewK 用来过滤当 NewK 已经存在 T 中的时候，转为 never，从而达到报错的目的。

其实我觉得到这里就可以了，反正已经有报错了。不太需要后面的那个 Omit

Solution by mistkafka #32639

type Chainable<T = {}> = {
  option<R extends string, U>(key: R extends keyof T ? never : R, value: U): Chainable<{ [P in Exclude<keyof T, R>]: T[P] } & Record<R, U>>
  get(): T
}

Solution by nivenice #32367

// your answers

type Chainable<T = {}> = {
  option: <K extends string, V>(key: K extends keyof T ?
    V extends T[K] ? never : K
    : K, value: V) => Chainable<Omit<T, K> & Record<K, V>>
  get: () => T
}

declare const config: Chainable

const result = config
  .option('foo', 123)
  .option('name', 'type-challenges')
  .option('bar', { value: 'Hello World' })
  .get()

Solution by laqudee #32348

처음 풀이: option 메서드의 파라미터에 조건부 타입을 사용할 생각을 하지 못하고 정적인 타입만을 이용해 억지로 풀어냄

type Chainable<Result extends Record<string, unknown> = {}> = {
  option<Key extends (Extract<keyof Result, Key> extends never ? string : never), Value>(key: Key, value: Value):
    Key extends never 
      ? never
      : Chainable<{ [key in keyof Result]: Result[key] } & Record<Key, Value>>
  get(): Result
}

개선된 풀이

type Chainable<Result = {}> = {
  option<Key extends string, Value>(key: Key extends keyof Result ? never : Key, value: Value):
    Chainable<Omit<Result, Key> & Record<Key, Value>>
  get(): Result
}

알아갈 것: 메서드의 파라미터 타입에 조건부 타입을 적용시킬 생각을 하자

Solution by dev-hobin #32220

type Chainable<T = {}> = {
  option: <K extends string, V>(
    key: K extends keyof T ? never : K,
    value: V
  ) => Chainable< Omit<T, K> & Record<K, V> >
  get(): T
}

We define Chainable type with a generic type T that extends from an object. The method get returns the generic T itself and the option method types as following:

If the key passed as parameters extends from an already used key in T, then it must throw linter error. Otherwise, the type is accepted as valid
As we could eventually use an already used key (despite we shouldn't due to type checking), we must remove that key from our generic T and readd it with the new definition using Record

Solution by joyanedel #32151

// your answers
type Chainable<T = {}> = {
  option<Key extends string, Value>(key: Key, value: Value): Chainable<Omit<T, Key> & Record<Key, Value>>
  get(): T
}

Solution by trinhvinhtruong96 #32054

// your answers
type Chainable<R = {}> = {
  option<K extends string, V>(key: K extends keyof R ? never : K, value: V): Chainable<Omit<R, K> & Record<K, V>>
  get(): R
}

Solution by pea-sys #31907

00012-medium-chainable-options

문제 설명

풀이

options 메서드를 추가하여야

solution

문제 설명

풀이

options 메서드를 추가하여야

solution