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

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.