What types exist only at compile time in Typescript - Time & Space Complexity

Time Complexity: What types exist only at compile time

O(1)

Understanding Time Complexity

We want to understand how TypeScript handles types that only exist when the code is checked, not when it runs.

How does this affect the work the computer does as the program grows?

Scenario Under Consideration

Analyze the time complexity of the following TypeScript code snippet.

type User = {
  id: number;
  name: string;
};

function greet(user: User) {
  console.log(`Hello, ${user.name}`);
}

This code defines a type and uses it only to check the function input during development.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: There are no loops or repeated operations at runtime related to types.
• How many times: Type checks happen only once during compilation, not during running the program.

How Execution Grows With Input

Type checking work grows as the code and types grow, but this does not affect the running program's speed.

Input Size (n)	Approx. Operations
10 lines of typed code	Small amount of type checks
100 lines of typed code	More type checks, but still only at compile time
1000 lines of typed code	Much more type checking work, still no runtime cost

Pattern observation: The checking work grows with code size, but it does not slow down the program when it runs.

Final Time Complexity

Time Complexity: O(1)

This means the program's running speed does not change because of these compile-time-only types.

Common Mistake

[X] Wrong: "Types slow down the program when it runs because they add extra work."

[OK] Correct: Types in TypeScript exist only during development and disappear when the program runs, so they do not affect runtime speed.

Interview Connect

Knowing that some types only exist during compile time helps you explain how TypeScript keeps code safe without slowing down the program, a useful skill in real projects.

Self-Check

"What if we added runtime type checks inside the function? How would the time complexity change?"