Testing scope functions and lambdas in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of nested scope functions with lambdas

What is the output of this Kotlin code snippet?

Kotlin

val result = "Hello".run {
    val upper = this.uppercase()
    also { println("Inside also: $it") }
    lowercase()
}
println(result)

A

Inside also: hello
hello

B

Inside also: HELLO
hello

C

Inside also: Hello
hello

D

Inside also: Hello
HELLO

💡 Hint

Remember what 'run' and 'also' return and what 'this' and 'it' refer to inside lambdas.

The run function uses the string as this. Inside, upper is the uppercase version but not returned. The also lambda prints the original string it which is "Hello". Finally, lowercase() is the last expression and returned by run. So the printed lines are:
Inside also: Hello
hello

❓ Predict Output

intermediate

Return value of 'apply' with lambda

What does this Kotlin code print?

Kotlin

val list = mutableListOf(1, 2, 3).apply {
    add(4)
    remove(2)
}
println(list)

A [1, 3]

B [1, 2, 3, 4]

C [4]

D [1, 3, 4]

💡 Hint

Recall that 'apply' returns the object it was called on after running the lambda.

The apply function runs the lambda on the list and returns the list itself. Inside the lambda, add(4) adds 4, and remove(2) removes the element 2. So the final list is [1, 3, 4].

❓ Predict Output

advanced

Effect of 'let' on nullable types

What is the output of this Kotlin code?

Kotlin

val name: String? = null
val length = name?.let {
    println("Name is not null: $it")
    it.length
} ?: -1
println(length)

A -1

B

Name is not null: null
0

C

Name is not null: null
-1

D NullPointerException

💡 Hint

Check how safe call operator and 'let' work with null values.

The variable name is null. The safe call name?.let { ... } skips the lambda because name is null. So the Elvis operator ?: -1 returns -1. Nothing is printed inside the lambda.

❓ Predict Output

advanced

Output of 'also' modifying external variable

What will be printed by this Kotlin code?

Kotlin

var count = 0
val result = listOf(1, 2, 3).also {
    count = it.sum()
}
println("count = $count, result = $result")

A count = 6, result = [1, 2, 3]

B count = 0, result = 6

C count = 6, result = 6

D count = 0, result = [1, 2, 3]

💡 Hint

'also' returns the original object but allows side effects inside the lambda.

The also function runs the lambda with the list as it. Inside, count is set to the sum of the list elements (6). The also returns the original list. So the print shows count = 6 and result = [1, 2, 3].

❓ Predict Output

expert

Complex chaining of scope functions and lambdas

What is the output of this Kotlin code?

Kotlin

val output = mutableListOf<String>().run {
    add("Start")
    apply {
        add("Middle")
        also {
            add("Almost End")
        }
    }
    add("End")
    this
}
println(output)

A [Start, Almost End, End]

B [Start, Middle, Almost End, End]

C [Start, Middle, End]

D [Start, Middle, Almost End]

💡 Hint

Trace each scope function carefully and remember what each returns.

The run block starts with an empty mutable list. add("Start") adds "Start". Then apply adds "Middle" and inside also adds "Almost End". apply returns the list, so the chain continues. Then add("End") adds "End". Finally, run returns the list. The final list contains all four strings in order.

Practice

1. Which Kotlin scope function returns the object it was called on after executing the given lambda?

easy

A. run

B. also

C. let

D. apply

Solution

1. Step 1: Understand scope function behavior

   The also function executes the lambda with the object as it and returns the original object.

2. Step 2: Compare with other functions

   let returns the lambda result, run returns lambda result, apply returns the object but uses this inside lambda.

3. Final Answer:

   also -> Option B

4. Quick Check:

   Returns original object after lambda = also [OK]

Hint: Remember: also returns object, let returns lambda result [OK]

Common Mistakes:

• Confusing 'also' with 'let' return values
• Mixing 'apply' and 'also' usage
• Assuming 'run' returns the object

2. Which of the following is the correct syntax to use the let scope function on a nullable variable name?

easy

A. name?.let { println(it) }

B. name.let { println(it) }

C. let(name) { println(it) }

D. name?.let println(it)

Solution

1. Step 1: Check nullable safe call usage

   To safely call let on a nullable variable, use the safe call operator ?..

2. Step 2: Validate lambda syntax

   The lambda must be enclosed in braces {} and use it as the implicit parameter.

3. Final Answer:

   name?.let { println(it) } -> Option A

4. Quick Check:

   Safe call with lambda braces = name?.let { println(it) } [OK]

Hint: Use ?.let { } for nullable variables to avoid errors [OK]

Common Mistakes:

• Omitting safe call operator on nullable
• Incorrect lambda syntax without braces
• Trying to call let as a standalone function

3. What is the output of this Kotlin code?

val result = "hello".run {
    println(this.uppercase())
    this.length
}
println(result)

medium

A. 5
HELLO

B. hello
5

C. HELLO
hello

D. HELLO
5

Solution

1. Step 1: Understand run behavior

   The run function executes the lambda with this as the receiver and returns the lambda's last expression.

2. Step 2: Trace the code execution

   Inside lambda, println(this.uppercase()) prints "HELLO". Then this.length returns 5, assigned to result. Finally, println(result) prints 5.

3. Final Answer:

   HELLO 5 -> Option D

4. Quick Check:

   run prints uppercase then returns length = HELLO and 5 [OK]

Hint: run returns last lambda value; println outputs immediately [OK]

Common Mistakes:

• Assuming run returns the printed string
• Confusing this with it inside lambda
• Mixing order of printed lines

4. Identify the error in this Kotlin code snippet:

val numbers = listOf(1, 2, 3)
numbers.also {
    it.add(4)
}
println(numbers)

medium

A. Missing lambda parameter name

B. also does not return the list

C. Cannot call add on immutable list

D. Syntax error in lambda

Solution

1. Step 1: Check list mutability

   listOf creates an immutable list; calling add is not allowed.

2. Step 2: Understand scope function effect

   also runs the lambda but does not change immutability; trying to add causes a runtime error.

3. Final Answer:

   Cannot call add on immutable list -> Option C

4. Quick Check:

   Immutable list blocks add() method = Cannot call add on immutable list [OK]

Hint: listOf creates immutable list; use mutableListOf to add [OK]

Common Mistakes:

• Assuming also changes list mutability
• Ignoring immutable list restrictions
• Thinking lambda syntax is wrong

5. Given a list of nullable integers val nums = listOf(1, null, 3, null, 5), which code snippet correctly uses scope functions and lambdas to create a list of doubled non-null values?

hard

A. nums.filterNotNull().map { it * 2 }

B. nums.map { it * 2 }.filterNotNull()

C. nums.also { it.map { it * 2 } }

D. nums.run { map { it!! * 2 } }

Solution

1. Step 1: Remove nulls before mapping

   Use filterNotNull() to exclude null values safely.

2. Step 2: Map remaining values to double

   Apply map { it * 2 } on non-null list to double each integer.

3. Final Answer:

   nums.filterNotNull().map { it * 2 } -> Option A

4. Quick Check:

   Filter nulls then map doubling = nums.filterNotNull().map { it * 2 } [OK]

Hint: Filter nulls first, then map to avoid null errors [OK]

Common Mistakes:

• Mapping before filtering nulls causes null results
• Using unsafe !! operator risking exceptions
• Misusing also or run without returning correct list