initial draft for multi-level enums

[esarbe]

A draft SIP for https://contributors.scala-lang.org/t/proposal-for-multi-level-enums/3344

[bishabosha]

to avoid getting into the weeds, because this is the wrong desugaring, its probably better to explain it in a set of recursive steps, where each case enum becomes an enum in the companion that extends the parent enum class (because an enum is a class not a sealed trait)
see the spec here: https://scala-lang.org/files/archive/spec/3.4/05-classes-and-objects.html#lowering-of-enum-definitions

[esarbe]

Thanks for the pointer!

I'll look into that and update the spec.

[bishabosha]

also good to demonstrate how parameters work (e.g. case enum Bird(val call: String):) and optional extends clauses

[bishabosha]

also the rules of extends clauses, e.g. what class is allowed to be extended

[bishabosha]

also another point to address - enum constructor expression are widened to the parent enum, so which parent should a nested case widen to - as a rule it should be included

[JD557]

Maybe I missed it, but I think is not explicit how non-leaf ordinals are computed.

Would it be?

enum Animal:        // No ordinal
  case enum Mammal: // Ordinal 0
    case Dog        // Ordinal 0
    case Cat        // Ordinal 1
  case enum Bird:   // Ordinal 1
    case Sparrow    // Ordinal 2
    case Pinguin    // Ordinal 3
  case Fish         // Ordinal 2

If that is the case, I assume Mammal.fromOrdinal(...) won't exist.
If it does exist, how would Bird.fromOrdinal(...) work? Would it take "global ordinals" (2 for Sparrow and 3 for Penguin), or would it expect "local ordinals" (0 for Sparrow and 1 for Penguin)?

[esarbe]

No, you didn't miss it. It's currently not specified.

Do Mammal or Bird, i.e. "sub-enums", need their own ordinal? Can we even instantiate them?

enum Animal:        // No ordinal
  case enum Mammal:       // No ordinal
    case Dog        // Ordinal 0
    case Cat        // Ordinal 1
  case enum Bird:       // No ordinal
    case Sparrow    // Ordinal 2
    case Pinguin    // Ordinal 3
  case Fish         // Ordinal 4

[sjrd]

One really thorny question is what type gets inferred for term subcases:

val x = Animal.Mammal.Dog

What is the inferred type for x? Choosing Dog.type would be completely inconsistent with current enums. But then is it Animal or Mammal?

---

The SIP does not mention sub class cases at all. IMO that's missing.

[sjrd]

The nested enum is itself a valid case of the parent enum

This does not make sense to me. It's a subtype, sure. But it cannot be a valid (term) case of the parent enum while at the same time having several "sub-terms". A term must be unique.

[sjrd]

Enums are abstract classes, not traits.

[esarbe]

fixed.

[sjrd]

This does not make sense. Matching on Mammal itself already has meaning, which is to test if it is the Mammal companion object itself. That cannot be changed to means case Cat | Dog.

[esarbe]

True, which is a shame. We can still match on supercase type though.

def laysEggs(a: Animal) = a match {
  case _: Bird | Fish => true
  case _ => false 
}