infer 키워드 — 조건부 타입에서 타입 추출하기

// T가 배열이면 그 요소의 타입을 추출
type ElementOf<T> = T extends (infer E)[] ? E : never;

type A = ElementOf<string[]>;    // string
type B = ElementOf<number[]>;    // number
type C = ElementOf<string>;      // never (배열이 아니므로)

// ReturnType 내부 구현
type ReturnType<T extends (...args: any) => any> =
  T extends (...args: any) => infer R ? R : any;
//                            ^^^^^^^ 반환 타입을 R로 캡처

type A = ReturnType<() => string>;         // string
type B = ReturnType<() => Promise<number>>; // Promise<number>

// Parameters 내부 구현
type Parameters<T extends (...args: any) => any> =
  T extends (...args: infer P) => any ? P : never;
//                    ^^^^^^^ 매개변수 타입을 P로 캡처

type C = Parameters<(a: string, b: number) => void>;
// [a: string, b: number]

type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;

type A = UnwrapPromise<Promise<string>>;  // string
type B = UnwrapPromise<Promise<number>>;  // number
type C = UnwrapPromise<string>;            // string (Promise가 아니면 그대로)

// 중첩 Promise도 재귀적으로 풀기
type DeepUnwrapPromise<T> = T extends Promise<infer U>
  ? DeepUnwrapPromise<U>
  : T;

type D = DeepUnwrapPromise<Promise<Promise<Promise<string>>>>;
// string

type First<T extends any[]> = T extends [infer F, ...any[]] ? F : never;
type Last<T extends any[]> = T extends [...any[], infer L] ? L : never;

type A = First<[string, number, boolean]>; // string
type B = Last<[string, number, boolean]>;  // boolean
type C = First<[]>;                         // never

// 문자열의 첫 글자 추출
type FirstChar<S extends string> = S extends `${infer C}${string}` ? C : never;

type A = FirstChar<'hello'>; // 'h'
type B = FirstChar<''>;      // never

// 문자열 트리밍
type TrimLeft<S extends string> = S extends ` ${infer Rest}` ? TrimLeft<Rest> : S;

type C = TrimLeft<'   hello'>; // 'hello'

type FirstArg<T extends (...args: any) => any> =
  T extends (first: infer A, ...rest: any[]) => any ? A : never;

type A = FirstArg<(name: string, age: number) => void>; // string
type B = FirstArg<() => void>;                           // unknown (매개변수 없음)

// 같은 위치에 여러 infer — 유니온 또는 인터섹션으로 결합

// 공변 위치 (반환 타입 등) — 유니온
type ReturnUnion<T> = T extends {
  a: () => infer R;
  b: () => infer R;
} ? R : never;

type Test1 = ReturnUnion<{ a: () => string; b: () => number }>;
// string | number (유니온)

// 반공변 위치 (매개변수 등) — 인터섹션
type ParamIntersection<T> = T extends {
  a: (x: infer P) => void;
  b: (x: infer P) => void;
} ? P : never;

type Test2 = ParamIntersection<{ a: (x: { name: string }) => void; b: (x: { age: number }) => void }>;
// { name: string } & { age: number } (인터섹션)

// infer에도 extends 제약을 걸 수 있음 (TS 4.7+)
type FirstString<T> = T extends [infer S extends string, ...any[]] ? S : never;

type A = FirstString<['hello', 42]>;    // 'hello'
type B = FirstString<[42, 'hello']>;    // never (첫 번째가 string이 아님)