MergeAll

In this medium-level challenge, you'll implement MergeAll<XS>, a type that takes a tuple of object types and merges them into a single object, combining overlapping keys into union types.

type Foo = { a: 1; b: 2 }
type Bar = { a: 2 }
type Baz = { c: 3 }
 
type Result = MergeAll<[Foo, Bar, Baz]> // expected to be { a: 1 | 2; b: 2; c: 3 }

type cases = [
  Expect<Equal<MergeAll<[]>, {}>>,
  Expect<Equal<MergeAll<[{ a: 1 }]>, { a: 1 }>>,
  Expect<Equal<MergeAll<[{ a: string }, { a: string }]>, { a: string }>>,
  Expect<Equal<MergeAll<[{}, { a: string }]>, { a: string }>>,
  Expect<Equal<MergeAll<[{ a: 1 }, { c: 2 }]>, { a: 1; c: 2 }>>,
  Expect<
    Equal<
      MergeAll<[{ a: 1; b: 2 }, { a: 2 }, { c: 3 }]>,
      { a: 1 | 2; b: 2; c: 3 }
    >
  >,
  Expect<Equal<MergeAll<[{ a: 1 }, { a: number }]>, { a: number }>>,
  Expect<Equal<MergeAll<[{ a: number }, { a: 1 }]>, { a: number }>>,
  Expect<Equal<MergeAll<[{ a: 1 | 2 }, { a: 

Detailed Explanation

type MergeAll<XS, Acc = {}> =
  XS extends [infer First, ...infer Rest]
    ? MergeAll<Rest, Merge<Acc, First>>
    : Acc;
 
type Merge<A, B> = {
  [K in keyof A | keyof B]:
    K extends keyof A
      ? K extends keyof B
        ? A[K] | B[K]
        : A[K]
      : K extends keyof B
        ? B[K]
        : never;
};

How it works:

• MergeAll recursively processes the tuple by extracting the first element and merging it into an accumulator using the Merge helper type
• The Merge helper combines two objects by iterating over the union of all keys from both A and B
• For keys that exist in both objects, the values are combined into a union type (A[K] | B[K]), which naturally collapses when one type is a subtype of the other (e.g., 1 | number simplifies to number)
• For keys that exist in only one object, the value type is preserved as-is
• The recursion starts with an empty object {} as the accumulator and processes each element in the tuple left to right, building up the merged result incrementally
• The base case returns the accumulator when the tuple is empty

This challenge helps you understand recursive tuple processing and object type merging with union values, and how to apply these concepts in real-world scenarios.