Question

我有一系列实例，其中每个实例都可以隐式转换为相同的类型。转换这种序列的最佳方法是什么？

  class A
  class B

  trait Resolver {
    def resolve: String
  }

  implicit class AResolver(a: A) extends Resolver {
    def resolve: String = "a"
  }
  implicit class BResolver(b: B) extends Resolver {
    def resolve: String = "b"
  }

  def resolveThem(a: Option[A], b: Option[B]): Iterable[String] = {
    val resolvers: Seq[Resolver] = a ++ b // type error
    val resolvers: Seq[Resolver] = List(a, b).collect{case Some(x: Resolver) => x} // empty
    val resolvers: Seq[Resolver] = List(a, b).collect{case Some(x: A) => x} // unexpectedly for me but it is also type error when there is an x:A
    val resolvers: Seq[Resolver] = List(a, b).collect{case Some(x: A) => x:Resolver} // works but returns only A as resolver
    val resolvers: Seq[Resolver] = List(a, b).collect{case Some(x /*something that can be implicitly converted to Resolver*/) => x:Resolver} // Is it possible?
    val resolvers: Seq[Resolver] = List(a.get, b.get) // this bad approach works
    resolvers.map(_.resolve) // this is what I want as result
    a.map(_.resolve) ++ b.map(_.resolve) // there is another way but if I have more arguments it becomes too long
  }

Answer 1

只有在编译器可以使用确切类型时才能使用implicits。只要将对象放入简单的List中，它们的各个类型就会消失。（你可以使用HList。）
对于两个参数，您只需使用您的工作方法。

对于更多参数，您可能希望拥有一个带有一个参数的构建器。

trait Builder {
  def add[A: Resolver](a: A): Builder = {
    use(a.resolve)
    this
  }
}

如果只有几个类，则可以使用运行时匹配：

def getResolver(any: Any): Resolver = any match {
  case a: A => a: Resolver
  case b: B => b: Resolver
  case _ => throw new IllegalArgumentException(s"$any is not supported"
}

然而，这种方法非常糟糕。它不可扩展。

您也可以使用类型类而不是隐式转换。

  trait Resolvable[T] {
    def resolve(a: T): String
  }
  implicit class AResolvable extends Resolvable[A] {
    def resolve(a: A): String = "a"
  }

我猜这是首选方式。

Answer 2

方法collect接受PartialFunction[A, B]，这意味着函数仅在可能的输入参数A的子集上定义，并且不会应用隐式转换。

转换应明确或事先进行。为您的案例执行此操作的一种方法是采用varargs或序列的方法：

def resolveThem (resolvers: Option[Resolver]*): Iterable[String] = {
  resolvers.flatten.map(_.resolve)
}

resolveThem(Option(new A), Option(new B))

序列中的隐式转换

2 个答案: