无法获取依赖于路径的类型以在Scala枚举中工作

Question

I'm trying to spin my head around the path-dependent types in Scala's enums while making a Reads/Writes for Play2. Here is the code I have so far, it works, but with an asInstanceOf:

implicit def enumerationReads[T <: Enumeration](implicit t: T): Reads[t.Value] = {
    val validationError = ValidationError("error.expected.enum.name", t.values.mkString(", "))
    Reads.of[String].filter(validationError)(s ⇒ t.values.exists(v ⇒ v.toString == s)).map(t.withName(_))
  }

implicit def enumerationValueSetReads[T <: Enumeration](implicit t: T): Reads[t.ValueSet] =
    Reads.seq(enumerationReads[T]).map(seq ⇒ t.ValueSet(seq.asInstanceOf[Seq[t.Value]]: _*))

What can I do to get rid of the asInstanceOf on the last line? I tried typing the enumerationReads as enumerationReads[t.Value], but that doesn't work, the compiler complains in the argument of t.ValueSet that Seq[t.Value] cannot be cast to Seq[t.Value]. Yes, that didn't make sense to me too, until I started to realize these different t's might actually be different, since they are used in a closure.

So, what to do to make my code super-duper asInstanceOf free?

Answer 1

The following code might do the trick:

implicit def enumerationReads(t : Enumeration) : Reads[t.Value] = {
    val validationError = ValidationError("error.expected.enum.name", t.values.mkString(", "))
    Reads.of[String].filter(validationError)(s ⇒ t.values.exists(v ⇒ v.toString == s)).map(t.withName(_))
}

implicit def enumerationValueSetReads(t: Enumeration): Reads[t.ValueSet] =
    Reads.seq(enumerationReads(t : t.type)).map(set => t.ValueSet(set : _*))

or maybe more useful

implicit def enumerationValueSetReads(t: Enumeration): Reads[Set[t.Value]] =
    Reads.set(enumerationReads(t : t.type))

An enumeration is already an object (of class Enumeration ) so you can use it directly. You don't need to introduce a type T . To type your functions correctly the compiler has to check that types Value and ValueSet both belong to the correct instance of Enumeration (here t ). That's called path-dependent types .

In the following code

class T extends Enumeration

object Animals extends T {
    val Cow, Pig, Rabbit = Value
}

object Food extends T {
    val Rice, Potatoes, Fries = Value
}

Both Animals and Food are instances of T but the types T # Value , Animals.Value and Food.Value are different. T # Value represent any type Value of any instance of T whereas Animals.Value (respectively Food.Value ) is the type that belongs to Animals and Animals alone.

In the error "Seq[t.Value] cannot be cast to Seq[t.Value]", which i admit is very confusing, the two occurences of t are different instances. If you call enumerationReads[T] with type T , it considers its argument t to be any, unknown, instance of T . So you lose the track of the instance. That's why you have to call it with type t.type .