Can compose infer stability of a `sealed` class ? ```sealed class MyClass { object A : MyClass()...

# compose

[ritesh]

Can compose infer stability of a sealed class ?

sealed class MyClass {
  object A :  MyClass()
  data class SomeClass(val value:String): MyClass()
}

[gildor]

I think compose doesn’t infer stability automatically for user classes

[gildor]

You can mark it as @Stable though

[ritesh]

It can infer for data class, say - if i have a data class with with val of primitives

[ritesh]

I was wondering in this case if it can or not

[ritesh]

Also, it should be @Immutable i believe if i have to mark it, not @Stable - as there is no reactive stream in the class

[gildor]

Yeah, maybe for primitive val, not quite sure about it though

[gildor]

pretty sure it will not infer it from sealed class automatically

[gildor]

But you can try, it’s easy to check

[gildor]

Also, it should be @Immutable i believe

Yep, you right, Immutable

[ritesh]

But you can try, it’s easy to check

Ahh sure. thanks!

[myanmarking]

so, is it ?

[ritesh]

Not sure if i checked it correctly, but re-comp was skipped when using sealed class, same example as above
https://twitter.com/mochadwic/status/1415860219213537282?s=19

[ritesh]

Also, earlier i was under the impression that, something like this is not stable, when we do-not use val but use var

data class SomeClass(var value:String)

But re-comp was skipped in this case well, i believe it doesn't matter if it's var or val, compose considers all primitives as stable as mentioned in the documentation.

[myanmarking]

don’t think it’s true. It was not skipped. The Composable that read that value was skipped because equals returns true

[myanmarking]

@Composable
fun SomeClassComposable(item: SomeClass){
Text(item.value)
}
SomeClassComposable entered body, but probably text will skip because content equals

[ritesh]

Yeah, you are correct, i had made a mistake, while checking for data class stability, var or val does makes a difference.

@Composable
fun ComposeTest(vm:MyVm){
    val dataClassstate = vm.state.value
    val sealedState = vm.sealedState.value
    LogCompositions(tag = "ComposeTest")
    Column {
        ButtonComposable(onClick = vm::valueChanged) // it changes sealedState, not dataClassstate state 
        SomeClassRecomp(someClass = dataClassstate)
    }
}

@Composable
fun SomeClassRecomp(someClass: SomeClass){
    LogCompositions(tag = "SomeClassRecomp")
    Text(text = someClass.value)
}

On Button click i am changing sealedState which ends of re-composing ComposeTest on every button click.

If my SomeClass holds a var, SomeClassRecomp gets called irrespective of any change in it's state. But if i change it to val, it won't get called.

[ritesh]

SomeClassComposable entered body, but probably text will skip because content equals

yeah and also it won't enter the SomeClassComposable body, if SomeClass is stable and haven't changed, it will enter even if equals returns true and but it isn't stable (example using var instead of val)

[ritesh]

@Zach Klippenstein (he/him) [MOD] Sorry for tagging you in - would like to understand/know your pov on this as well.

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

The best way to answer these questions is to just ask the compiler to tell you:

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
    kotlinOptions {
        freeCompilerArgs += [
                "-P",
                "plugin:androidx.compose.compiler.plugins.kotlin:reportsDestination=${buildDir}/composeReports"
        ]
    }
}

Will spit out a file named something like *-classes.txt that describes what’s inferred for each class.

So for your case, I get:

stable class A {
  <runtime stability> = Stable
}
stable class SomeClass {
  stable val value: String
  <runtime stability> = Stable
}
stable class MyClass {
  <runtime stability> = Stable
}

[ritesh]

This is great. Thanks.

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

this is the only public doc about this atm: https://github.com/androidx/androidx/blob/androidx-main/compose/compiler/design/compiler-metrics.md

[ritesh]

Had been exploring compiler metrics. It looks like compose does infer stability of sealed classes as well, no need to mark them Immutable.

sealed class SealedClass{
    object Loading : SealedClass()
    data class SomeClass(val error:String):SealedClass()
}

stable class Loading {
  <runtime stability> = Stable
}
stable class SomeClass {
  stable val error: String
  <runtime stability> = Stable
}
stable class SealedClass {
  <runtime stability> = Stable
}

[ritesh]

What does <runtime stability> means? It's stability will be resolved at run-time? but it says Stable though

<runtime stability> = Stable

[ritesh]

For eg:
Here, the var is stable, but at run-time it makes the class unstable. What does that mean, if just use value in a composable function, re-comp will be skipped, even though if it's a var ?

class AA {
    var value:String = "String"
}

unstable class AA {
  stable var value: String 
  <runtime stability> = Unstable
}

class AA {
    val value:String = "String"
}

stable class AA {
  stable val value: String
  <runtime stability> = Stable
}

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

What do you mean the var is stable?

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

A class with a var that’s not backed by a MutableState can’t be inferred to be stable because it probably doesn’t satisfy the contract of stability: if the var changes, the composition won’t be automatically notified

[ritesh]

unstable class AA {
  stable var value: String 
  <runtime stability> = Unstable
}

Yeah, I was referring to the fact that compiler says it's stable stable var value: String but also marks it as unstable at run-time. I think i got confused between run-time and compile-time stability inference.

Makes sense in case of var

Thanks

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

I think that's because the property type, String, is stable, but not sure