Afair I also need the ordering that enums have naturally

So what you two suggest is basically this, right?

sealed class Boo(val ordinal: Int) : Comparable<Boo> {
    val name: String = javaClass.simpleName

    open val foo: String get() = error("no foo set for ${javaClass.superclass.simpleName}.${name}")

    final override fun compareTo(other: Boo) = compareValues(ordinal, other.ordinal)

    object BAZ : Boo(0)

    object BAM : Boo(1) {
        override val foo: String = "bar"
    }

    companion object {
        fun values() = Boo::class.sealedSubclasses.mapNotNull { it.objectInstance }
    }
}

Ah stupid me, when writing the enum I forgot about overwriting properties that I now used in the sealed class. So what I was after is simply

enum class Boo {
    BAZ,
    BAM {
        override val foo = "bar"
    };

    open val foo: String get() = error("no foo set for ${javaClass.simpleName}.${name}")
}

What would be the benefit of using a sealed class hierarchy instead @tddmonkey?

But for the ordering I then still need to define the ordinals manually

So now it is

sealed class Boo(val ordinal: Int) : Comparable<Boo> {
    val name: String = javaClass.simpleName
    final override fun compareTo(other: Boo) = compareValues(ordinal, other.ordinal)

    sealed class BooWithFoo(
            ordinal: Int,
            val foo: String
    ) : Boo(ordinal) {
        object BAM : BooWithFoo(1, "bar")
    }

    object BAZ : Boo(0)

    companion object {
        fun values() = listOf(Boo::class, BooWithFoo::class)
                .flatMap { it.sealedSubclasses }
                .mapNotNull { it.objectInstance }
    }
}

😕

Hm, maybe like this:

sealed class Boo(val ordinal: Int) : Comparable<Boo> {
    val name: String = javaClass.simpleName
    final override fun compareTo(other: Boo) = compareValues(ordinal, other.ordinal)

    interface WithFoo {
        val foo: String
    }

    object BAZ : Boo(0)
    object BAM : Boo(1), WithFoo {
        override val foo = "bar"
    }

    companion object {
        fun values() = Boo::class.sealedSubclasses.mapNotNull { it.objectInstance }.sorted()
    }
}

But then I still need to receive

Boo

in the method and then check for

is WithFoo

as other classes could implement the

WithFoo

interface and I also need the other properties in the method.

Ah, where clause on generic function parameter and we are fine maybe

sealed class Boo(val ordinal: Int) : Comparable<Boo> {
    val name: String = javaClass.simpleName
    final override fun compareTo(other: Boo) = compareValues(ordinal, other.ordinal)

    interface WithFoo {
        val foo: String
    }

    object BAZ : Boo(0)
    object BAM : Boo(1), WithFoo {
        override val foo = "bar"
    }

    companion object {
        fun values() = Boo::class.sealedSubclasses.mapNotNull { it.objectInstance }.sorted()
    }
}

fun <T> hoo(boo: T) where T : Boo, T : Boo.WithFoo {
    println(boo.name)
    println(boo.foo)
}

Ok, so I think this will be the final solution, thanks:

sealed class Boo(val ordinal: Int) : Comparable<Boo> {
    val name: String = javaClass.simpleName

    init {
        if (!usedOrdinals.add(ordinal)) {
            throw IllegalArgumentException("${javaClass.superclass.simpleName}.$name: " +
                    "The ordinal $ordinal is already used by another instance")
        }
    }

    final override fun compareTo(other: Boo) = compareValues(ordinal, other.ordinal)

    object BAZ : Boo(0)
    object BAM : Boo(1), WithFoo {
        override val foo = "bar"
    }

    companion object {
        private val usedOrdinals = mutableSetOf<Int>()

        fun values() = Boo::class
                .sealedSubclasses
                .mapNotNull { it.objectInstance }
                .sorted()
    }

    interface WithFoo {
        val foo: String
    }
}

// verify ordinals are unique
private val booValues = Boo.values()

fun <T> hoo(boo: T) where T : Boo, T : Boo.WithFoo {
    println(boo.name)
    println(boo.foo)
}

Hm, no, giving the ordinals manually is tedious, especially when new constants get added in the middle or beginning. 😕

And then of course you could just remove

values()

and make

order

public

And this wouldn't change that I have two lists with 60+ entries

Again - im not sure why you have 2 lists?

> ah, it doesn’t need to implement 

Comparable

 anymore Yes it does, or is not comparable > you did that to do the sorting in the old 

values()

 method. You are assuming too much, I made it comparable because I need it comparable, I just used it in

values

as the list should be sorted > Again - im not sure why you have 2 lists?

@bezrukov hm, do you have another idea on how to get the list of object instances?

kotlin-reflect

is there and I can get the

sealedSubclasses

. But unfortunatley there is a

SecurityManager

in place that denies

("java.lang.RuntimePermission" "accessDeclaredMembers")

, so the

it.objectInstance

fails with

AccessControlException

. :-(

Hm, I think I just switch back to

enum

. What I really would like to have is (https://youtrack.jetbrains.com/issue/KT-39466)

enum class Boo {
    BAZ,
    BAM : WithFoo {
        override val foo = "bar"
    };
}

interface WithFoo {
    val foo: String
}

But I guess I'll go with

enum class Boo {
    BAZ,
    BAM {
        override val foo = "bar"
    };

    open val foo: String
        get() = error("no foo set for ${javaClass.simpleName}.${name}")
}

for now, that at least removes the

fooDelegate

naming need

Thanks for your help and patience though 🙂