ReturnType이 어떻게 동작하는지 궁금했다면 — infer 키워드 완전 분석

type IsString<T> = T extends string ? "yes" : "no";
 
type A = IsString<string>; // "yes"
type B = IsString<number>; // "no"

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

type A = GetReturnType<() => string>;        // string
type B = GetReturnType<(x: number) => boolean>; // boolean
type C = GetReturnType<string>;              // never (함수가 아님)

type ElementType<T> = T extends (infer E)[] ? E : never;
 
type A = ElementType<string[]>;  // string
type B = ElementType<number[]>;  // number
type C = ElementType<boolean[]>; // boolean
type D = ElementType<string>;    // never (배열이 아님)

type FlatOne<T> = T extends (infer E)[] ? E : T;
 
type A = FlatOne<string[][]>; // string[]
type B = FlatOne<string[]>;   // string
type C = FlatOne<string>;     // string (배열이 아니면 그대로)

type GetParameters<T> = T extends (...args: infer P) => any ? P : never;
 
type A = GetParameters<(x: string, y: number) => void>; // [string, number]
type B = GetParameters<() => void>;                      // []

type FirstParam<T> = T extends (first: infer F, ...rest: any[]) => any ? F : never;
 
type A = FirstParam<(x: string, y: number) => void>; // string
type B = FirstParam<(x: number) => void>;             // number
type C = FirstParam<() => void>;                      // never

type Unwrap<T> = T extends Promise<infer U> ? U : T;
 
type A = Unwrap<Promise<string>>; // string
type B = Unwrap<Promise<number>>; // number
type C = Unwrap<string>;          // string (Promise가 아니면 그대로)

type DeepUnwrap<T> = T extends Promise<infer U> ? DeepUnwrap<U> : T;
 
type A = DeepUnwrap<Promise<Promise<string>>>; // string
type B = DeepUnwrap<Promise<number>>;          // number

type ValueOf<T> = T extends { [K in keyof T]: infer V } ? V : never;
 
type Obj = { a: string; b: number; c: boolean };
type Values = ValueOf<Obj>; // string | number | boolean

type ToArray<T> = T extends any ? T[] : never;
 
type A = ToArray<string | number>;
// string[] | number[] — 각각 적용됨
// string | number 전체를 감싸는 (string | number)[]이 아님

type ToArrayNonDist<T> = [T] extends [any] ? T[] : never;
 
type A = ToArrayNonDist<string | number>; // (string | number)[]

type SplitFunction<T> = T extends (...args: infer P) => infer R
  ? { params: P; return: R }
  : never;
 
type A = SplitFunction<(x: string, y: number) => boolean>;
// {
//   params: [string, number];
//   return: boolean;
// }

// 라이브러리 함수 (수정 불가)
declare function createStore<S>(reducer: (state: S) => S): { getState(): S };
 
type StoreState<T extends (...args: any) => any> =
  ReturnType<T> extends { getState(): infer S } ? S : never;
 
type MyState = StoreState<typeof createStore>;

type EventType<T> = T extends (event: infer E) => any ? E : never;
 
type ClickEventType = EventType<React.MouseEventHandler>; // React.MouseEvent<...>
type ChangeEventType = EventType<React.ChangeEventHandler<HTMLInputElement>>; // React.ChangeEvent<HTMLInputElement>

type PropType<T, K extends keyof T> = T extends { [P in K]: infer V } ? V : never;
 
interface User {
  name: string;
  age: number;
}
 
type NameType = PropType<User, "name">; // string
type AgeType = PropType<User, "age">;   // number

// ReturnType
type ReturnType<T extends (...args: any) => any> =
  T extends (...args: any) => infer R ? R : any;
 
// Parameters
type Parameters<T extends (...args: any) => any> =
  T extends (...args: infer P) => any ? P : never;
 
// InstanceType
type InstanceType<T extends abstract new (...args: any) => any> =
  T extends abstract new (...args: any) => infer R ? R : any;
 
// Awaited
type Awaited<T> =
  T extends null | undefined ? T :
  T extends object & { then(onfulfilled: infer F, ...args: infer _): any } ?
    F extends ((value: infer V, ...args: infer _) => any) ?
      Awaited<V> :
      never :
  T;

type Bad<T> = infer R; // 오류: 'infer' declarations are only permitted in the 'extends' clause

type GetAllReturnTypes<T> =
  T extends { [K in keyof T]: () => infer R } ? R : never;
 
type Obj = {
  a: () => string;
  b: () => number;
};
 
type A = GetAllReturnTypes<Obj>; // string | number