有没有办法让外部模块添加可以在内部模块中使用的隐式？答案

【问题标题】：Is there a way to let external modules add implicits that can be used in an internal module?有没有办法让外部模块添加可以在内部模块中使用的隐式？
【发布时间】：2020-12-04 21:43:04
【问题描述】：

所以我想创建一个模块，添加一个特征 Convertible，它是一个伴随对象，在初始化时对 Convertibles 列表做一些事情。

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 个不能更改文件“Convertible”但可以访问它的编码器实现了这样的事情：

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

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

【问题讨论】：

你想要一个typeclass + magnet pattern。
你的前提有问题。 objects 是 List[Any] 类型。它的所有元素都不会通过Convertible 测试。

标签： scala implicit-conversion implicit

【解决方案1】：

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

您想要在 scala 中有一个惯用的解决方案 - 它是 typeclass 模式。我建议你在Scala with cats 阅读它。

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

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
}

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

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 的转换，你会自动地从 string 到 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 with cats 中了解它。

之后会是这样的

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 => ???
  }

PS：在 Scala 3 中，类型类将具有惯用的语法糖，因此使用起来会更加简洁明了。

【讨论】：