TypeScript: Transforming Union Types into Intersection Types

Updated: December 14, 2023 By: Frienzied Flame Post a comment

The world of TypeScript is filled with intricate, advanced type manipulation utilities. Two of the most prevalent and adaptable type constructs in TypeScript are the Union and Intersection types. This article dives deep into understanding these types, their applications, and how to convert a Union type into an Intersection type.

Understanding Union and Intersection Types

Union Types

Union Types in TypeScript provide an entity with the ability to be one of several types. The | symbol represents them. They are used to denote that a value can be of any of the types mentioned.

type Fruit = "apple" | "orange" | "banana";

In the above code snippet, the Fruit type can be either “apple”, “orange”, or “banana”.

Intersection Types

Intersection Types, on the other hand, are about combining multiple types into one. They are represented by the & symbol. The purpose of Intersection Types is to merge multiple types.

type Named = { name: string };
type Aged = { age: number };
type Person = Named & Aged;

In this example, a Person is both Named and Aged. It combines the types into one.

The Challenge of Transformation

The transformation from Union to Intersection might seem counter-intuitive due to the fundamental semantic differences between Union and Intersection types:

  • A value of a Union type is always exactly one of the constituent types.
  • A value of an Intersection type simultaneously belongs to all the constituent types.

Given this semantic difference, we can’t just convert them without an intermediate process. But, how do we do that?

The Transformation Technique

The transformation from Union to Intersection is achievable through a combination of generic types and conditional types. Here’s a generic helper to accomplish this:

type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;

Let us break this down:

  • U extends any ? (k: U) => void : never: For each member U of the union, we are creating a function type (k: U) => void.
  • extends ((k: infer I) => void) ? I : never: This is where the magic happens. The TypeScript…

Breaking Down the Transformation Technique

To understand the transformation technique better, let’s break down the steps:

Step 1: Union Type Check

U extends any ? (k: U) => void : never

For each member U of the union, we create a function type (k: U) => void. This step checks if U is part of the union.

Step 2: Inferring the Intersection Type

extends ((k: infer I) => void) ? I : never

This step is the critical part of the transformation. The TypeScript compiler infers the intersection type I from the function type (k: U) => void. If U can be inferred, it returns I; otherwise, it returns never.

Practical Example of Transformation

To make this concept more concrete, let’s consider an example where we have a union type and we want to convert it to an intersection type.

type Fruit = "apple" | "orange" | "banana";
type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;

In this case, the Fruit type can be either “apple”, “orange”, or “banana”. And we are using our UnionToIntersection helper to convert this union type into an intersection type.


Converting Union types to Intersection types in TypeScript may seem daunting initially due to the fundamental differences between these types. However, with a good understanding of Union and Intersection types and the use of TypeScript’s advanced type manipulation utilities, it becomes a manageable task.

As we saw, the key to the transformation lies in inferring the intersection type from a function type, which stems from each member of the union. This technique might seem counter-intuitive, but it’s a powerful tool in TypeScript’s type manipulation toolbox. It’s a testament to TypeScript’s flexibility and expressiveness in handling complex type transformations.

The understanding of this transformation can be particularly useful in scenarios where you need to ensure type safety across diverse and complex types. As TypeScript continues to evolve, mastering such techniques will undoubtedly be beneficial for developers aiming to leverage TypeScript’s full potential in building robust, type-safe applications.