RunCatching for safe execution in Kotlin - Time & Space Complexity

Time Complexity: RunCatching for safe execution

O(n)

Understanding Time Complexity

We want to understand how the time cost changes when using runCatching in Kotlin.

Specifically, how does wrapping code in runCatching affect the number of steps the program takes?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

val result = runCatching {
    val list = (1..n).toList()
    list.map { it * 2 }
}

result.onSuccess { doubledList ->
    println(doubledList)
}.onFailure {
    println("Error occurred")
}
    

This code creates a list of numbers from 1 to n, doubles each number safely using runCatching, and prints the result or an error.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The map function loops through the list of size n once.
• How many times: Exactly n times, once for each element.

How Execution Grows With Input

As the input size n grows, the number of operations grows in a straight line.

Input Size (n)	Approx. Operations
10	About 10 map operations
100	About 100 map operations
1000	About 1000 map operations

Pattern observation: Doubling the input roughly doubles the work done.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows directly with the size of the list.

Common Mistake

[X] Wrong: "Using runCatching adds extra loops or slows down the code a lot."

[OK] Correct: runCatching just wraps the code to catch errors; it does not add loops or repeat work. The main cost is still from the original operations like map.

Interview Connect

Understanding how safe execution wrappers like runCatching affect performance shows you can write reliable code without losing track of efficiency.

Self-Check

"What if we replaced map with a nested loop inside runCatching? How would the time complexity change?"