What is the standard way to refactor a lazy property to a su

Question

What is the standard way to refactor a lazy property to a suspend function that uses a cached value on subsequent runs `CompletableDeferred` or something else ``` from this val someProperty Int by lazy refactoring to perform some suspendable logic to this suspend fun someProperty Int only should be executed max once and then cached ```

Mark · Answer

Maybe to use this ```fun lt T gt suspendableLazy scope CoroutineScope provider suspend gt T = object SuspendableProvider lt T gt private val computed = scope async start = CoroutineStart LAZY provider override val isCompleted Boolean get = computed isCompleted override suspend fun get = computed await ``` But then I end up passing some application scope e g `GlobalScope` Wouldn t it be better to use a scope of the coroutine calling the function for the first time

ephemient · Answer

and what do you do if it s cancelled before the value is computed

Mark · Answer

The next call would end up doing the work

ephemient · Answer

wrap a var with a mutex then similar to how Lazy in the default LazyThreadSafetyMode SYNCHRONIZED works but with coroutines

ephemient · Answer

```fun lt T Any gt suspendableLazy provider suspend gt T = object SuspendableProvider lt T gt private val mutex = Mutex private var result T = null override val isCompleted Boolean get = result = null override suspend fun get = mutex withLock result provider also result = it ```

ephemient · Answer

or something like that tweak as needed

Mark · Answer

Thanks I wonder if that logic can be wrapped in a delegated property of type Deferred lt T gt so that the suspending fun just has to do `deferredProperty await `

Mark · Answer

This doesn t look right not sure I m getting the benefits of a lazy delegate here ```private class CachingSuspendableProvider lt T gt private val provider suspend gt T SuspendableProvider lt T gt private var result T = null private val mutex = Mutex override suspend fun get T = result mutex withLock result provider also result = it override val isCompleted Boolean get = result = null private class SuspendableLazy lt T gt provider suspend gt T Lazy lt suspend gt T gt private val suspendableLazy = CachingSuspendableProvider provider override val value suspend gt T get = suspendableLazy get override fun isInitialized = suspendableLazy isCompleted fun lt T gt suspendableLazy provider suspend gt T Lazy lt suspend gt T gt = SuspendableLazy provider usage private val fooDelegate by suspendableLazy compute Foo suspend fun getFoo Foo = fooDelegate ```

ephemient · Answer

no you re not equivalent to `val lazyValue = suspendableLazy compute get` with the previous implementation and less ceremony

Oliver.O · Answer

< ephemient> Looks like the above implementation of `suspendableLazy` contains an unsynchronized read on `result` ```override val isCompleted Boolean get = result = null``` Wouldn t that require annotating `result` with ` Volatile`

ephemient · Answer

isComplete is racy but it doesn t matter

ephemient · Answer

what are you going to do `if isComplete get ` it s going to wait on the mutex for the value no matter what

ephemient · Answer

there s just inherent races with callers using isComplete no need to try to narrow it

Oliver.O · Answer

The problem is not the inherent race but that a caller reading from one thread might due to weak processor Depends on what you use `isCompleted` for Anyway I don t really see it working `val lazyValue = suspendableLazy compute get` returns a function not a value

ephemient · Answer

it has to be a function there s no suspendable property delegates yet <https youtrack jetbrains com issue KT 20414>