Scala 通用优先级队列中的协变和逆变类型
我试图在Scala中实现一个通用数据类型,该数据类型在类型Scala 通用优先级队列中的协变和逆变类型,scala,covariance,priority-queue,abstract-data-type,Scala,Covariance,Priority Queue,Abstract Data Type,我试图在Scala中实现一个通用数据类型,该数据类型在类型T上参数化,应该是Ordered[T]。具体来说,它是Sleator&Tarjan优先级队列的持久版本。在基于解释和Odersky Poon Venners中添加了大量复杂的类型参数声明之后,在测试/调试实际功能之前,我只发现了一个编译器错误 下面是我的代码的简化版本 abstract class SkewHeap[+T] { // merge two heaps def +[U >: T <% Ordered[U]]
T
上参数化,应该是Ordered[T]
。具体来说,它是Sleator&Tarjan优先级队列的持久版本。在基于解释和Odersky Poon Venners中添加了大量复杂的类型参数声明之后,在测试/调试实际功能之前,我只发现了一个编译器错误
下面是我的代码的简化版本
abstract class SkewHeap[+T] {
// merge two heaps
def +[U >: T <% Ordered[U]](x : SkewHeap[U]) : SkewHeap[U]
// remove least element, return new heap
def delMin[U >: T <% Ordered[U]] : SkewHeap[U]
def isEmpty : Boolean
def min : T
def left : SkewHeap[T]
def right : SkewHeap[T]
}
case object Leaf extends SkewHeap[Nothing] {
def +[U <% Ordered[U]](that : SkewHeap[U]) = that
def isEmpty = true
}
case class Node[+T](left : SkewHeap[T],
min : T,
right : SkewHeap[T]) extends SkewHeap[T] {
def +[U >: T <% Ordered[U]](that : SkewHeap[U]) : SkewHeap[U] =
that match {
case Leaf => this
case Node(l,y,r) => if (this.min < that.min)
Node(this.right + that, this.min, this.left)
else
Node(this + that.right, that.min, that.left)
}
def delMin[U >: T <% Ordered[U]] : SkewHeap[U] = left + right
def isEmpty = false
}
抽象类堆[+T]{
//合并两堆
def+[U>:T:T如果(this.min:找到了按顺序排列的[T]。
def delMin[U>:T而不是使用
但是所有这些都有一个很大的问题,这个问题是你可以得到一个不同的<代码>命令< /代码>实现,在每个上下文中,你使用视图绑定<代码> < P>其他建议,你可以考虑从有序切换到隐式参数排序[t]。,这更易于控制,并为您提供更大的灵活性
[编辑]
一个非常简单的例子:
class Foo[T](val t:T)(implicit val ord: Ordering[T]) {
def min(that:Foo[T]) = if (ord.compare(this.t, that.t) < 0) this else that
}
在此之后,您可以创建一个Foo[Bar]
(很抱歉,我的电脑坏了,我没有可用的IDE…没有,它绑定到U
scala>def+[U>:T:T](隐式证据$1:(U)=>有序[U])Int
。好的,我该怎么做?+1如果你能用例子给我一个很好的解释。我发现用Scala编程和用Scala编程在这些问题上都不是很清楚(但还没有从头到尾阅读)。我仍然无法实现你的建议。它抱怨“没有隐式参数匹配参数类型排序[无]
”和其他类型错误。
def delMin[U >: T](implicit ord: U => Ordered[U]): SkewHeap[U] = left + right
abstract class SkewHeap[+T <% Ordered[T]] {
// merge two heaps
def +[U >: T <% Ordered[U]](x : SkewHeap[U]) : SkewHeap[U]
// remove least element, return new heap
def delMin : SkewHeap[T]
def isEmpty : Boolean
def min : T
def left : SkewHeap[T]
def right : SkewHeap[T]
}
case object Leaf extends SkewHeap[Nothing] {
def +[U <% Ordered[U]](that : SkewHeap[U]) = that
def isEmpty = true
def min = throw new RuntimeException
def left = throw new RuntimeException
def right = throw new RuntimeException
def delMin = throw new RuntimeException
}
case class Node[+T <% Ordered[T]](left : SkewHeap[T],
min : T,
right : SkewHeap[T]) extends SkewHeap[T] {
def +[U >: T <% Ordered[U]](that : SkewHeap[U]) : SkewHeap[U] =
that match {
case Leaf => this
case Node(l,y,r) => if ((this.min:Ordered[U]) < that.min)
Node(this.right + that, this.min, this.left)
else
Node(this + that.right, that.min, that.left)
}
def delMin : SkewHeap[T] = left + right
def isEmpty = false
}
class Foo[T](val t:T)(implicit val ord: Ordering[T]) {
def min(that:Foo[T]) = if (ord.compare(this.t, that.t) < 0) this else that
}
implicit object barOrdering extends Ordering[Bar] {...}