Scope functions: summary

We have already figured out how scope functions apply, also, with, let, and run work. However, we have also encountered a few complicated issues: some of the functions can be used interchangeably, and there is also some confusion with choosing it or this when accessing the context object. Now it's time to cut this famous "Kotlinian knot"! We will learn how to choose the right function and why we need these two similar keywords: it and this. Let's get started!

What is the difference: result of functions

There is an important difference between the scope functions, which greatly influences our choice of the most appropriate one.

1. apply and also return context objects.

2. let, run, and with return a lambda result.

With apply and also, we change the original context object and can make a long chain of functions around it. It's called side steps.

fun main() {
    val numbers = mutableListOf<Int>()
    numbers.also { println("Let's add some elements in this list") }
        .apply {
            add(2)
            add(3)
            add(1)
        }
        .also { println("And now let's sort these elements in the list") }
        .sort() // also() and sort() get as a parameter our changed context object - numbers
    println(numbers)
}

We performed all these operations on the same object, our mutableList(). An alternative way is using apply and also with return. In this case, we can decide what we want to return.

Unlike the case in the first example, let, run, and with return some result, and as a result Kotlin takes the last expression in the function's body. Therefore, we can assign the result of these functions to a variable or make a long chain and transform different data.

fun main() {
    val numbers = mutableListOf<Int>(2, 6, 8, 9, 74)
    val bigNumbers = numbers.run {
        add(15) // Remember that run uses this
        add(5)
        count { it > 10 }
    } // If you put here another method or function, it will receive as a parameter the result of the last expression, the number of elements greater than ten
    println("There are $bigNumbers numbers greater than ten")
}

Another way to use these functions is making a temporary scope for a variable, performing some actions, getting the results, and forgetting about it like a little guppy fish forgets that it already had lunch.

fun main() {
    val numbers = mutableListOf<Int>(2, 6, 8, 9, 74)
    with(numbers) {
        val firstNum = first() // Remember that with uses this
        val lastNum = last()
        println("First element is $firstNum, last element is $lastNum")
    }
}

What is the difference: context object

In terms of scope functions, there are five practical differences between this and it.

1. this refers directly to the context object, while it can refer to separate members of the object on which we invoke a scope function.

2. In both cases, we refer to some object with which we will work, but with it we can pass several parameters, while with this we're dealing with one function parameter.

3. We can omit this in a function and access the arguments or object methods directly, but in the case of it, we have to call arguments and parameters with the it keyword.

4. With it we can rename our parameters and use a more appropriate name inside the function.

5. If you have only one function in the body and it as a parameter, you can replace that with the :: reference to the function.

run, with, and apply work with this, while let and also work with it. Let's see some simple examples.

data class Musician(var name: String, var instrument: String = "Guitar", var band: String = "Radiohead")

fun main() {
    Musician("Jonny Greenwood").apply {
      instrument = "harmonica" // here we can use this.instrument
      band = "Pavement"
     
    }

    Musician("Jonny Greenwood").also {
      it.instrument = "harmonica"
    }

    Musician("Dave Glowl", "Drums", "Nirvana").let { (musicianName, instr, newBand) ->
        musicianName.length + instr.length + newBand.count { it == 'a' }
    }
    // With it, we can pass several parameters and use them as separate parameter members. We can also rename these parameters
}

Now, look at the table, which summarizes the differences between scope functions.

Function selection

Once again, like in the previous topic, you might think: "Hey, I can receive the same result if I, for example, replace run with let and add the word it to a parameter inside the function body. And I can replace run with with." Indeed, in many cases you can do so.

Why is it cool? Because you will know: ok, if I see run, I understand that we use it for certain purposes. You see it and you immediately understand: yes, this piece of code does the job! And that is the beauty and purpose of scope functions: they can help you make code more readable and clear. We can say that scope functions are primarily semantic elements.

However, Kotlin language creators give us the following recommendations (they refer to them in Kotlin coding conventions):

• Executing a lambda on non-null objects: let

• Introducing an expression as a variable in local scope: let

• Object configuration: apply

• Object configuration and computing the result: run

• Running statements where an expression is required: non-extension run

• Additional effects: also

• Grouping function calls on an object: with

In our two previous topics about scope functions, we already used these official recommendations in our examples.

Conclusion

We have considered an important and complicated topic – how to use scope functions. Why is it so important? Because you will certainly encounter these functions in real practice no matter what you work on: Android apps, Kotlin backend, or something else. So, here's what we've learned:

• You can define use cases for different scope functions in your team.

• You can skip the keyword this but must use it as a reference to your context object in scope functions.

• Knowing that different scope functions return different results, you can make function chains. However, be careful with chains: scope functions must make code more readable, while long chains make it more confusing.