Off the top of my head, this compiles and may be what you’re looking for—

sealed class OutsideGroup {
    class Option1: OutsideGroup()
    class Option2: OutsideGroup()

    sealed class InsideGroup: OutsideGroup() {
        class Option3: InsideGroup()
        class Option4: InsideGroup()
    }
}

fun returnOuter(): OutsideGroup = OutsideGroup.Option1()

fun returnInner(): OutsideGroup.InsideGroup = OutsideGroup.InsideGroup.Option3()

use

òbject

instead of

class

in this example, there is no need for multiple instances

true, this example assumes that you’d be filling it in with parameters

Thanks I will consider that. Unfortunately it is still not possible (afaik) to flatten nested sealed classes which will pose a problem with naming. But what if the two deriving classes each may only return non-disjoint subsets of the enum? The method above wouldn't work anymore, since the elements in the intersection can not extend two sealed classes at the same time

@tschuchort can you give us an example of the desired hierarchy?

something like this:

interface Interf {
   fun foo(): A|B|C
}

class X : Interf {
   override fun foo(): A|B
}

class Y : Interf {
   override fun foo(): B|C
}

the only way I can think of is using a sealed class + an interface

How would you do it?

actually you'd need two interfaces + a sealed class (or just 3 interfaces), but not sure if its worth it (no when-exhaustiveness for

Return2

or

Interf.foo()

)

interface Base { }

sealed class Return1: Base
interface Return2: Base

object A : Return1()
object B : Return1(), Return2
object C: Return2

interface Interf {
   fun foo(): Base
}

class X : Interf {
   override fun foo(): Return1
}

class Y : Interf {
   override fun foo(): Return2
}