Is there a better way to do memoization? ```import kotlinx.coroutines.* @JvmName("_memoize_receiver...

# coroutines

[Derek Berner]

Is there a better way to do memoization?

import kotlinx.coroutines.*

@JvmName("_memoize_receiver")
fun <T,R> (suspend (T) -> R).memoize(): suspend (T) -> R {
    val memos = mutableMapOf<T, Deferred<R>>()
    val f = this
    return { t ->
        coroutineScope {
            withContext(coroutineContext + <http://Dispatchers.IO|Dispatchers.IO>) {
                synchronized(memos) {
                    memos.computeIfAbsent(t) { async { f(t) } }
                }
            }.await()
        }
    }
}

fun <T,R> memoize(f: suspend (T) -> R): suspend (T) -> R = f.memoize()

[jw]

Here's mine: https://github.com/JakeWharton/SdkSearch/blob/master/backend/dac-proxy/src/main/java/com/jakewharton/sdksearch/proxy/memoize.kt

Usage: https://github.com/JakeWharton/SdkSearch/blob/master/backend/dac-proxy/src/main/java/com/jakewharton/sdksearch/proxy/proxy.kt#L43

[jw]

I guess notably it suspends instead of blocking by virtue of the mutex use.

[Derek Berner]

Yeah that mutex is exactly what I'm looking for

[Derek Berner]

blocking within IO seems bad, where avoidable

[yschimke]

That's a nice library function. Would it be easy/possible to adapt that to work for any shape function? e.g. two args instead of zero args?

[yschimke]

I hope at some point there is a memoize tied to coroutine scopes. Provided by the standard libraries. Tying to a request, or application seems very natural.

[Antanas A.]

My implementation:

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
    }
}