메티의 블로그

5310 - Join

Implement the type version of Array.join, Join<T, U> takes an Array T, string or number U and returns the Array T with U stitching up.


type Res = Join<["a", "p", "p", "l", "e"], "-">; // expected to be 'a-p-p-l-e'
type Res1 = Join<["Hello", "World"], " ">; // expected to be 'Hello World'
type Res2 = Join<["2", "2", "2"], 1>; // expected to be '21212'
type Res3 = Join<["o"], "u">; // expected to be 'o'


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

type RemoveTail<T extends string, U extends string | number> = `${T}` extends `${infer F}${U}` ? F : T;

type MergeString<T extends string[], U extends string | number> = 
	T extends [infer F extends string, ...infer R extends string[]] ?
  `${F}${U}${MergeString<R, U>}` : T extends string ? `${T}` : '';

type Join<T extends string[], U extends string | number = ","> = RemoveTail<MergeString<T, U>, U>

/* _____________ 테스트 케이스 _____________ */
import type { Equal, Expect } from '@type-challenges/utils'

type cases = [
  Expect<Equal<Join<['a', 'p', 'p', 'l', 'e'], '-'>, 'a-p-p-l-e'>>,
  Expect<Equal<Join<['Hello', 'World'], ' '>, 'Hello World'>>,
  Expect<Equal<Join<['2', '2', '2'], 1>, '21212'>>,
  Expect<Equal<Join<['o'], 'u'>, 'o'>>,
  Expect<Equal<Join<[], 'u'>, ''>>,
  Expect<Equal<Join<['1', '1', '1']>, '1,1,1'>>,
]

풀이

템플릿 문자열 형태로 합침
단, MergeString 타입처럼 합치면 뒤에 Join key 가 남으므로, 지워주는 타입 추가해서 래핑
테스트케이스에 Join key 값이 , 가 디폴트로 되어있으므로 디폴트 지정

배운 점

문자열 안에서도 재귀 타입이 잘 들어간다는 것 상기

5317 - LastIndexOf

Implement the type version of Array.lastIndexOf, LastIndexOf<T, U> takes an Array T, any U and returns the index of the last U in Array T


type Res1 = LastIndexOf<[1, 2, 3, 2, 1], 2> // 3
type Res2 = LastIndexOf<[0, 0, 0], 2> // -1


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

type LastIndexOf<T extends unknown[], U> = T extends [...infer R, infer L] ? 
	Equal<L, U> extends true ? 
		R['length'] : 
		LastIndexOf<R, U> : 
	-1;

type Test = LastIndexOf<[1,2,3,4], 5>

/* _____________ 테스트 케이스 _____________ */
import type { Equal, Expect } from '@type-challenges/utils'

type cases = [
  Expect<Equal<LastIndexOf<[1, 2, 3, 2, 1], 2>, 3>>,
  Expect<Equal<LastIndexOf<[2, 6, 3, 8, 4, 1, 7, 3, 9], 3>, 7>>,
  Expect<Equal<LastIndexOf<[0, 0, 0], 2>, -1>>,
  Expect<Equal<LastIndexOf<[string, 2, number, 'a', number, 1], number>, 4>>,
  Expect<Equal<LastIndexOf<[string, any, 1, number, 'a', any, 1], any>, 5>>,
]

풀이

뒤에서 부터 순회하며 L 이 같은지 확인, 인덱스는 length-1 이므로 Rest 의 길이를 리턴한다.

배운 점

뒤에서 부터 순회 가능했다는 점 상기
length-1 은 Rest 배열의 length 로 가져오는 아이디어 좋았다

5360 - Unique

Implement the type version of Lodash.uniq, Unique<T> takes an Array T, returns the Array T without repeated values.


type Res = Unique<[1, 1, 2, 2, 3, 3]>; // expected to be [1, 2, 3]
type Res1 = Unique<[1, 2, 3, 4, 4, 5, 6, 7]>; // expected to be [1, 2, 3, 4, 5, 6, 7]
type Res2 = Unique<[1, "a", 2, "b", 2, "a"]>; // expected to be [1, "a", 2, "b"]
type Res3 = Unique<[string, number, 1, "a", 1, string, 2, "b", 2, number]>; // expected to be [string, number, 1, "a", 2, "b"]
type Res4 = Unique<[unknown, unknown, any, any, never, never]>; // expected to be [unknown, any, never]


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

