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)
}

但是编译器不喜欢它。

找不到

：输入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]（隐式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])

此外，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

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

1 个答案: