Extensions for DSL building in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define an extension function named greet for the String class that prints a greeting message.

Kotlin

fun String.[1]() {
    println("Hello, $this!")
}

"World".greet()

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

Awelcome

Bhello

CsayHello

Dgreet

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different function name than the one called on the string.

Forgetting to define the function as an extension (missing 'String.' before the function name).

The extension function is named 'greet', so the blank should be filled with 'greet'.

2fill in blank

medium

Complete the code to create a DSL builder function html that takes a lambda with receiver of type HtmlBuilder.

Kotlin

fun html(block: [1].() -> Unit) {
    val builder = HtmlBuilder()
    builder.block()
    println(builder.result)
}

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

AHtmlBuilder

BString

CInt

DUnit

Attempts:

3 left

💡 Hint

Common Mistakes

Using a wrong receiver type like String or Int.

Not matching the receiver type with the builder instance.

The lambda with receiver should be of type HtmlBuilder to allow building HTML inside the block.

3fill in blank

hard

Fix the error in the extension function that adds an li element inside a ul builder.

Kotlin

class UlBuilder {
    val items = mutableListOf<String>()
    fun li(text: String) {
        items.add(text)
    }
}

fun UlBuilder.[1](text: String) {
    li(text)
}

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

Ali

BlistItem

Citem

DaddItem

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different function name that does not match the existing method.

Causing ambiguity by defining a different name for the same action.

The extension function should have the same name 'li' to correctly add list items inside UlBuilder.

4fill in blank

hard

Fill both blanks to create a DSL function body inside HtmlBuilder that takes a lambda with receiver BodyBuilder.

Kotlin

class HtmlBuilder {
    var result = ""
    fun [1](block: [2].() -> Unit) {
        val bodyBuilder = BodyBuilder()
        bodyBuilder.block()
        result += bodyBuilder.content
    }
}

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

Abody

Bhead

CBodyBuilder

DHeadBuilder

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'head' or 'HeadBuilder' instead of 'body' and 'BodyBuilder'.

Mixing function name and receiver type.

The function name is 'body' and the lambda receiver type is 'BodyBuilder' to build the body content.

5fill in blank

hard

Fill all three blanks to create a DSL function div inside BodyBuilder that takes a lambda with receiver DivBuilder and appends the result.

Kotlin

class BodyBuilder {
    var content = ""
    fun [1](block: [2].() -> Unit) {
        val divBuilder = [3]()
        divBuilder.block()
        content += divBuilder.html
    }
}

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

Adiv

BDivBuilder

DBodyBuilder

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for function, receiver, or instance.

Confusing BodyBuilder with DivBuilder.

The function name is 'div', the lambda receiver is 'DivBuilder', and the instance created is 'DivBuilder()'.

Practice

1. What is the main purpose of using extensions in Kotlin for DSL building?

easy

A. To add new functions to existing classes without modifying their source code

B. To create new classes from scratch

C. To change the behavior of existing functions permanently

D. To restrict access to class members

Solution

1. Step 1: Understand what extensions do

   Extensions allow adding new functions to existing classes without changing their original code.

2. Step 2: Relate to DSL building

   This helps create readable DSLs by extending classes with custom functions.

3. Final Answer:

   To add new functions to existing classes without modifying their source code -> Option A

4. Quick Check:

   Extensions add functions without modifying classes [OK]

Hint: Extensions add functions without changing original classes [OK]

Common Mistakes:

• Thinking extensions create new classes
• Believing extensions permanently change existing functions
• Confusing extensions with access control

2. Which of the following is the correct syntax to define an extension function greet for the String class in Kotlin?

easy

A. extension fun String greet() { println("Hello") }

B. fun greet(String) { println("Hello") }

C. fun String.greet() { println("Hello") }

D. fun greet() String { println("Hello") }

Solution

1. Step 1: Recall extension function syntax

   Extension functions are declared with fun ClassName.functionName().

2. Step 2: Match syntax to options

   fun String.greet() { println("Hello") } uses fun String.greet(), which is correct syntax.

3. Final Answer:

   fun String.greet() { println("Hello") } -> Option C

4. Quick Check:

   Extension syntax = fun ClassName.functionName() [OK]

Hint: Extension syntax: fun ClassName.functionName() [OK]

Common Mistakes:

• Placing class name as parameter instead of receiver
• Using 'extension' keyword which doesn't exist
• Incorrect function return type placement

3. What will be the output of the following Kotlin code?

class Box(var content: String)

fun Box.describe() = "Box contains: $content"

fun main() {
    val box = Box("Apples")
    println(box.describe())
}

medium

A. Box contains: Apples

B. Box contains: content

C. Compilation error

D. Box@<memory_address>

Solution

1. Step 1: Understand the extension function

   The extension function describe returns a string with the content property of Box.

2. Step 2: Check the main function output

   Creating Box("Apples") and calling describe() prints "Box contains: Apples".

3. Final Answer:

   Box contains: Apples -> Option A

4. Quick Check:

   Extension uses property value correctly [OK]

Hint: Extension functions use class properties directly [OK]

Common Mistakes:

• Expecting 'content' literal instead of property value
• Confusing extension with overriding toString()
• Thinking it prints memory address

4. Identify the error in this Kotlin code snippet that tries to build a simple DSL using extensions:

class Menu {
    val items = mutableListOf<String>()
}

fun Menu.addItem(name: String) {
    items.add(name)
}

fun buildMenu(block: Menu.() -> Unit): Menu {
    val menu = Menu()
    block(menu)
    return menu
}

fun main() {
    val menu = buildMenu {
        addItem("Home")
        addItem("About")
    }
    println(menu.items)
}

medium

A. The extension function addItem should be inside the Menu class

B. The block should be called with menu.block() instead of block(menu)

C. MutableList should be immutableList

D. No error, code runs correctly

Solution

1. Step 1: Understand the block parameter type

   The block is a lambda with receiver: Menu.() -> Unit, so it should be called as menu.block().

2. Step 2: Identify the call mistake

   The code calls block(menu), which treats block as a normal function, causing an error.

3. Final Answer:

   The block should be called with menu.block() instead of block(menu) -> Option B

4. Quick Check:

   Lambda with receiver called as receiver.lambda() [OK]

Hint: Call lambdas with receiver as receiver.lambda() [OK]

Common Mistakes:

• Calling lambda with receiver as normal function
• Placing extension function inside class unnecessarily
• Confusing mutable and immutable lists

5. Given the following Kotlin DSL code, what is the output?

class Html {
    val children = mutableListOf<String>()
}

fun Html.body(block: Html.() -> Unit) {
    this.block()
}

fun Html.p(text: String) {
    children.add("
$text
")
}

fun html(block: Html.() -> Unit): Html {
    val html = Html()
    html.block()
    return html
}

fun main() {
    val page = html {
        body {
            p("Hello")
            p("World")
        }
    }
    println(page.children)
}

hard

A. Compilation error due to missing body class

B. []

C. ["HelloWorld"]

D. ["Hello", "World"]

Solution

1. Step 1: Trace the DSL calls

   The html function creates an Html object and calls body extension, which calls p twice adding paragraphs to children.

2. Step 2: Check the children list content

   Both p calls add strings "

   Hello

   " and "

   World

   " to the children list.

3. Final Answer:

   ["

   Hello

   ", "

   World

   "] -> Option D

4. Quick Check:

   Extensions build nested structure as list of strings [OK]

Hint: Extensions add elements to list step-by-step [OK]

Common Mistakes:

• Expecting nested tags as single string
• Assuming body creates separate object
• Thinking code causes compilation error