Permutation

In this medium-level challenge, you'll implement a Permutation type that transforms a union type into a union of all possible tuple orderings of its members.

type perm = Permutation<'A' | 'B' | 'C'>; // ['A', 'B', 'C'] | ['A', 'C', 'B'] | ['B', 'A', 'C'] | ['B', 'C', 'A'] | ['C', 'A', 'B'] | ['C', 'B', 'A']

Detailed Explanation

type Permutation<T, U = T> =
  [T] extends [never]
    ? []
    : U extends U
      ? [U, ...Permutation<Exclude<T, U>>]
      : never

How it works:

• The [T] extends [never] check is the base case. We wrap T in a tuple to prevent distributive behavior -- a bare T extends never would itself distribute and produce never instead of matching. When the union is exhausted (i.e., T is never), we return an empty tuple [].
• U = T creates a copy of the original union. The U extends U pattern triggers distributive conditional types, which iterates over each member of the union one at a time.
• For each member U, we place it at the front of a tuple and recursively compute Permutation<Exclude<T, U>> -- the permutations of the remaining members with U removed.
• The distributed results are automatically collected into a union of all possible orderings.

This challenge helps you understand distributive conditional types and recursive union manipulation, and how to apply these concepts in real-world scenarios.