Kotlin has provided several powerful functions in Standard.kt. Let’s go through them here quickly.
apply()
The apply() function passes the context object as a receiver, and returns the object itself. We can use it to configure an object after creation, e.g.:
val foo = Foo().apply {
this.field = initialValue
}also()
The apply() function passes the context object as a parameter, and returns the object itself. We can use it to do some additional effects to the object, e.g.:
val foo = Foo().also {
doSomething(it)
}let()
The let() function passes the context object as a parameter, and returns the result of the lambda function. We can use it to execute some code on a nullable object, e.g.:
val result = nullableObject?.let {
it.doSomething()
}We can also use it to define a variable within the scope and prevent it from leaking out, e.g.:
val result = getReference().let {
it.doSomething()
}
// the reference is no longer visible herewith()
The with() function it the only non-extension function here. It passes the context object as a receiver, and returns the result of the lambda function. We can use it to group function calls on an object, e.g.:
with(view) {
alpha = 0.0F
visibility = View.VISIBLE
}run()
The run() function passes the context object as a receiver, and returns the result of the lambda function. We can use it to configure an object and compute the result, e.g.:
val result = Foo().run {
this.field = initialValue
this.doSomething()
}We can also use it to group function calls on an object, e.g.:
view.run {
alpha = 0.0F
visibility = View.VISIBLE
}That’s it! All these are just regular functions, but they can be easily combined to make the code nicer.