I want to be able to directly invalidate a `remember`. It seems that `currentComposer.cache` does th...

# compose

[Youssef Shoaib [MOD]]

I want to be able to directly invalidate a remember. It seems that currentComposer.cache does this, but with a big disclaimer and no-no all over it. Is there any supported way to do this? Would it be okay to do something like this instead:

private object Flip {
  override fun equals(other: Any?): Boolean {
    // Not equal to itself
    return Keep == other
  }
}

private data object Keep

remember(if (shouldUpdate) Flip else Keep) { ... }

This works, but I'm concerned that it might break in the future

[Chris Fillmore]

You could use an Int as a trigger, increment it to invalidate

[Stylianos Gakis]

There’s also neverEqualPolicy as the SnapshotMutationPolicy to apply to a mutableState which will consider itself not equal to the previous value if you set the same value to it again.
Not sure if that’s what you want here, but what you say kinda makes me think about it.

[Alex Vanyo]

+1 to an incrementing counter, or a UUID that represents some sort of “session” that you can use as a key. That will keep you in the realm of normal Compose behavior.

I’ve tried to get clever with custom equals, and almost immediately started getting confused by behavior.

[Youssef Shoaib [MOD]]

What I want is akin to SnapshopMutationPolicy yes.
I didn't want to keep an Int around because If I'm keeping a mutable object anyways then I might aswell just:

data class State<S>(var state: S?)
remember { State<Blah>(null) }.apply { if(shouldUpdate || state == null) state = ... }

[Alex Vanyo]

Having a shouldUpdate in there feels suspicious, what is driving the value of shouldUpdate?

[Youssef Shoaib [MOD]]

It's derived from an implicit dependency. It's also derived from an isEmpty call on a piece of outside state. Both of these I can't really see being able to easily transform into the form that remember wants.