When does a remember() function's lambda get calle...

# compose

[bnvinay92]

When does a remember() function's lambda get called again?
I have:

ParentComposable {
  ChildComposable {
     remember("constant") { someConstructor() }
  }
}

My assumption is that someConstructor will only get called once but it seems whenever the ParentComposable recomposes the constructor gets called again. Is this how compose works or am i missing something else that's causing the remember to run again?

[vide]

are you sure your constant doesn't change?

[vide]

another possibility could be that the remember call is removed from the composition and added back later?

[ascii]

If a composable leaves composition, then of course stuff like remember and effect(Unit) will "re-execute" when the particular composable comes back.

If compose would store snapshots for everything forever, things would quickly go out of hand.

[ascii]

If you want one-off code to truly run only once regardless of leaving composition, you'll have to use some external controls, e.g. an atomic or volatile boolean flag that you'd check (and set) inside the block.

Or in your constructor example, store it yourself in a var outside of compose.

[Adib Faramarzi]

It will get called one every composition and not every recomposition. So if your composable is kept in the composition and is recomposing (due to changes, animations, etc...), since the key that you provided has not changed, someConstructor will not get called. But if it goes away from composition and is brought back, it will be called again.

[bnvinay92]

Thanks for the direction

[bnvinay92]

Any techniques to debug when a composable leaves a composition?

[bnvinay92]

Nvm, found it:
DisposableEffect(Unit) {
// Log when disposed (removed)
onDispose {
Log.d("MyComposable", "Disposed (Removed)")
}
}

[bnvinay92]

So what was happening was that my ChildComposable was actually:

ParentComposable {
   when {
     case 1 -> ChildComposable
     case 2 -> ChildComposable
   }    
}

It looks like the compose compiler generates different uids for each one so my case statements were removing and adding these from the composition instead of recomposing it.

[Zach Klippenstein (he/him) [MOD]]

Yep, that’s the “positional” part of positional memoization

[ascii]

I think this is where key() could be useful; if it's the same composable fn and you don't want one to be removed and the other added.

[Adib Faramarzi]

Yes. This is explained as an example for a for code in the Android docs for Compose (in which they use a key(item.id) in the for block to know which item is which.