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

我想知道什么时候隐式 def Option[T](implicit 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]: 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])

此外， T在F[T]实际上不能在方法的参数列表中使用，所以实际上你的定义更像是如此

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

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

trait Ordering[T]

其中T是一个适当的类型。 否则它会被定义为

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