How to inherit from enums?

I have two different enums:

enum class As(val value: String) {
    A1("a1"),
    A2("a2"),
    A3("a3"),
    Unknown("null")
}

and

enum class Bs(val value: String) {
    B1("b1"),
    B2("b2"),
    Unknown("null")
}

since both have a common entry, I would like to inherit enums:

enum class Upper(val value: String) {
    
    Unknown("null")
}

and then:

enum class As(val value: String): Upper(value) {
    A1("a1"),
    A2("a2"),
    A3("a3")
}

and

enum class Bs(val value: String): Upper(value) {
    B1("b1"),
    B2("b2")
}

Also I would like to use the Upper as a parameter in a function:

@Composable
fun aFunc(upper: Upper, ....) {
    when(upper){
        is As -> //..
        is Bs -> //..
        else //..
    }
}

Unfortunately I can not inherit from enums. Otherwise I would have to overload parameters:

@Composable
fun aFunc(a: As, ....) {
    //..
}

and

@Composable
fun aFunc(b: Bs, ....) {
    //..
}

Any smart solution here?

Enum inheritance is not supported in Kotlin (and in Java it's not possible too). Let's see this example:

enum class Coordinates { X, Y }
enum class Coordinates3D : Coordinates { Z }

val xd: Coordinates = ... // which is a limited set of this assigment? X, Y or Z too?

So, is there something we can replace enums with?
Yes! Sealed classes

sealed class S(val value: String) {
    object Unknown : S("null")
}

sealed class As(value: String) : S(value) {
    object A1 : As("a1")
    object A2 : As("a2")
    object A3 : As("a3")
}

sealed class Bs(value: String) : S(value) {
    object B1 : Bs("a1")
    object B2 : Bs("a2")
}

// You can use exhaustive branching for all possible types.
fun example(s: S): String {
	return when(s) {
		// must define all possible cases of S (and all possible subcases)
		S.Unknown -> "S.Unknown"
		As.A1 -> "As.a1"
		As.A2 -> "As.a2"
		As.A3 -> "As.a3"
		Bs.B1 -> "Bs.b1"
		Bs.B2 -> "Bs.b2"
	}
}

// You can match by "subtype family" too.
fun example2(s: S): String {
	return when(s) {
		S.Unknown -> "Unknown"
		is As -> "As"
		is Bs -> "Bs"
	}
}

One possibility is to eliminate enums As and Bs, and create a new enum that represents the sub type (either A or B).

enum class SubType { A, B }

Then you specify the subtype as a property in the enum.

enum class Upper(val value: String, val subType: SubType? = null) {
    A1("a1", SubType.A),
    A2("a2", SubType.A),
    A3("a3", SubType.A),
    B1("b1", SubType.B),
    B2("b2", SubType.B),
    Unknown("null")
}

In your function, you check the subType property rather than its type.

fun aFunc(upper: Upper) {
    when(upper.subType){
        SubType.A -> //..
        SubType.B -> //..
        null -> //..
    }
}

Bonus

However, now the built-in static method values() will return all enum values, rather than just As or Bs. So, we can add a new method:

enum class Upper(val value: String, val subType: SubType? = null) {
    A1("a1", SubType.A),
    A2("a2", SubType.A),
    A3("a3", SubType.A),
    B1("b1", SubType.B),
    B2("b2", SubType.B),
    Unknown("null");

    companion object {
        fun valuesOf(subType: SubType?): List<Upper> =
            values().filter { it.subType == subType }
    }
}

Other Thoughts

It's also important to consider if inheritance is truly necessary for your problem. A little bit of duplication is better than making the wrong abstraction, and inheritance can often be a huge footgun. I recommend checking out Code Aesthetic's The Flaws of Inheritance

Unrelated, but worth mentioning - the naming convention for composable functions is to use PascalCase, not camelCase.