20

假设我有一个隐式转换：

implicit def aToB(a: A):B={
...
}

如何让这种隐式转换对 List 的元素起作用？

如果我有：

val listOfA: List[A] ...

我有一个接受 B 列表的函数，是否可以让 Scala 将所有元素从 A 隐式转换为 B？

如果没有隐式转换，转换可能如下所示：

lisftOfA.map(a => new B(a.someValue, a.anotherValue))

但我希望这会像“魔术”一样发生……这要求太多了。

4

4 回答 4

18

以下是您可能希望考虑的一些替代方案：

1.使用视图绑定

如果可以更改采用 B 列表的函数，这将是最简单的解决方案。修改它以接受可以转换为 Bs 的事物列表。那是，

def yourFn(l: List[B]) = ...

会成为

def yourFn[X <% B](l: List[X]) = ...

然后，您可以使用 listOfA 调用该函数：

yourFn(listOfA)

2.介绍一种转换方法

这类似于 Rogach 的第一个解决方案，只是外部转换是非隐式的：

def convert[B, A <% B](l: List[A]): List[B] = l map { a => a: B }

然后在你函数的调用点，你会写

yourFn(convert(listOfA))

像 Rogach 的第二个解决方案一样，这比引入隐式转换更安全。

3.引入隐式转换

这相当于 Rogach 的第一个解决方案，但表示法更好一些（IMO）。

implicit def convert[B, A <% B](l: List[A]): List[B] = l map { a => a: B }

如果此转换在您的调用站点范围内，您可以使用 listOfA 调用您的函数：

yourFn(listOfA)

离别的思念

考虑如何以一般方式解决这个问题很有趣。如果我想定义我的转换方法以便它可以处理实现该map方法的任何类型怎么办？IE，

def convert[B, A <% B, C[_]](c: C[A]): C[B] = c map { a => a: B }

当然，这是行不通的，因为签名中没有任何内容表示C必须实现的约束map。据我所知，表达这个约束是相当复杂的，不能以一种为任何实现map. 请参阅类型安全的 Scala 序列推导。

于 2012-09-16T23:23:47.937 回答
4

以下是一个通用解决方案，如果隐式转换 A=>B 在范围内可用，则启用列表的隐式转换 (List[A] => List[B])：

scala> class A
defined class A

scala> class B
defined class B

scala> implicit def a2b(a:A) = new B
a2b: (a: A)B

scala> implicit def mapI[A,B](l: List[A])(implicit conv: A => B): List[B] = l.map(conv)
mapI: [A, B](l: List[A])(implicit conv: (A) => B)List[B]

scala> List(new A): List[B]
res0: List[B] = List(B@efa0bf4)

这是你需要的吗？

此外，由于您已经进行了隐式转换，因此您可以编写：

listOfA.map(a2b) // List[B]

它会更冗长一些，但可以让您更明确地控制代码。

于 2012-09-16T15:15:07.850 回答
3

我认为最好的可能是

implicit def asToBs(as: List[A]): List[B] = as map aToB
于 2012-09-16T15:16:52.080 回答
1

为了完整起见，您可能希望考虑一种更通用的方法，使用CanBuildFrom.

这个程序：

import scala.collection.generic.CanBuildFrom
import scala.language.{higherKinds, implicitConversions}

implicit def implyConvertedTraversable[A, B, C[X] <: Traversable[X]](as: C[A])(implicit conversion: A => B, cbf: CanBuildFrom[C[A], B, C[B]]): C[B] = {
  val builder = cbf(as)
  builder.sizeHint(as)
  builder ++= as.map(conversion)
  builder.result()
}

implicit def implyString(a: Int): String = a.toString

val intList = List(1, 2, 3)
val intStream = Stream(1, 2, 3)

val stringList: List[String] = intList
val stringStream: Stream[String] = intStream

产量：

intList: List[Int] = List(1, 2, 3)
intStream: scala.collection.immutable.Stream[Int] = Stream(1, ?)

stringList: List[String] = List(1, 2, 3)
stringStream: Stream[String] = Stream(1, ?)
于 2016-06-22T22:21:26.537 回答