对同一类型使用不同的隐式值答案

【问题标题】：Use different implicit values for same type对同一类型使用不同的隐式值
【发布时间】：2017-09-27 20:11:26
【问题描述】：

我需要通过使用implicitly 来调用带有隐式Ordering 参数的库的排序方法，如下所示：

class OrderedRDDFunctions[K : Ordering : ClassTag,
                          V: ClassTag] (self: RDD[P]) {

  private val ordering = implicitly[Ordering[K]]

  def sort() = {
    // uses ordering value
  }
}

现在，我需要在一个循环中调用这个函数两次，使用不同的Orderings，如下所示。

var A: RDD[(Int, Int, Int)] = ...
var C: RDD[(Int, Int, Int)] = ...

while(...) {

    implicit val ijOrdering:Ordering[(Int, Int, Int)] = new Ordering[(Int, Int, Int)] {
      override def compare(a: (Int, Int, Int), b: (Int, Int, Int)) = {
        val c = a._1.compare(b._1)
        if(c != 0) c
        else a._2.compare(b._2)
      }
    }
    A.sort() // should use ijOrdering above

    implicit val kjOrdering:Ordering[(Int, Int, Int)] = new Ordering[(Int, Int, Int)] {
      override def compare(a: (Int, Int, Int), b: (Int, Int, Int)) = {
        val c = a._3.compare(b._3)
        if(c != 0) c
        else a._2.compare(b._2)
      }
    }
    C.sort() // should use kjOrdering above

}

在 sort() 方法中有两个不同的隐式 Ordering 实例。但这给了我一个编译错误。如何在此设置中声明不同的隐式排序？请注意，我无法更改库方法。

【问题讨论】：

标签： scala apache-spark

【解决方案1】：

您可以使用块来限制隐式的范围。一个简单的例子：

object Blocks extends App {
  def meth()(implicit e: Int) = e * 2

  locally {
    implicit val k = 21
    println(meth()) // finds k and prints 42
  }

  locally {
    implicit val j = 11
    println(meth()) // finds j and prints 22
  }
}

如果块外存在冲突的隐式，这将不起作用。

请注意，locally { ..stmts.. } 通常等同于{ ..stmts.. }，但为了便于阅读，我更喜欢它。你可以阅读更多关于那是什么here

【讨论】：