타입 레벨 프로그래밍 — 재귀, 패턴 매칭, 튜플 조작

// 길이
type Length<T extends readonly any[]> = T['length'];
type L = Length<[1, 2, 3]>; // 3

// 첫 번째 요소
type Head<T extends readonly any[]> = T extends [infer H, ...any[]] ? H : never;
type H = Head<[1, 2, 3]>; // 1

// 나머지 요소
type Tail<T extends readonly any[]> = T extends [any, ...infer R] ? R : [];
type T = Tail<[1, 2, 3]>; // [2, 3]

// 마지막 요소
type Last<T extends readonly any[]> = T extends [...any[], infer L] ? L : never;
type La = Last<[1, 2, 3]>; // 3

// 앞에 추가
type Prepend<T extends readonly any[], E> = [E, ...T];
type P = Prepend<[2, 3], 1>; // [1, 2, 3]

// 뒤에 추가
type Append<T extends readonly any[], E> = [...T, E];
type A = Append<[1, 2], 3>; // [1, 2, 3]

type Reverse<T extends readonly any[]> =
  T extends [infer H, ...infer R]
    ? [...Reverse<R>, H]
    : [];

type Rev = Reverse<[1, 2, 3, 4]>; // [4, 3, 2, 1]

type Concat<A extends readonly any[], B extends readonly any[]> = [...A, ...B];
type C = Concat<[1, 2], [3, 4]>; // [1, 2, 3, 4]

type FnArgs<T> = T extends (...args: infer A) => any ? A : never;
type FnReturn<T> = T extends (...args: any) => infer R ? R : never;

type Args = FnArgs<(a: string, b: number) => boolean>; // [a: string, b: number]
type Ret = FnReturn<(a: string) => boolean>; // boolean

type Awaited<T> =
  T extends null | undefined ? T :
  T extends object & { then(onfulfilled: infer F): any }
    ? F extends (value: infer V, ...args: any) => any
      ? Awaited<V>
      : never
    : T;

type A = Awaited<Promise<Promise<string>>>; // string

// 문자열을 구분자로 분할
type Split<
  S extends string,
  D extends string
> = S extends `${infer Head}${D}${infer Tail}`
  ? [Head, ...Split<Tail, D>]
  : [S];

type Parts = Split<'a.b.c', '.'>; // ['a', 'b', 'c']
type Words = Split<'hello world foo', ' '>; // ['hello', 'world', 'foo']

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

type Filter<T extends readonly any[], U> =
  T extends [infer H, ...infer R]
    ? H extends U
      ? [H, ...Filter<R, U>]
      : Filter<R, U>
    : [];

type OnlyStrings = Filter<[1, 'a', 2, 'b', true], string>;
// ['a', 'b']

type FlatMap<T extends readonly any[]> =
  T extends [infer H, ...infer R]
    ? H extends readonly any[]
      ? [...H, ...FlatMap<R>]
      : [H, ...FlatMap<R>]
    : [];

type Flat = FlatMap<[[1, 2], [3, 4], 5]>;
// [1, 2, 3, 4, 5]

// N개의 요소를 가진 튜플 생성
type BuildTuple<N extends number, T extends any[] = []> =
  T['length'] extends N ? T : BuildTuple<N, [...T, unknown]>;

// 덧셈
type Add<A extends number, B extends number> =
  [...BuildTuple<A>, ...BuildTuple<B>]['length'] & number;

type Sum = Add<13, 29>; // 42

// 비교
type GreaterThan<A extends number, B extends number> =
  BuildTuple<A> extends [...BuildTuple<B>, ...infer Rest]
    ? Rest extends [any, ...any[]]
      ? true
      : false
    : false;

type GT = GreaterThan<5, 3>; // true
type LT = GreaterThan<2, 5>; // false

// ⚠️ 너무 깊은 재귀는 에러
type TooDeep<N extends number> =
  N extends 0 ? 'done' : TooDeep<Subtract<N, 1>>;
// Type instantiation is excessively deep