Building blocks of type-safe builders in Kotlin - Mini Project: Build & Apply

Building blocks of type-safe builders

📖 Scenario: Imagine you want to create a simple HTML-like structure in Kotlin using type-safe builders. This helps you write code that looks like HTML but is checked by the compiler to avoid mistakes.

🎯 Goal: You will build a small type-safe builder that creates a simple HTML structure with a html root, a body, and some p paragraphs inside. You will learn how to create builder classes and use lambda functions to build nested structures safely.

📋 What You'll Learn

Create a class called HTML with a body function

Create a class called Body with a p function

Use lambda functions with receiver to build nested elements

Create a html function that starts the building process

Print the built HTML structure as a string

💡 Why This Matters

🌍 Real World

Type-safe builders are used in Kotlin to create DSLs (domain-specific languages) that make code easier to read and write, such as building HTML, XML, or UI layouts.

💼 Career

Understanding type-safe builders helps you work with Kotlin DSLs in real projects, improving code safety and clarity, which is valuable for Android development and backend services.

1

Create the HTML and Body classes

Create a class called HTML with a mutable list of strings called content. Also create a class called Body with a mutable list of strings called paragraphs.

Kotlin

# Your code here

Need a hint?

Use class keyword to create classes and mutableListOf<String>() to create lists.

2

Add builder functions to HTML and Body

Add a function body inside HTML that takes a lambda with receiver Body.() -> Unit. Inside it, create a Body instance, call the lambda on it, and add all paragraphs from Body to content. Also add a function p inside Body that takes a String and adds it to paragraphs.

Kotlin

class HTML {
    val content = mutableListOf()

    // Add body function here
    // Your code here
}

class Body {
    val paragraphs = mutableListOf()

    // Add p function here
    // Your code here
}

Need a hint?

Use lambda with receiver to build nested structures. Add paragraphs as strings with <p> tags.

3

Create the html builder function

Create a function called html that takes a lambda with receiver HTML.() -> Unit. Inside it, create an HTML instance, call the lambda on it, and return the HTML instance.

Kotlin

class HTML {
    val content = mutableListOf()

    fun body(init: Body.() -> Unit) {
        val body = Body()
        body.init()
        content.addAll(body.paragraphs)
    }
}

class Body {
    val paragraphs = mutableListOf()

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

// Create html function here
// Your code here

Need a hint?

This function starts the building process by creating an HTML object and applying the lambda.

4

Build and print the HTML structure

Use the html function to build an HTML structure with a body containing two paragraphs: "Hello, world!" and "Welcome to type-safe builders.". Then print the content of the HTML instance as a single string by joining the content list.

Kotlin

class HTML {
    val content = mutableListOf()

    fun body(init: Body.() -> Unit) {
        val body = Body()
        body.init()
        content.addAll(body.paragraphs)
    }
}

class Body {
    val paragraphs = mutableListOf()

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

fun html(init: HTML.() -> Unit): HTML {
    val html = HTML()
    html.init()
    return html
}

// Build and print HTML here
// Your code here

Need a hint?

Use the html function with nested body and p calls. Then print the joined content.