理解Scala隐式转换和泛型类型推理

Question

trait LowPriorityOrderingImplicits {
  implicit def ordered[A <: Ordered[A]]: Ordering[A] = new Ordering[A] {
    def compare(x: A, y: A) = x.compare(y)
  }
}

上面的代码是做什么的？

1. A<：有序的意思是？A怎么可能是Ordered[A]的子类型
2. "new Ordering[A]{…"究竟做什么？它是否为Ordering[A]创建了一个新的匿名类

此外，对于此代码(取自DataStax Cassandra连接器(，

        object TableWriter{
          def apply[T : RowWriterFactory](
          connector: CassandraConnector,
          keyspaceName: String,
          tableName: String,
          columnNames: ColumnSelector,
          writeConf: WriteConf): TableWriter[T] = {
            ...//some code
            val rowWriter = implicitly[RowWriterFactory[T]].rowWriter(tableDef, selectedColumns)
            new TableWriter[T](connector, tableDef, rowWriter, writeConf)
          }
        }
        val writer = TableWriter(connector, keyspaceName, tableName, columns, writeConf) // first call
        def saveToCassandra(keyspaceName: String,
                          tableName: String,
                          columns: ColumnSelector = AllColumns,
                          writeConf: WriteConf = WriteConf.fromSparkConf(sparkContext.getConf))
                         (implicit connector: CassandraConnector = CassandraConnector(sparkContext.getConf),
                          rwf: RowWriterFactory[T]): Unit = {
             val writer = TableWriter(connector, keyspaceName, tableName, columns, writeConf)// 2nd call
        }

1. T的类型是如何推断出来的
2. rwf隐式参数的目的是什么
3. 对TableWriter的第一次和第二次调用有什么区别

Answer 1

A<：有序的意思是？A怎么可能是Ordered[A]的子类型？

让我们看看Ordered:的定义

trait Ordered[A] extends Any with java.lang.Comparable[A] {
  def compare(that: A): Int
  /* ... */
}

如果我们说A <: Ordered[A]，那么我们指定A的实例与A的其他实例相当。为什么在给定的情况下这是必要的？好说我们有

implicit def ordered[B, A <: Ordered[B]]: Ordering[A] = new Ordering[A] {
  def compare(x: A, y: A) = x.compare(y)
}

此代码不会编译，因为Ordered[B]没有方法compare(x: A)(请注意，y的类型为A(。

"new Ordering[A]{…"到底做什么？它为Ordering[A]创建了一个新的匿名类吗？

是的，这是一个匿名类。

T的类型是如何推断出来的？

T: RowWriterFactory是上下文绑定的。另请参阅Scala文档中关于类型标记和清单的内容。

据我所知，

def foo[T: RowWriterFactory](x: Int) 

与写入相同

def foo[T](x: Int)(implicit evidence: RowWriterFactory[T])

rwf隐式参数的目的是什么？

这源于对上一个问题的回答：这是上下文限制。虽然我不知道这个例子的用法编辑由于TableWriter的apply-方法需要通过上下文绑定的RowWriterFactory，因此rfw的目的是用作TableWriter.apply的隐式参数。

对TableWriter的第一次和第二次调用有什么区别？

在不知道第一次通话的论据的情况下，它们是完全相同的，不是吗？