Scope Functions

What Scope Functions Do

Scope functions execute a block of code within the context of an object. They reduce boilerplate by eliminating repetitive variable references. Kotlin provides five: let, run, with, apply, and also.

Reference: this vs it

Each scope function provides the object differently:

let

let executes the block with it as the object. It returns the lambda result. Use it for null-safe calls and transformations:

val name: String? = "Kotlin"

// Transform the value only if non-null
val length = name?.let {
    println("Processing $it")
    it.length
}
println(length)  // 6

// Use with collections
val numbers = listOf(1, 2, 3, 4, 5)
val sum = numbers.let {
    println("List has ${it.size} elements")
    it.sum()
}
println(sum)  // 15

run

run executes the block with this as the object. It returns the lambda result. Use it when you need both object access and a computed result:

data class ServerConfig(val host: String, val port: Int)

val config = ServerConfig("localhost", 8080)
val urlString = config.run {
    "http://$host:$port"
}
println(urlString)  // http://localhost:8080

with

with is similar to run but is called differently. It takes the object as a parameter rather than being called on it:

val sb = StringBuilder()
with(sb) {
    append("Hello")
    append(", ")
    append("World")
}
println(sb.toString())  // Hello, World

Use with when you need to call multiple methods on the same object and the result is not needed.

apply

apply executes the block with this but returns the object itself (not the lambda result). It is the standard choice for object configuration:

data class User(var name: String = "", var age: Int = 0, var email: String = "")

val user = User().apply {
    name = "Alice"
    age = 30
    email = "alice@example.com"
}
println(user)  // User(name=Alice, age=30, email=alice@example.com)

// Builder pattern
val textView = TextView().apply {
    textSize = 16f
    setTextColor(Color.BLACK)
    text = "Hello"
}

apply is the most commonly used scope function for initialization.

also

also executes the block with it and returns the object itself. Use it for side effects that should not change the object:

val numbers = mutableListOf(1, 2, 3)
    .also {
        println("Initial list: $it")
    }
    .also {
        it.add(4)
        println("After add: $it")
    }
println(numbers)  // [1, 2, 3, 4]

Chaining Scope Functions

Scope functions can be chained for fluent object construction:

val person = Person()
    .apply {
        name = "Alice"
        age = 30
    }
    .also {
        println("Created: $it")
    }

Choosing the Right One

• apply: Configure an object (returns the object)
• also: Perform side effects on an object (returns the object)
• let: Transform or null-check a value (returns the lambda result)
• run: Configure and compute a result (returns the lambda result)
• with: Call multiple methods on an object (returns the lambda result)