0

我在 Scala 中声明了一个 Value 类：

sealed abstract class Value extends Expression with Ordered[Value] {
  type T <: Ordered[T]
  def value: T

  override def compare(that: Value): Int = { ... } 
}

类型约束 T <: Ordered[T] 的原因是我想将compareValue 中的方法委托给value: T.

然后是一个具体的 IntValue 为：

case class IntValue(value: Int) extends Value {
  type T = Int
  // ... 
}

但是，当我尝试编译此代码时，我得到以下信息：''

... incompatible type in overriding
[error] type T <: Ordered[IntValue.this.T] (defined in class Value);
[error]  found   : Int
[error]  required:  <: Ordered[IntValue.this.T]
[error]     (which expands to)   <: Ordered[Int]
[error]   type T = Int

我认为我应该在这里使用一些隐式转换，但我不清楚如何进行。

4

1 回答 1

3

该错误与覆盖中的不兼容类型有关，而不是与隐式有关。

您应该删除上限type T <: Ordered[T]。

Int不扩展Ordered。

尝试类型参数而不是类型成员

sealed abstract class Value[T] extends /*Expression with*/ Ordered[Value[T]] {
  def value: T
  override def compare(that: Value[T]): Int
}

case class IntValue(value: Int) extends Value[Int] {
  override def compare(that: Value[Int]): Int = value.compare(that.value)
}

与类型成员类似的代码

sealed abstract class Value extends /*Expression with*/ Ordered[Value {type T = self.T}] { self =>
  type T
  def value: T   
  override def compare(that: Value {type T = self.T}): Int
}

case class IntValue(value: Int) extends Value {
  type T = Int  
  override def compare(that: Value {type T = Int}): Int = value.compare(that.value)
}

是不可能的，因为Error: illegal cyclic reference。

Scala：抽象类型与泛型

https://typelevel.org/blog/2015/07/13/type-members-parameters.html

https://www.youtube.com/watch?v=R8GksuRw3VI

https://tpolecat.github.io/2015/04/29/f-bounds.html

如果你想委托，那么你应该使用type class Ordering而不是 OOP trait Ordered。Int没有扩展Ordered，但有一个Orderingfor的实例Int

sealed abstract class Value[T] {
  def value: T
}

case class IntValue(value: Int) extends Value[Int]

implicit def valueOrdering[T, A](implicit 
  ev: A <:< Value[T], 
  ordering: Ordering[T]
): Ordering[A] = ordering.on(_.value)

import Ordering.Implicits._
IntValue(1) < IntValue(2) // -1

或者

import Ordered._
IntValue(1) < IntValue(2) // true
IntValue(1).compare(IntValue(2)) // -1

类型类的方法可用于类型成员

sealed abstract class Value {
  type T
  def value: T
}

case class IntValue(value: Int) extends Value {
  override type T = Int
}

implicit def valueOrdering[A <: Value](implicit 
  ordering: Ordering[A#T]
): Ordering[A] = ordering.on(_.value)

// implicit def valueOrdering[_T, A](implicit 
//   ev: A <:< Value { type T = _T }, 
//   ordering: Ordering[_T]
// ): Ordering[A] = ordering.on(_.value)
于 2021-08-18T15:11:50.973 回答