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.

[object Object]

/* _____________ Your Code Here _____________ */

type Permutation<T> = any

/* _____________ Test Cases _____________ */
import type { Equal, Expect } from '../helpers'

type cases = [
  Expect<Equal<Permutation<'A'>, ['A']>>,
  Expect<
    Equal<
      Permutation<'A' | 'B' | 'C'>,
      | ['A', 'B', 'C']
      | ['A', 'C', 'B']
      | ['B', 'A', 'C']
      | ['B', 'C', 'A']
      | ['C', 'A', 'B']
      | ['C', 'B', 'A']
    >
  >,
  Expect<
    Equal<
      Permutation<'B' | 'A' | 'C'>,
      | ['A', 'B', 'C']
      | ['A', 'C', 'B']
      | ['B', 'A', 'C']
      | ['B', 'C', '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.