如何編寫一個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返回的結果是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) 

我有點修補了this answer from 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然後map，所以我改變了實現。這裏是您實現：

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

注this article提供類型構造模式的一些背景。