Why Conditional type with generics in Typescript? - Purpose & Use Cases

The Big Idea

What if your code could think about types and choose the right one all by itself?

The Scenario

Imagine you want to create a function that returns different types based on the input type, but you have to write separate versions for each case manually.

The Problem

Writing many versions of similar functions is slow and error-prone. It's hard to keep track and update all versions when requirements change.

The Solution

Conditional types with generics let you write one flexible type that changes automatically based on input, saving time and reducing mistakes.

Before vs After

✗ Before

function process(input: string): string { return input.toUpperCase(); }
function process(input: number): number { return input * 2; }

✓ After

type Process<T> = T extends string ? string : number;
function process<T>(input: T): Process<T> {
  return (typeof input === 'string' ? input.toUpperCase() : input * 2) as Process<T>;
}

What It Enables

You can create smarter, reusable code that adapts types automatically, making your programs safer and easier to maintain.

Real Life Example

Building a utility that formats user input differently if it's text or a number, without writing separate functions for each type.

Key Takeaways

Manual type handling is repetitive and error-prone.

Conditional types with generics automate type decisions.

This leads to cleaner, safer, and more flexible code.