กรณีใช้งาน infer ในทางปฏิบัติ: การคลายห่อ Promise

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

type A = Awaited<Promise<Promise<string>>>; // string
// Handles arbitrary nesting automatically

type DeepAwaited<T> =
  T extends Promise<infer U> ? DeepAwaited<U> : T;
type A = DeepAwaited<Promise<Promise<number>>>; // number

type Element<T> = T extends (infer U)[] ? U : never;
type A = Element<string[]>; // string
type B = Element<number[]>; // number

type ObservableType<T> = T extends Observable<infer U> ? U : never;
type A = ObservableType<Observable<User>>; // User

async function getUser(): Promise<User> { /* ... */ }
type UserResult = Awaited<ReturnType<typeof getUser>>; // User

type UnwrapPromiseArray<T> =
  T extends Promise<infer U>
    ? U extends (infer V)[]
      ? V
      : U
    : T;
type A = UnwrapPromiseArray<Promise<User[]>>; // User

type MaybeUnwrap<T> =
  T extends Promise<infer U> ? U : T extends (infer V)[] ? V : T;

type A = MaybeUnwrap<Promise<string>>;  // string
type B = MaybeUnwrap<number[]>;         // number
type C = MaybeUnwrap<boolean>;          // boolean

async function fetchData<T>(url: string): Promise<T> {
  const res = await fetch(url);
  return res.json() as T;
}
type UserData = Awaited<ReturnType<typeof fetchData<User>>>; // User

type Ok<T> = { ok: true; value: T };
type Err = { ok: false; error: string };
type ExtractOk<T> = T extends Ok<infer V> ? V : never;
type A = ExtractOk<Ok<number> | Err>; // number