Infix functions in DSLs in Kotlin - Step-by-Step Execution

Concept Flow - Infix functions in DSLs

Define infix function

↓

Call function using infix syntax

↓

Function executes with passed argument

↓

Return or side effect

↓

Use in DSL for readable code

Infix functions let you call functions without dots or parentheses, making DSL code look clean and readable.

Execution Sample

Kotlin

infix fun String.shouldBe(expected: String) {
    if (this != expected) throw AssertionError("Expected $expected but got $this")
}

"hello" shouldBe "hello"

Defines an infix function to compare strings and throws error if they don't match.

Execution Table

Step	Action	Evaluation	Result
1	Call "hello" shouldBe "hello"	this = "hello", expected = "hello"	Check if "hello" != "hello"
2	Compare strings	"hello" == "hello"	True, no error thrown
3	Function ends	No exception	Execution successful

💡 Function ends normally because strings match

Variable Tracker

Variable	Start	After Call	Final
this	N/A	"hello"	"hello"
expected	N/A	"hello"	"hello"

Key Moments - 2 Insights

Why can we call the function without parentheses or dot?

Because the function is declared with the 'infix' keyword, Kotlin allows calling it using infix notation as shown in step 1 of the execution_table.

What happens if the strings don't match?

The function throws an AssertionError, stopping execution. This would be seen as an exception instead of the normal end in step 3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'expected' at step 2?

A "world"

B null

C "hello"

D undefined

💡 Hint

Check variable_tracker column 'After Call' for 'expected'

At which step does the function check if the strings are equal?

A Step 1

B Step 2

C Step 3

D No check is done

💡 Hint

See execution_table row where comparison happens

If the function was not declared as infix, how would the call change?

A "hello".shouldBe("hello")

B shouldBe "hello" "hello"

C "hello" shouldBe "hello"

D shouldBe("hello", "hello")

💡 Hint

In Kotlin, normal function calls require dot and parentheses

Concept Snapshot

infix fun functionName(param: Type) { ... }
Call with: receiver functionName argument
No dots or parentheses needed
Makes DSLs readable and natural
Only one parameter allowed
Used for clean, fluent code

Full Transcript

In Kotlin, infix functions let you call functions without dots or parentheses, making code look like natural language. You define them with the 'infix' keyword and they must have exactly one parameter. When you call an infix function, Kotlin passes the receiver object as 'this' and the argument as the parameter. For example, "hello" shouldBe "hello" calls the infix function shouldBe on the string "hello" with argument "hello". The function compares the two strings and throws an error if they don't match. This style is very useful in DSLs to write clean and readable code.

Practice

1. What is the main benefit of using infix functions in Kotlin DSLs?

easy

A. They allow calling functions without dots or parentheses, making code more readable.

B. They improve the performance of the program.

C. They enable functions to have multiple return types.

D. They automatically generate UI components.

Solution

1. Step 1: Understand the purpose of infix functions

   Infix functions let you call a function with one argument without using dots or parentheses, making code look cleaner.

2. Step 2: Identify the benefit in DSLs

   This style makes domain-specific languages (DSLs) easier to read and write, resembling natural language.

3. Final Answer:

   They allow calling functions without dots or parentheses, making code more readable. -> Option A

4. Quick Check:

   Infix functions improve readability = C [OK]

Hint: Infix means no dots or parentheses for one-argument calls [OK]

Common Mistakes:

• Thinking infix improves performance
• Believing infix allows multiple return types
• Assuming infix auto-generates UI

2. Which of the following is the correct syntax to declare an infix function in Kotlin?

easy

A. infix fun add(x: Int) { }

B. fun infix add(x: Int) { }

C. fun add infix(x: Int) { }

D. fun add(x: Int) infix { }

Solution

1. Step 1: Recall infix function declaration rules

   In Kotlin, the keyword infix must appear before fun when declaring an infix function.

2. Step 2: Match the correct syntax

   infix fun add(x: Int) { } correctly places infix before fun and declares the function with one parameter.

3. Final Answer:

   infix fun add(x: Int) { } -> Option A

4. Quick Check:

   Keyword order: infix before fun = A [OK]

Hint: Remember: 'infix' keyword comes before 'fun' in declaration [OK]

Common Mistakes:

• Placing 'infix' after function name
• Putting 'infix' after parameter list
• Omitting 'infix' keyword entirely

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

class Builder {
    infix fun add(value: String) {
        println("Added: $value")
    }
}

fun main() {
    val b = Builder()
    b add "Kotlin"
}

medium

A. No output

B. b add Kotlin

C. Syntax error

D. Added: Kotlin

Solution

1. Step 1: Understand infix function call

   The infix function add is called on object b with argument "Kotlin" without dots or parentheses.

2. Step 2: Check the function behavior

   The function prints "Added: Kotlin" to the console.

3. Final Answer:

   Added: Kotlin -> Option D

4. Quick Check:

   Infix call prints 'Added: Kotlin' = A [OK]

Hint: Infix calls print inside function as expected [OK]

Common Mistakes:

• Expecting syntax error due to missing parentheses
• Thinking it prints the call expression
• Assuming no output without explicit print

4. Identify the error in this Kotlin code using an infix function:

class Config {
    infix fun set(key: String, value: String) {
        println("$key = $value")
    }
}

fun main() {
    val c = Config()
    c set ("color", "blue")
}

medium

A. Missing return type declaration.

B. Infix functions cannot have more than one parameter.

C. The function name 'set' is reserved and cannot be infix.

D. Parentheses are not allowed in infix calls.

Solution

1. Step 1: Check infix function parameter count

   Kotlin infix functions must have exactly one parameter, but here set has two parameters.

2. Step 2: Understand the error cause

   This causes a compilation error because infix functions cannot have multiple parameters.

3. Final Answer:

   Infix functions cannot have more than one parameter. -> Option B

4. Quick Check:

   One parameter only for infix = D [OK]

Hint: Infix functions accept exactly one parameter [OK]

Common Mistakes:

• Trying to use multiple parameters in infix
• Assuming parentheses are forbidden in all calls
• Thinking 'set' is a reserved infix name

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

class HtmlTag(val name: String) {
    private val children = mutableListOf<HtmlTag>()
    infix fun add(child: HtmlTag) {
        children.add(child)
    }
    fun render(): String {
        val inner = children.joinToString("") { it.render() }
        return "<$name>$inner</$name>"
    }
}

fun main() {
    val html = HtmlTag("html")
    val body = HtmlTag("body")
    val p = HtmlTag("p")
    html add body
    body add p
    println(html.render())
}

hard

A.

B.

C.

D. Compilation error due to infix usage

Solution

1. Step 1: Understand the infix add function

   The infix function add adds child tags to the parent's children list, building a tree structure.

2. Step 2: Trace the tag hierarchy and rendering

   html adds body, body adds p, so the structure is html > body > p. The render function outputs nested tags accordingly.

3. Final Answer:

   <html><body><p></p></body></html> -> Option C

4. Quick Check:

   Nested tags render correctly = B [OK]

Hint: Infix builds nested structure; render outputs nested tags [OK]

Common Mistakes:

• Mixing tag closing order
• Assuming infix causes compile error
• Ignoring nested children in render