Suspending version of `lazy { ... }`

Right now, I implement this with:

class LazyValue<T>(private val inner: suspend () -> T) {
    private val latch = Channel(Channel.RENDEZVOUS)
    private val cond = AtomicBoolean()
    private var value = null
    suspend fun get(): T {
        if (this.cond.compareAndSet(false, true)) {
            this.value = this.inner()
            this.latch.close()
        } else {
            this.latch.receiveOrNull()
        }
        return this.value
    }
}

Although this kind of primitive seems reasonable enough to add by default.

[alamothe]

Wow, lazy blocks a thread while waiting? Are you kidding me?? I thought Kotlin is all about coroutines.

[qwwdfsad]

You can use val lazyValue = GlobalScope.async(Dispatchers.Unconined, start = LAZY) { inner() } And even provide your own dispatcher if you need one to offload the computation.

I don’t think such shorthand worth its own primitive: we don’t have suspend getters and thus can’t have by lazy like API. But let’s keep this issue open and see whether we have a demand on suspendable lazy.