如何编写一个 zipWith 方法，该方法返回与传递给它的集合类型相同的集合？

Question

我已经到达这里了：

implicit def collectionExtras[A](xs: Iterable[A]) = new {
  def zipWith[B, C, That](ys: Iterable[B])(f: (A, B) => C)(implicit cbf: CanBuildFrom[Iterable[A], C, That]) = {
    val builder = cbf(xs.repr)
    val (i, j) = (xs.iterator, ys.iterator)
    while(i.hasNext && j.hasNext) {
      builder += f(i.next, j.next)
    }
    builder.result
  }
}
// collectionExtras: [A](xs: Iterable[A])java.lang.Object{def zipWith[B,C,That](ys: Iterable[B])(f: (A, B) => C)(implicit cbf: scala.collection.generic.CanBuildFrom[Iterable[A],C,That]): That}

Vector(2, 2, 2).zipWith(Vector(4, 4, 4))(_ * _)
// res3: Iterable[Int] = Vector(8, 8, 8)

现在的问题是上面的方法总是返回一个Iterable。如何让它返回传递给它的类型集合？ （在本例中为Vector）谢谢。

Answer 1

你已经足够接近了。只需两行的小改动：

implicit def collectionExtras[A, CC[A] <: IterableLike[A, CC[A]]](xs: CC[A]) = new {
  def zipWith[B, C, That](ys: Iterable[B])(f: (A, B) => C)(implicit cbf: CanBuildFrom[CC[A], C, That]) = {
    val builder = cbf(xs.repr)
    val (i, j) = (xs.iterator, ys.iterator)
    while(i.hasNext && j.hasNext) {
      builder += f(i.next, j.next)
    }
    builder.result
  }
}

首先，您需要获取传递的集合类型，因此我添加了 CC[A] 作为类型参数。此外，该集合需要能够“复制”自身——这是由 IterableLike 的第二个类型参数保证的——所以 CC[A] <: IterableLike[A, CC [A]]。请注意，IterableLike 的第二个参数是 Repr，正是 xs.repr 的类型。

当然，CanBuildFrom 需要接收 CC[A] 而不是 Iterable[A]。这就是全部内容。

结果：

scala> Vector(2, 2, 2).zipWith(Vector(4, 4, 4))(_ * _)
res0: scala.collection.immutable.Vector[Int] = Vector(8, 8, 8)

Answer 2

上面的问题是你的隐式转换collectionExtras导致获取的对象丢失类型信息。特别是，在上面的解决方案中，具体的集合类型丢失了，因为您向它传递了 Iterable[A] 类型的对象 - 从这一点开始，编译器不再知道的真实类型xs。尽管构建器工厂 CanBuildFrom 以编程方式确保集合的动态类型是正确的（您确实获得了 Vector），但静态地，编译器只知道 zipWith< /code> 返回一个 Iterable 的东西。

为了解决这个问题，不要让隐式转换采用 Iterable[A]，而是让它采用 IterableLike[A, Repr]。为什么？

Iterable[A] 通常声明为：

Iterable[A] extends IterableLike[A, Iterable[A]]

与 Iterable 的区别在于，这个 IterableLike[A, Repr] 保留了具体的集合类型作为Repr。大多数具体集合，除了混合 Iterable[A] 之外，还混合了 IterableLike[A, Repr] 特征，替换 Repr 他们可以这样做，

Vector[A] extends Iterable[A] with IterableLike[A, Vector[A]]

因为类型参数 Repr 被声明为协变。

长话短说，使用 IterableLike 会导致隐式转换以保留具体的集合类型信息（即 Repr），并在定义 zipWith 时使用它> - 请注意，构建器工厂 CanBuildFrom 现在将包含 Repr 而不是 Iterable[A] 作为第一个类型参数，从而导致相应的隐式对象待解决：

import collection._
import collection.generic._

implicit def collectionExtras[A, Repr](xs: IterableLike[A, Repr]) = new {
  def zipWith[B, C, That](ys: Iterable[B])(f: (A, B) => C)(implicit cbf: CanBuildFrom[Repr, C, That]) = {
    val builder = cbf(xs.repr)
    val (i, j) = (xs.iterator, ys.iterator)
    while(i.hasNext && j.hasNext) {
      builder += f(i.next, j.next)
    }
    builder.result
  }
}

更仔细地阅读您的问题表述（“如何编写一个 zipWith 方法，该方法返回与传递给它的集合类型相同的集合？”），在我看来，您希望拥有与那些相同类型的集合传递给zipWith，而不是隐式转换，它与ys类型相同。

原因与之前相同，请参阅下面的解决方案：

import collection._
import collection.generic._

implicit def collectionExtras[A](xs: Iterable[A]) = new {
  def zipWith[B, C, That, Repr](ys: IterableLike[B, Repr])(f: (A, B) => C)(implicit cbf: CanBuildFrom[Repr, C, That]) = {
    val builder = cbf(ys.repr)
    val (i, j) = (xs.iterator, ys.iterator)
    while(i.hasNext && j.hasNext) {
      builder += f(i.next, j.next)
    }
    builder.result
  }
}

结果：

scala> immutable.Vector(2, 2, 2).zipWith(mutable.ArrayBuffer(4, 4, 4))(_ * _)
res1: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(8, 8, 8)

Answer 3

老实说，我不确定这到底是如何工作的：

implicit def collectionExtras[CC[X] <: Iterable[X], A](xs: CC[A]) = new {
  import collection.generic.CanBuildFrom
  def zipWith[B, C](ys: Iterable[B])(f: (A, B) => C)
  (implicit cbf:CanBuildFrom[Nothing, C, CC[C]]): CC[C] = {
    xs.zip(ys).map(f.tupled)(collection.breakOut)
  }
}

scala> Vector(2, 2, 2).zipWith(Vector(4, 4, 4))(_ * _)
res1: scala.collection.immutable.Vector[Int] = Vector(8, 8, 8)

我有点猴子修补 这个答案来自 Retronym 直到它起作用！

基本上，我想使用 CC[X] 类型构造函数来指示 zipWith 应返回 xs 的集合类型，但使用 C 作为类型参数 (CC[C])。我想使用 breakOut 来获得正确的结果类型。我有点希望作用域中有一个隐式的 CanBuildFrom ，但随后收到了此错误消息：

required: scala.collection.generic.CanBuildFrom[Iterable[(A, B)],C,CC[C]]

技巧是使用 Nothing 而不是 Iterable[(A, B）]。我猜隐式是在某处定义的...

另外，我喜欢将您的 zipWith 视为 zip ，然后是地图，所以我更改了执行。这是您的实现：

implicit def collectionExtras[CC[X] <: Iterable[X], A](xs: CC[A]) = new {
  import collection.generic.CanBuildFrom
  def zipWith[B, C](ys: Iterable[B])(f: (A, B) => C)
  (implicit cbf:CanBuildFrom[Nothing, C, CC[C]]) : CC[C] = {
    val builder = cbf()
    val (i, j) = (xs.iterator, ys.iterator)
    while(i.hasNext && j.hasNext) {
      builder += f(i.next, j.next)
    }
    builder.result
  }
}

注意本文提供了有关类型构造函数模式的一些背景知识。