如何为Scala中的任何Traversable实现通用算法？

Question

我正在实现一个通用算法来返回基于另外两个集合的集合。 问题可以简化为

def add[Repr <: Traversable[_]](coll1: Repr, coll2: Repr) = coll1 ++ coll2

当我将算法应用于我定义为的集合A时，会出现问题

class A[T] extends Iterable[(Int,T)] with IterableLike[(Int,T), A[T]] { ... }

即，A的类型参数与继承的Iterable的类型参数不同。 Map使用类似的方法。

地图示例：

scala> val m1 = Map("a" -> 1, "b" -> 1, "c" -> 1)
m1: scala.collection.immutable.Map[java.lang.String,Int] = Map(a -> 1, b -> 1, c -> 1)

scala> val m2 = Map("a" -> 2, "c" -> 1)
m2: scala.collection.immutable.Map[java.lang.String,Int] = Map(a -> 2, c -> 1)

将m1和m2作为参数应用add会导致List：

scala> add(m1,m2)
res3: Traversable[Any] = List((a,1), (b,1), (c,1), (a,2), (c,1))

...虽然想要的结果类似于直接使用++方法：

scala> m1 ++ m2
res0: scala.collection.immutable.Map[java.lang.String,Int] = Map(a -> 2, b -> 1, c -> 1)

使用定义为的集合B不会发生此问题：

class B[T] extends Iterable[T] with IterableLike[T, B[T]] { ... }

例如，队列以类似的方式实现。

队列示例：

scala> val q1 = Queue(9,2,5)
q1: scala.collection.immutable.Queue[Int] = Queue(9, 2, 5)

scala> val q2 = Queue(7,3,1)
q2: scala.collection.immutable.Queue[Int] = Queue(7, 3, 1)

在q1和q2上应用add会得到想要的结果：

scala> add(q1,q2)
res4: Traversable[Any] = Queue(9, 2, 5, 7, 3, 1)

问题：有没有办法实现添加，这样结果将与直接使用++方法时的结果相同，适用于各种可追溯的（包括类似于Map实现的集合）？ 我一直在尝试在A类的伴随对象中实现隐式CanBuildFrom，但没有运气。 在我看来，问题在于算法，而不是集合实现，因为它也不适用于Map。

Answer 1

鉴于add只不过是TraversableLike.++的别名，第一步是看看++的签名：

trait TraversableLike[+A, +Repr] extends ... {
  ...
  def ++:[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
  ...
}

然后，您所要做的就是将this转换为第一个参数，并将that转换为第二个参数：

import collection.TraversableLike
import collection.generic.CanBuildFrom
def add[A, Repr, B >: A, That](coll1: TraversableLike[A, Repr], coll2: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
  coll1 ++ coll2
}

---

更新 ：我还调查了你需要做些什么才能让A在add方面表现得正常。 因为它代表（没有做任何特殊的事情），在A实例上添加应用返回Iterable而不是A ：

import collection.{IterableLike, TraversableLike}
// Dummy `A` implementation, for illustration
class A[T]( val inner: Seq[(Int, T)] ) extends Iterable[(Int,T)] with IterableLike[(Int,T), A[T]] {
  def iterator: Iterator[(Int, T)] = inner.iterator
  override protected[this] def newBuilder: scala.collection.mutable.Builder[(Int, T),A[T]] = ???
  def :+(elem: (Int, T) ): A[T] = new A[T]( inner :+ elem )
}
object A  {
  def apply[T]( elems: (Int, T)* ) = new A( elems )
}
val a1 = A( 1-> "one", 2 -> "two" )
val a2 = A( 3-> "three", 4 -> "four", 5 -> "five" )
add(a1, a2)

结果是：

res0: Iterable[(Int, String)] = List((1,one), (2,two), (3,three), (4,four), (5,five))

这是我与CanBuildFrom 。 我不能保证这是最好的例子，但它确实有效（我的意思是我们在调用add时得到A结果）：

import collection.IterableLike
import collection.generic.CanBuildFrom
import collection.mutable.Builder

class A[T]( val inner: Seq[(Int, T)] ) extends Iterable[(Int,T)] with IterableLike[(Int,T), A[T]] {
  def iterator: Iterator[(Int, T)] = inner.iterator
  override protected[this] def newBuilder: scala.collection.mutable.Builder[(Int, T),A[T]] = new A.ABuilder[T]
  def :+(elem: (Int, T) ): A[T] = new A[T]( inner :+ elem )
}
object A  {
  private val _empty = new A[Nothing]( Nil )
  def empty[T]: A[T] = _empty.asInstanceOf[A[T]]
  def apply[T]( elems: (Int, T)* ) = new A( elems )

  class ABuilder[T] extends Builder[(Int,T), A[T]] {
    protected var elems: A[T] = empty
    def +=(x: (Int, T)): this.type = { elems = elems :+ x; this }
    def clear() { elems = empty }
    def result: A[T] = elems
  }

  implicit def canBuildFrom[T]: CanBuildFrom[A[_], (Int,T), A[T]] = new CanBuildFrom[A[_], (Int,T), A[T]] {
    def apply(from: A[_]) = apply()
    def apply() = new ABuilder[T]
  }
}

结果是：

res0: A[String] = ((1,one), (2,two), (3,three), (4,four), (5,five))