Продвинутые типы

Условный тип выбирает один из двух типов, проверяя совместимость: T extends U ? X : Y даёт X, если T совместим с U, и Y в противном случае. Это if уровня типов, вычисляемый компилятором и полностью стираемый из итогового JavaScript.

keyof T даёт объединение имён свойств T как литеральных типов: для { a: number; b: string } это 'a' | 'b'. Вместе с индексированным доступом T[K] он типизирует безопасное чтение свойства, как в <K extends keyof T>(o: T, k: K) => T[K]. Для типа с строковой индексной сигнатурой он расширяется до string | number.

Mapped-тип строит новый объектный тип, перебирая объединение ключей. { [K in keyof T]: T[K] } проходит по каждому ключу T и задаёт ему тип значения, воспроизводя T. Readonly<T> и Partial<T> написаны ровно так, добавляя при переборе модификатор readonly или ?. Результат — свежий тип, вычисленный компилятором.

Псевдоним типа может ссылаться на себя, поэтому Json — это рекурсивное объединение: type Json = string | number | boolean | null | Json[] | { [k: string]: Json }. Обе ссылки на себя стоят внутри массива или индексной сигнатуры, что откладывает рекурсию, поэтому компилятор разворачивает её лениво и вложенность работает на любую глубину.

Template literal type строит строковые литеральные типы из других типов и пишется как шаблонная строка JS, но в позиции типа. Подстановка объединения раскрывается в декартово произведение, поэтому сочетание 'a' | 'b' и 1 | 2 даёт 'a-1' | 'a-2' | 'b-1' | 'b-2'. Вместе с Capitalize и infer он может собирать и даже разбирать имена ключей на этапе компиляции.

Условный тип распределяется, когда проверяемый тип — голый параметр типа, а аргумент — объединение: проверка выполняется для каждого члена, а результаты снова объединяются. Поэтому NonNullable<string | null> даёт string. Обёртка обеих сторон в кортеж — [T] extends [U] ? X : Y — делает операнд не голым, и объединение проверяется целиком за один раз.

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

Клауза as переименовывает ключи: сопоставление K с template literal type даёт новое имя, а сопоставление с never полностью отбрасывает ключ. Модификаторы +/- добавляют или снимают readonly и ? — через -? и определён Required<T>. Гомоморфный перебор, записанный поверх keyof T, переносит существующие readonly и ? из T, пока вы их явно не переопределите.

Объедините полную форму с формой, все ключи которой необязательны и типа never: type AllOrNothing<T> = T | { [K in keyof T]?: never }. Вторая половина — mapped-тип поверх keyof T, поэтому она следует за T сама. Передача только start не подходит ни к одной ветке — в первой нет end, а во второй значение получает never, — и компилятор её отвергает.

Рекурсивный вызов стоит внутри template literal, то есть не в хвостовой позиции: каждый уровень остаётся в стеке инстанцирования, ожидая свой результат, и бюджет глубины кончается. Протащите аккумулятор, чтобы ветка возвращала рекурсивный вызов напрямую, склеивая строку до рекурсии — такую хвостовую форму компилятор оптимизирует и раскручивает намного глубже.

Гомоморфный mapped-тип — { [K in keyof T]: … } с голым параметром T — распределяется по объединению, поэтому Partial<A | B> превращается в Partial<A> | Partial<B>, и каждый член сохраняет свои ключи. Перебор по keyof (A | B) не гомоморфен: keyof от объединения даёт лишь ключи, общие для всех членов, поэтому результат схлопывается до общих ключей и молча теряет остальные.

Компилятор ограничивает глубину инстанцирования типа, за которой считает разворачивание потенциально бесконечным, и условный тип, раскручивающийся по разу на элемент, упирается в предел с ошибкой «Type instantiation is excessively deep and possibly infinite». Рекурсия в хвостовой позиции оптимизирована и уходит намного дальше, поэтому лечится это переводом в хвостовую форму, обработкой пачками или счётчиком глубины.

type MyReturnType<T extends (...a: any) => any> = T extends (...a: any) => infer R ? R : never — условный тип сопоставляет T с формой функции, а infer R связывает позицию возврата. Awaited<T> на этом остановиться не может: промис может разрешиться в другой промис, поэтому он применяет себя к выведенному значению — T extends PromiseLike<infer U> ? MyAwaited<U> : T — пока нагрузка ещё thenable.

Судите каждый тип по тому, устраняет ли он реальный класс ошибок: сложный тип окупается на широко используемой границе, а не в листе. Разбейте монолиты на маленькие именованные псевдонимы, чтобы ошибки и подсказки называли осмысленное имя, добавьте тесты уровня типов на каждую ветку и держите рекурсию неглубокой. Приведения отклоните — они меняют проблему читаемости на проблему корректности.

Сохраните каталог с as const, чтобы литералы уцелели, затем выведите объединение ключей рекурсивным типом, который обходит объект и собирает точечные пути через template literal type. Индексированный доступ возвращает по пути литерал сообщения, а вторая рекурсия разбирает из него плейсхолдеры в объект аргументов. Ждите пределов глубины инстанцирования и размера объединения — ограничьте вложенность, разбейте большие каталоги.

В TypeScript нет типов высших порядков: параметр типа всегда обозначает конкретный тип, а не неприменённый конструктор типов, поэтому нельзя написать F<_> и затем применить его как F<string>. Абстрагироваться над «любым контейнером» напрямую невозможно. Библиотеки подменяют это дефункционализацией — регистрируют конструктор под строковым ключом в интерфейсе, передают ключ и применяют индексированным доступом.