Scala 如何使用我自己的通用映射来丰富TraversableOnce？_Scala

Scala 如何使用我自己的通用映射来丰富TraversableOnce？

scala

Scala 如何使用我自己的通用映射来丰富TraversableOnce？,scala,Scala,我试图丰富所有TraversableOnce[String]对象，但我无法找到构建迭代器的正确语法。这就是我到目前为止所做的： class Exclaimer[R <: TraversableOnce[String]](val lines:R) { import scala.collection.generic.CanBuildFrom def exclaim(implicit bf:CanBuildFrom[R,String,R]):R = { val b = bf(li

我试图丰富所有TraversableOnce[String]对象，但我无法找到构建迭代器的正确语法。这就是我到目前为止所做的：

class Exclaimer[R <: TraversableOnce[String]](val lines:R) {
  import scala.collection.generic.CanBuildFrom
  def exclaim(implicit bf:CanBuildFrom[R,String,R]):R = {
    val b = bf(lines)
    lines.foreach(b += _)
    b.result
  }
}
implicit def WrapExclaimer[R <: TraversableOnce[String]](lines:R) = new Exclaimer(lines)

2.10的一般解决方案您应该使用

感叹[That]（隐式bf:CanBuildFrom[R，String，That]）

而不是

CanBuildFrom[R，String，R]

。还请注意，有一种更通用的方法来扩展类集合-

IsTraversableOnce

（还有

IsTraversableLike

）

此方法适用于

数组

：

Array("a","b","c").exclaim
// Array[String] = Array(a, b, c)

固定的初始实现这是您的初始实现（已修复）。它与

迭代器

一起工作，但在

数组

上失败，因为

数组

不是

可遍历的一次

：

class Exclaimer[R <: TraversableOnce[String]](val lines:R) {
  import scala.collection.generic.CanBuildFrom
  def exclaim[That](implicit bf:CanBuildFrom[R,String,That]):That = {
    val b = bf(lines)
    lines.foreach(b += _)
    b.result
  }
}
implicit def WrapExclaimer[R <: TraversableOnce[String]](lines:R) = new Exclaimer(lines)

scala> List("a","b","c").iterator.exclaim
res0: Iterator[String] = non-empty iterator

scala> Array("a","b","c").exclaim
<console>:10: error: value exclaim is not a member of Array[String]
              Array("a","b","c").exclaim
                                 ^

要获得

迭代器

，您必须创建自己的隐式

CanBuildFrom

，如下所示：

import collection.generic.CanBuildFrom
import collection.mutable.Builder
import collection.immutable.VectorBuilder

implicit def iteratorCbf[A, B] = new CanBuildFrom[Iterator[A], B, Iterator[B]]{
  def apply(): Builder[B, Iterator[B]] = new Builder[B, Iterator[B]]{
    private[this] val inner = new VectorBuilder[B]
    def +=(elem: B) = {
      inner += elem
      this
    }
    def clear(): Unit = inner.clear()
    def result(): Iterator[B] = inner.result().iterator
  }
  def apply(i: Iterator[A]) = apply()
}

不，您将获得

迭代器[String]

而不是

可遍历一次[String]

：

List("a","b","c").iterator.exclaim
// Iterator[String] = non-empty iterator

您应该将隐式

iteratorCbf

方法添加到您的

equiremer

类的伴生对象中。

2.10的通用解决方案您应该使用

感叹[That]（隐式bf:CanBuildFrom[R，String，That]）

而不是

CanBuildFrom[R，String，R]