Transpose

In this medium-level challenge, you'll implement a Transpose type that flips a matrix over its diagonal, swapping row and column indices to produce the transposed matrix entirely at the type level.

type Matrix = Transpose <[[1]]>; // expected to be [[1]]
type Matrix1 = Transpose <[[1, 2], [3, 4]]>; // expected to be [[1, 3], [2, 4]]
type Matrix2 = Transpose <[[1, 2, 3], [4, 5, 6]]>; // expected to be [[1, 4], [2, 5], [3, 6]]

type cases = [
  Expect<Equal<Transpose<[]>, []>>,
  Expect<Equal<Transpose<[[1]]>, [[1]]>>,
  Expect<Equal<Transpose<[[1, 2]]>, [[1], [2]]>>,
  Expect<Equal<Transpose<[[1, 2], [3, 4]]>, [[1, 3], [2, 4]]>>,
  Expect<Equal<Transpose<[[1, 2, 3], [4, 5, 6]]>, [[1, 4], [2, 5], [3, 6]]>>,
  Expect<Equal<Transpose<[[1, 4], [2, 5], [3, 6]]>, [[1, 2, 3], [4, 5, 6]]>>,
  Expect<
    Equal<
      Transpose<[[1, 2, 3], [4, 5, 6], [7, 8, 9]]>,
      [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
    >
  >,
]

Detailed Explanation

type Transpose<M extends unknown[][]> =
  M extends []
    ? []
    : M[0] extends []
      ? []
      : [
          { [K in keyof M]: M[K] extends [infer F, ...any[]] ? F : never }
            & unknown[],
          ...Transpose<
            { [K in keyof M]: M[K] extends [any, ...infer R] ? R : never }
              & unknown[][]
          >,
        ];

How it works:

• The base cases handle an empty matrix (M extends []) and rows that have been fully consumed (M[0] extends []), both returning an empty tuple
• For the recursive case, the first element of the result is a tuple formed by extracting the first element from each row using a mapped type: { [K in keyof M]: M[K] extends [infer F, ...any[]] ? F : never }
• The intersection with unknown[] ensures TypeScript treats the mapped type result as a proper array/tuple
• The rest of the result comes from recursively transposing the "tail" of each row -- a new matrix where the first column has been removed via M[K] extends [any, ...infer R] ? R : never
• This effectively peels off one column at a time from the original matrix and stacks each column as a row in the transposed result

This challenge helps you understand recursive mapped types over tuples and matrix manipulation at the type level, and how to apply these concepts in real-world scenarios.