Рекурсивні типи даних та маніпуляції з кортежами (Tuples)

+-------------------------------------------------------------------------+
|                  ЗВИЧАЙНА РЕКУРСІЯ (Ліміт: ~50 кроків)                  |
|                  Reverse<[1, 2, 3]> => [...Reverse<[2, 3]>, 1]          |
+-------------------------------------------------------------------------+
|  Стек компілятора змушений зберігати нерозв'язані операції спреду:      |
|  [... [... [...Reverse<[]>, 3], 2], 1]                                  |
|  => Переповнення стека tsc при N > 50 (Помилка TS2589)!                 |
+-------------------------------------------------------------------------+
|                                                                         |
|                  ХВОСТОВА РЕКУРСІЯ (TCO) (Ліміт: 1000 кроків!)          |
|                  ReverseTCO<T, Acc = []>                                |
+-------------------------------------------------------------------------+
|  Компілятор одразу передає результат в акумулятор на кожному кроці:     |
|  1. Step 1: T = [2, 3], Acc = [1]                                       |
|  2. Step 2: T = [3],    Acc = [2, 1]                                    |
|  3. Step 3: T = [],     Acc = [3, 2, 1]                                 |
|  => Термінальний вихід: повертається готовий Acc без очікування стека!  |
+-------------------------------------------------------------------------+

// 1. Вилучення першого елемента (Head)
export type Head<TTuple extends readonly unknown[]> = TTuple extends readonly [
  infer THead,
  ...unknown[]
]
  ? THead
  : never;

// 2. Вилучення хвоста кортежу без першого елемента (Tail)
export type Tail<TTuple extends readonly unknown[]> = TTuple extends readonly [
  unknown,
  ...infer TTail
]
  ? TTail
  : [];

// 3. Додавання елемента в кінець кортежу (Push)
export type Push<TTuple extends readonly unknown[], TElement> = [...TTuple, TElement];

// 4. Додавання елемента на початок кортежу (Unshift)
export type Unshift<TTuple extends readonly unknown[], TElement> = [TElement, ...TTuple];

// 5. Вилучення останнього елемента (Last)
export type Last<TTuple extends readonly unknown[]> = TTuple extends readonly [
  ...unknown[],
  infer TLast
]
  ? TLast
  : never;

// 6. Видалення останнього елемента (Pop)
export type Pop<TTuple extends readonly unknown[]> = TTuple extends readonly [
  ...infer TRest,
  unknown
]
  ? TRest
  : [];

// Тестові перевірки
type TestTuple = [string, number, boolean];

type T1 = Head<TestTuple>;      // string
type T2 = Tail<TestTuple>;      // [number, boolean]
type T3 = Push<TestTuple, Date>; // [string, number, boolean, Date]
type T4 = Last<TestTuple>;      // boolean
type T5 = Pop<TestTuple>;       // [string, number]

// ❌ НЕ-TCO РЕАЛІЗАЦІЯ: компілятор падає на кортежі довше 45 елементів!
export type ReverseNaive<T extends readonly unknown[]> = T extends readonly [
  infer Head,
  ...infer Tail
]
  ? [...ReverseNaive<Tail>, Head] // Наявність спреду [...] зовні ламає TCO!
  : [];

// ✅ TCO РЕАЛІЗАЦІЯ: хвостовий виклик з акумулятором працює до 1000 елементів!
export type Reverse<
  TTuple extends readonly unknown[],
  TAccumulator extends readonly unknown[] = []
> = TTuple extends readonly [infer THead, ...infer TTail]
  ? Reverse<TTail, [THead, ...TAccumulator]> // Чистий хвостовий виклик!
  : TAccumulator;

// Перевірка роботи
type Original = ["a", "b", "c", "d"];
type Inverted = Reverse<Original>; // ["d", "c", "b", "a"]

// Рекурсивний каррифікатор кортежу аргументів
export type Curry<TFunction> = TFunction extends (
  ...args: infer TArgs
) => infer TReturn
  ? TArgs extends [infer TFirst, ...infer TRest]
    ? TRest["length"] extends 0
      ? (arg: TFirst) => TReturn
      : (arg: TFirst) => Curry<(...args: TRest) => TReturn>
    : () => TReturn
  : never;

// Демонстрація роботи каррування
function calculateOrderTotal(
  basePrice: number,
  taxRate: number,
  discountCode: string,
  isVip: boolean
): number {
  const discount = isVip ? 0.2 : 0.05;
  return basePrice * (1 + taxRate) * (1 - discount);
}

// Заглушка функції curry в рантаймі
declare function curry<F extends (...args: any[]) => any>(fn: F): Curry<F>;

const curriedOrder = curry(calculateOrderTotal);

// IDE забезпечує бездоганний послідовний автокомпліт кожного кроку!
const step1 = curriedOrder(1000);         // (taxRate: number) => ...
const step2 = step1(0.2);                 // (discountCode: string) => ...
const step3 = step2("SUMMER2026");        // (isVip: boolean) => number
const finalPrice = step3(true);           // number

export type DeepReadonly<T> = T extends Function
  ? T
  : T extends readonly (infer ElementType)[]
  ? ReadonlyArray<DeepReadonly<ElementType>>
  : T extends object
  ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
  : T;

interface ComplexMutableGraph {
  rootId: string;
  nodes: Array<{
    id: number;
    metadata: {
      tags: string[];
      owner: { name: string };
    };
  }>;
}

export type FrozenGraph = DeepReadonly<ComplexMutableGraph>;

declare const graph: FrozenGraph;
// ❌ Помилки компіляції на всіх рівнях вкладеності:
// graph.rootId = "new-id";                     // TS2540: Cannot assign to 'rootId'
// graph.nodes.push({ ... });                   // TS2339: Property 'push' does not exist on 'ReadonlyArray'
// graph.nodes[0].metadata.tags[0] = "mutated"; // TS2542: Index signature in type 'readonly string[]' only permits reading