Permutations of Tuple

In this medium-level challenge, you'll write a type that takes a tuple and produces a union of all possible permutations of that tuple's elements, preserving their individual types.

PermutationsOfTuple<[1, number, unknown]>
// Should return:
// | [1, number, unknown]
// | [1, unknown, number]
// | [number, 1, unknown]
// | [unknown, 1, number]
// | [number, unknown, 1]
// | [unknown, number ,1]

Detailed Explanation

type PermutationsOfTuple<T extends unknown[], Prev extends unknown[] = []> =
  T extends [infer First, ...infer Rest]
    ? [First, ...PermutationsOfTuple<[...Prev, ...Rest]>] | PermutationsOfTuple<Rest, [...Prev, First]>
    : Prev extends []
      ? []
      : never

How it works:

• The type recursively processes the tuple T from left to right. Prev accumulates elements that have been skipped over (not yet placed).
• When T has at least one element, we branch into two possibilities via a union (|):
  • Place First now: We put First at the head of the result and recursively permute the remaining elements [...Prev, ...Rest] (everything we skipped plus everything after First).
  • Skip First for later: We move First into Prev and continue looking at Rest for the next element to place.
• When T is empty, we check Prev: if Prev is also empty, we have placed all elements and return []. If Prev still has elements but T is empty, we return never since this path cannot complete a valid permutation on its own (those elements will be handled by the "place now" branch).

This challenge helps you understand recursive tuple manipulation combined with union distribution, and how to apply these concepts in real-world scenarios.