Extension property in Kotlin — what it is, syntax and usage

What is an extension property in Kotlin?

An extension property is a syntactic construct in Kotlin that adds a property to an existing type without changing its declaration. The property is declared with a receiver type and must contain a getter. The key difference from regular properties is the absence of a backing field: an extension property cannot store data, only compute it based on the receiver object.

According to the Kotlin Foundation Survey (2024), extension properties are less popular than extension functions — about 45% of developers use them regularly. This is due to the limitation of having no state, which narrows the scope of application. Nevertheless, for computed properties that are logically tied to a type, extension properties are the most concise option.

Extension properties compile into a pair of static getter and setter methods. At the bytecode level, there is no difference between calling an extension property and calling an extension function — both become static methods with a receiver parameter. According to JetBrains (Kotlin Docs, 2025), there is no overhead at all.

Use extension properties for short computed values that should look like properties rather than method calls — this improves code readability and adheres to the Uniform Access Principle.

Extension property syntax: val and var

To declare an extension property, use a syntax similar to a regular property, but with the receiver type prefix. val declares a read-only extension property with a mandatory getter, var declares a mutable one with a getter and an optional setter.

// Read-only extension property
val String.isEmail: Boolean
    get() = this.contains("@") && this.contains(".")

// Call
val valid = "test@test.com".isEmail

Note: an extension property is called without parentheses — str.isEmail, not str.isEmail(). This is the key difference between an extension property and an extension function: a property looks like a field, although it is actually computed through a getter.

Generic extension property

Extension properties can be generic — the receiver can use generic type parameters. This allows creating universal properties that work with any collection type.

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

val items = listOf("a", "b", "c")
val second = items.secondOrNull // "b"

The secondOrNull property works for any type T, returning the second element of the list or null if there are fewer than two elements. This is a typical example where an extension property is more appropriate than a function — accessing it looks like reading a field.

Why an extension property cannot store state

An extension property cannot have a backing field because it is not added to the class metadata — it exists only as a pair of static getter/setter functions. Backing field (the field keyword in Kotlin) is an internal class field that stores the property value. An extension property has no access to the internal structure of the class.

// ❌ ERROR: extension property cannot have a backing field
var String.cachedValue: String
    get() = "computed"
    set(value) {
        field = value // field is not accessible!
    }

// ✅ CORRECT: use external storage
val cache = MutableMap<String, String>()

var String.cachedValue: String
    get() = cache[this] ?: ""
    set(value) { cache[this] = value }

An external Map in the example solves the storage problem but creates another one — a memory leak. Values obtained through an extension property live in the Map forever if not cleaned up. This limitation makes extension properties unsuitable for caching or storing temporary data.

For caching, it is recommended to use a WeakHashMap or mechanisms with automatic cleanup. JetBrains recommends avoiding the use of var extension properties with external storage in production code without careful lifecycle management.

Extension property vs extension function: when to choose what

The choice between an extension property and an extension function depends on semantics: a property describes a characteristic of an object, while a function describes an action. The Uniform Access Principle states: the client should not know whether a value is computed or stored. If the value can be represented as a characteristic (length, size, status) — use a property.

The rule is simple: if the operation takes parameters — use an extension function. If it is a simple computed value without parameters — use an extension property. According to the Android Architecture Guide (Google, 2025), preference should be given to extension properties for data access and extension functions for operations with side effects.

Mutable extension property with var and setter

An extension property with the var keyword supports a setter, but without the ability to store a value — the setter usually performs a side effect or saves data to an external store. The syntax is similar to mutable class properties.

// Mutable extension property with setter
var StringBuilder.lastChar: Char
    get() = this[length - 1]
    set(value) {
        this.setCharAt(length - 1, value)
    }

val sb = StringBuilder("Kotlin")
println(sb.lastChar) // n
sb.lastChar = '!'
println(sb) // Kotli!

The lastChar property is a classic example from the Kotlin documentation. The getter returns the last character of StringBuilder, the setter replaces it with a new value. Note: the state is stored in the StringBuilder itself (via setCharAt), not in a separate field — this is a correct use of an extension property.

Practical examples of extension properties

In real projects, extension properties are most often used to simplify access to collection data, to calculate sizes or statuses of UI elements, and to create a convenient API on top of existing classes. The Kotlin standard library actively uses this mechanism: size, indices, lastIndex for collections are extension properties.

// Extension properties for collections
val List<Int>.sumFast: Int
    get() = fold(0) { acc, i -> acc + i }

val String.half: String
    get() = this.substring(0, length / 2)

// Extension property for Android View
val View.isVisible: Boolean
    get() = visibility == View.VISIBLE

// Null check via safe receiver
val String?.isNullOrBlank: Boolean
    get() = this == null || this.isBlank()

The extension property isVisible for View is an example every Android developer should know. Instead of view.visibility == View.VISIBLE, you can write view.isVisible. This is not only shorter but also reads like natural language: "if the view is visible". Despite their simplicity, such properties significantly improve code readability.