Kotlin read only property with and without getter

Question

Are these equivalent?

• val foo = someFooReturningFunction()

• val foo get() = someFooReturningFunction()

The way I understood the documentation they were, but in my own testing they are not.

With the get() someFooReturningFunction() is evaluated each time the property is accessed, without it is only evaluated once.

Answer 1

They are not equivalent. The custom getter is indeed evaluated on each property access, similarly to a normal function, while a val property with no custom accessors is only evaluated once on initialization (and is actually stored in a final field on JVM platform).

Here are at least a few more differences:

• The control flow analysis and nullability inference takes it into account if a property has a custom getter (or is open and thus might be overridden with a custom getter), because there's no guarantee that the property returns the same value on successive calls:

  if (someObject.defaultGetterProperty != null) {
      someObject.defaultGetterProperty.let { println(it) } // OK
  }
  

  if (someObject.propertyWithCustomGetter != null) {
      someObject.propertyWithCustomGetter { println(it) } // Error: cannot smart-cast
  }
  

• When a property is private, if it has no custom getter then the getter is not generated at all and the backing field is accessed directly. This, however, is an implementation detail and not something to rely on.

Answer 2

No. In addition to @hotkey's reasons, here's a simple demonstration using mutable properties showing when they're definitely not equivalent. TLDR: if your property is calculated using a mutable property, always use a custom getter over an initializer.

data class Calculation(val value1: Int, var value2: Int) {
    val sum: Int = value1 + value2
    val sumWithGetter: Int
        get() = value1 + value2
}

val calculation = Calculation(1, 2)
println(calculation.sumWithGetter) // prints 3
println(calculation.sum)           // prints 3

calculation.value2 = 0
println(calculation.sumWithGetter) // prints 1 (correct)
println(calculation.sum)           // prints 3!