Hey, is extending sealed classes bugged or I'm missing something ? For example, with this ```sealed ...

# getting-started

[Nino]

Hey, is extending sealed classes bugged or I'm missing something ? For example, with this

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

sealed class Bar {
    object B: Bar()
}

it's totally OK to write this code :

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

I would expect B to be required in the branches

[ephemient]

Why? B is not a Foo

[Sam]

Your hierarchy is Bar -> Foo -> A, right?

[Nino]

Worse, the B branch is needed only with Bar :

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

[Nino]

Why? B is not a Foo

B is a Bar, and Foo extends Bar, so... here comes my confusion ^^

[Sam]

Foo and B are both Bars, but that does’t make B a Foo

[ephemient]

Bar
 `- B
 `- Foo
     `- A

[Nino]

Here's what I imagined but I can't find a solution with sealed classes :

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
        }
    }
}

Is it possible to have a "common ancestor" between 2 sealed classes so the "common ancestor" branches should be treated as well as "child" branches ?

[ephemient]

your hierarchy doesn't make sense even without sealed

[ephemient]

if it were

sealed interface Common
sealed interface ASpecific : Common
sealed interface BSpecific : Common
object A : CommonWithA
object B : CommonWithB
object C : CommonWithA, CommonWithB

then both A is ASpecific && C is ASpecific (but that naming is rather bad)

[Nino]

I get it, I was thinking all inverted 😕

So there's no way to define SealedClassForScreenA and SealedClassForScreenB that would makes such a code work ?

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

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

[ephemient]

there is, in my example in the immediately prior message.

[Nino]

Yes sorry I meant without C implementing all the other sealed classes ?

[Nino]

I just realised I make no sense with this last sentence, I get it now ^^

[ephemient]

no. if it doesn't implement them, then it isn't a subtype of them

[Nino]

Exactly !

[Nino]

Thanks a lot 🙂