A modern programming language that makes developers happier.

kotlinlang

I've got a StateFlow that doesn't seem to emit any values (classic StateFlow problem)

I don't _think_ this is due to object equality, but I can't figure out what's going on..

```    val skuDetails: MutableStateFlow&lt;Set&lt;SkuDetails&gt;&gt; = MutableStateFlow(emptySet())```
Elsewhere:

```    val newSet = skuDetails.value.toMutableSet()
    newSet.addAll(skuDetailsResult.skuDetailsList.orEmpty())
    skuDetails.value = newSet```
Collecting values:

```    coroutineScope.launch {
       skuDetails.collect {
            Timber.i("sku details: $it") // Never called
        }
    }```

Any ideas? The CoroutineScope isn't being cancelled. The new set of values != the previous set.

This code should work, I think only debug can help
Maybe some deadlock? Maybe you have some blocking code which blocks dispatcher of you scope

OK, I think I'm just calling `collect` too late, and missing the emissions

Nope. I don't really understand what's going on.

I am calling the 'collecting values' block from a function. If I instead move that to the class `init { }`, the StateFlow emits as expected

This works:

```init {
    skuDetails.onEach {
        Timber.i("Emitting ${it.size} sku details")
    }.launchIn(coroutineScope)
}```
This doesn't:

```fun start() {
    skuDetails.onEach {
        Timber.i("Emitting ${it.size} sku details")
    }.launchIn(coroutineScope)
}

foo.start()```


Even though the StateFlow isn't updated until after `start()` is called.

I'm sure there's a logical explanation, but I just don't understand what's going on here

You’d need to give some more context, just changing `init` to `fun start()` is trivial but clearly there’s something more tricky going on in your codebase

Looks like you want a SharedFlow with a replay buffer instead of StateFlow.

OK, I'll see if I can replicate this in Kotlin playgrounds. Hard for me to provide more context without dumping a lot of code

I don't know, I said "looks like", you know your exact use case better.

Can you explain why it looks that way to you?

Because it seems you want to get value updates that happen before collect is called.

Doesn't StateFlow hold the most recent value though?

Yes it does, and I'm pretty sure you have it.

<@US7DACDEH> are you calling the collect block from a suspend function?