If that assumption is true, maybe you can count the number of entries with the same type and give each "duplicate" an unique ID. Something like incrementing the counter of entries with the same key and give each entry the current counter value and increment.

And back to the initial question

val movableEntries = entries.map { entry ->
  movableContentOf {
    Renderer(entry)
  }
}

This will be "immediately disposed" because you have to remember the

movableContentOf

or store it outside of the composition.

you have to remember the

movableContentOf

or store it outside of the composition.

For the sake of understanding I've been trying to make

movableContentOf

work for me, but I think I'm missing something. In the example I linked above it doesn't look like the

movableContentOf

is remembered or stored outside of the composition. I was able to get my use case to work by using a

Map

approach where I store the

movableContentOf

outside of the composition keyed by my

Key

. But to me that seems functionally the same (and much more complex) than using the

key

function. I'm trying to do something similar to the linked example. This was the closest I could get (still stuck using my key), but when removing the first entry in the list, all the other entries get disposed. I changed my

Renderer

function to take the entry's composable as a param (wrapped in the

movableContentOf

) because the

Renderer

is also responsible for indirectly mutating the list, which seemed to cause several state issues.

val entries by entriesUpdateFlow.collectAsState()

val movableEntries = entries.map { entry ->
  remember(it.key) { movableContentOf { it.Render() } }
}

entries.forEachIndexed { index, entry ->
  RenderEntry(entry, movableEntries[index])
}

Maybe @Jorge Castillo has some ideas? The example came from his blog post.