Hello, is it possible to have by lazy property whi...

# announcements

[Antanas A.]

Hello,
is it possible to have by lazy property which calls suspend function for a value?
Eg

val context by lazy { contextProvider() }

where contextProvider() is suspend function

[diesieben07]

That would require the getter for context to be suspend as well. Since suspend getters / setters aren't supported yet this is not possible

[Antanas A.]

understood

[Antanas A.]

maybe, for alternative there is some function memoization mechanism inside kotlin sdk?

[Antanas A.]

Problem is that I had source where only one place required call to contextProvider() which is expensive

[Antanas A.]

and now there are couple places where contextProvider's value are needed

[gildor]

Just use async for this, it has almost the same semantics, just use await() instead of direct property access

[Antanas A.]

I wish to write something as:
val contextProviderFun = memoized {contextProvider() }

[Antanas A.]

contextProviderFun()

[gildor]

val context = async(start = Lazy) { contextProvider() }

[Antanas A.]

!

[Antanas A.]

legit 🙂

[Antanas A.]

thanks!

[gildor]

To get result use it directly;
context.await()

[Antanas A.]

I do not know is this semantics is not too advanced, but will work in my case

[gildor]

Or abstract with some suspend function

[Antanas A.]

:))

[Antanas A.]

could be some memo inline fun inside kotlin sdk for that

[gildor]

Like:
suspend fun context() = context.await()

[gildor]

And how would this memo work? Looks exactly as existing Lazy

[Antanas A.]

as this:
https://lodash.com/docs/4.17.10#memoize

[gildor]

How is that different from lazy?

[Antanas A.]

Lazy do not allow suspend functions

[Antanas A.]

just by that

[gildor]

I mean memoize is not hard, but you still need a place to keep instance of this function

[gildor]

Than async!

[gildor]

I don't see in docs that this memoize from lodash is asyncronous

[Antanas A.]

it will do the same, but actually concepts is not the same, Memoization

[gildor]

Why not the same?

[Antanas A.]

no, but in general, memoization - is storing computed value by function and not calling function again if arguments is the same

[Antanas A.]

async - is async

[Antanas A.]

😄

[gildor]

This is exactly what async does

[gildor]

You can create own coroutine builder with name memoize

[Antanas A.]

to be precise async uses memoization

[Antanas A.]

but it's not memoization

[gildor]

🤔

[gildor]

I mean memoization itself is easy

[gildor]

But if you add asyncronous background job to it become not so easy at all

[Antanas A.]

https://en.wikipedia.org/wiki/Memoization

[gildor]

I know what is memoization

[Antanas A.]

oh, you mean that in async context

[Antanas A.]

memoization is not memoization by definition

[Antanas A.]

but from a callers perspective there should be no worry if it's async or not with suspend functions

[Antanas A.]

just must be called inside some coroutine context

[gildor]

It's not so easy, it would be against structured concurrency, because you always should be explicit about scope and pure suspend function will not work

[Antanas A.]

wait I'll write a little example of how I'm imagining this

[Antanas A.]

suspend fun <R>memoize(block: suspend () -> R): () -> R {
    val Undef = object {}
    var value: Any = Undef
    return {
        if (value === Undef) value = block()
        value
    }
}

[gildor]

Yeah, you can do this like that

[Antanas A.]

suspend fun context() = memoize {
    contextProvider()
}

[gildor]

yes

[Antanas A.]

problem that i cannot call block()

[Antanas A.]

inside return {
}

[Antanas A.]

because it's not suspend lambda

[Antanas A.]

😕

[gildor]

you can

[gildor]

return suspend { }

[Antanas A.]

suspend fun <R> memoize(block: suspend () -> R): suspend () -> Any {
    val Undef = object {}
    var value: Any = Undef
    return suspend {
        if (value === Undef) value = block() as Any
        value
    }
}

seems this is ok

[Antanas A.]

but it's only for zero argument functions

[gildor]

you can just create N overrides for different arguments

[Antanas A.]

and it not looks complicated as it will execute everything on the same coroutine

[Antanas A.]

but it could be inside kotlin std

[gildor]

why complicated and what is problem with the same coroutine

[gildor]

I don’t think that it really worth to add to stdlib

[gildor]

but if you think it’s useful, just create own library

[Antanas A.]

I think Arrow library should have these

[gildor]

Yes, probably

[gildor]

https://github.com/MarioAriasC/funKTionale/blob/master/funktionale-memoization/src/main/kotlin/org/funktionale/memoization/namespace.kt

[gildor]

Funktionale had it

[Antanas A.]

suspend fun <R> (suspend () -> R).memoize(): suspend () -> Any {
    val Undef = object {}
    var value: Any = Undef
    return suspend {
        if (value === Undef) value = this() as Any
        value
    }
}

and it could be extension function on any function
(maybe too much)

[gildor]

yeah, also have it
https://github.com/arrow-kt/arrow/blob/master/modules/core/arrow-syntax/src/main/kotlin/arrow/syntax/function/memoization.kt

[gildor]

this() as Any

Is invalid. R may be null

[Antanas A.]

oh, shoud be "Any?" yes?

[Antanas A.]

these implementations (Funktionale,Arrow) are not suspend friendly

[Antanas A.]

suspend inline fun <R> (suspend () -> R).memoize(): suspend () -> R {
    val Undef = object {}
    var value: Any? = Undef
    return suspend {
        if (value === Undef) value = this() as Any?
        value as R
    }
}

and usage:

val lazyContextProvider = contextProvider.memoize()
/// ...
val context = lazyContextProvider()

[Big Chungus]

why can't you use runBlocking block in lazy property initializer block?

[Big Chungus]

val context by lazy { runBlocking{ contextProvider() } }

[gildor]

Yes, it should be Any?

[gildor]

Oh, it’s blocks the thread! I don’t think that it’s expected behavior

[Big Chungus]

I think the OPs issue is that he needs to retreive the data from suspend function, which requires coroutine scope. Not an async lazy property

[gildor]

You don’t need coroutine scope to call suspend function, you need suspend lambda
Anyway. block thread just make coroutines useless in this case. It can be valid in some cases, but always should be explicit

[gildor]

these implementations (Funktionale,Arrow) are not suspend friendly

@Antanas A. Yes, I know, there is no way to make them suspend friendly, only by generating suspend version of them, If you use Arrow, you can create a feature requests about it

[Antanas A.]

We're using runBlocking only in tests and in integration with legacy (thread based) libraries

[Antanas A.]

No, for us, the Arrow is too advanced today :))

[Antanas A.]

as team is currently only in OOP thinking

[Dico]

suspend operator fun getValue(...) is invalid?

[Dico]

I guess so