One of the most powerful features of Kotlin is its scope functions. In this blog, we'll delve into the world of Kotlin's scope functions, exploring their various types and how they can be used to write clean, concise, and efficient code.

What are Scope Functions?

The Kotlin standard library contains several functions whose sole purpose is to execute a block of code within the context of an object. When you call such a function on an object with a lambda expression provided it forms a temporary scope. In this scope, you can access the object without its name. Such functions are called scope functions

Kotlin provides five scope functions:

1. let

2. run

3. with

4. apply

5. also

Basically, these functions all perform the same action: execute a block of code on an object. What's different is how this object becomes available inside the block and what the result of the whole expression is.

Because scope functions are similar in nature, it's important to understand the differences between them. There are two main differences between each scope function:

• The way they refer to the context object.

• Their return value.

1. The way they refer to the context object:

Each scope function in Kotlin provides a different way to refer to the context object within the lambda expression

this:

run, with, and apply reference the context object as a lambda receiver by keyword this. Hence, in their lambdas, the object is available as it would be in ordinary class functions.

it:

let and also reference the context object as a lambda argument. If the argument name is not specified, the object is accessed by the implicit default name it. it is shorter than this and expressions with it are usually easier to read.

2. Their return value:

Scope functions differ by the result they return:

• apply and also return the context object.

The return value of apply and also is the context object itself. Hence, they can be included into call chains as side steps: you can continue chaining function calls on the same object, one after another. They also can be used in return statements of functions returning the context object.

• let, run, and with return the lambda result.

let, run, and with return the lambda result. So you can use them when assigning the result to a variable, chaining operations on the result, and so on. you can ignore the return value and use a scope function to create a temporary scope for local variables.

You should consider carefully what return value you want based on what you want to do next in your code. This helps you to choose the best scope function to use.

1.let

• The context object is available as an argument (it).

• The return value is the lambda result.

The let function allows you to execute a block of code on a nullable object, providing a safe way to handle nullable values. It takes the object as its receiver and returns the result of the lambda expression. This function is particularly useful for performing null-checks and executing code only if the object is not null.

val nullableString: String? = "Hello, Kotlin"
val result = nullableString?.let { str ->
    println("String length: ${str.length}")
    str.toUpperCase()
}
println("Result: $result")

//Output
String length: 13
Result: HELLO, KOTLIN

2.run

• The context object is available as a receiver (this).

• The return value is the lambda result.

The run function is used to execute a block of code within the context of an object. It operates on the object itself, allowing you to access its properties and methods directly without the need for qualification. This function is often used for scoping operations where you need to perform multiple operations on the same object.

val someObject = SomeClass()
val result = someObject.run {
    println("Object property: $property")
    method()
    "Result"
}
println("Result: $result")

// Output
Object property: SomeProperty
Result: Result

3. with

• The context object is available as a receiver (this).

• The return value is the lambda result.

Similar to run, the with function allows you to perform operations on an object without the need for qualification. However, unlike run, with is not an extension function but rather a regular function that takes the object as its first argument.

val someObject = SomeClass()
val result = with(someObject) {
    println("Object property: $property")
    method()
    "Result"
}
println("Result: $result")

//Output
Object property: SomeProperty
Result: Result

4. apply

• The context object is available as a receiver (this).

• The return value is the object itself.

The apply function is used to configure properties of an object. It operates on the object itself and returns the object after applying the configuration. This function is commonly used for initializing or configuring objects.

val someObject = SomeClass().apply {
    property1 = "Value1"
    property2 = "Value2"
}
println("Property1: ${someObject.property1}, Property2: ${someObject.property2}")

//Output
Property1: Value1, Property2: Value2

5. also

• The context object is available as an argument (it).

• The return value is the object itself.

The also function is similar to apply, but it returns the original object instead of the result of the lambda expression. It is often used for performing side-effects such as logging or debugging while chaining method calls.

val someObject = SomeClass()
val result = someObject.also { obj ->
    println("Performing side-effects on $obj")
    obj.method()
}.let {
    it.property
}
println("Result: $result")

//Output
Performing side-effects on SomeClass@1234567
Result: SomeProperty

Conclusion

Kotlin's scope functions provide a powerful and concise way to work with objects within a defined scope. Whether you need to handle nullable values, execute code within an object's context, or configure properties, there's a scope function for every use case. By leveraging these functions effectively, you can write clean, expressive, and maintainable code in Kotlin. So, the next time you find yourself working with objects in Kotlin, don't forget to unleash the power of scope functions!