infer: достать тип изнутри

Тип Promise<User> — это единое имя, а не объект, у которого можно взять поле. Достать User из него точкой или скобками не выйдет. Зато можно описать образец — «что-то похожее на промис от чего-то» — и попросить компилятор запомнить, что именно оказалось на месте этого «чего-то».

Синтаксис короткий: infer ставится справа от extends, ровно в том месте образца, содержимое которого нужно узнать. Имя после него — обычный параметр типа, и в ветке «да» им уже можно пользоваться.

type ElementOf<T> = T extends Array<infer U> ? U : never;

const cities: string[] = ["Дубай", "Абу-Даби"];
const first: ElementOf<typeof cities> = 42;
console.log(first);

Диагностика сама назвала результат: «Тип "number" не может быть назначен для типа "string"». Компилятор приложил string[] к образцу Array<infer U>, увидел на месте U тип string — и вернул его из ветки «да». Никакого перебора вариантов руками: ElementOf работает с любым массивом, хоть с Date[].

Что будет, если образец не подойдёт, решает ветка «нет». Обычно там пишут never — «такого типа не бывает».

type ElementOf<T> = T extends Array<infer U> ? U : never;

const nothing: ElementOf<string> = "хоть что-нибудь";
console.log(nothing);

«Тип ""хоть что-нибудь"" не может быть назначен для типа "never"» — присвоить значение типа never нельзя ничем, и это удобный сигнал: образец не сошёлся. Выполнение, как всегда, продолжилось: строка напечаталась, потому что типы до браузера не доезжают.

infer похож на скобочную группу в регулярном выражении: образец описывает форму, а группа помечает кусок, который нужно вернуть. Только сопоставляется не строка, а тип.

type Names = string[];
// индексный доступ уже умеет доставать элемент — infer тут лишний
type Name = Names[number];

const value: Name = 42;
console.log(value);

Асинхронная функция возвращает не данные, а обёртку вокруг них. Тип этой обёртки в коде встречается постоянно, а нужен обычно тот, что внутри. Образец пишется так же, только вместо Array — Promise.

Прежде чем запускать: Promise<Promise<string>> — что достанет отсюда наш Unwrap?

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

const doubled: Unwrap<Promise<Promise<string>>> = "готово";
console.log(doubled);

«Тип "string" не может быть назначен для типа "Promise<string>"». Образец сработал ровно один раз и снял ровно один слой: на месте U оказался внутренний Promise<string>, им дело и кончилось. Условный тип не повторяется сам по себе — но его можно попросить.

// ветка «да» снова обращается к самому типу
type Deep<T> = T extends Promise<infer U> ? Deep<U> : T;

const value: Deep<Promise<Promise<string>>> = 42;
console.log(value);

const same: Awaited<Promise<Promise<string>>> = 42;
console.log(same);

Обе строки дали одинаковую диагностику про string, и это не совпадение: встроенный Awaited из главы про утилитные типы устроен ровно так же — условный тип с infer, который вызывает сам себя. В настоящем Awaited ещё пара веток на null и на объекты с методом then, но ядро вы только что написали своими руками.

В настоящем коде источником типа обычно служит функция, а не выдуманный Promise<...>.

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

async function loadNote(): Promise<{ id: number; title: string }> {
  return { id: 7, title: "Заметка о infer" };
}

// тип ответа не переписан руками, а вынут из самой функции
type Note = Payload<ReturnType<typeof loadNote>>;

loadNote().then((note: Note) => console.log(note.title));

Добавится поле в loadNote — Note изменится сам. Ручная копия типа так не умеет: она расходится с оригиналом молча.

Тип функции — тоже форма: (параметры) => результат. Значит, infer ставится и туда, причём в оба места сразу.

type Result<F> = F extends (...args: never[]) => infer R ? R : never;

function format(price: number): string {
  return price.toFixed(2) + " AED";
}

const shown: Result<typeof format> = 100;
console.log(shown);

Получился string — результат format, вытащенный из её типа. Странно выглядит только never[] на месте параметров. Смысл там такой: «параметры любые, они нас не интересуют». Проверим очевидное на вид написание — unknown[], «массив чего угодно».

type Loose<F> = F extends (...args: unknown[]) => infer R ? R : never;

function format(price: number): string {
  return price.toFixed(2) + " AED";
}

const shown: Loose<typeof format> = "100.00 AED";
console.log(shown);

never — образец не подошёл. Параметры при сравнении функций работают наоборот, чем всё остальное: подходит та функция, которая принимает не меньше, чем требует образец. (...args: unknown[]) требует функцию, готовую съесть что угодно, а format берёт только число — значит, не годится. С never[] требование пустое: принять «ничто» способна любая функция, и образец сходится всегда.

В стандартной библиотеке на этом месте стоит any — и в ограничении параметра, и в самом образце: type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;. Тот самый any, которого мы избегаем со статьи про две двери из системы типов: здесь он выключен намеренно и ровно в одном месте — на списке параметров, который образцу безразличен. В своём коде тот же результат даёт never[], и лазейки не появляется.

