Configuration DSL pattern in Kotlin - Time & Space Complexity

Time Complexity: Configuration DSL pattern

O(n)

Understanding Time Complexity

When using a configuration DSL pattern in Kotlin, it's important to see how the time to set up configurations grows as we add more settings.

We want to know how the number of configuration steps affects the total work done.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Config {
    val options = mutableListOf()

    fun option(name: String) {
        options.add(name)
    }
}

fun configure(block: Config.() -> Unit): Config {
    val config = Config()
    config.block()
    return config
}

This code defines a simple configuration DSL where options are added inside a block to build a config object.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Adding each option to the list inside the configuration block.
• How many times: Once for each option specified in the block.

How Execution Grows With Input

Each new option adds one more step to the work done.

Input Size (n)	Approx. Operations
10	10 additions to the list
100	100 additions to the list
1000	1000 additions to the list

Pattern observation: The work grows directly with the number of options added.

Final Time Complexity

Time Complexity: O(n)

This means the time to build the configuration grows linearly with the number of options you add.

Common Mistake

[X] Wrong: "Adding options inside the DSL block happens all at once, so time stays the same no matter how many options."

[OK] Correct: Each option requires a separate step to add it, so more options mean more work.

Interview Connect

Understanding how configuration DSLs scale helps you reason about code readability and performance when building flexible APIs.

Self-Check

What if the configuration block called another function that itself added options in a loop? How would the time complexity change?