Configuration DSL pattern in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin DSL configuration?

Consider this Kotlin DSL code that configures a server. What will be printed when running the main function?

Kotlin

class ServerConfig {
    var host: String = "localhost"
    var port: Int = 80

    fun printConfig() {
        println("Server running on $host:$port")
    }
}

fun server(block: ServerConfig.() -> Unit): ServerConfig {
    val config = ServerConfig()
    config.block()
    return config
}

fun main() {
    val config = server {
        host = "192.168.1.1"
        port = 8080
    }
    config.printConfig()
}

A Server running on localhost:80

B Server running on 192.168.1.1:80

C Server running on 192.168.1.1:8080

D Server running on localhost:8080

💡 Hint

Look at how the DSL block changes the properties inside ServerConfig.

The DSL block sets host to "192.168.1.1" and port to 8080, so the printed output reflects these values.

🧠 Conceptual

intermediate

Which Kotlin feature enables the Configuration DSL pattern?

Which Kotlin language feature is primarily used to create a Configuration DSL pattern like the example below? ```kotlin fun server(block: ServerConfig.() -> Unit): ServerConfig { val config = ServerConfig() config.block() return config } ```

A Extension functions with lambda receiver

B Data classes with default parameters

C Companion objects with factory methods

D Sealed classes with inheritance

💡 Hint

Think about how the lambda can access ServerConfig's members directly inside the block.

Extension functions with lambda receiver allow the lambda to operate as if it is inside the ServerConfig class, enabling the DSL style.

🔧 Debug

advanced

Why does this Kotlin DSL configuration fail to set the port?

Given this code, why does the port remain 80 instead of changing to 9090? ```kotlin class ServerConfig { var host: String = "localhost" var port: Int = 80 } fun server(block: ServerConfig.() -> Unit): ServerConfig { val config = ServerConfig() block() return config } fun main() { val config = server { host = "example.com" port = 9090 } println("${config.host}:${config.port}") } ```

A The host property is set but port is shadowed by a local variable.

B The port property is immutable and cannot be changed.

C The server function returns a new ServerConfig ignoring the block changes.

D The block() call is not invoked on the config instance, so it modifies nothing.

💡 Hint

Check how the block lambda is called inside the server function.

The block lambda is called without a receiver, so it does not modify the config instance. It should be called as config.block() to apply changes.

📝 Syntax

advanced

Which option correctly defines a Kotlin DSL function with a lambda receiver?

Select the correct Kotlin function signature for a DSL function that takes a lambda with receiver of type Config and returns Config.

A fun configure(block: Config -> Unit): Config

B fun configure(block: Config.() -> Unit): Config

C fun configure(block: (Config) -> Unit): Config

D fun configure(block: () -> Config): Config

💡 Hint

Look for the syntax that declares a lambda with receiver.

The syntax Config.() -> Unit means the lambda has Config as receiver, enabling DSL style access.

🚀 Application

expert

How many items are in the resulting map after this Kotlin DSL runs?

Consider this Kotlin code using a DSL to build a map: ```kotlin class MapBuilder { private val map = mutableMapOf() fun entry(key: String, value: Int) { map[key] = value } fun build(): Map = map } fun map(block: MapBuilder.() -> Unit): Map { val builder = MapBuilder() builder.block() return builder.build() } fun main() { val result = map { entry("a", 1) entry("b", 2) entry("a", 3) } println(result.size) } ```

A 2

B 3

C 1

D 0

💡 Hint

Think about what happens when the same key is added twice in a map.

The key "a" is added twice; the second value overwrites the first, so the map has keys "a" and "b", total 2 entries.