Combination key type

In this medium-level challenge, you'll implement Combs<T> which generates all unique two-key combinations from a tuple of modifier keys, preserving the original order so that 'cmd ctrl' is valid but 'ctrl cmd' is not.

type ModifierKeys = ['cmd', 'ctrl', 'opt', 'fn']
type CaseTypeOne =
  | 'cmd ctrl'
  | 'cmd opt'
  | 'cmd fn'
  | 'ctrl opt'
  | 'ctrl fn'
  | 'opt fn'

type cases = [Expect<Equal<Combs<ModifierKeys>, CaseTypeOne>>]

Detailed Explanation

type Combs<T extends any[]> = T extends [infer First extends string, ...infer Rest extends string[]]
  ? `${First} ${Rest[number]}` | Combs<Rest>
  : never

How it works:

• T extends [infer First extends string, ...infer Rest extends string[]] destructures the tuple, pulling out the first element and the remaining elements
• ${First} ${Rest[number]} creates a union of template literal strings by pairing First with every element in Rest using Rest[number]
• Combs<Rest> recursively processes the remaining elements, so each subsequent element is paired only with elements that come after it
• The base case returns never when the tuple is empty or has one element, ending the recursion
• This naturally enforces order since each element is only combined with elements appearing later in the tuple

This challenge helps you understand recursive type processing of tuples combined with template literal types and how to apply these concepts in real-world scenarios.