Solutions to type challenges

A repository for storing all my solutions to the awesome type challenges found on https://github.com/type-challenges/type-challenges.

The title of the challenge is a hyperlink to the TS playground with the full solution and tests, and below the title is just its solution.

Easy

See challenges and solutions

4 - Pick

type MyPick<T extends object, K extends keyof T> = {
  [Key in keyof T as Key extends K ? Key : never]: T[Key]
}

7 - Readonly

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

11 - Tuple to object

type TupleToObject<T extends readonly (number | string | symbol)[]> = {
  [K in T[number]]: K
}

14 - First of array

type First<T extends any[]> = T["length"] extends 0 ? never : T[0]

18 - Length of tuple

type Length<T extends readonly any[]> = T["length"]

43 - Exclude

type MyExclude<T, U> = T extends U ? never : T

189 - Awaited

type MyAwaited<T extends HasThen<unknown>> = 
T extends HasThen<infer R> 
? R extends HasThen<any> 
  ? MyAwaited<R> 
  : R 
: never

268 - If

type If<C extends boolean, T, F> = C extends true ? T : F

533 - Concat

type Concat<T extends any[], U extends any[]> = [...T, ...U]

898 - Includes

type Includes<T extends readonly any[], U> = 
  T extends [infer First, ...infer Rest] 
  ? Equal<First, U> extends true 
    ? true 
    : Includes<[...Rest], U> 
  : false

3057 - Push

type Push<T extends any[], U> = [...T, U]

3060 - Unshift

type Unshift<T extends any[], U> = [U, ...T]

3312 - Parameters

type MyParameters<T extends (...args: any[]) => any> = T extends (...args: infer Parameters) => any ? Parameters : never;

Medium

See challenges and solutions

2 - Get return type

type MyReturnType<T> = T extends (...args: any[]) => infer R ? R : never

3 - Omit

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

8 - Readonly

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

9 - Deep readonly

type DeepReadonly<T> = {
  readonly [K in keyof T]: 
    T[K] extends [...infer R] 
    ? readonly [...DeepReadonly<R>] 
    : T[K] extends Function 
      ? T[K] 
      : T[K] extends object 
        ? DeepReadonly<T[K]> 
        : T[K]
}

10 - Tuple to union

type TupleToUnion<T extends any[]> = T[number]

15 - Last of Array

type Last<T extends any[], LastElement = unknown> = T extends [infer F, ...infer R] ? Last<R, F> : LastElement

16 - Pop

type Pop<T extends any[]> = T extends [...infer AllExceptLast, infer Last] ? [...AllExceptLast] : []

20 - Promise.all

declare function PromiseAll<T extends unknown[]>(values: readonly [...T]): Promise<{
  [Key in keyof T]: Awaited<T[Key]>
}>;

62 - Type Lookup

type LookUp<U, T> = U extends { type: infer R } ? R extends T ? U : never : never;

62 - Type Lookup

type LookUp<U, T> = U extends { type: infer R } ? R extends T ? U : never : never;

106 - Trim Left

type ToTrim = ' ' | '\n' | '\t'
type TrimLeft<S extends string> = S extends `${ToTrim}${infer Rest}` ? TrimLeft<Rest> : S

108 - Trim

type ToTrim = ' ' | '\n' | '\t'
type Trim<S extends string> = S extends `${ToTrim}${infer Rest}` ? Trim<Rest> : S extends `${infer Rest}${ToTrim}` ? Trim<Rest> : S

110 - Capitalize

type MyCapitalize<S extends string> = S extends `${infer First}${infer Rest}` ? `${Uppercase<First>}${Rest}` : Uppercase<S>

116 - Replace

type Replace<S extends string, From extends string, To extends string> = 
From extends '' 
? S 
: S extends `${From}${infer R}` 
  ? `${To}${R}` 
  : S extends `${infer R1}${From}${infer R2}`
    ? `${R1}${To}${R2}`
    : S extends `${infer R}${From}`
      ? `${R}${To}`
      : S

116 - ReplaceAll

type ReplaceAll<S extends string, From extends string, To extends string> =
  S extends `${infer L}${From extends '' ? never : From}${infer R}`
    ? `${L}${To}${ReplaceAll<R, From, To>}`
    : S

191 - Append Argument

type AppendArgument<Fn extends Function, A> = Fn extends (...args: infer Args) => infer R ? (...args: [...Args, A]) => R : never;

296 - Permutation

type IsNever<T> = [T] extends never[] ? true : false;
type Permutation<T, I = T> = IsNever<T> extends true ? [] : I extends infer R ? [R, ...Permutation<Exclude<T, R>>] : [];