Extensions for DSL building in Kotlin - Step-by-Step Execution

Concept Flow - Extensions for DSL building

Define Extension Function

↓

Call Extension in DSL

↓

Build DSL Structure

↓

Use Lambda with Receiver

↓

Configure Object Inside Lambda

↓

Return Configured Object

This flow shows how Kotlin extension functions help build DSLs by adding functions to existing types, using lambdas with receivers to configure objects inside a clean syntax.

Execution Sample

Kotlin

class Robot(var name: String) {
    var speed = 0
}

fun Robot.move(block: Robot.() -> Unit) {
    this.block()
}

fun main() {
    val r = Robot("R2D2")
    r.move { speed = 10 }
    println(r.speed)
}

This code defines an extension function 'move' for Robot that takes a lambda to configure the robot's speed, then prints the speed.

Execution Table

Step	Action	Evaluation	Result
1	Create Robot instance r with name 'R2D2'	Robot(name='R2D2', speed=0)	r = Robot(name='R2D2', speed=0)
2	Call extension function r.move with lambda { speed = 10 }	Invoke move extension	Inside move: this = r
3	Execute lambda: speed = 10	Set r.speed to 10	r.speed = 10
4	Exit move function	Return Unit	r.speed remains 10
5	Print r.speed	Output value	10

💡 Program ends after printing the robot's speed, which is 10

Variable Tracker

Variable	Start	After Step 1	After Step 3	Final
r.name	undefined	R2D2	R2D2	R2D2
r.speed	0	0	10	10

Key Moments - 2 Insights

Why can we call 'speed = 10' inside the lambda without specifying 'r.speed'?

Inside the lambda passed to the extension function, 'this' refers to the Robot instance 'r', so we can access its properties directly, as shown in execution_table step 3.

What does the extension function 'move' add to the Robot class?

It adds a new function that takes a lambda with receiver, allowing configuration of Robot instances in a DSL style, demonstrated in execution_table step 2.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of r.speed after step 3?

A 10

B 0

C undefined

D Error

💡 Hint

Check the 'Result' column in row for step 3 in the execution_table.

At which step is the lambda passed to 'move' executed?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Action' and 'Evaluation' columns in execution_table rows to find when 'speed = 10' is set.

If we remove 'this.block()' from the 'move' extension, what happens?

A Compilation error

B The lambda runs automatically, speed becomes 10

C The lambda is never executed, speed stays 0

D Robot instance is not created

💡 Hint

Refer to execution_table step 2 and 3 where the lambda is explicitly called.

Concept Snapshot

Kotlin extensions let you add functions to existing classes.
Use lambdas with receiver (e.g., Robot.() -> Unit) to build DSLs.
Inside the lambda, 'this' is the receiver object.
Call the lambda inside the extension to apply configuration.
This creates clean, readable DSL-style code.

Full Transcript

This example shows how Kotlin extension functions help build DSLs by adding new functions to existing classes. We define a Robot class with a speed property. Then we add an extension function 'move' that takes a lambda with receiver to configure the Robot instance. When we call r.move { speed = 10 }, the lambda runs with 'this' as the Robot, so we set speed directly. The execution table traces creating the Robot, calling move, running the lambda, and printing the speed. The variable tracker shows how r.speed changes from 0 to 10. Key moments clarify why we can access speed directly inside the lambda and what the extension function adds. The quiz tests understanding of variable values and lambda execution. The snapshot summarizes how extensions and lambdas with receiver enable DSL building in Kotlin.