sealed class Foo : Bar() {
    object A : Foo()
}

sealed class Bar {
    object B: Bar()
}

val foo: Foo = getFoo()
val baz = when (foo) {
    A -> Unit
}

B

B

Foo

Bar -> Foo -> A

B

val bar: Bar = getBar()
val baz = when (bar) {
    A,
    B -> Unit
}

Bar
 `- B
 `- Foo
     `- A

sealed class ASpecific : Common() {
    object A : ASpecific()
}

sealed class BSpecific : Common() {
    object B : BSpecific()
}

sealed class Common {
    object C: Common()
}

class ScreenA {
    fun run(a : ASpecific) {
        when (a) {
            A -> TODO()
            // I would love to be able to treat 'C' there too
        }
    }
}

class ScreenB {
    fun run(b : BSpecific) {
        when (b) {
            B -> TODO()
            // I would love to be able to treat 'C' there too
        }
    }
}

sealed

SealedClassForScreenA

SealedClassForScreenB

class ScreenA {
    fun run(a: SealedClassForScreenA) {
        when (a) {
            A -> TODO()
            C -> TODO()
        }
    }
}

class ScreenB {
    fun run(b: SealedClassForScreenB) {
        when (b) {
            B -> TODO()
            C -> TODO()
        }
    }
}