It would be great to have this: ```val Foo.propert...

# language-proposals

[Marc Knaup]

It would be great to have this:

val Foo.property = "foo"

as syntactic sugar for something like that:

private const val _foo = "foo"
val Foo.property get() = _foo

Typically such a construct is used when the value
• is computed and must not change between invocations
• is expensive to compute even if pure

For example:

// avoid that value changes
val Foo.staticProperty = generateRandomId()

 // avoid repeated expensive computation
val Foo.expensiveProperty = someExpensiveSetup()

 // avoid temporary object creation
val Foo.someComplexData = SomeComplexData(…)
val Foo.someDependentProp1 get() = someComplexData.prop1
val Foo.someDependentProp2 get() = someComplexData.prop2
val Foo.someDependentProp3 get() = someComplexData.prop3
val Foo.someDependentProp4 get() = someComplexData.prop4

Because such a value is static, i.e. independent of the actual instance of Foo, you can’t use this in that context except for referring to other such static values or if the receiver is an object.

I personally use such properties often in two situations:
• add static values to an object or companion object
• add static values to marker interfaces (e.g. for DSL)

[jw]

You don't really need a named const there. It just wastes a symbol. val Foo.property get() = "foo" is equally as optimal in bytecode.

[Marc Knaup]

That only works for very simple cases.
If you add plenty of getters that also depend on each other, you create a huge amount of temporary objects.

[Marc Knaup]

Same if the object creation is expensive.

[jw]

Your initial proposal indicated nothing about such cases. I thought you just wanted an optimization for constant expressions.

[Marc Knaup]

Yeah, my focus is on having only a single initialization.
I’ll add a better example for that, thanks.

[Marc Knaup]

Done

[Derek Peirce]

Now it looks like you're trying to store a new field-backed property in Foo where it didn't exist before. That goes beyond extension methods/vals, as it requires either more space for every Foo allocation across the entire program, or a synchronized global map of `Foo`s to their new properties. This would not be the syntactic sugar you're looking for.
As the examples no longer require constants, why not just declare the property directly?

[Marc Knaup]

In my example all of them are constants, allocated once per class, not per instance.

This is mostly useful for object types and for interface types that are used as namespaces or implemented by objects.