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.

Practice

1. What is the main reason Kotlin scope functions reduce boilerplate code?

easy

A. They let you access an object inside a block without repeating its name

B. They automatically generate variable names for you

C. They replace all loops with simpler syntax

D. They convert functions into classes

Solution

1. Step 1: Understand boilerplate in Kotlin

   Boilerplate means writing the same object name multiple times when calling its properties or functions.

2. Step 2: Role of scope functions

   Scope functions let you work inside a block where the object is implicit, so you don't repeat its name.

3. Final Answer:

   They let you access an object inside a block without repeating its name -> Option A

4. Quick Check:

   Scope functions reduce repeated object names [OK]

Hint: Scope functions hide object name repetition inside blocks [OK]

Common Mistakes:

• Thinking scope functions generate variable names
• Confusing scope functions with loops
• Believing scope functions convert functions to classes

2. Which of the following is the correct syntax to use the let scope function in Kotlin?

easy

A. let { object -> println(object) }

B. let.object { println(this) }

C. object.let() println(it)

D. object.let { it -> println(it) }

Solution

1. Step 1: Recall let syntax

   The let function is called on an object with a lambda receiving the object as it or a named parameter.

2. Step 2: Check each option

   object.let { it -> println(it) } correctly calls object.let { it -> ... }. Others have wrong syntax or order.

3. Final Answer:

   object.let { it -> println(it) } -> Option D

4. Quick Check:

   let called on object with lambda [OK]

Hint: Remember: object.let { it -> ... } is correct [OK]

Common Mistakes:

• Placing let before the object
• Omitting parentheses or braces
• Using wrong lambda parameter names

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

val name = "Alice"
val result = name.run {
    println(this)
    length
}
println(result)

medium

A. Alice\n5

B. Alice\nAlice

C. 5\n5

D. Compilation error

Solution

1. Step 1: Understand run behavior

   run executes the block with this as the object and returns the last expression's value.

2. Step 2: Trace the code

   Inside run, println(this) prints "Alice". The block returns length which is 5. Then println(result) prints 5.

3. Final Answer:

   Alice 5 -> Option A

4. Quick Check:

   run prints object then returns last expression [OK]

Hint: Remember run returns last expression, prints inside block [OK]

Common Mistakes:

• Confusing this with it
• Expecting run to return the object
• Ignoring the printed output inside the block

4. Identify the error in this Kotlin code using apply:

val builder = StringBuilder()
builder.apply {
    append("Hello")
}
println(builder.toString())

medium

A. append should be called outside apply

B. Missing return statement inside apply block

C. No error; code works and prints "Hello"

D. apply cannot be used with StringBuilder

Solution

1. Step 1: Understand apply usage

   apply runs the block with this as the object and returns the object itself.

2. Step 2: Check code correctness

   The code appends "Hello" inside apply and then prints the builder content. This is valid and prints "Hello".

3. Final Answer:

   No error; code works and prints "Hello" -> Option C

4. Quick Check:

   apply returns object, no return needed [OK]

Hint: apply returns object; no explicit return needed [OK]

Common Mistakes:

• Thinking return is required inside apply
• Believing apply can't be used with StringBuilder
• Trying to call append outside apply unnecessarily

5. You want to initialize a mutable list and add elements to it without repeating the list name. Which scope function helps reduce boilerplate and returns the list itself after adding elements?

hard

A. let

B. apply

C. run

D. also

Solution

1. Step 1: Identify scope function behavior

   apply runs a block with this as the object and returns the object itself, perfect for initialization.

2. Step 2: Compare with other functions

   run returns last expression, let returns lambda result, also returns object but uses it. apply is best for adding elements and returning the list.

3. Final Answer:

   apply -> Option B

4. Quick Check:

   Initialize and return object = apply [OK]

Hint: apply returns object after block; ideal for initialization [OK]

Common Mistakes:

• Choosing let which returns lambda result
• Confusing also with apply
• Using run which returns last expression, not object