隐式排序 [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 }

我想知道 implicit def Option[T](implicit 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)
}

但是编译器不喜欢

未找到：键入 T def test[Option[T]: Ordering](value1: Option[T], value2: Option[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]] 时，将调用此函数来解决隐式问题。但我无法做到这一点....

编辑好吧，我写了以下更有意义的

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

I wonder when is implicit def Option[T](implicit ord: Ordering[T]): Ordering[Option[T]] useful or called.

隐式方法可用于从其他类型 class 实例中构造类型 class 实例，这可以节省样板文件

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

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

what's wrong with [Option[T]: Ordering]

关键是理解类型构造函数和正确类型之间的区别。例如 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 需要类型 class 实例 Ordering[F] 其中 F 是类型构造函数但是没有这样的类型 class 实例因为类型 [=58= 的定义] Ordering是

trait Ordering[T]

其中 T 是正确的类型。否则它会被定义为

trait Ordering[F[_]]

这种类型的一个例子 class 是 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

隐式排序 [Option[T]] 如何在 Scala 中工作？

How Implicit Ordering[Option[T]] works in scala?

scala

implicit