Параметры ловятся так же — но приезжают не по одному, а кортежем.

type Args<F> = F extends (...args: infer P) => unknown ? P : never;

function makeUser(name: string, age: number): string {
  return name + ", " + age;
}

const good: Args<typeof makeUser> = ["Рико", 39];
console.log(makeUser(...good));

const bad: Args<typeof makeUser> = ["Рико", "39"];
console.log(bad.length);

Кортеж из главы про массивы и кортежи, только собранный компилятором: [name: string, age: number]. Его можно хранить, передавать и разворачивать обратно в вызов через spread — а вторая строка со строкой вместо числа получает диагностику ровно на нужном месте.

Готовое из правой колонки и стоит брать в работе. Левая нужна для случаев, которых в библиотеке нет, — а их в любом настоящем проекте хватает.

Соблазн написать infer где-нибудь ещё возникает быстро — например, просто объявить «переменную типа». Компилятор на это отвечает отдельным кодом ошибки.

type Element<T> = infer U;

const value: Element<string[]> = "что-нибудь";
console.log(value);

«TS1338: объявления "infer" допустимы только в предложении "extends" условного типа». Это не придирка, а суть механизма: infer не объявляет тип, а ловит его при сопоставлении. Сопоставлять нечего — ловить нечего. Вторая диагностика, про присваивание, здесь лишь эхо первой: раз запись не разобрана, компилятор не знает, чем считать U.

Второе ограничение — область видимости. Пойманное имя живёт только в ветке «да».

type Element<T> = T extends Array<infer U> ? U : U;

const value: Element<string[]> = "строка";
console.log(value);

«Не удается найти имя "U"» — и правильно: в ветку «нет» попадают как раз те типы, для которых сопоставление провалилось и U не получил значения. Ставьте туда never, исходный T или что-то осмысленное вроде запасного типа.

А вот полезная возможность, о которой узнают поздно: пойманному типу можно сразу поставить условие через extends. Не подошёл под него — сработает ветка «нет», как будто образец не сошёлся вовсе.

type IdOf<T> = T extends { id: infer I extends number } ? I : "у id не числовой тип";

const first: IdOf<{ id: 7 }> = 7;
const second: IdOf<{ id: string }> = 7;
console.log(first, second);

Первая строка молчит — I поймал литеральный тип 7. Вторая получила диагностику: string ограничение не прошёл, и IdOf вернул строку из ветки «нет». Так один образец и достаёт тип, и проверяет его.

type Both<T> = T extends { a: infer U; b: infer U } ? U : never;

const value: Both<{ a: string; b: number }> = true;
console.log(value);

type Handler<T> = T extends (a: infer U, b: infer U) => void ? U : never;

const value: Handler<(a: string, b: number) => void> = "строка";
console.log(value);

Первая ловушка ждёт там, где infer обычно и применяют впервые: на массиве из as const.

type ElementOf<T> = T extends Array<infer U> ? U : never;

const roles = ["админ", "автор", "гость"] as const;
const role: ElementOf<typeof roles> = "админ";
console.log(role);

Ветка «нет», never — хотя массив вот он. Дело в as const из статьи про неизменяемость: он делает не string[], а readonly ["админ", "автор", "гость"]. Изменяемый Array такому кортежу не родня, образец не сходится. Лечится одним словом.

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

const roles = ["админ", "автор", "гость"] as const;
const role: ElementOf<typeof roles> = "модератор";
console.log(role);

Теперь образец принимает и изменяемые массивы, и readonly-кортежи, а U собрал из кортежа объединение литералов — диагностика перечисляет все три роли. Пишите в своих утилитах readonly (infer U)[] по умолчанию: этот вариант шире.

Вторая ловушка — распределение по объединению из прошлой статьи главы. Оно никуда не делось и работает вместе с infer.

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

const value: ElementOf<string[] | number[]> = true;
console.log(value);

Образец приложился к каждому варианту отдельно, и результаты собрались обратно: string | number. Обычно это то, что нужно. Но если требуется рассмотреть объединение целиком, придётся глушить распределение — тем самым приёмом с квадратными скобками, который разбирали в прошлой статье.

Третья ловушка серьёзнее и не имеет никакого отношения к синтаксису. Ниже компилятор промолчит — предскажите, что произойдёт на запуске.

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

// as заставляет компилятор поверить на слово
const raw = JSON.parse("[1, 2, 3]") as string[];
const first: ElementOf<typeof raw> = raw[0];
console.log(first.toUpperCase());

Ни одной диагностики — и TypeError на исполнении. infer достаёт то, что написано в типах, а не то, что лежит в памяти. Соврали образцу через as — он честно вытащит вашу же неправду и передаст дальше по всем производным типам.

infer — инструмент вывода, а не проверки. Данные с границы программы всё так же нужно проверять кодом, который выполняется.