Trace

In this medium-level challenge, you'll implement a Trace type that extracts the diagonal elements of a square matrix and returns them as a union type, mirroring the mathematical concept of a matrix trace at the type level.

type Arr = [
[1,2],
[3,4]
]
type Test = Trace<Arr> // expected to be 1 | 4

Detailed Explanation

type Trace<T extends any[][], I extends any[] = []> =
  I['length'] extends T['length']
    ? never
    : T[I['length']][I['length']] | Trace<T, [...I, 0]>;

How it works:

• The type uses a counter tuple I that starts empty and grows by one element on each recursive step, allowing us to track the current index
• At each step, I['length'] serves as the index into both the row and column of the matrix, extracting T[I['length']][I['length']] -- the diagonal element
• The extracted element is combined with the result of the next recursive call using a union (|), collecting all diagonal elements together
• The base case checks whether I['length'] equals T['length'] (the number of rows), returning never to terminate the recursion without adding to the union

An alternative approach uses a mapped type over the matrix rows:

type Trace<T extends any[][]> = {
  [K in keyof T]: K extends `${infer N extends number}` ? T[K][N] : never;
}[number];

This maps over each row index K, converts it from a string key to a numeric index N using template literal inference, then accesses T[K][N] to get the diagonal element. The final [number] indexes into the mapped tuple to produce a union of all diagonal values.

This challenge helps you understand recursive type-level iteration and tuple indexing, and how to apply these concepts in real-world scenarios.