Hi, how to use

@Stable

annotation properly? From documentation

The result of

equals

will always return the same result for the same two instances.

So, should I override

equals

and

hashcode

methods for the following class?

@Stable
class State (
    text: String,
    enabled: Boolean
) {
    var text by mutableStateOf(text)
    var enabled by mutablesStateOf(enabled)
}

I am not sure because I see a lot of

Stable

annotated classes where those methods are not overridden

if you implement structural

equals

, that will not be a valid type for `@Stable`:

val state1 = State("1", false)
val state2 = State("1", false)
state1 == state2
state2.text = "2"
state1 != state2

yes, I was talking about structural equals. Why is that not valid for

Stable

?

for comparison, a standard

@Stable

type:

val state1 = rememberScrollState(initial = 0)
val state2 = rememberScrollState(initial = 0)
state1 != state2 // regardless of whether state1.value == state2.value

got it 👍 so the conclusion is that we never should override

equals

for

Stable

annotated classes. What about

@Immutable

annotation? As far as I understand, in that case we have to override those methods (considering that all other requirements are met)

I can't think of a practical application but "never" seems too strong. in principle this should be fine

@Stable class Keyed(val key: String, private val map: SnapshotStateMap<String, String>) {
    var value: String by map
    override fun equals(other: Any?): Boolean = other is Keyed && key == other.key && map == other.map
    override fun hashCode(): Int = key.hashCode() * 31 + map.hashCode()
}
val map = remember { mutableMapOf("foo" to "hello", "bar" to "world") }
val state1 = Keyed("foo", map)
val state2 = Keyed("foo", map)
val state3 = Keyed("bar", map)
state1 == state2; state1 != state3; state2 != state3 // regardless of anything value is set to

FWIW. I've shipped 4 apps to prod with compose without any real issues. I've never used @Stable 🙈