Ключевое слово infer: сопоставить тип с образцом и захватить его кусок

Дыра в образце

Когда нужно достать тип, живущий внутри чужого типа — возвращаемое значение функции, разрешённое значение промиса, первый элемент кортежа — можно оборачивать и разворачивать вручную. Или пробить дыру в образце и дать TypeScript самому найти решение.

infer допустим только внутри части extends условного типа. Он объявляет новую типовую переменную прямо на месте и позволяет TypeScript решить её, сопоставляя структуру:

type ElementOf<T> = T extends (infer E)[] ? E : never;

type A = ElementOf<string[]>;       // ^? string
type B = ElementOf<[1, 2, 3]>;      // ^? 1 | 2 | 3   (тип элемента кортежа)
type C = ElementOf<number>;         // ^? never       (не массив — ложная ветка)

Вы написали форму (infer E)[] — «массив чего-то» — и TypeScript унифицирует её с входом, связывая E с этим «чем-то». E существует только в истинной ветке. Это та же механика, что использует стандартная библиотека:

type Unwrap<T> = T extends Promise<infer V> ? V : T;
type R1 = Unwrap<Promise<number>>;  // ^? number
type R2 = Unwrap<string>;           // ^? string  (ложная ветка возвращает T)

type Params<T> = T extends (...args: infer P) => unknown ? P : never;
type R3 = Params<(a: string, b: number) => void>; // ^? [a: string, b: number]

Голова, хвост кортежа и несколько infer в одном образце

Вы можете разместить несколько переменных infer в одном образце и захватить разные куски одновременно:

type Head<T extends readonly unknown[]> =
  T extends [infer H, ...unknown[]] ? H : never;
type Tail<T extends readonly unknown[]> =
  T extends [unknown, ...infer Rest] ? Rest : never;

type H = Head<[1, 2, 3]>; // ^? 1
type Te = Tail<[1, 2, 3]>; // ^? [2, 3]

type Last<T extends readonly unknown[]> =
  T extends [...unknown[], infer L] ? L : never;
type L = Last<[1, 2, 3]>; // ^? 3

Вариативные позиции кортежа (...infer Rest) делают голову/хвост/последний тривиальными — и они строительный блок для рекурсивных списков на уровне типов, которые вы напишете в юните 05.

Ограниченный infer (TS 4.7): infer R extends ...

До TS 4.7 приходилось захватывать, а затем перепроверять во вложенном условии. С 4.7 можно ограничить вывод прямо в строке, что одновременно валидирует и сужает захваченный тип:

// Захватываем строковый литерал-элемент и сужаем его до string за один шаг
type FirstString<T> =
  T extends [infer S extends string, ...unknown[]] ? S : never;

type S1 = FirstString<["hello", 1, 2]>; // ^? "hello"
type S2 = FirstString<[1, "x"]>;        // ^? never   (первый — не строка)

Практическая выгода: infer N extends number позволяет пронести числовой литерал без его расширения, что полезно в числовой арифметике типов.

Подвох с вариантностью: одно имя, несколько позиций

Вот часть, где ошибаются. Когда одно имя infer встречается в нескольких позициях, TypeScript собирает всех кандидатов и комбинирует их — но как зависит от вариантности. В ковариантных позициях (значения свойств объекта, элементы массива, возвращаемые типы) кандидаты объединяются:

type Co<T> = T extends { a: infer U; b: infer U } ? U : never;
type X = Co<{ a: string; b: number }>;
// ^? string | number   — ковариантные позиции => ОБЪЕДИНЕНИЕ

В контравариантных позициях — параметрах функций — кандидаты пересекаются:

type Contra<T> =
  T extends { f: (x: infer U) => void; g: (x: infer U) => void } ? U : never;
type Y = Contra<{ f: (x: string) => void; g: (x: number) => void }>;
// ^? string & number   — контравариантные позиции => ПЕРЕСЕЧЕНИЕ  (здесь: never)

Цена: infer дёшев в написании, дорог в цепочке

Один infer почти бесплатен. Ловушка — рекурсивный infer: снятие кортежа по одной голове или разворачивание вложенных обёрток, потому что каждая рекурсия — это новое инстанцирование условия. TypeScript ограничивает нехвостовую рекурсию глубиной инстанцирования около 50, прежде чем сдаться с Type instantiation is excessively deep and possibly infinite; хвосторекурсивные формы доходят дальше, примерно до 1000 уровней. Обход infer по кортежу из 2000 элементов упрётся в эту стену, и симптом — не падение, а молчаливо подставленный на дне рекурсии any, который затем отравляет каждый зависящий от него нижестоящий тип.

Senior-критерий: infer уместен, когда нужный кусок действительно внутри типа, которым владеет кто-то другой — библиотечный ReturnType, Awaited над неизвестным промисом. Он неуместен, когда тип контролируете вы и кусок можно просто назвать. type UserId = User["id"] — это индексированный доступ, разрешается мгновенно, тривиально наводится — против type UserId = Extract<...infer...>, который читатель должен мысленно выполнить. А когда вы пишете 30-строчный рекурсивный infer, разбирающий строку или глубоко вложенную форму, это сигнал, что систему типов просят выполнить работу парсера: маленький шаг кодогенерации, выдающий плоский именованный тип, компилируется за микросекунды и даёт коллегам читаемый артефакт, тогда как рекурсивный infer стоит секунд проверки и порождает нечитаемое сообщение об ошибке.