Автоматический вывод предикатов типов в TypeScript 5.5+

Зачем это нужно#

На протяжении более десяти лет одной из самых раздражающих проблем типизации в TypeScript была неспособность компилятора автоматически сузить тип массива после вызова стандартного метода Array.prototype.filter():

// Legacy TypeScript (версии ниже 5.5):
const numbersOrNull = [1, 2, null, 4, null];
const onlyNumbers = numbersOrNull.filter((x) => x !== null);
// ТИП ВЫВОДИЛСЯ КАК: (number | null)[]
// Компилятор не понимал, что все null были гарантированно отфильтрованы!

Чтобы исключить null или undefined из результирующего массива, разработчики были вынуждены писать ручные функции с предикатами типов (Type Predicate):

// Вынужденный boilerplate до TypeScript 5.5:
const onlyNumbers = numbersOrNull.filter(
  (x): x is number => x !== null
);

Этот подход порождал опасный класс архитектурных дефектов — Type Guard Lie. Если программист ошибался в предикате или теле функции, компилятор слепо верил сигнатуре x is number, маскируя критические рантайм-сбои Cannot read property of undefined.

Начиная с TypeScript 5.5+, компилятор научился производить автоматический вывод предикатов типов (Inferred Type Predicates) при анализе потока управления (Control Flow Analysis / CFA).

Ментальная модель#

В TypeScript 5.5+ компилятор инспектирует абстрактное синтаксическое дерево (AST) тела функции и сопоставляет входящие аргументы с возвращаемым булевым выражением.

Если функция удовлетворяет четырём строгим инвариантам:

1. Отсутствует явная аннотация типа возврата: Если написать : boolean, компилятор принудительно отключит вывод предиката и вернет примитивный логический тип;
2. Детерминированные пути возврата: Тело функции представляет собой одно выражение return condition или все ветки однозначно возвращают булевы результаты;
3. Параметр является объектом сужения: Возвращаемое выражение выполняет сужение типа аргумента (typeof x === 'string', x !== null, x instanceof Date, проверка дискриминатора x.kind === 'admin');
4. Отсутствие мутаций: Внутри тела функции аргумент не мутирует и не переназначается,

компилятор автоматически синтезирует тип возврата parameter is NarrowedType вместо тривиального boolean.

+-------------------------------------------------------------------------+
|              Эволюция вывода предикатов в TypeScript 5.5+               |
+-------------------------------------------------------------------------+
| До TypeScript 5.5:                                                      |
| const isString = (x: unknown) => typeof x === 'string';                 |
| • Сигнатура функции: (x: unknown) => boolean                            |
| • items.filter(isString) => тип остается unknown[]                      |
| • Требовалось: (x: unknown): x is string => ... (хрупкий boilerplate)   |
+-------------------------------------------------------------------------+
                                    │
                                    ▼ Релиз TypeScript 5.5+
+-------------------------------------------------------------------------+
| Современный TypeScript 5.5+:                                            |
| const isString = (x: unknown) => typeof x === 'string';                 |
| • Сигнатура компилятора: (x: unknown): x is string                      |
| • items.filter(isString) => тип автоматически сужается до string[]      |
| • Нулевой бойлерплейт, математическая гарантия соответствия тела функции|
+-------------------------------------------------------------------------+

На практике применяется#

1. Фильтрация результатов Promise.allSettled#

Разделение успешных и отклоненных параллельных асинхронных задач: settled.filter(r => r.status === 'fulfilled'). Компилятор автоматически сужает массив до PromiseFulfilledResult<T>[], давая безопасный доступ к полю .value без ручных приведений типов as.

2. Очистка коллекций от null и undefined (Nullable Arrays)#

При выборках из GraphQL или реляционных БД с опциональными связями: users.filter(u => u.profile !== null). Результирующий список получает тип гарантированно инициализированных профилей.

3. Маршрутизация в шинах событий (Event Bus & Redux)#

Фильтрация потока доменных событий: events.filter(e => e.type === 'ORDER_CREATED'). Компилятор мгновенно распознает Discriminated Unions и сужает тип события.

4. Поиск первого подходящего элемента через Array.find#

