Tuple to Nested Object

In this medium-level challenge, you'll implement a TupleToNestedObject type that takes a tuple of string keys and a value type, then builds a deeply nested object type where each key wraps the next level.

type a = TupleToNestedObject<['a'], string> // {a: string}
type b = TupleToNestedObject<['a', 'b'], number> // {a: {b: number}}
type c = TupleToNestedObject<[], boolean> // boolean. if the tuple is empty, just return the U type

type cases = [
  Expect<Equal<TupleToNestedObject<['a'], string>, { a: string }>>,
  Expect<Equal<TupleToNestedObject<['a', 'b'], number>, { a: { b: number } }>>,
  Expect<
    Equal<
      TupleToNestedObject<['a', 'b', 'c'], boolean>,
      { a: { b: { c: boolean } } }
    >
  >,
  Expect<Equal<TupleToNestedObject<[], boolean>, boolean>>,
]

Detailed Explanation

type TupleToNestedObject<T extends string[], U> =
  T extends [infer First extends string, ...infer Rest extends string[]]
    ? { [K in First]: TupleToNestedObject<Rest, U> }
    : U;

How it works:

• The type destructures the tuple T into its first element First (constrained to string) and the remaining elements Rest (constrained to string[])
• For each key, it creates an object type { [K in First]: ... } using a mapped type with a single key, where the value is the recursive result of processing the rest of the tuple
• When the tuple is empty (the base case), the recursion returns the value type U directly, placing it at the innermost nesting level
• For example, TupleToNestedObject<['a', 'b'], number> first creates { a: TupleToNestedObject<['b'], number> }, which becomes { a: { b: number } }

This challenge helps you understand recursive type construction and tuple-to-object transformation, and how to apply these concepts in real-world scenarios.