Extension Function

An extension function in Kotlin is a statically resolved mechanism that allows developers to augment an existing class with new functionality without requiring inheritance, modification of the original class source code, or the use of structural design patterns like Decorator.

Syntax Anatomy

To declare an extension function, prefix the function name with a receiver type—the type being extended. Inside the function body, the this keyword acts as the receiver object, representing the instance on which the function is invoked.

fun String.addExclamation(): String {
    // 'this' refers to the instance of String
    return this + "!"
}

Generic Extension Functions

To define an extension function for a generic type, the type parameters must be declared before the receiver type in the function signature. This syntax ensures the type parameter is available to the receiver type, the function arguments, and the return type.

fun <T> List<T>.customFilter(predicate: (T) -> Boolean): List<T> {
    val result = mutableListOf<T>()
    for (item in this) {
        if (predicate(item)) result.add(item)
    }
    return result
}

Companion Object Extensions

If a class has a companion object defined, extension functions can be declared on the companion object itself. This mechanism allows the addition of functions that are callable using only the class name as the qualifier, structurally mimicking static methods.

class DatabaseConnection {
    companion object {}
}

fun DatabaseConnection.Companion.createPool(): String {
    return "Pool created"
}

fun main() {
    // Invoked on the companion object via the class name
    DatabaseConnection.createPool() 
}

Declaring Extensions as Members

Extension functions can be declared as members inside another class. In this context, the extension function has multiple implicit receivers:

1. Extension receiver: The instance of the class being extended.
2. Dispatch receiver: The instance of the class in which the extension is declared.

When a naming conflict occurs between the members of the dispatch receiver and the extension receiver, the extension receiver takes precedence. To access the dispatch receiver’s members, the qualified this syntax (this@ClassName) must be used.

class Connection {
    fun send(data: String) = println("Sending: $data")
}

class Session {
    fun send(data: String) = println("Session send: $data")

    // Extension function declared as a member
    fun Connection.transmit(payload: String) {
        send(payload)          // Resolves to Connection.send() (Extension receiver)
        [e-mail](payload) // Resolves to Session.send() (Dispatch receiver)
    }
}

Under the Hood (JVM Compilation)

Extension functions do not mutate the classes they extend. Their compilation strategy depends on where they are declared:

Top-Level Extensions At the bytecode level, the Kotlin compiler translates a top-level extension function into a standard static method. The receiver object is explicitly passed as the first argument to this static method.

By default, the enclosing Java class generated by the compiler is named after the file with a Kt suffix. For example, an extension defined in StringExtensions.kt compiles to a static method inside a class named StringExtensionsKt. This generated class name is required when invoking the extension from Java.

// In file: StringExtensions.kt
fun String.removeFirstChar(): String = this.substring(1)

// Equivalent Java compilation and invocation
public final class StringExtensionsKt {
    public static final String removeFirstChar(String $this$removeFirstChar) {
        return $this$removeFirstChar.substring(1);
    }
}

// Java caller: StringExtensionsKt.removeFirstChar("test");

Member Extensions When an extension is declared as a member of another class, it is compiled as an instance method of the dispatch receiver class, not a static method. The extension receiver is passed as the first parameter to this instance method. Because it is an instance method, member extensions can be declared open and overridden in subclasses of the dispatch receiver.

Dispatch and Resolution Mechanics

Static vs. Dynamic Dispatch Extension functions are resolved statically at compile-time with respect to the extension receiver. The extension function invoked is determined by the declared type of the variable in the code, not the runtime type of the evaluated expression.

open class Shape
class Circle : Shape()

fun Shape.getName() = "Shape"
fun Circle.getName() = "Circle"

fun printName(shape: Shape) {
    // Resolved statically based on the parameter type 'Shape'
    println(shape.getName()) 
}

fun main() {
    printName(Circle()) // Prints "Shape", not "Circle"
}

However, when an extension function is declared as an open member inside a class and overridden in a subclass, the dispatch is dynamic (virtual) with respect to the dispatch receiver. The compiler resolves the extension statically based on the extension receiver’s type, but dynamically selects the implementation based on the dispatch receiver’s runtime type.

open class BaseDispatcher {
    open fun String.transmit() = println("Base transmitting: $this")
    fun dispatch(s: String) = s.transmit()
}

class DerivedDispatcher : BaseDispatcher() {
    // Overriding the member extension
    override fun String.transmit() = println("Derived transmitting: $this")
}

fun main() {
    val dispatcher: BaseDispatcher = DerivedDispatcher()
    // Dynamic dispatch on the dispatch receiver (DerivedDispatcher)
    dispatcher.dispatch("Payload") // Prints "Derived transmitting: Payload"
}

Member Function Precedence If a class has a member function and an extension function is defined with the exact same receiver type, name, and signature, the member function always wins. The compiler will bind to the member function and ignore the extension. However, extension functions can successfully overload member functions by providing a different parameter signature.

Encapsulation Boundaries Because extension functions are compiled as external methods relative to the receiver class, they do not bypass access modifiers. An extension function cannot access private or protected members of the receiver type. It only has access to the public API of the class, as well as internal members, provided the extension function is defined (compiled) within the same module as the receiver class.

Imports and Visibility If an extension function is defined in a different package from where it is used, it must be explicitly imported at the call site. The compiler does not automatically resolve extensions across package boundaries, even if the receiver type is in scope.

// In file: com/example/utils/StringExtensions.kt
package com.example.utils

fun String.reverseWords(): String = this.split(" ").reversed().joinToString(" ")

// In file: com/example/app/Main.kt
package com.example.app

import com.example.utils.reverseWords // Explicit import required for the extension

fun main() {
    println("Kotlin is fun".reverseWords())
}

Nullable Receivers

Extensions can be defined on a nullable receiver type (ReceiverType?). This allows the function to be invoked on an object reference even if its value is null, shifting the null-check responsibility from the caller to the extension function’s internal logic.

fun Any?.safeToString(): String {
    // 'this' can be null, requiring explicit handling
    if (this == null) return "null"
    return this.toString()
}

fun main() {
    val text: String? = null
    println(text.safeToString()) // Prints "null" without throwing NullPointerException
}

Master Kotlin with Deep Grasping Methodology!

Learn More