scala - 在函数参数级别实现 Ad hoc 多态性(混合不同类型的参数)

Question

当我在 Scala 中有一个函数时:

def toString[T: Show](xs: T*): String = paths.map(_.show).mkString

以及范围内的以下类型类实例:

implicit val showA: Show[MyTypeA]
implicit val showB: Show[MyTypeB]

我可以使用函数 toString通过以下方式:

val a1: MyTypeA
val a2: MyTypeA
val stringA = toString(a1, a2)

val b1: MyTypeB
val b2: MyTypeB
val stringB = toString(b1, b2)

但我不能调用 toString MyTypeA 类型的混合参数和 MyTypeB :

// doesn't compile, T is inferred to be of type Any
toString(a1, b1)

是否可以重新定义 toString这样就可以混合不同类型的参数(但只有 Show 类型类可用)？
请注意，我知道 cat show interpolator 可以解决此特定示例，但我正在寻找一种也可以应用于不同情况的解决方案(例如 toNumber )。
我也知道通过调用 .show 来规避问题。在将参数传递给 toString 之前函数，但我正在寻找一种方法来避免这种情况，因为它会导致代码重复。

Answer 1

无形示例:

object myToString extends ProductArgs { //ProductArgs allows changing variable number of arguments to HList

    //polymorphic function to iterate over values of HList and change to a string using Show instances
    object showMapper extends Poly1 {

      implicit def caseShow[V](implicit show: Show[V]): Case.Aux[V, String] = {
        at[V](v => show.show(v))
      }

    }

    def applyProduct[ARepr <: HList](
        l: ARepr
    )(
        implicit mapper: Mapper[showMapper.type, ARepr]
    ): String = l.map(showMapper).mkString("", "", "")
}

现在让我们测试一下:

case class Test1(value: String)
case class Test2(value: String)
case class Test3(value: String)

implicit val show1: Show[Test1] = Show.show(_.value)
implicit val show2: Show[Test2] = Show.show(_.value)

println(myToString(Test1("a"), Test2("b"))) //"ab"

println(myToString(Test1("a"), Test2("b"), Test3("c"))) //won't compile since there's no instance of Show for Test3

顺便说一句，我认为 toString不是最好的名字，因为它可能会导致与 toString 的奇怪冲突来自 java.lang.Object .

如果您不想弄乱无形的，我想到的另一个解决方案是创建具有不同数量的函数:

def toString[A: Show](a: A): String = ???
def toString[A: Show, B: Show](a: A, b: B): String = ???
//etc

这肯定很麻烦，但它可能是解决问题的最简单方法。