run / with

// run: called as an extension function. References the object as this inside the lambda.
object.run {
    // You can access properties and methods without this.
    returnValue
}

// with: called as a regular function. The object is passed as an argument.
with(object) {
    // You can access properties and methods without this.
    returnValue
}

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

fun main() {
    // run: compute a value using the object's properties.
    val user = User("Taro", 25, "taro@example.com")
    val summary = user.run {
        // this = user. You can omit this.
        "Name: $name, Age: $age"
    }
    println(summary) // Name: Taro, Age: 25

    // run: combine a null check with further processing.
    val nullableUser: User? = user
    val result = nullableUser?.run {
        "Email: $email"
    }
    println(result) // Email: taro@example.com

    // with: group multiple property accesses together.
    val report = with(user) {
        buildString {
            appendLine("=== User Info ===")
            appendLine("Name: $name")
            appendLine("Age: $age")
            append("Email: $email")
        }
    }
    println(report)

    // with: use the object while accessing its members.
    val numbers = mutableListOf(3, 1, 4, 1, 5, 9)
    val max = with(numbers) {
        sort()
        last() // The last expression in the lambda is the return value.
    }
    println("Max: $max") // Max: 9
}

Both run and with reference the object as this (which can be omitted) inside the lambda, and return the last expression of the lambda as the result. The main difference is how they are called: run is an extension function written as object.run { }, while with is a regular function written as with(object) { }.

Because with cannot be combined with the safe-call operator (?.), use run when the object could be null. If you only need to call multiple methods and do not need a return value, consider apply, whose return value is the receiver itself.