// type Unique<T extends unknown[], U = never, Acc extends unknown[] = []> = T extends [infer F, ...infer R] ? 
//   F extends U ? 
//     Unique<R, U, Acc>: 
//     Unique<R, U | F, [...Acc, F]>:
//   Acc;

// type Test = Unique<[string, number, 1, 'a', 1, string, 2, 'b', 2, number]>

type Includes<T extends readonly unknown[], U> =
  T extends [infer F, ...infer R]
    ? Equal<F, U> extends true
      ? true
      : Includes<R, U>
    : false;

type Unique<T extends unknown[], Acc extends unknown[] = []> =
  T extends [infer F, ...infer R]
    ? Includes<Acc, F> extends true
      ? Unique<R, Acc>
      : Unique<R, [...Acc, F]>
    : Acc;

/* _____________ 테스트 케이스 _____________ */
import type { Equal, Expect } from '@type-challenges/utils'

type cases = [
  Expect<Equal<Unique<[1, 1, 2, 2, 3, 3]>, [1, 2, 3]>>,
  Expect<Equal<Unique<[1, 2, 3, 4, 4, 5, 6, 7]>, [1, 2, 3, 4, 5, 6, 7]>>,
  Expect<Equal<Unique<[1, 'a', 2, 'b', 2, 'a']>, [1, 'a', 2, 'b']>>,
  Expect<Equal<Unique<[string, number, 1, 'a', 1, string, 2, 'b', 2, number]>, [string, number, 1, 'a', 2, 'b']>>,
  Expect<Equal<Unique<[unknown, unknown, any, any, never, never]>, [unknown, any, never]>>,
]

풀이

첫 시도 로직은 U 에 유니온을 쌓아가며 필터를 만들려고 했으나, 유니온으로는 any 나 number 등 원시 타입이 등장 시 제대로 구분이 안 된다는 것을 파악
쌓아가고있는 정답 배열을 순회하며 하나하나 비교 후 중복 확인하는 방식으로 변경

배운 점

유니온이 좋은 필터 역할을 하긴 하지만, 이는 리터럴 타입일 때 유용하며 원시 타입 일 때는 알아서 잘 걸러야함

5821 - MapTypes

Implement MapTypes<T, R> which will transform types in object T to different types defined by type R which has the following structure


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

type MapTypesInput = { mapFrom: unknown, mapTo: unknown };

// type MapTypes<T extends object, R extends MapTypesInput> = {[K in keyof T]: T[K] extends R['mapFrom'] ? R['mapFrom'] extends T[K] ? R['mapTo'] : never : T[K]};
type MapTypes<T extends object, R extends MapTypesInput> = {[K in keyof T]: T[K] extends R['mapFrom'] ? R extends { mapFrom: T[K] } ? R['mapTo'] : never : T[K]};


type Test = MapTypes<{ name: string, date: Date }, { mapFrom: string, mapTo: boolean } | { mapFrom: Date, mapTo: string }>

/* _____________ 테스트 케이스 _____________ */
import type { Equal, Expect } from '@type-challenges/utils'

type cases = [
  Expect<Equal<MapTypes<{ stringToArray: string }, { mapFrom: string, mapTo: [] }>, { stringToArray: [] }>>,
  Expect<Equal<MapTypes<{ stringToNumber: string }, { mapFrom: string, mapTo: number }>, { stringToNumber: number }>>,
  Expect<Equal<MapTypes<{ stringToNumber: string, skipParsingMe: boolean }, { mapFrom: string, mapTo: number }>, { stringToNumber: number, skipParsingMe: boolean }>>,
  Expect<Equal<MapTypes<{ date: string }, { mapFrom: string, mapTo: Date } | { mapFrom: string, mapTo: null }>, { date: null | Date }>>,
  Expect<Equal<MapTypes<{ date: string }, { mapFrom: string, mapTo: Date | null }>, { date: null | Date }>>,
  Expect<Equal<MapTypes<{ fields: Record<string, boolean> }, { mapFrom: Record<string, boolean>, mapTo: string[] }>, { fields: string[] }>>,
  Expect<Equal<MapTypes<{ name: string }, { mapFrom: boolean, mapTo: never }>, { name: string }>>,
  Expect<Equal<MapTypes<{ name: string, date: Date }, { mapFrom: string, mapTo: boolean } | { mapFrom: Date, mapTo: string }>, { name: boolean, date: string }>>,
]

