Extension Functions

The Problem: Adding Behavior to Existing Classes

Sometimes you need to add functionality to a class you do not own. Java requires wrapper classes or utility methods. Kotlin solves this with extension functions, which let you add methods to existing classes without modifying their source code.

Syntax

An extension function is declared with a receiver type before the function name:

fun String.removeVowels(): String {
    return this.filter { it !in "aeiouAEIOU" }
}

println("Hello World".removeVowels())  // Hll Wrld

The this keyword inside the function refers to the receiver object (the String instance the function is called on). The function is called as if it were a member of the class.

How Extension Functions Are Resolved

Extension functions are resolved statically, not polymorphically. The compiler determines which extension function to call based on the declared type of the variable, not its runtime type:

open class Animal
class Dog : Animal()

fun Animal.speak() = "Generic sound"
fun Dog.speak() = "Woof!"

val animal: Animal = Dog()
println(animal.speak())  // Generic sound (not Woof!)

This is different from virtual method calls. If you need polymorphic behavior, use regular inheritance.

Extension Functions on Nullable Types

You can define extensions on nullable types to handle null cases gracefully:

fun String?.isNullOrEmpty(): Boolean {
    return this == null || this.isEmpty()
}

val name: String? = null
println(name.isNullOrEmpty())  // true
println("".isNullOrEmpty())    // true
println("Kotlin".isNullOrEmpty())  // false

This pattern is used extensively in Kotlin's standard library.

Member vs Extension Functions

If a class already has a member function with the same signature as an extension function, the member function always wins:

class Sample {
    fun foo() = "member"
}

fun Sample.foo() = "extension"

println(Sample().foo())  // member

This rule prevents ambiguity: existing APIs always take precedence over extensions.

Computed Extension Properties

Extension properties add computed properties to existing classes. They do not have backing fields, so they must be defined with custom getters:

val String.wordCount: Int
    get() = split(" ").size

println("hello world".wordCount)  // 2

Extension properties are useful for derived computations that do not need storage.

Practical Examples

val String.isEmail: Boolean
    get() = contains("@") && "." in substringAfter("@")

val String.truncated: String
    get() = if (length > 20) take(20) + "..." else this

val <T> List<T>.secondOrNull: T?
    get() = if (size >= 2) this[1] else null

println("user@example.com".isEmail)       // true
println(listOf(1).secondOrNull)            // null
println(listOf(1, 2, 3).secondOrNull)      // 2

Chaining Extensions

Extension functions and properties can be chained for readable pipelines:

val result = "  Hello World  "
    .trim()
    .lowercase()
    .replace(" ", "-")
    .take(10)

println(result)  // hello-world

When to Write Extensions

• When you need a method on a class you do not own (e.g., Android SDK classes)
• When the method is logically related to the class but not core functionality
• When you want to add DSL-like syntax to existing types
• When the method would be useful across multiple call sites

Avoid extensions that change the meaning of existing methods or depend on mutable state.