Why scope functions reduce boilerplate in Kotlin - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of using 'let' to avoid null checks

What is the output of this Kotlin code using the let scope function?

Kotlin

val name: String? = "Alice"
val result = name?.let { "Hello, $it!" } ?: "No name"
println(result)

A Hello, !

B No name

C null

D Hello, Alice!

💡 Hint

Think about what happens when name is not null and how let works.

The let function executes the block only if name is not null. Here, name is "Alice", so the block returns "Hello, Alice!". The Elvis operator ?: is not used.

❓ Predict Output

intermediate

Using 'apply' to initialize an object

What does this Kotlin code print?

Kotlin

class Person {
    var name: String = ""
    var age: Int = 0
}

val person = Person().apply {
    name = "Bob"
    age = 30
}
println("${person.name} is ${person.age} years old")

A Bob is 0 years old

B null is 30 years old

C Bob is 30 years old

D is 0 years old

💡 Hint

Remember that apply returns the object itself after running the block.

The apply function runs the block on the object and returns the object itself. Here, it sets name and age before returning the Person instance.

🔧 Debug

advanced

Identify the error in this 'run' usage

What error does this Kotlin code produce?

Kotlin

val result = run {
    val x = 10
    val y = 0
    x / y
}
println(result)

A ArithmeticException: / by zero

B NullPointerException

C SyntaxError

D No error, prints 0

💡 Hint

Consider what happens when dividing by zero in Kotlin.

The code divides 10 by 0 inside run. This causes an ArithmeticException for division by zero at runtime.

🧠 Conceptual

advanced

Why does 'also' help reduce boilerplate?

Which statement best explains how the also scope function reduces boilerplate in Kotlin?

A It replaces the need for constructors by initializing properties automatically.

B It allows performing additional actions on an object without altering it, avoiding temporary variables.

C It changes the object type to a different class to simplify code.

D It forces the object to be immutable, reducing code complexity.

💡 Hint

Think about how also lets you do something extra with the object while keeping it unchanged.

also lets you run code using the object as it and returns the original object unchanged. This avoids creating extra variables or repeating the object reference.

❓ Predict Output

expert

Output of nested scope functions

What is the output of this Kotlin code using nested scope functions?

Kotlin

data class Config(var host: String = "", var port: Int = 0)

val config = Config().apply {
    host = "localhost"
}.also {
    it.port = 8080
}
println("Host: ${config.host}, Port: ${config.port}")

A Host: localhost, Port: 8080

B Host: localhost, Port: 0

C Host: , Port: 8080

D Host: , Port: 0

💡 Hint

Remember that apply and also both return the original object after running their blocks.

The apply block sets host to "localhost" and returns the object. Then also sets port to 8080 on the same object. The final print shows both updated values.