隐式排序[Option[T]]在scala中是如何工作的

Question

我玩了一点隐式解析，想了解这个隐式val有什么用处？订购时我们有

trait OptionOrdering[T] extends Ordering[Option[T]] {
def optionOrdering: Ordering[T]
def compare(x: Option[T], y: Option[T]) = (x, y) match {
case (None, None)       => 0
case (None, _)          => -1
case (_, None)          => 1
case (Some(x), Some(y)) => optionOrdering.compare(x, y)
}
}
implicit def Option[T](implicit ord: Ordering[T]): Ordering[Option[T]] =
new OptionOrdering[T] { val optionOrdering = ord }

我想知道什么时候隐式def Option[T](隐式ord:Ordering[T](：Ordering[Option[T]]有用或被调用。

我尝试了以下方法：

def test[Option[T]: Ordering](value1: Option[T], value2: Option[T]) = {
val e = implicitly(Ordering[Option[T]]).compare(value1, value2)
}

但是编译器不喜欢它。

未找到：类型Tdef-test[选项[T]：排序](值1:选项[T]，值2:选项[T](=｛

如果我这样做，那可能没有意义，但只是为了

def test[Option[Int]: Ordering](value1: Option[Int], value2: Option[Int]) = {
val e = implicitly(Ordering[Option[Int]]).compare(value1, value2)
}
I get 
type Option takes type parameters
def test[Option[Int]: Ordering](value1: Option[Int], value2: Option[Int]) = {
No implicit Ordering defined for Option[Int]

有人能举一个例子说明如何使用隐含的，或者它在哪里有用和实际使用吗？

我的假设是，当需要Ordering[Option[T]]时，会调用此函数来解决隐式问题。但我无法做到这一点。。。。

EDIT我写了以下更有意义的

def test(value1: Option[Int], value2: Option[Int]) = {
val e = implicitly(Ordering[Option[Int]]).compare(value1, value2)
}

然后我不明白的是的上下文绑定问题

def test[Option[T]: Ordering](value1: Option[T], value2: Option[T]) = {
val e = implicitly(Ordering[Option[T]]).compare(value1, value2)
}
What's wrong with writing a context bound like that ?

Answer 1

我想知道隐式def Option[T](隐式ord:Ordering[T](：Ordering[Option[T]]何时有用或被调用。

隐式方法可以用于从其他类型类实例中构造类型类实例，这可以保存样板

implicit def Option[T](implicit ord: Ordering[T]): Ordering[Option[T]] =
new OptionOrdering[T] { val optionOrdering = ord }

例如，给定类型类实例Ordering[Int]，上述隐式方法可以构造类型类实例Ordering[Option[Int]]。(不要忘记implicit参数，否则我们会得到不受欢迎的隐式转换(。

[Option[T]：订购]有什么问题

关键是要理解类型构造函数和正确类型之间的区别。例如，Option是一个可以构造正确类型Option[Int]的类型构造函数。定义中的类型参数子句[Option[T]: Ordering]

def test[Option[T]: Ordering](value1: Option[T], value2: Option[T])

实际上并没有指定Option类型构造函数。只是碰巧你给它起的名字是一样的，但你指定的实际上更像

def test[F[T]: Ordering](value1: F[T], value2: F[T])

此外，F[T]中的T实际上不能用于方法参数列表，因此实际上您的定义更像

def test[F[_]: Ordering](value1: F[T], value2: F[T])

现在错误应该更清楚了；F[_]: Ordering需要类型类实例Ordering[F]，其中F是类型构造函数，但是没有这样的类型类实例，因为类型类Ordering的定义是

trait Ordering[T]

其中CCD_ 14是适当的类型。否则，它将被定义为类似的东西

trait Ordering[F[_]]

这种类型类的一个例子是Functor

trait Functor[F[_]]

因此，要从语法上修复您的定义，请尝试类似的东西

def test[T](value1: Option[T], value2: Option[T])(implicit ev: Ordering[Option[T]]) = {
ev.compare(value1, value2)
}
test(Some(1), Some(42))
// res0: Int = -1
implicitly[Ordering[Option[Int]]].compare(Some(1), Some(42))
// res1: Int = -1

这里test(Some(1), Some(42))相当于

test[Int](Some(1), Some(42))(Option[Int])
|
implicit method call