Albert Latacz

Technical Lead • Security And Testability Craftsman • Software Development Mentor • Open Source Contributor • Founder

Kotlin’s extension functions stand out as one of the language most powerful features. These functions allow developers to add new functionality to existing classes without modifying their source code or inheriting from them. Unique capability enables cleaner, more expressive syntax by extending classes with custom code and works, even those from external libraries or the Java standard library. In this blog post we’ll dive into extension functions exploring their benefits and how to use them.

What Are Extension Functions?

An extension function is a way to add a new function to a class from outside of it. This means you can extend the functionality of classes you don’t own or can’t modify (including classes from the standard library as well as third-party libraries).

The basic syntax for an extension function is:

1

fun Receiver.functionName() {}

Here, Receiver is the type you’re extending, and functionName is the name of your new function.

Why Use Extension Functions?

Using extension functions offer many benefits but here are some to consider:

  • Code organization - They allow you to keep related functions together, even if they operate on different types.
  • Utility functions - They are great for creating utility functions that operate on existing types.
  • Context-specific functionality - You can add methods that are relevant only in certain contexts.
  • API design - Extension functions can be used to design more fluent and expressive APIs.
  • Readability - Extension functions can make code more readable and expressive (e.g. when creating domain-specific language).

Why Not Just Member Functions?

You might be wondering why use extension functions instead of just adding a member function to the class? There are several reasons:

  • External classes - You can’t modify external classes (e.g. from libraries) to add new methods.
  • Separation of concerns - Extension functions allow you to keep utility functions separate from the main class definition.
  • Contextual usage - You can define extensions only for the specific modules where they’re needed.

It’s important to note though that extension functions are resolved statically. They don’t actually modify the class they extend, and they can’t access private members of the class.

Examples

Let’s start with some simple examples to illustrate how extension functions work:

1
2

fun String.exclaim() = "$this!"
println("Hello".exclaim()) // Prints "Hello!"

In this example we have added a new function exclaim() to the existing String class. We can now call this function on any String instance.

You can also define extensions functions with parameters (same as with standard functions):

1
2
3

fun Int.isMultipleOf(number: Int) = this % number == 0
println(12.isMultipleOf(3))// Prints "true"
println(12.isMultipleOf(5))// Prints "false"

Nullability And Extension Functions

Kotlin’s null safety is one of its fundamental features as we explored in Null Safety post, and it works seamlessly with extension functions. You can define extension functions on nullable types:

1
2
3

fun String?.orEmpty() = this ?: ""
val someValue: String? = null
println(someValue.orEmpty())

This is particularly useful for providing default behaviors for null values.

Extension Properties

In addition to functions, Kotlin also allows you to define extension properties:

1
2
3
4

val String.lastChar: Char
    get() = this[length - 1]

println("Kotlin".lastChar)  // Outputs: n

Companion Object Extensions

You can even extend companion objects, allowing you to add methods to classes or interfaces:

1
2
3
4
5
6
7

class MyClass {
    companion object
}

fun MyClass.Companion.greeting() = "Hello from companion object extension"

println(MyClass.greeting())

This can be useful for adding utility functions that are related to a class but don’t need an instance of the class.

Generic Extensions

Extension functions can also be generic, allowing you to write more flexible and reusable code:

1
2
3
4
5

fun <T> T.println() = println(this)

5.println()           // Outputs: 5
"Hello".println()     // Outputs: Hello
listOf(1, 2, 3).println()  // Outputs: [1, 2, 3]

This example defines a println() extension function that works on any type.

Infix Notation

It is also possible to define extension functions with infix notation which, in certain situations, can lead to more readable code:

1
2

infix fun Int.isMultipleOf(number: Int) = this % number == 0
println(10 isMultipleOf 5)  // Outputs: true

The infix keyword allows you to call the function using infix notation (without the dot and parentheses).

Common Use Case Examples

Here are some common use case examples for using extension functions.

DSL Creation

Extension functions are often used in creating domain-specific languages (DSLs) in Kotlin.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class Html private constructor() {
    companion object {
        fun html(fn: Html.() -> Unit) =
            Html().apply(fn).render()
    }

    private var content: String = ""
    internal fun append(value: String) {
        content += value
    }

    fun render() = "<html>$content</html>"
}

class Body {
    private var content: String = ""
    internal fun append(value: String) {
        content += value
    }
    internal fun render() = "<body>$content</body>"
}

fun Html.body(fn: Body.() -> Unit) = append(Body().apply(fn).render())
fun Body.p(text: String) = append("<p>$text</p>")
fun Body.a(href: String, text: String) = append("<a href='$href'>$text</a>")

This example demonstrates how extension functions can be used to create a DSL for HTML generation.

String Manipulation

Adding utility functions for common string operations.

1
2
3

fun String.removeFirstAndLast() = substring(1, length - 1)
println("Hello".removeFirstAndLast())  // Outputs: ell

Collection Operations

Adding custom operations to collections.

1
2
3
4

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

println(listOf(1, 2, 3).secondOrNull())  // Outputs: 2
println(listOf(1).secondOrNull())        // Outputs: null

Standard Library Examples

Kotlin’s standard library makes extensive use of extension functions. Some examples include:

  • let, apply, run, with, and also for scoping and object manipulation
  • forEach, map, filter, etc., for collections
  • last, substring and other various string manipulation functions

Understanding these can help you write more idiomatic Kotlin code and make better use of the language’s features.

Best Practices, Considerations and Limitations

While extension functions are very powerful, here are some best practices and limitations to keep in mind:

  • Don’t overuse: Not everything needs to be an extension function. Use them when they genuinely improve readability or organization.
  • Naming conventions: Follow naming conventions to avoid confusion. For example, don’t give an extension function the same name as a member function unless you’re intentionally overloading it.
  • Use for utility functions: Extension functions are great for utility functions that operate on existing types.
  • No override of extension functions: You can’t override extension functions. If a class has a member function with the same name and signature as an extension function, the member function will always take precedence.
  • Shadowing: If an extension function has the same name and signature as a member function, the member function will be used instead of the extension function.
  • No access to private members: Extension functions can’t access private or protected members of the class they’re extending.

Conclusion

Extension functions are a powerful feature in Kotlin that can significantly enhance code readability, organization, and reusability. They allow developers to extend existing classes with new functionality without modifying their source code, which is particularly useful when working with classes from external libraries or the standard library.

By using extension functions and following best practices, you can create more expressive and maintainable code. They’re particularly useful for utility functions, DSL creation, and adding convenience methods to existing types.

As with any powerful feature, it’s important to use extension functions thoughtfully. When used well, they can make your Kotlin code more concise, readable, and enjoyable to work with.

Whether you’re new to Kotlin or an experienced developer, mastering extension functions can significantly improve your coding skills and help you write more elegant and efficient code.

You May Also Enjoy