Conditional type with generics in Typescript - Time & Space Complexity

Time Complexity: Conditional type with generics

O(n)

Understanding Time Complexity

We want to understand how the time needed to check types changes when using conditional types with generics in TypeScript.

Specifically, how does the complexity grow as the input types get more complex?

Scenario Under Consideration

Analyze the time complexity of the following TypeScript conditional type with generics.

type IsString<T> = T extends string ? true : false;

// Example usage:
type Test1 = IsString<string>;  // true
type Test2 = IsString<number>;  // false
    

This code defines a conditional type that checks if a generic type T is a string type.

Identify Repeating Operations

• Primary operation: Type comparison of T against string.
• How many times: Once per type evaluation; no loops or recursion here.

How Execution Grows With Input

The time to evaluate this conditional type depends on how complex the input type T is.

Input Type Complexity	Approx. Operations
Simple type (e.g., string)	1 check
Union type (e.g., string | number)	Checks per union member
Nested conditional types	More checks, grows with nesting

Pattern observation: The more complex or nested the input type, the more checks TypeScript performs.

Final Time Complexity

Time Complexity: O(n)

This means the time grows linearly with the complexity or number of parts in the input type.

Common Mistake

[X] Wrong: "Conditional types always run instantly regardless of input complexity."

[OK] Correct: TypeScript must check each part of complex types, so more complex inputs take more time.

Interview Connect

Understanding how conditional types scale helps you write efficient type logic and shows you think about performance beyond runtime code.

Self-Check

"What if we changed the conditional type to check a union type with many members? How would the time complexity change?"