如何以一种面向未来的方式使用 Scala “拉皮条我的库”？

Question

我使用 Scala 隐式类来扩展我经常使用的对象。例如，我有一个类似于 Spark DataFrame 上定义的方法：

implicit class DataFrameExtensions(df: DataFrame) {
  def deduplicate: Boolean = 
    df.groupBy(df.columns.map(col): _*).count
}

但是如果类已经定义了相同的方法，则不会调用隐式定义。如果我稍后升级到定义了DataFrame#deduplicate 方法的新版本的 Spark，会发生什么？客户端代码将静默切换到新的实现，这可能会导致细微的错误（或明显的错误，问题较少）。

使用反射，如果 DataFrame 在我的隐式定义之前已经定义了 deduplicate，我可以抛出 runtime 错误。然后，理论上，如果我的隐式方法与现有方法冲突，我可以检测到它并重命名我的隐式版本。但是，一旦我升级 Spark、运行应用程序并检测到问题，使用 IDE 重命名旧方法为时已晚，因为任何对 df.deduplicate 的引用现在都指的是原生 Spark 版本。我必须恢复我的 Spark 版本，通过 IDE 重命名方法，然后再次升级。不是世界末日，但不是一个伟大的工作流程。

有没有更好的方法来处理这种情况？如何安全地使用“pimp my library”模式？

Answer 1

如果通过导入启用了扩展方法，则使用-Xlint 表示不再使用导入：

//class C
class C { def x = 17 }

trait T {
  import Extras._
  def f = new C().x
}

object Extras {
  implicit class X(val c: C) {
    def x = 42
  }
}

另一种观点，证据必须在-Xlint -Xfatal-warnings下使用：

//class C[A]
class C[A] { def x = 17 }

trait T {
  import Mine.ev
  val c = new C[Mine]
  def f = c.x
}

trait Mine
object Mine {
  implicit class X[A](val c: C[A]) {
    def x(implicit @deprecated("unused","") ev: Mine) = 42
  }
  implicit val ev: Mine = null
}

object Test {
  def main(args: Array[String]): Unit = println {
    val t = new T {}
    t.f
  }
}

Answer 2

安全地做到这一点的解决方案是显式请求扩展数据帧，为了尽量减少影响，您可以使用隐式来获得一个很好的转换语法（如 toJava/toScala 等）：

implicit class DataFrameExtSyntax(df: DataFrame) { 
 def toExtended: DataFrameExtensions = DataFrameExtensions(df)
}

然后您的调用将如下所示：

myDf.asExtended
  .deduplicate
  .someOtherExtensionMethod
  .andMore

这样您就可以在没有运行时检查/linting/单元测试技巧的情况下对扩展方法进行面向未来的验证 （你甚至可以使用myDf.ext 它myDf.toExtended 太长了:)

Answer 3

您可以将test that ensures that certain code snippets do not compile 添加到DataFrameExtension 的测试套件中。也许是这样的：

"(???: DataFrame).deduplicate" shouldNot compile

如果它在没有你的隐式转换的情况下编译，那么这意味着方法 deduplicate 已被 Spark 库引入。在这种情况下，测试失败了，你知道你必须更新你的隐式。