Kotlin var lazy init - delegates

Question

I want to do a lazy initialization for a var property. Since by lazy is restricted only to val properties I have to write something like this:
private var currentContextProvider: ContextProvider? = null
get() {
if (field == null) {
field = DefaultContextProvider()
}
return field
}
And now I have to deal with those pointless nullability-aware calls: currentContextProvider?.getContext() or alternatively currentContextProvider!!.getContext()
Am I doing something wrong?

Answer 1

Instead of making it nullable, you can decide to initialise it with some default value, which on first access will be replaced with the lazily calculated value:
private val noInit = "noinit"
var currentContextProvider: String = noInit
get() = if (field == noInit) {
synchronized(this) {
return if (field == noInit) "lazyinit" else field
}
} else field
(I've replaced the ContextProvider with String)
Custom Delegate
The following implements a custom delegate reusing the former solution. It can be used just like lazy() by defining var currentContextProvider: ContextProvider by LazyMutable { DefaultContextProvider() }
class LazyMutable<T>(val initializer: () -> T) : ReadWriteProperty<Any?, T> {
private object UNINITIALIZED_VALUE
private var prop: Any? = UNINITIALIZED_VALUE
#Suppress("UNCHECKED_CAST")
override fun getValue(thisRef: Any?, property: KProperty<*>): T {
return if (prop == UNINITIALIZED_VALUE) {
synchronized(this) {
return if (prop == UNINITIALIZED_VALUE) initializer().also { prop = it } else prop as T
}
} else prop as T
}
override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
synchronized(this) {
prop = value
}
}
}

Answer 2

I needed a lazy delegated property that initializes and caches when you get the property, but allows you to set it to null to remove that cached result (and re-initialize() it when you get it again).
Thanks to the above answer for the code so I could tweak it.
#Suppress("ClassName")
class lazyNullCacheable<T>(val initializer: () -> T) : ReadWriteProperty<Any?, T> {
private object UNINITIALIZED_VALUE
private var prop: Any? = UNINITIALIZED_VALUE
#Suppress("UNCHECKED_CAST")
override fun getValue(thisRef: Any?, property: KProperty<*>): T {
return if (prop == UNINITIALIZED_VALUE || prop == null) {
synchronized(this) {
initializer().also { prop = it }
}
} else prop as T
}
override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
synchronized(this) {
prop = value
}
}
}
Usage :
var prop: String? by lazyNullCacheable {
"string"
}
prop // get prop
prop = null // when you're done using it and want to recalculate / cache it next time
prop // get prop, it will initialize() and cache again
Functionally equivalent to doing something like this (but this is uglier imho)
var _prop: Type? = null
val prop: Type
get() = _prop ?: run {
_prop = Type()
_prop!!
}
prop // get result
_prop = null // clear cache
prop // next get will recalculate it

Answer 3

class LazyMutable<T>(
val initializer: () -> T,
) : ReadWriteProperty<Any?, T> {
private val lazyValue by lazy { initializer() }
private var newValue: T? = null
override fun getValue(thisRef: Any?, property: KProperty<*>) =
newValue ?: lazyValue
override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
newValue = value
}
}
usage:
var foo by LazyMutable { "initial value" }
(doesn't support nullable foo)

Answer 4

Test:
class LazyVarTest {
#Test
fun testLazyVar() {
var testVar: String by lazyVar { "initial" }
assertEquals("initial", testVar)
testVar = "test"
assertEquals("test", testVar)
}
#Test
fun testNullableLazyVar() {
var testVar: String? by lazyVar { "initial" }
assertEquals("initial", testVar)
testVar = "test"
assertEquals("test", testVar)
testVar = null
assertEquals(null, testVar)
}
}
Implementation:
fun <T> lazyVar(initializer: () -> T) = LazyVar(initializer)
class LazyVar<T>(initializer: () -> T) : ReadWriteProperty<Any?, T> {
private object initialValue
var isSet = false
private val lazyValue by lazy { initializer() }
private var value: Any? = initialValue
override fun getValue(thisRef: Any?, property: KProperty<*>): T =
synchronized(this) {
if (!isSet) return lazyValue
return value as T
}
override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) =
synchronized(this) {
this.value = value
isSet = true
}
}