Enum families and overlapping enums

This works:

sealed trait Foo extends EnumEntry
object Foo extends Enum[Foo] {
  val values = findValues

  case object Foo1 extends Foo
  case object Foo2 extends Foo

  sealed trait Bar extends Foo
  object Bar extends Enum[Bar] {
    val values = findValues
    case object Bar1 extends Bar
    case object Bar2 extends Bar
  }

  sealed trait Qux extends Foo
  object Qux extends Enum[Qux] {
    val values = findValues
    case object Qux1 extends Qux
    case object Qux2 extends Qux
  }
}

What I want:

sealed trait Foo extends EnumEntry
object Foo extends Enum[Foo] {
  val values = findValues

  case object Foo1 extends Foo
  case object Foo2 extends Foo

  case object Bar1 extends Bar
  case object Bar2 extends Bar

  case object Qux1 extends Qux
  case object Qux2 extends Qux

  case object BarQux1 extends Bar with Qux
  case object BarQux2 extends Bar with Qux

  sealed trait Bar extends Foo
  object Bar extends Enum[Bar] {
    val values = findValues
  }

  sealed trait Qux extends Foo
  object Qux extends Enum[Qux] {
    val values = findValues
  }
}

Now that compiles, but at runtime Bar.values and Qux.values are empty!

Work around with Shapeless:

trait EnumValues[A] {
  def find: IndexedSeq[A]
}

object EnumValues {
  def apply[A : EnumValues]: EnumValues[A] = implicitly
  def find[A : EnumValues]: IndexedSeq[A]  = apply[A].find

  @nowarn("cat=unused")
  implicit def instance[A, C <: Coproduct, V <: HList](implicit
      generic: Generic.Aux[A, C],
      witnesses: LiftAll.Aux[Witness.Aux, C, V],
      toArraySeq: ToTraversable.Aux[V, ArraySeq, Witness.Lt[A]]
  ): EnumValues[A] = new EnumValues[A] {
    val find = toArraySeq(witnesses.instances).map(_.value)
  }
}

[lloydmeta]

I’m fine with saying this is working as intended. But note that the case objects in my example are still nested in an enclosing object.

In your original post, you stated that your issue was that

Bar.values and Qux.values are empty`

Your Bar.values is declared as

  sealed trait Bar extends Foo
  object Bar extends Enum[Bar] {
    val values = findValues
  }

There are no Bars inside the scope of the immediately enveloping Enum[Bar].

It’s not impossible to find them without using knownDirectSubclasses and still preserving all the properties you mentioned

Last I checked Shapeless conjures its Generic and friends eventually using knownDirectSubclasses anyways, then sorts them (https://github.com/milessabin/shapeless/issues/892).

In any case, you can get what you want by doing something like this:

import enumeratum._

sealed trait Foo extends EnumEntry
object Foo extends Enum[Foo] {
  val values = findValues

  case object Foo1 extends Foo
  case object Foo2 extends Foo

  case object Bar1 extends Bar
  case object Bar2 extends Bar

  case object Qux1 extends Qux
  case object Qux2 extends Qux

  case object BarQux1 extends Bar with Qux
  case object BarQux2 extends Bar with Qux

  sealed trait Bar extends Foo
  object Bar extends Enum[Bar] {
    val values = Foo.values.collect { case e: Bar => e }
  }

  sealed trait Qux extends Foo
  object Qux extends Enum[Qux] {
    val values = Foo.values.collect { case e: Qux => e }
  }
}

println(Foo.values)
println(Foo.Bar.values)
println(Foo.Qux.values)

Scastie: https://scastie.scala-lang.org/Adc4z1d3TXCh3UOhz4CM1A

[joroKr21]

That’s a really nice way to make it work and no need for shapeless. Thank you 👍 Closing this now. But WDYT about a compiler warning when findValues is empty?