What are 'scope functions' in Kotlin and when should they be used?

Scope functions allow executing a block of code in the context of an object. The main functions are: let, run, with, apply, also. Each has its own features regarding the receiver (invoker, receiver) and the return value.

Function	Receiver	Return value
let	it	Result of the last expression in the block
run	this	Result of the last expression in the block
with	this (not as an extension method)	Result of the last expression in the block
apply	this	The object itself after configuration
also	it	The object itself after configuration

Usage:

• let: For performing actions on an object that may be null, or for introducing a local variable with a shorter name.

// Example: safe call on a nullable object
val str: String? = "Hello"
str?.let {
    println(it.length) // Executes only if str is not null
}

• run: For executing a code block with the context of an object (like with), but as an extension method, or when a value needs to be computed in the context of an object.

// Example: configuring an object and getting a result
val configurations = buildList {
    add("Config 1")
    add("Config 2")
}.run {
    println("Applying configurations...")
    joinToString(", ") // Executes in the context of List<String>, returns String
}
println(configurations)

• with: For grouping method calls on an object without using "dot" before each call. Not an extension method.

// Example: grouping method calls on a single object
val person = Person("Alice", 30)
with(person) {
    println(name) // Access properties directly
    println(age)
}

• apply: For configuring an object. Returns the configured object itself. Convenient for creating and initializing objects in one expression.

// Example: creating and configuring an object in one step
val button = Button().apply {
    text = "Click Me"
    onClick = { println("Button clicked") }
}

• also: For performing additional actions on an object, such as logging, after some operation. Returns the object itself.

// Example: logging after an action
val number = 42
val squared = number.also {
    println("Processing number: $it") // Executed on it (number), returns number
}.run {
    this * this // Executed on this (number), returns the square
}
println("Squared value: $squared")

Choosing the appropriate scope function depends on what needs to be done with the object and what value should be returned.