为什么我不能在没有丑陋的匿名类的情况下在Scala中实现这个Java接口

Question

I have the following interface in Java

public interface IProperty<T extends Comparable<T>> {
    String getName();

    Collection<T> getAllowedValues();

    Class<T> getValueClass();

    String getName(T value);
}

And trying to implement it in scala, but can't get it to work

---

First attempt:

class EnumerationProperty1[T <: Enumeration](val enum: T, val name: String) extends IProperty[enum.Value] {
  override def getName = name
  override def getValueClass = classOf[enum.Value]
  override def getName(value: enum.Value): String = value.toString
  override def getAllowedValues: java.util.Collection[enum.Value] = enum.values.toList
}

Doesn't compile with Error: not found: value enum

---

Second attempt:

class EnumerationProperty2[T <: Enumeration](val enum: T, val name: String) extends IProperty[T#Value] {
  override def getName = name
  override def getValueClass = classOf[T#Value]
  override def getName(value: T#Value): String = value.toString
  override def getAllowedValues: java.util.Collection[T#Value] = enum.values.toList
}

Doesn't compile with Error: type arguments [T#Value] do not conform to trait IProperty's type parameter bounds [T <: Comparable[T]]

---

Finally i figured out a way to do it but it looks pretty ugly to me:

object EnumerationPropertyAnonymous {
  def create[T <: Enumeration](enum: T, name: String) = {
    new IProperty[enum.Value] {
      override def getName = name
      override def getValueClass = classOf[enum.Value]
      override def getName(value: enum.Value): String = value.toString
      override def getAllowedValues: java.util.Collection[enum.Value] = enum.values.toList
    }
  }
}

---

Questions:

1. What is the right way to do this?
2. Why enum.Value doesn't work in my first attempt, but does work when used in an anonymous class?
3. Why enum.Value and T#Value aren't the same?
4. Why does the compiler complain about T#Value not matching Comparable[T], since Value extends Ordered[Value] which extends Comparable[Value]?

Answer 1

Ah, the joys of working with path dependent types ...

Enumeration#Value is a path dependent type. That is the actual type of Value depends on the current instance of the implementation of Enumeration .

Thus if you have two Enumerations like

object A extends Enumeration {
  val first = Value(0, "first")
}

object B extends Enumeration {
  val first = Value(0, "first")
}

the following conditions return false .

A.first == B.first
A.first.isInstanceOf[B.first.type]

but this is true

A.first.isInstanceOf[Enumeration#Value]

For more about path dependent types, refer to this article

To the questions:

@1) that depends on what you are trying to accomplish. A quick way to do it would be with a factory. Somewhat similar to your 'anonymous' example, but a bit more scala-ish:

// it is recommended to use converters instead of conversions.
import scala.collection.JavaConverters._

case class EnumPropertyFactory[T <: Enumeration](val enum: T) {
  def apply(name: String) = new EnumerationProperty(name)

  class EnumerationProperty(val name: String) extends IProperty[enum.Value] {
    override def getName = name
    override def getValueClass = classOf[enum.Value]
    override def getName(value: enum.Value): String = value.toString
    override def getAllowedValues: java.util.Collection[enum.Value] = enum.values.toList.asJavaCollection
  }
}

// can be used with something like
val enum1PropertyFactory = EnumPropertyFactory(EnumOne)
val foo = enum1PropertyFactory("foo")
val bar = enum1PropertyFactory("bar")

@2) Because in the first example enum is a constructor parameter and in the second example it's a local val . Remember what the class definition would look like in java:

class EnumerationProperty1<T extends Enumeration> extends IProperty<enum.Value> {
    public EnumerationProperty1(T enum, String name) { ... }
}

Here it is clear, why enum cannot be known before the constructor has been called.

@3) see above: path dependent types

@4) I'm afraid, that is a bit above me. But I'd bet some that it has to do with Enumeration#Value being path dependent and the voodoo done with # ;)