Метод array.find(item => item instanceof AdminUser) в TypeScript 5.5+ автоматически возвращает тип AdminUser | undefined вместо базового User | undefined.

Архитектура конвейера и реализация#

Разберем конвейер фильтрации разнородных событий и агрегации параллельных задач.

Реализация типобезопасных фильтров коллекций#

export interface UserSession {
  id: string;
  email: string;
  role: 'admin' | 'editor' | 'guest';
  lastActive: Date | null;
}

/**
 * 1. Фильтрация примитивов:
 * Компилятор выводит: (val: string | number | null): val is string
 */
export const isString = (val: string | number | null) => typeof val === 'string';

const mixedValues: (string | number | null)[] = ['alpha', 42, null, 'beta'];
// В TypeScript 5.5+ stringsOnly имеет строгий тип string[]!
export const stringsOnly = mixedValues.filter(isString);

/**
 * 2. Инлайн-фильтрация с оператором неравенства:
 * Сигнатура автоматически выводится как: (s: UserSession | null | undefined): s is UserSession
 */
export function getActiveSessions(
  sessions: readonly (UserSession | null | undefined)[]
): UserSession[] {
  // Тип автоматически сужается до UserSession[]
  return sessions.filter((s) => s !== null && s !== undefined);
}

/**
 * 3. Сужение размеченных объединений (Discriminated Unions)
 */
export type AppEvent =
  | { type: 'AUTH_SUCCESS'; userId: string; token: string }
  | { type: 'AUTH_FAILURE'; error: string }
  | { type: 'HEARTBEAT'; timestamp: number };

/**
 * Сигнатура автоматически инферится как:
 * (event: AppEvent): event is { type: 'AUTH_SUCCESS'; userId: string; token: string }
 */
export const isAuthSuccessEvent = (event: AppEvent) => event.type === 'AUTH_SUCCESS';

export function extractAuthTokens(events: readonly AppEvent[]): string[] {
  // Компилятор знает, что у отфильтрованных событий гарантированно есть поле .token!
  return events
    .filter(isAuthSuccessEvent)
    .map((e) => e.token);
}

Готовый рабочий артефакт#

Демонстрация промышленного агрегатора асинхронных задач, использующего автоматический вывод предикатов для мгновенного и безопасного разделения результатов Promise.allSettled.

export interface TaskResult<T> {
  successful: T[];
  failedErrors: Error[];
}

/**
 * Агрегатор параллельных задач с автоматическим сужением типов PromiseSettledResult
 */
export async function runParallelTasks<T>(
  tasks: readonly Promise<T>[]
): Promise<TaskResult<T>> {
  const settled = await Promise.allSettled(tasks);

  // Предикат (r): r is PromiseFulfilledResult<T> выводится АВТОМАТИЧЕСКИ!
  const fulfilled = settled.filter(
    (r) => r.status === 'fulfilled'
  );

  // Предикат (r): r is PromiseRejectedResult выводится АВТОМАТИЧЕСКИ!
  const rejected = settled.filter(
    (r) => r.status === 'rejected'
  );

  return {
    successful: fulfilled.map((r) => r.value),
    failedErrors: rejected.map((r) =>
      r.reason instanceof Error ? r.reason : new Error(String(r.reason))
    ),
  };
}

Распространённые ошибки (Pitfalls)#

// ❌ АНТИПАТТЕРН: Явный : boolean подавляет вывод предиката
const isNotNull = (x: string | null): boolean => x !== null;
const list = ['a', null, 'b'].filter(isNotNull); // Тип: (string | null)[]

// ✅ ПРАВИЛЬНО: Отсутствие аннотации активирует автоматический предикат x is string
const isNotNull = (x: string | null) => x !== null;
const list = ['a', null, 'b'].filter(isNotNull); // Тип: string[]

Резюме#

Появление Inferred Type Predicates в TypeScript 5.5+ — одно из самых долгожданных улучшений языка за последние годы. Оно делает работу со стандартным методом Array.prototype.filter интуитивной и типобезопасной «из коробки», исключает написание хрупкого бойлерплейта x is Type и математически защищает кодовую базу от фатальных ошибок рассинхронизации типов (Type Guard Lie).