풀이

첫 풀이는 마지막 케이스를 통과하지 못 함

R[’mapFrom’] 이 유니온 형태(string | Date)로 들어오기 때문에 항상 never 로 빠짐

두번째 풀이는

R 이 유니온 형태({ mapFrom: string, mapTo: boolean } | { mapFrom: Date, mapTo: string })로 들어온 후 { mapFrom: T[K] } 이 타입으로 걸러지므로 R 이 포함된 하나만 빠져나오게 됨

배운 점

제네릭은 분배 조건부 연산이 default 이며, 아래와 같은 방법으로 유니온 타입을 필터링 할 수 있다.


type UnionTest1<T> = T extends 1 ? T : never;
// 1 -> 1 | never | never 로 1임
type UnionTest1Test = UnionTest<1 | 2 | 3>;

type UnionTest2<T> = T extends { mapFrom: string } ? T : never;
// {mapFrom: string} -> {mapFrom: string} | never 로 {mapFrom: string} 임
type UnionTest2Test = UnionTest<{ mapFrom: Date} | {mapFrom: string}>;

// false
type UnionTest3 = string | Date extends string ? true : false;

type UnionTest4<T> = [T] extends [1] ? T : never;
// never
type UnionTest4Test = UnionTest4<1|2|3>

7544 - Construct Tuple

Construct a tuple with a given length.


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

type ConstructTuple<L extends number, C extends unknown[] = []> = C['length'] extends L ? C : ConstructTuple<L, [...C, unknown]>;

/* _____________ 테스트 케이스 _____________ */
import type { Equal, Expect } from '@type-challenges/utils'

type cases = [
  Expect<Equal<ConstructTuple<0>, []>>,
  Expect<Equal<ConstructTuple<2>, [unknown, unknown]>>,
  Expect<Equal<ConstructTuple<999>['length'], 999>>,
  // @ts-expect-error
  Expect<Equal<ConstructTuple<1000>['length'], 1000>>,
]

풀이

자주 사용하던 누적 배열을 이용해 길이 만큼 재귀

배운 점

재귀는 1000 depth 부터 에러가 나나보다.

8640 - Number Range

Sometimes we want to limit the range of numbers…


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

type NumberRange<L extends number, H extends number, U = never, C extends never[] = [], Flag extends boolean = false> = C['length'] extends H ? 
  U | C['length'] :
    Flag extends true ? 
      NumberRange<L, H, U | C['length'], [...C, never], true>:
        C['length'] extends L ? 
          NumberRange<L, H, U | C['length'], [...C, never], true>:
          NumberRange<L, H, U, [...C, never], false>;

type Test = NumberRange<2,5>

/* _____________ 테스트 케이스 _____________ */
import type { Equal, Expect } from '@type-challenges/utils'

type Result1 = | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
type Result2 = | 0 | 1 | 2
type Result3 =
  | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10
  | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20
  | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30
  | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40
  | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50
  | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60
  | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70
  | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80
  | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90
  | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100
  | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110
  | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120
  | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130
  | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140
type cases = [
  Expect<Equal<NumberRange<2, 9>, Result1>>,
  Expect<Equal<NumberRange<0, 2>, Result2>>,
  Expect<Equal<NumberRange<0, 140>, Result3>>,
]

풀이

배열을 늘려가며 (C['length'] 를 기반으로) 누적 유니온 타입에 추가할 숫자 마련
H 가 높은 수 이므로 이에 도달하면 재귀 종료
아닌 경우 Flag 확인 후 쭉 이어나감, Flag 는 누적 배열 길이가 L 이상인지 판별함(이전 문제에서 해결했던 방식 사용)

13주차 타입챌린지 스터디

5310 - Join

5317 - LastIndexOf

5360 - Unique

5821 - MapTypes

7544 - Construct Tuple

8640 - Number Range

12주차 타입챌린지 스터디

12주차 타입챌린지 스터디

11주차 타입챌린지 스터디

10주차 타입챌린지 스터디

9주차 타입챌린지 스터디

8주차 타입챌린지 스터디

7주차 타입챌린지 스터디

6주차 타입챌린지 스터디

5주차 타입챌린지 스터디

4주차 타입챌린지 스터디

never, any, unknown, mixed 타입 비교

textarea 입력 3줄 까지만 늘어나게 하기