Scope Functions

run, with, let, apply, also

First things first, They are higher order functions

But... What are higher order functions anyways

On a very basic level they execute a function which is supplied to it. The Kotlin standard library is full of higher order functions. One of them being repeat.

 public inline fun repeat(times: Int, action: (Int) -> Unit) 

The repeat function takes an action as an argument and returns Unit, but a higher order function can return any object. If you would want to invoke repeat, you would have to pass a function to this which will be invoked by the repeat function.
e.g.

 repeat(3) { println("current value $it") } 

If you would want to write my very own higher order repeat function you can follow the same syntax.

 fun <T> T.myFunction(action: (T) -> String) { ... } 

So, with that knowledge we can approach scope functions knowing they are higher order functions provided by the Kotlin standard library just like repeat.

• run Takes an expression which is a piece of code, and executes it. This may or may not return a value. The whole idea of the run scope function is to run a piece of code.

 data class Person( var name: String, var age: Int, var job: String ) { fun printPerson() = println(this) } val john = Person("John Doe", 20, "Plumber") val jane = Person("Jane Doe", 20, "Waitress") john.run { if (age > jane.age) println("John") } john.run { if (age > jane.age) this else jane }.printPerson() run { if (john.age > jane.age) john else jane }.printPerson() 

• with Exactly the same as run, the only difference being it takes a receiver as an input. It is the same as calling run with an object instead of an argument.

 with(john) { // similar to the run function being called with the object age += 1 "Age is $age" }.printThis() 

• let let takes a 'this' value and performs operations on it (see what I did there..) and may or may not return a value.

 john?.let { it.age += 1 "Age is ${it.age}" }.printThis() ?: defaultValue() 

let is most useful when used with Kotlin's null checks. This allows you to execute a piece of code only when an object exists.

• apply It takes an object argument and returns the same object. It is very useful when we are transforming the object.

 jane.apply { jane.age = 22 jane.job = "Restaurant Owner" }.printPerson() 

Another use case of apply is to initialize objects. In the below case the property name can be lazily initialized or transformed using apply.

 val apply = Planet().apply { name = "Earth" } 

• also Is similar to apply, the only difference being it receives a lambda which is accessed within the lambda with a name.

 val apply = Planet().also { it.name = "Earth" }