Okay, I've been staring at this too long. Am I mis...

# getting-started

[Colton Idle]

Okay, I've been staring at this too long. Am I missing something basic here. Why can't I do

myMap.value[MyType.A] = listOf(MyThing(1), MyThing(2))
myMap.value[MyType.B] = listOf(MyThing(3), MyThing(4))
myMap.value[MyType.C] = listOf(MyThing(5), MyThing(6))

with a map defined of

val myMap = _MutableStateFlow_<Map<MyType, List<MyThing>>>(_emptyMap_())

[Chris Lee]

That .value doesn’t seem right, though am unfamiliar with that map impl.

[Vampire]

I'd say Map vs. MutableMap

[Colton Idle]

🤦

[Colton Idle]

Looks like my eyesw kept going to MutableStateFlow and thinking that it should be fine to be mutated.

[Colton Idle]

I wonder if MutableStateFlow with a MutableMap is fine?

[Wout Werkman]

I would not recommend using MutableMap inside MutableStateFlow. Whoever observes the flow will not observe changes in the MutableMap. While in theory it's possible to design your flows with this in mind, nesting mutable data is generally considered a bug magnet.

[Wout Werkman]

In the example you showed here, the value might be updated in between the insertions you make into the map.
This could make that:
1. You insert the MyType.A entry into one map.
2. myMap.value get's updated from another thread
3. You insert the MyType.B and MyType.C entries into the new map
4. The new map is now missing the MyType.A entry

[Wout Werkman]

You could achieve the same semantics without race conditions as follows:

val myMap = MutableStateFlow<Map<MyType, List<MyThing>>>(emptyMap())
myMap.update { oldValue ->
  oldValue + mapOf(
    MyType.A to listOf(MyThing(1), MyThing(2)),
    MyType.B to listOf(MyThing(3), MyThing(4)),
    MyType.C to listOf(MyThing(5), MyThing(6)),
  )
}

[Colton Idle]

hm. cant seem to get something like that to compile. i'll keep trying. maybe some extension function isn't making it's way it.

one last question though. is there a way to be able to set the data in this sort of way? Where I can udpate a specific item in the map vs adding to the map?

myMap.value[MyType.A] = listOf(MyThing(1), MyThing(2))

[Chris Lee]

yes, mutable maps support the [] operator and assignment. Won’t work if map is not mutable.

[Wout Werkman]

No, it won't work on immutable maps. It's always recommended to use update

myMap.update { it + (MyType.A to listOf(MyThing(1), MyThing(2)) }

You can wrap it in a utility function:

operator fun MutableStateFlow<Map<MyType, List<MyThing>>>.set(key: MyType, value: List<MyThing>): Unit = update { it + (key to value) }

myMap[MyType.A] = listOf(MyThing(1), MyThing(2))

[Francesc]

if you use a mutable map or list on the state flow it won't emit when you make changes to it because, internally, the state flow is comparing it against the current value, which is the same, so nothing gets emitted.