如何按scala中的顺序对Int进行参数化

我有一个参数化类型的类，我想对它执行比较运算符。我想我需要使用有序特征来实现这一点，但编译器不喜欢我使用它。假设我有以下课程：

class Test[T <: Ordered[T]] {

  def someOp(t: T) if(t < 3) ...
  ...
}

编译器抱怨如下：

val test = new Test[Int]()

类型参数[Test[Int]]与类测试的类型不一致

---

参数边界[T之所以出现这种情况，是因为

Int

不是

有序[Int]

的子类（请参见原因）

但是，有一个从

Int

到

RichInt

的隐式强制，它是

Ordered[Int]

的子类，但它不会触发下限。使用

可以将type类用作隐式参数。如果要编写一个通用max函数，它将如下所示：

def max[T](a:T, b:T)(implicit ordering:Ordering[T]) = { 
  if(ordering.gt(a,b)) a else b 
}

def max[T](a:T, b:T)(implicit ordering:Ordering[T]) = { 
  import ordering._; 
  if(a>b) a else b 
}

对于Int、Float等基本数据类型，作用域中有一个隐式排序[T]，因此您可以按预期使用它

max(1,2) // gives 2

对于实现有序[T]的所有类型，还存在一个隐式函数来提供有序[T]

作用域中还有各种方法可以组合排序。例如，如果您有一个N元组，其中每个元素都有一个排序[T]，则该元组类型自动存在一个排序

max((1,2), (3,4)) // gives (3,4) because 3 is larger than 1

但是，如果您对任何隐式提供的排序都不满意，您可以编写自己的排序，并显式传递它，甚至将其作为隐式val放入范围中。如下所示：

val negativeIntOrdering = new Ordering[Int] { 
  def compare(a:Int,b:Int) = b - a 
}

max(1,2)(negativeIntOrdering) // gives 1

因此，基于类型类的方法比基于继承的方法灵活得多。这就是为什么数学库喜欢广泛使用它

上面的代码有一点不太好，那就是您必须使用lt方法而不是运算符。但也有一个解决方案。Ordering有一个名为mkOrderingOps的隐式方法，它为T提供运算符。您只需通过导入Ordering将其放入作用域中即可。\u如下图所示：

def max[T](a:T, b:T)(implicit ordering:Ordering[T]) = { 
  if(ordering.gt(a,b)) a else b 
}

def max[T](a:T, b:T)(implicit ordering:Ordering[T]) = { 
  import ordering._; 
  if(a>b) a else b 
}

在这种情况下，使用
排序
而不是
排序
通常是一种更好的方法。查看scala 2.11中不推荐的边界，它似乎保存了我的b**t：我正要完全放弃
排序
/
排序
等等