Kotlin lambdas are powerful and flexible, but they have a behavior that often surprises developers: when a lambda captures an object, external modifications to that object reflect inside the lambda. This can lead to unexpected side effects, especially if you’re dealing with mutable data.

In this blog, we’ll explore why this happens, how capturing works in Kotlin lambdas, and how to handle this behavior effectively.

What Does “Capturing Objects in Kotlin Lambdas” Mean?

When we pass a variable to a lambda in Kotlin, we might assume that the lambda gets a copy of it. However, that’s not entirely true. Instead, Kotlin captures references to objects, not their values.

This means that if the captured object is mutable and changes externally, the lambda will see the updated state.

Let’s look at a simple example to understand this behavior:

fun main() {
    val numbers = mutableListOf(1, 2, 3)
    val lambda = { println("Inside lambda: $numbers") }
    
    numbers.add(4)
    lambda()  // The lambda sees the updated list
}


//OUTPUT

Inside lambda: [1, 2, 3, 4]

Here’s what happens:

• The lambda captures a reference to numbers, not a snapshot or copy of its values.
• When we modify numbers outside the lambda, the lambda reflects those changes.
• When we invoke lambda(), it prints the updated list with 4 included.

Capturing References vs. Values

It is important to understand when Kotlin captures a reference and when it captures a value.

fun main() {
    val list = mutableListOf(1, 2, 3)
    var number = 10

    val lambda = {
        println("Captured list: $list")
        println("Captured number: $number")
    }

    list.add(4)
    number = 20
    
    lambda()
}


// OUTPUT

Captured list: [1, 2, 3, 4]  // Captured reference, reflects changes
Captured number: 20          // Captured reference, reflects changes

Why This Happens?

• Mutable Objects (list) → Captured by reference → Any external changes are visible inside the lambda.
• Variables (var number) → Captured by reference, not value → External changes are reflected inside the lambda.
• If Immutable values (val number = 10) → Captured by value, meaning they remain unchanged.

Learn more at: [Main Article URL]

Conclusion

Capturing objects in Kotlin lambdas is a powerful feature, but it requires careful handling. When a lambda captures a mutable variable, it retains a reference to it, meaning external modifications will be reflected inside the lambda and vice versa.

To avoid unintended side effects:

• Use immutable data structures where possible to prevent modifications.
• Explicitly create a copy (list.toList(), copy() for data classes) if you need an independent object.
• Prefer passing objects as function parameters instead of capturing them.

By mastering these techniques, you can leverage Kotlin lambdas effectively while ensuring code clarity and correctness.