Scala排序、排序和视图绑定

我正在编写以下代码来说明这个问题：

def max[T <% Ordered[T]](a: T, b: T) = {
  val c = a.compare(b)
  if (c > 0) a else b
}

def min[T <% Ordering[T]](a: T, b: T) = {
    val ord = implicitly[Ordering[T]]
    val c = ord.compare(a, b)
    if (c > 0) b else a
}

println(s"max is ${max(10, 20)}")
implicit val intOrdering = new Ordering[Int] {
  override def compare(x: Int, y: Int): Int = x - y
}
println(s"min is ${min(10, 20)}")

def最大值[t0）a其他b
}
def最小值[T 0）b其他a
}
println（s“max是${max（10,20）}”）
隐式val intOrdering=新排序[Int]{
覆盖def比较（x:Int，y:Int）：Int=x-y
}
println（s“min是${min（10,20）}”）

max

方法工作得很好，而

min

方法工作得不好，抱怨

没有为t

定义隐式排序，即使我将

定义为排序

，它仍然抱怨

---

我会问为什么

Ordered

有效，但是

Ordering

在这里无效，即使我已经为

Ordering[Int]

Ordered

和

Ordering

提供了隐式定义。一个

Ordered[t]

是一个支持与其他

Ordered[t]进行比较的对象

s，而

排序[T]

是单个对象，它是一组能够比较普通

T

s的函数

这种差异反映在这里需要使用的两种类型的边界中。视图绑定在范围中的某个位置。此函数是隐式转换

intWrapper（Int）：RichInt

。这些

RichInt

通过比较方法直接支持它们之间的比较

---

但是，

defmin[T*

，导致创建类型为

Right[Left]

的隐式参数，在

max

方法中使用的

视图绑定实际上只是一条捷径：

def max[T](a: T, b: T)(implicit ord: T => Ordered[T]) = {
  val c = a.compare(b)
  if (c > 0) a else b
}

Ordering
要求您的
min
方法有一个隐式值（与
Ordered
的隐式函数相反），如下所示，因此
视图绑定
不适用：

def min[T](a: T, b: T)(implicit ord: Ordering[T]) = {
  val c = ord.compare(a, b)
  if (c > 0) b else a
}

以
上下文绑定的形式表达上述内容会产生以下结果：

def min[T: Ordering](a: T, b: T) = {
  val ord = implicitly[Ordering[T]]
  val c = ord.compare(a, b)
  if (c > 0) b else a
}