有没有办法让外部模块添加可以在内部模块中使用的隐含项

Question

所以我想创建一个模块，它添加了一个特性Convertible和它的伴随对象，该对象在初始化时使用Convertible列表做一些事情。

trait Convertible {
def toInt: Int
def toBoolean: Boolean
def toFloat: Float
}
object Convertible {
val objects = List(1, 2, "", 4, 44.4f, "Hello World!", 42)

def init(): Unit = {
for(obj <- objects) {
obj match {
case con: Convertible => ImportantStuff.doStuff(con.toInt, con.toBoolean, con.toFloat)
case _ =>
}
}
}
}

现在的问题是：我可以让其他人的模块从这个模块之外的某些类型声明隐式声明吗？

让我们说2个不能改变文件的其他编码器"；可转换的"；但是可以访问它实现这样的东西：

object SomeGuysModule {
implicit class ConvertibleString(val string: String) extends Convertible {
def toInt = string.length
def toBoolean = string.isEmpty
def toFloat = string.length / 1024
}
}
object AnotherGuysModule {
implicit class ConvertibleInt(val int: Int) extends Convertible {
def toInt = int
def toBoolean = int != 0
def toFloat = int + int / 10F
}
}

有没有办法让初始模块在运行中识别附加模块的隐式转换？

Answer 1

首先，不使用任何隐式转换。至少在你完全确定这是绝对必要的之前。但在实践中，99.99%的任务并非如此。

您想要做的是在scala中有一个惯用的解决方案，它是类型类模式。我建议你在斯卡拉和猫一起读这篇文章。

所以在你的情况下，你可以写

trait Convertible[A] {
def toInt(a: A): Int
def toBoolean(a: A): Boolean
def toFloat(a: A): Float
}

或者你也可以从第二种类型中提取

trait Convertible[A, B] {
def convert(a: A): B
}

然后，在其他具有自定义类型的模块中的客户端代码中，可以为所需的类编写typeclass实例。

object AnotherGuysModule {
type AnotherModuleDataType = Int // there can be any type that you want
objec AnotherModuleDataType {
implicit val andtToIntInstance:     Convertable[AnotherModuleDataType, Int]     = ??? // implementation AnotherModuleDataType to Int
implicit val andtToFloatInstance:   Convertable[AnotherModuleDataType, Float]   = ??? // implementation AnotherModuleDataType to Float
implicit val andtToBooleanInstance: Convertable[AnotherModuleDataType, Boolean] = ??? // implementation AnotherModuleDataType to Int
}
}

在通用代码中，你可以像这样使用它：

def init(): Unit = 
objects.foreach {
case someInt: Int => 
val toFloat: Float = implicitly[Convertable[Int, Float]].convert(someInt)
case someBiInteger: BigInteger => 
val toFloat: Float = implicitly[Convertable[BigInteger, Float]].convert(someBiInteger)
case etc => ???
}}

它将是静态类型的。你将拥有参数多态性的力量你将能够在类型组、程序类型关系上进行抽象。例如，如果您有一个从字符串到int的转换，以及从int到boolean的转换，那么您会自动地有一个由字符串到boolean的转换。你只需要用一个常见的函数来写这个关系：

implicit def chain[A, B, C](a: A)(implicit aToB: Convertible[A,B], bToC: Convertible[B,C]): Convertible[A, C]  = {
val b = aToB.convert(a)
bToC.convert(b)
}

您可以编写许多实用程序函数，以消除客户端和库代码中的样板文件。怎么做？同样，你可以在Scala中用猫来阅读它。

之后，它将看起来像

import your.lib.Convertable.syntax._
def init(): Unit = 
objects.foreach {
case someInt: Int => 
val toFloat: Float = convert(someInt)
case someBiInteger: BigInteger => 
val toFloat: Float = convert(someBiInteger)
case etc => ???
}

附言：在Scala3中，类型类将有惯用的语法糖，因此它在使用中会更加简洁明了。