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

问题描述

因此，我想创建一个添加可转换特征的模块，它是一个伴随对象，该对象在初始化时会对可转换对象列表执行某些操作。

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

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

让我们说另外两个无法更改文件“可转换”但可以访问该文件的编码器，其实现方式如下：

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

总有没有办法让初始模块随时随地识别其他模块的隐式转换？

解决方法

首先，请勿使用任何隐式转换。至少直到您完全确定这是绝对必要的。但实际上，在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
}

然后在其他具有自定义类型的模块的客户端代码中，可以为所需的类编写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 => ???
}}

它将被静态键入。您将拥有参数多态性的强大功能。您将能够抽象类型组，程序类型关系。 例如，如果您具有从string到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中，类型类将使用惯用的语法糖，因此使用起来更加简洁明了。