A modern programming language that makes developers happier.

kotlinlang

Suppose I have a suspend function that provides an instance of some interface. How can I use Koin to inject such an instance where required? Like mentioned <https://github.com/InsertKoinIO/koin/issues/388>

I’m thinking maybe the best way to go is for the instance to internally lazily perform some suspending init() rather than requiring the caller to explicitly do so.

can you be more explicit? :thinking_face:

Suppose I have a singleton that requires a one time call to a suspending function `init()` before it can be used. Ideally any code that wants to use this singleton would call some suspending equivalent of `get()` (or somehow `by inject()`) in such a way that init() is called behind the scenes (presumably in some equivalent to single {} that takes a suspending lambda) only when necessary.

Currently, I do something like this:
```single(named("instanceProvider")) {
    suspendableLazy {
        createAndInitInstance()
    }
}```
and then:
```private val instanceProvider by lazy {
   get&lt;SuspendableProvider&lt;MyClass&gt;&gt;(named("instanceProvider"))
}

suspend fun getInstance(): MyClass? = try {
    instanceProvider.get()
} catch (e: Exception) {
    Log.e("di", "unable to create instance", e)
    null
}```
where using some common code:
```interface SuspendableProvider&lt;T&gt; {
    suspend fun get(): T
    val isCompleted: Boolean
}

fun &lt;T&gt; suspendableLazy(provider: suspend () -&gt; T) = object : SuspendableProvider&lt;T&gt; {
    private val computed = GlobalScope.async(start = CoroutineStart.LAZY) { provider() }

    override val isCompleted: Boolean
        get() = computed.isCompleted

    override suspend fun get() = computed.await()
}```

yeah, can be interesting to something in this way yes :+1: