Configuration DSL pattern in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a simple DSL function named config.

Kotlin

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

Drag options to blanks, or click blank then click option'

Aconfig

Bconfigure

Csetup

DbuildConfig

Attempts:

3 left

💡 Hint

Common Mistakes

Using a function name that is too generic or unrelated to configuration.

The DSL function is commonly named config to clearly indicate configuration setup.

2fill in blank

medium

Complete the code to declare a mutable property host inside the Config class.

Kotlin

class Config {
    var [1]: String = ""
}

Drag options to blanks, or click blank then click option'

Aport

Bhost

Curl

Daddress

Attempts:

3 left

💡 Hint

Common Mistakes

Using unrelated property names like port or url here.

The property host holds the hostname in the configuration.

3fill in blank

hard

Fix the error in the DSL usage by completing the code to set the port property inside the config block.

Kotlin

val conf = config {
    port = [1]
}

Drag options to blanks, or click blank then click option'

A"8080"

Bport

C8080

Dconfig.port

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning port as a string instead of an integer.

The port property is an integer, so assign it a number without quotes.

4fill in blank

hard

Fill both blanks to define the Config class with host and port properties.

Kotlin

class Config {
    var [1]: String = ""
    var [2]: Int = 0
}

Drag options to blanks, or click blank then click option'

Ahost

Burl

Cport

Daddress

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing property names or types incorrectly.

The host is a string and port is an integer property in the configuration.

5fill in blank

hard

Fill all three blanks to create a DSL function config that returns a configured Config object with host and port properties.

Kotlin

fun [1](block: Config.() -> Unit): Config {
    val config = [2]()
    config.[3]()
    return config
}

Drag options to blanks, or click blank then click option'

Aconfig

BConfig

Cblock

Dconfigure

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong function or variable names, or forgetting to call the lambda.

The function is named config, creates a Config instance, and calls the block lambda on it.

Practice

1. What is the main purpose of the Configuration DSL pattern in Kotlin?

easy

A. To write complex algorithms for data processing

B. To handle exceptions in a program

C. To create a simple and readable way to set up configuration using blocks

D. To manage database connections automatically

Solution

1. Step 1: Understand the Configuration DSL pattern

   This pattern is designed to make configuration code simple and clear by using blocks with a configuration object as receiver.

2. Step 2: Identify the main purpose

   The main goal is to write setup code that looks like a small language, making it easy to read and write configurations.

3. Final Answer:

   To create a simple and readable way to set up configuration using blocks -> Option C

4. Quick Check:

   Configuration DSL = simple setup blocks [OK]

Hint: Think: configuration setup made easy and readable [OK]

Common Mistakes:

• Confusing DSL with general programming logic
• Thinking it manages databases or exceptions
• Assuming it is for algorithm implementation

2. Which Kotlin syntax correctly defines a configuration DSL block with a receiver?

easy

A. fun configure(block: () -> Unit) { block() }

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

C. fun configure(block: Config) { block() }

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

Solution

1. Step 1: Identify the correct DSL block signature

   A configuration DSL block uses a receiver function type like Config.() -> Unit to allow calling config properties inside the block.

2. Step 2: Check the function implementation

   fun configure(block: Config.() -> Unit) { val config = Config(); config.block() } creates a Config instance and calls the block with config as receiver, which is the correct pattern.

3. Final Answer:

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

4. Quick Check:

   Receiver function type = fun configure(block: Config.() -> Unit) { val config = Config(); config.block() } [OK]

Hint: Look for Config.() -> Unit receiver syntax [OK]

Common Mistakes:

• Using () -> Config instead of Config.() -> Unit
• Passing Config instance as parameter instead of receiver
• Omitting the receiver call inside the function

3. Given the code below, what is the output?

class Config { var name = ""; var enabled = false }

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

fun main() {
    val c = configure {
        name = "Test"
        enabled = true
    }
    println("Name: ${c.name}, Enabled: ${c.enabled}")
}

medium

A. Name: Test, Enabled: true

B. Name: , Enabled: false

C. Name: Test, Enabled: false

D. Compilation error

Solution

1. Step 1: Understand the configure function

   The configure function creates a Config object, applies the block to set properties, then returns it.

2. Step 2: Analyze the block in main

   The block sets name to "Test" and enabled to true on the Config instance.

3. Step 3: Check the printed output

   Printing c.name and c.enabled shows "Test" and true respectively.

4. Final Answer:

   Name: Test, Enabled: true -> Option A

5. Quick Check:

   Block sets properties correctly = Name: Test, Enabled: true [OK]

Hint: Block sets properties on Config instance returned [OK]

Common Mistakes:

• Assuming default values remain unchanged
• Thinking block does not modify config
• Confusing syntax causing compilation error

4. What is wrong with this configuration DSL usage?

class Config { var port = 0 }

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

fun main() {
    val c = configure {
        port = 8080
    }
    println(c.port)
}

medium

A. The block is called without receiver, so port is not set

B. Config class is missing a constructor

C. The configure function should return Unit, not Config

D. The println statement is incorrect

Solution

1. Step 1: Check how block is called inside configure

   The block is called as block() without receiver, so it does not modify the config instance.

2. Step 2: Understand the effect on port property

   Since the block does not apply to config, port remains 0, the default value.

3. Final Answer:

   The block is called without receiver, so port is not set -> Option A

4. Quick Check:

   Missing receiver call = The block is called without receiver, so port is not set [OK]

Hint: Call block with config.block() to apply receiver [OK]

Common Mistakes:

• Calling block() instead of config.block()
• Assuming default constructor is missing
• Thinking return type causes error

5. How can you extend the Configuration DSL pattern to support nested configuration blocks for a server with database settings?
Choose the best approach.

hard

A. Use global variables for database settings inside the server config block

B. Define nested classes for ServerConfig and DatabaseConfig, then use nested receiver blocks

C. Pass database settings as strings to the server config block without nesting

D. Create separate functions for server and database config without nesting

Solution

1. Step 1: Understand nested configuration needs

   To configure server and database settings clearly, nested blocks with receivers allow intuitive setup.

2. Step 2: Use nested classes and receiver blocks

   Define ServerConfig with a DatabaseConfig property and provide a nested block to configure database inside server block.

3. Step 3: Why other options are less suitable

   Global variables reduce clarity, passing strings loses structure, separate functions lose nesting benefits.

4. Final Answer:

   Define nested classes for ServerConfig and DatabaseConfig, then use nested receiver blocks -> Option B

5. Quick Check:

   Nested classes + blocks = Define nested classes for ServerConfig and DatabaseConfig, then use nested receiver blocks [OK]

Hint: Use nested classes and blocks for clear hierarchical config [OK]

Common Mistakes:

• Using global variables instead of nested blocks
• Passing unstructured strings for nested config
• Avoiding nested blocks reduces readability