Difference between someFunction() and val x : Int get() = someFunction()


#1

The title says it , I couldn’t understand the real difference in the effect of those two

val x : Any get() = someFunction()
//or 
someFunction()

Do they have any difference memory wise , performance wise , and other perspectives ?


#2

Not sure what exactly you’re asking about; the two statements are entirely different. The first one declares a property with a getter that invokes a function. The other one is simply a function call.


#3

Yes I know what by definition they are different , by I mean which is more efficient and what are the use cases for each


#4

Sorry, I don’t understand how it’s possible to compare the efficiency of declaring a property and calling a function. Declaring a property does not execute any code at all; it just creates a property that you can access later. Calling a function executes that function.


#5

So what difference does it make if I need let’s say an instance of a class to make it as a function or an immutable variable with a getter

class Instance {
    companion object {
        fun getInstance() = Instance()
        val INSTANCE : Instance get() = Instance()
    }
}

#6

In this case the only difference is the syntax you will use to access the value from Kotlin code. The getter of a property will be compiled to a method which will be identical to the getInstance() method you’ve declared.


#7

Ahh i see, it got me a bit confused between being “immutable” and of variable value … it seems a bit confusing , I thought the whole purpose of immutability is to make the thing non-changing or independent


#8

A val property is not necessarily immutable. The only thing val means is that the value of the property can’t be changed through the external API of the class.


#9

What you may be thinking about is a value without a getter that does not call the function but keeps the value.

class Instance {
   companion object {
     val INSTANCE = Instance()
   }
}

Or, although through the vaguaries of jvm classloaders not needed:

class Instance {
   companion object {
     val INSTANCE by lazy { Instance() }
   }
}

#10

No the thing was some confusion between immutability, val , and val with a getter , i thought that val was supposed to be immutable and still it can have a changed value.

Yole cleared it out clearly. Thanks !