Арифметика на уровне типов

Представление: число — это длина кортежа

Спросите себя: если 3 + 4 нельзя написать как выражение типа, как вообще проверить на этапе компиляции, что два вектора одной размерности? Весь приём умещается в одну идею. На уровне типов нет оператора +. Стандартная кодировка: число N — это любой кортеж с length, равным N. Постройте его, хвостово-рекурсивно добавляя unknown, пока длина не совпадёт:

type BuildTuple<N extends number, Acc extends unknown[] = []> =
  Acc["length"] extends N ? Acc : BuildTuple<N, [unknown, ...Acc]>;

type Three = BuildTuple<3>;
//   ^? type Three = [unknown, unknown, unknown]
type Len = Three["length"];
//   ^? type Len = 3

Это в точности хвостово-рекурсивный Build из урока 1. Вся арифметическая библиотека сводится к: преобразовать числа в кортежи, манипулировать кортежами, считать ["length"] обратно.

Add: конкатенация двух кортежей

Сложение A + B — это построить оба кортежа, спредить их в один и считать совместную длину:

type Add<A extends number, B extends number> =
  [...BuildTuple<A>, ...BuildTuple<B>]["length"] & number;

type Seven = Add<3, 4>;
//   ^? type Seven = 7

& number сужает ["length"] (в общем случае типизированную как number) обратно к литералу. Конкатенация — это + на уровне типов.

Subtract: вывести разницу с начала

Вычитание A - B строит кортеж для A, затем срезает B элементов с начала, матча префикс BuildTuple<B> и выводя остаток:

type Subtract<A extends number, B extends number> =
  BuildTuple<A> extends [...BuildTuple<B>, ...infer Rest]
    ? Rest["length"]
    : never;   // A < B: такого префикса нет, переполнение вниз -> never

type Two = Subtract<5, 3>;
//   ^? type Two = 2
type Under = Subtract<3, 5>;
//   ^? type Under = never   (отрицательные числа непредставимы)

Паттерн [...BuildTuple<B>, ...infer Rest] говорит «кортеж, начинающийся с B элементов, где Rest — то, что после». Rest["length"] — это A - B. Для отрицательных нет представления, поэтому недобор проваливается в never — это намеренный сигнал, а не баг.

Compare: гонка длин

GreaterThan<A, B> идёт по обоим кортежам синхронно; кто опустеет первым — тот меньше:

type GreaterThan<A extends number, B extends number> =
  BuildTuple<B> extends [...BuildTuple<A>, ...infer _Rest]
    ? false        // B не короче A  ->  A <= B
    : true;        // B НЕ является префикс-надмножеством A  ->  A > B

type G1 = GreaterThan<5, 3>;   // ^? type G1 = true
type G2 = GreaterThan<3, 5>;   // ^? type G2 = false
type G3 = GreaterThan<4, 4>;   // ^? type G3 = false

Парсинг числовых литералов из строк

Когда вы пишете тип роутера, вытаскивающий :42 из строки пути, вам нужен обратно числовой тип, а не строка. ${number} в шаблонном литерале матчит числовую строку, но захваченный infer всё ещё строка. Чтобы получить числовой тип, выведите его, а затем сразу скоэрсите через ограниченный infer:

type ParseInt<S extends string> =
  S extends `${infer N extends number}` ? N : never;

type P = ParseInt<"42">;
//   ^? type P = 42   (`infer N extends number` делает приведение string->number)

infer N extends number (TS 4.8+) одновременно захватывает и приводит: он пытается интерпретировать совпавшую подстроку как числовой литеральный тип. Так типы роутера/путей вытаскивают сегменты вроде :42 в числа.