Wzorce głęboko zagnieżdżonego wnioskowania

Dlaczego głębokie wnioskowanie?

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

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

Rekurencyjne typy warunkowe

type Flatten<T> = T extends Array<infer U> ? Flatten<U> : T;
type B = Flatten<string[][][]>; // string

Wnioskowanie z zagnieżdżonych generyków

type InnerValue<T> =
  T extends Map<any, infer V>
    ? V extends Set<infer S>
      ? S
      : V
    : T;
type C = InnerValue<Map<string, Set<number>>>; // number

Typy głęboko zagnieżdżonych właściwości obiektu

type DeepGet<T, K extends keyof T> =
  T[K] extends object ? T[K] : never;

type Nested = { user: { profile: { name: string } } };
type Profile = DeepGet<Nested, "user">; // { profile: { name: string } }

Głębokie wyodrębnianie typów elementów tablic

type ElementType<T> = T extends (infer U)[] ? ElementType<U> : T;
type D = ElementType<number[][][]>; // number

Rekurencja ogonowa krotek

type Last<T extends any[]> =
  T extends [...infer _, infer L] ? L : never;
type E = Last<[1, 2, 3]>; // 3

Limity głębokości i praktyczne uwagi

// Deep recursion may hit "Type instantiation is excessively deep"
// Simplify or use branded types to break deep chains

Infer podczas rozdzielania unii

type Unwrap<T> = T extends Promise<infer U> ? U : T;
type F = Unwrap<Promise<string> | Promise<number> | boolean>;
// string | number | boolean

Wnioskowanie z krotek resztowych

type Init<T extends any[]> =
  T extends [...infer I, any] ? I : never;
type G = Init<[1, 2, 3, 4]>; // [1, 2, 3]

Przykład z praktyki: zagnieżdżona odpowiedź API

type ApiResponse<T> = { data: T; status: number };
type UnwrapApi<T> = T extends ApiResponse<infer D> ? D : T;
type H = UnwrapApi<ApiResponse<{ users: string[] }>>; // { users: string[] }

Podsumowanie: głębokie wnioskowanie

Szybkie sprawdzenie

Czego się nauczyłeś