When should one prefer Kotlin extension functions?

by

Extension functions are useful in a few cases, and mandatory in others:

Idiomatic Cases:

  1. When you want to enhance, extend or change an existing API. An extension function is the idiomatic way to change a class by adding new functionality. You can add extension functions and extension properties. See an example in the Jackson-Kotlin Module for adding methods to the ObjectMapper class simplifying the handling of TypeReference and generics.

  2. Adding null safety to new or existing methods that cannot be called on a null. For example the extension function for String of String?.isNullOrBlank() allows you to use that function even on a null String without having to do your own null check first. The function itself does the check before calling internal functions. See documentation for extensions with Nullable Receiver

Mandatory Cases:

  1. When you want an inline default function for an interface, you must use an extension function to add it to the interface because you cannot do so within the interface declaration (inlined functions must be final which is not currently allowed within an interface). This is useful when you need inline reified functions, for example this code from Injekt

  2. When you want to add for (item in collection) { ... } support to a class that does not currently support that usage. You can add an iterator() extension method that follows the rules described in the for loops documentation — even the returned iterator-like object can use extensions to satisfy the rules of providing next() and hasNext().

  3. Adding operators to existing classes such as + and * (specialization of #1 but you can’t do this in any other way, so is mandatory). See documentation for operator overloading

Optional Cases:

  1. You want to control the scoping of when something is visible to a caller, so you extend the class only in the context in which you will allow the call to be visible. This is optional because you could just allow the extensions to be seen always. see answer in other SO question for scoping extension functions

  2. You have an interface that you want to simplify the required implementation, while still allowing more easy helper functions for the user. You can optionally add default methods for the interface to help, or use extension functions to add the non-expected-to-be-implemented parts of the interface. One allows overriding of the defaults, the other does not (except for precedence of extensions vs. members).

  3. When you want to relate functions to a category of functionality; extension functions use their receiver class as a place from which to find them. Their name space becomes the class (or classes) from which they can be triggered. Whereas top-level functions will be harder to find, and will fill up the global name space in IDE code completion dialogs. You can also fix existing library name space issues. For example, in Java 7 you have the Path class and it is difficult to find the Files.exist(path) method because it is name spaced oddly. The function could be placed directly on Path.exists() instead. (@kirill)

Precedence Rules:

When extending existing classes, keep the precedence rules in mind. They are described in KT-10806 as:

For each implicit receiver on current context we try members, then local extension functions(also parameters which have extension function type), then non-local extensions.

More Related Contents:

  1. How to make clickable listview in android using kotlin
  2. What is a “receiver” in Kotlin?
  3. Kotlin and Immutable Collections?
  4. Kotlin’s Iterable and Sequence look exactly same. Why are two types required?
  5. How to check if a “lateinit” variable has been initialized?
  6. How to run Kotlin class from the command line?
  7. Is Kotlin “pass-by-value” or “pass-by-reference”?
  8. Kotlin static methods and variables
  9. Multiple variable let in Kotlin
  10. How can I detect a click with the view behind a Jetpack Compose Button?
  11. Example of when should we use run, let, apply, also and with on Kotlin
  12. How to create a fat JAR with Gradle Kotlin script?
  13. how to run compiled class file in Kotlin?
  14. Getters and Setters in Kotlin
  15. Why does this Kotlin method have enclosing backticks?
  16. Why does mutableStateOf without remember work sometimes?
  17. How to make “inappropriate blocking method call” appropriate?
  18. IntArray vs Array in Kotlin
  19. How to clone object in Kotlin?
  20. Override getter for Kotlin data class
  21. Cross references in type parameters
  22. Swift ‘if let’ statement equivalent in Kotlin
  23. How can one add static methods to Java classes in Kotlin
  24. Difference between ArrayList() and mutableListOf() in Kotlin
  25. How do I replace duplicate whitespaces in a String in Kotlin?
  26. Kotlin data class: how to read the value of property if I don’t know its name at compile time?
  27. Kotlin Foo::class.java “Unresolved Reference: Java” error
  28. How does erasure work in Kotlin?
  29. kotlin program error: no main manifest attribute in jar file
  30. Why do we use “companion object” as a kind of replacement for Java static fields in Kotlin?

Leave a Comment