What would be the best way to react to

mutableStateListOf

changes in effects? Say, I have

Parent

which has state

remember { mutableStateListOf<Int>() }

which can be changed by one of its children.

Parent

also has an effect (let’s say

DisposableEffect

) reading changes to the list, like

DisposableEffect(list){/* ... */}

. But that effect won’t be called more than once, because

list

won’t change instance (

SnapshotStateList

), even if items are added.

You could: 1- Pass a parameter down the tree

onListChanged: () -> Unit

to let the children notify the parent when it modifies the list; 2- Use

list.size

as key instead of

size

, however I'm not sure how it would react when swapping two elements; 3- Depends on your use case

You could use

snapshotFlow()

. It should emit when the list is updated.

Yep this is precisely what

snapshotFlow

is for. Or any of the lower-level apis for snapshot observation.

so having this in

val list = remember { mutableStateListOf<Int>() }

  LaunchedEffect(Unit) {
    snapshotFlow { list }.collect {
      Log.i("XXX", "snapshot updated!")
    }
  }

and then calling

list.add(2)

should print

snapshot updated!

, correct?

I think so. I can't remember off the top of my head if the flow will dedup emits because the list identity is the same - but if you move the log call into the snapshotFlow block and just use an empty collect it should definitely do that.

That was my first thought too about

snapshotFlow { list }

, to be updated whenever the list is modified. But it’s not the case here. If I do

snapshotFlow { list.size }

then it’s working as expected. Like you said,

list

has the same identity (due to remember)

Right, so a cool trick about snapshotFlow is that you don't actually have to use it as a flow. You can just use it to create a restartable function by doing all your work in the snapshotFlow lambda and just ignoring the emitted values with an empty collect.

Cool, nice trick 😄

LaunchedEffect(Unit) {
    snapshotFlow { Log.i("XXX", "list size: ${list.size}") }.collect {}
  }

It would be helpful to know more about your code to figure out what the best overall solution is, but you actually still want to pass the list as a key (since if the identity of the list changes, you need to restart the effect), but you probably want to combine them:

@Composable fun Foo(list: List<T>) {

LaunchedEffect(list) {
    snapshotFlow { list.… }.collect()
  }
}

I have

DisposableEffect

that should listen for changes in

list

, and that effect does not own coroutine scope, so it’s bit tricker

So just change it to a LaunchedEffect

Can’t really, there needs to be some cleanup done when

list

changes 😄

You can do that with a launched effect. Anything you can do with disposable effect you can do with a LaunchedEffect

Do you mind explaining this/show an example?

Exactly