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?"

Practice

1. What does a conditional type with generics in TypeScript do?

easy

A. It creates a new variable with a fixed type.

B. It selects one type or another based on a condition using generic types.

C. It runs a function only if a condition is true.

D. It converts all types to strings.

Solution

1. Step 1: Understand conditional types

   Conditional types choose between two types depending on a condition.

2. Step 2: Understand generics

   Generics allow types to be flexible and work with many types.

3. Final Answer:

   It selects one type or another based on a condition using generic types. -> Option B

4. Quick Check:

   Conditional type with generics = Selects type based on condition [OK]

Hint: Remember: conditional types pick types, generics make them flexible [OK]

Common Mistakes:

• Thinking conditional types run code instead of selecting types
• Confusing generics with fixed types
• Assuming conditional types convert values

2. Which of the following is the correct syntax for a conditional type with generics in TypeScript?

easy

A. type Result<T> = T extends string ? number : boolean;

B. function Result<T> = T ? number : boolean;

C. let Result<T> = T extends string ? number : boolean;

D. class Result<T> = T extends string ? number : boolean;

Solution

1. Step 1: Identify correct conditional type syntax

   Conditional types use the syntax: type Name<T> = T extends Condition ? TrueType : FalseType;

2. Step 2: Check each option

   type Result<T> = T extends string ? number : boolean; matches the correct syntax. Others use function, let, or class incorrectly.

3. Final Answer:

   type Result<T> = T extends string ? number : boolean; -> Option A

4. Quick Check:

   Correct conditional type syntax = type Result<T> = T extends string ? number : boolean; [OK]

Hint: Conditional types use 'type' keyword with generic and '? :' [OK]

Common Mistakes:

• Using function or class instead of type
• Missing the 'extends' keyword
• Using let instead of type

3. What is the type of Result<string> given this code?

type Result<T> = T extends number ? boolean : string;

medium

A. boolean

B. never

C. number

D. string

Solution

1. Step 1: Check the condition for T = string

   The condition is T extends number. Since string does not extend number, the condition is false.

2. Step 2: Determine the resulting type

   Because the condition is false, the type after the colon is chosen, which is string.

3. Final Answer:

   string -> Option D

4. Quick Check:

   string extends number? No, so type = string [OK]

Hint: Check if generic type matches condition; else pick false type [OK]

Common Mistakes:

• Assuming string extends number
• Choosing the true type instead of false
• Confusing extends with assignment

4. Identify the error in this conditional type with generics:

type Check<T> = T extends ? string : number;

medium

A. Incorrect use of generic parameter

B. Missing colon ':' after condition

C. Missing type after 'extends' keyword

D. Using 'type' instead of 'interface'

Solution

1. Step 1: Analyze the conditional type syntax

   The syntax requires a type after 'extends' to check the condition.

2. Step 2: Identify the missing part

   Here, 'T extends ?' is missing the type to compare with, causing a syntax error.

3. Final Answer:

   Missing type after 'extends' keyword -> Option C

4. Quick Check:

   Conditional type needs a type after 'extends' [OK]

Hint: Always put a type after 'extends' in conditional types [OK]

Common Mistakes:

• Leaving out the type after 'extends'
• Confusing '?' placement
• Using interface instead of type for conditional types

5. Given this code, what is the type of Output?

type IsArray<T> = T extends any[] ? 'array' : 'not array';
type Output = IsArray<string[] | number>;

hard

A. 'array' | 'not array'

B. 'array'

C. 'not array'

D. string[] | number

Solution

1. Step 1: Understand conditional type with union

   When conditional types receive a union, they distribute over each member separately.

2. Step 2: Apply condition to each union member

   string[] extends any[]? Yes, so 'array'. number extends any[]? No, so 'not array'.

3. Step 3: Combine results

   The result is the union of both: 'array' | 'not array'.

4. Final Answer:

   'array' | 'not array' -> Option A

5. Quick Check:

   Conditional distributes over union = 'array' | 'not array' [OK]

Hint: Conditional types distribute over unions automatically [OK]

Common Mistakes:

• Assuming single result for union input
• Forgetting distribution over union types
• Confusing output with input types