Как вы делаете рекурсивные типы в Typescript?

Проблема с универсальной функцией, сигнатура вызова которой выглядит как

declare function foo<T extends number | Record<string, T>>(t: T): void;

это то, что когда вы вызываете его с некоторым литералом объекта, например

foo({ a: 1 }) // error!

компилятор не использует ограничение number | Record<string, T> в качестве места вывода для T (как предлагалось, но никогда не применялось в microsoft/TypeScript#7234). Вместо этого он делает вывод T только из переданного значения, а затем проверяет его на соответствие ограничению.

Таким образом, в приведенном выше вызове T выводится как {a: 1}, потому что это тип литерала {a: 1}. А затем он сверяется с number | Record<string, T>, который равен number | Record<string, {a: 1}>. А {a: 1} не расширяет number | Record<string, {a: 1}>, поэтому значение не соответствует ограничению и возникает ошибка.

Единственный способ, которым вызов будет успешным, - это если переданное значение уже известно как рекурсивное желаемым образом, но этого не произойдет, если вы передаете литералы объекта.

Поэтому нам нужен другой подход.

Если вам не нужны дженерики, вы можете вместо этого сделать функции неуниверсальными и при необходимости заставить их действовать с соответствующим рекурсивным типом, например

type Summable = number | { [k: string]: Summable };

Таким образом, значение, полученное ранее, будет проверено на соответствие этому типу, который окажется успешным:

const val: Summable = { a: 1 }; // okay

Таким образом, вы можете выполнить рефакторинг:

function sum(array: Summable[], keys?: string[]): number {
  const totalSum = array.reduce((accumulator: number, element) => {
    if (typeof element === 'number') {
      return accumulator + element;
    }
    if (keys === undefined) {
      throw new Error(`keys not passed in as an argument and type of Array is not number`);
    }
    return accumulator + Number(getNestedProperty(element, keys));
  }, 0);
  return totalSum;
}

И возможно

function getNestedProperty(obj: unknown, keys: string[]): unknown {
  const nestedKeys = [...keys];
  const nestedKey = nestedKeys.shift();
  if ((nestedKey !== undefined) && (typeof obj === "object") && obj && (nestedKey in obj)) {
    const o = obj as Record<string, unknown>;
    return getNestedProperty(o[nestedKey], nestedKeys);
  } else {
    return obj;
  }
}

где мы просто собираемся сказать, что типы ввода и вывода getNestedProperty(obj, keys) - это unknown, потому что на самом деле нет ничего более полезного, чем сделать функцию универсальной.

Обратите внимание, что я бы, вероятно, реорганизовал реализацию

function getNestedProperty(obj: unknown, keys: string[]): unknown {
  return keys.reduce((acc, k) =>
    typeof acc === "object" && acc && k in acc ?
      (acc as Record<string, unknown>)[k] : acc,
    obj);
}

если вам не нужно, чтобы он был рекурсивным.

Если вам нужно сделать функцию универсальной, вам придется пройти через относительно болезненный процесс точного описания того, что будут делать функции. Например, getNestedProperty() может выглядеть как

type DeepIdx<T, K extends PropertyKey[]> =
  K extends [infer K0, ...infer KR extends PropertyKey[]] ?
  K0 extends keyof T ? DeepIdx<T[K0], KR> : T : T;

function getNestedProperty<T, K extends PropertyKey[]>(
  obj: T,
  keys: [...K]
): DeepIdx<T, K> {
  return keys.reduce<any>((acc, k) =>
    typeof acc === "object" && acc && k in acc ? acc[k] : acc,
    obj);
}

хотя я не собираюсь отвлекаться, чтобы объяснить, как именно это работает.

Площадка ссылка на код