Extension functions and scope functions: Kotlin and Android App Development (Beginner: Kotlin)

Extension functions

Sometimes you wish a type had one more function: String.toTitleCase(), Int.toRupees(). You cannot change the String class, but Kotlin lets you write an extension function: a function declared as if it were inside the type, using the type name before the function name. Inside, this refers to the value it was called on.

kotlin

fun String.initials(): String =
    split(" ").filter { it.isNotBlank() }.map { it[0].uppercaseChar() }.joinToString("")

fun Int.toRupees(): String = "Rs $this"

fun main() {
    println("rahul kumar sharma".initials())   // RKS
    println(499.toRupees())                     // Rs 499
}

They look like built-in methods, but they are ordinary functions behind the scenes.

Extensions do not really change the class and cannot access its private parts. They are resolved at compile time from the variable's declared type. Android libraries use them heavily (for example in Android KTX), so you will see many handy functions that are really extensions.

Extension properties

kotlin

val String.wordCount: Int
    get() = trim().split(Regex("\\s+")).size

fun main() {
    println("Jai Jawan Jai Kisan".wordCount)   // 4
}

An extension property computes a value; it cannot store data.

Scope functions

Scope functions run a block of code on an object. They exist to make some common patterns shorter: doing something only if a value is not null, configuring an object, or adding a side action like logging. There are five, and they differ in two ways: how you refer to the object inside the block, and what the call returns.

Function	Object inside block	Returns	Typical use
let	it	Block result	Run code on a non-null value: x?.let { }
run	this	Block result	Compute a result from an object
with(obj)	this	Block result	Call several functions on one object
apply	this	The object itself	Configure an object: Builder().apply { }
also	it	The object itself	Side effects: logging, validation

kotlin

data class Order(var item: String = "", var qty: Int = 0, var note: String = "")

fun main() {
    val order = Order().apply {          // configure: this = the Order
        item = "Paneer tikka"
        qty = 2
    }.also { println("Created $it") }    // side effect, returns the order

    val summary = with(order) { "$qty x $item" }   // compute from it
    val coupon: String? = "FEST10"
    coupon?.let { println("Applying $it") }        // only when not null
    println(summary)
}

apply and also return the object; with and let return the block's result.

Think of it like this: Scope functions are like different ways of handling a file at an office desk. apply is filling in the form and handing back the same form. also is photocopying it for records and handing back the original. let and run are reading the form and giving back a summary note instead.

Choosing one

Need to do something only if not null? ?.let.
Setting up properties of a new object? apply.
Logging or checking without changing the flow? also.
Calling many methods on one object and returning a result? with or run.

Common mistakes

Nesting scope functions three deep: nobody can tell what this or it means. Use named variables.
Using apply when you need the block result (apply always returns the object).
Writing extension functions for things that belong in the class you own. Extensions are best for types you cannot change.
Expecting an extension to be "overridden" in a subclass. Extensions are chosen by the declared type at compile time.

Extension functions and scope functions

Explanation