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)

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.

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.

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

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

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?

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.