When to Use run, let, apply, also, and with in Kotlin

By the end of this page, you will understand what Kotlin scope functions do, how run, let, apply, also, and with differ, and when each one is the best fit. You will also see practical examples, common mistakes, and a small project that helps you use them naturally in real Kotlin code.

Kotlin’s scope functions let you execute a block of code using an object in a shorter, more readable way.

The five commonly used scope functions are:

• let
• run
• apply
• also
• with

They all help you work with an object inside a block, but they differ in two important ways:

1. How the object is referenced inside the block

   • As it
   • As this

2. What the function returns

   • The object itself
   • The result of the block

That is the whole idea.

Why this matters

In real code, these functions help with tasks like:

• configuring objects
• avoiding repeated variable names
• handling nullable values safely
• performing extra side effects such as logging
• grouping related operations

The core differences

Think of a scope function like inviting an object into a small workspace.

You choose:

• what name the object has in the workspace: this or it
• what you take out of the workspace: the object itself or a new result

Analogy: working at a desk

Imagine you place an object on your desk.

• apply: You adjust the object, set it up, and then take the same object away.
• also: You keep the object the same, but make notes about it on the side, then take the same object away.
• let: You examine the object and produce some new result.
• run: You work with the object closely as if it were your current context, and produce some new result.
• with: Similar to run, but you already have the object and say, “work with this object for a moment.”

Quick intuition

• apply = configure this object
• also = do something extra with this object
• let = use this object and produce a result

1. let

let uses it and returns the result of the block.

val name: String? = "Kotlin"

val length = name?.let {
    it.length
}

println(length) // 6

This is common for nullable values. If name is not null, the block runs. The result is the length.

2. run

run uses this and returns the result of the block.

data class User(val firstName: String, val lastName: String)

val user = User("Ada", "Lovelace")

val fullName = user.run {
    "$firstName $lastName"
}

println(fullName) // Ada Lovelace

Inside run, you can access members directly because the receiver is .

Consider this example:

data class Box(var value: Int = 0)

val result = Box().apply {
    value = 10
}.also {
    println("Box after apply: $it")
}.run {
    value * 2
}

println(result)

Step by step

1. Box() creates a new object:

Box(value = 0)

1. apply { value = 10 } runs.
   • Inside apply, this is the Box object.
   • value becomes 10.
   • apply returns the same object.

Now the object is:

Box(value = 10)

let

Useful when working with nullable values or performing a short transformation.

val email: String? = getEmailFromApi()

val domain = email?.let {
    it.substringAfter("@")
}

Common uses:

• null-safe processing
• converting one value into another
• limiting variable scope

run

Useful when you want to do several operations on an object and return one computed result.

data class Order(val price: Double, val tax: Double)

val order = Order(100.0, 10.0)
val total = order.run {
    price + tax
}

Common uses:

• deriving values from an object
• formatting output
• combining several member accesses into one result

apply

Useful for building or configuring objects.

 intent = android.content.Intent().apply {
    action = 
    putExtra(, )
}

In real projects, developers usually choose scope functions based on intent, not just syntax.

1. Object configuration with apply

A very common pattern is object creation plus setup.

data class ApiConfig(var baseUrl: String = "", var timeout: Int = 0)

val config = ApiConfig().apply {
    baseUrl = "https://api.example.com"
    timeout = 30
}

This reads like: create this object, configure it, and keep it.

2. Null handling with let

Developers often use let after a safe call.

val token: String? = getToken()

token?.let {
    println("Using token: $it")
}

This avoids manual null checks.

3. Side effects with also

also is common in chains where you want extra behavior without changing the result.

1. Using the wrong function for configuration

If you want to configure an object and keep that object, use apply, not run.

Broken idea:

data class User(var name: String = "")

val user = User().run {
    name = "Mia"
}

println(user) // user is Unit, not User

Why it fails:

• run returns the last expression in the block
• Here, the assignment returns Unit

Correct:

val user = User().apply {
    name = "Mia"
}

2. Using let when it makes code unclear

Too many nested it references become confusing.

val text: String? = "hello"
text?.let {
    println(it)
    listOf(it.length).also {
        println(it)
    }
}

Quick rules

• let = use it, return result
• run = use this, return result
• apply = use this, return object
• also = use it, return object
• with = use this, return result

Best use cases

• let: null-safe calls and transformations
• run: compute a result from an object
• apply: configure an object
• also: logging or side effects
• with: group operations on an existing object

Return behavior

val x = "hello".let { it.length }   // Int
val y = "hello".run { length }      
 z = Person().apply { name =  } 
 w = Person().also { println(it) }  
 q = with() { length }    

When should I use let in Kotlin?

Use let when you want to work with a value, especially a nullable one, and return a new result from it.

What is the difference between apply and also in Kotlin?

Both return the original object. apply is mainly for configuring the object, while also is mainly for side effects like logging.

What is the difference between run and with in Kotlin?

Both use this and return the lambda result. run is called on an object as an extension function, while with takes the object as an argument.

Why is let often used with nullable values?

Because value?.let { ... } only runs the block if value is not null.

Which scope function should I use to initialize an object?

Usually apply, because it lets you set properties and returns the configured object.

• Null safety — let is commonly used with safe calls like ?.let {}.
• Lambda expressions — scope functions are built around lambda blocks.
• Extension functions — let, run, apply, and also are extension functions.
• Receivers in Kotlin — this-based scope functions rely on receiver context.
• Object initialization — apply is often used to initialize objects cleanly.
• Method chaining — scope functions are often used in chained expressions.
• Immutability and mutable objects — understanding whether you are modifying an object or returning a new value helps when using scope functions.
• Readable Kotlin style — choosing the right scope function is largely about code clarity.