理解这个问题的关键是要意识到在集合库中有两种不同的方式来构建和使用集合。一个是公共集合接口及其所有不错的方法。另一个在创建 collections 库中被广泛使用，但几乎从未在它之外使用过，它是builders。
我们在丰富方面的问题与集合库本身在尝试返回相同类型的集合时所面临的问题完全相同。也就是说，我们想要构建集合，但是在一般工作时，我们没有办法引用“集合已经是相同的类型”。所以我们需要建设者。
现在的问题是：我们从哪里获得构建器？明显的地方来自收藏本身。 这不起作用。我们已经决定，在转向泛型集合时，我们将忘记集合的类型。因此，即使集合可以返回一个生成器来生成更多我们想要的类型的集合，它也不知道类型是什么。
相反，我们从漂浮的CanBuildFrom 隐式中获取我们的构建器。这些专门用于匹配输入和输出类型并为您提供适当类型的构建器。
所以，我们有两个概念上的飞跃：
- 我们使用的不是标准集合操作，而是构建器。
- 我们从隐含的
CanBuildFroms 中获取这些构建器，而不是直接从我们的集合中获取。
让我们看一个例子。
class GroupingCollection[A, C[A] <: Iterable[A]](ca: C[A]) {
import collection.generic.CanBuildFrom
def groupedWhile(p: (A,A) => Boolean)(
implicit cbfcc: CanBuildFrom[C[A],C[A],C[C[A]]], cbfc: CanBuildFrom[C[A],A,C[A]]
): C[C[A]] = {
val it = ca.iterator
val cca = cbfcc()
if (!it.hasNext) cca.result
else {
val as = cbfc()
var olda = it.next
as += olda
while (it.hasNext) {
val a = it.next
if (p(olda,a)) as += a
else { cca += as.result; as.clear; as += a }
olda = a
}
cca += as.result
}
cca.result
}
}
implicit def iterable_has_grouping[A, C[A] <: Iterable[A]](ca: C[A]) = {
new GroupingCollection[A,C](ca)
}
让我们把它拆开。首先，为了构建集合的集合，我们知道我们需要构建两种类型的集合：C[A] 用于每个组，C[C[A]] 将所有组聚集在一起。因此，我们需要两个构建器，一个采用As 并构建C[A]s，另一个采用C[A]s 并构建C[C[A]]s。查看CanBuildFrom的类型签名，我们看到
CanBuildFrom[-From, -Elem, +To]
这意味着 CanBuildFrom 想知道我们开始使用的集合的类型——在我们的例子中，它是 C[A]，然后是生成的集合的元素和该集合的类型。所以我们将它们填充为隐式参数cbfcc 和cbfc。
意识到这一点，这就是大部分工作。我们可以使用我们的CanBuildFroms 为我们提供构建器（您需要做的就是应用它们）。并且一个构建器可以使用+= 建立一个集合，将其转换为最终应该与result 一起使用的集合，然后清空自身并准备以clear 重新开始。构建器一开始是空的，这解决了我们的第一个编译错误，并且由于我们使用构建器而不是递归，第二个错误也消失了。
最后一个小细节——除了实际工作的算法——是在隐式转换中。请注意，我们使用new GroupingCollection[A,C] 而不是[A,C[A]]。这是因为类声明是针对带有一个参数的C，它用传递给它的A 填充它自己。所以我们只需将类型C 交给它，并让它从中创建C[A]。次要细节，但如果您尝试其他方式，则会出现编译时错误。
在这里，我使该方法比“相等元素”集合更通用一些——相反，只要对顺序元素的测试失败，该方法就会将原始集合分开。
让我们看看我们的方法在起作用：
scala> List(1,2,2,2,3,4,4,4,5,5,1,1,1,2).groupedWhile(_ == _)
res0: List[List[Int]] = List(List(1), List(2, 2, 2), List(3), List(4, 4, 4),
List(5, 5), List(1, 1, 1), List(2))
scala> Vector(1,2,3,4,1,2,3,1,2,1).groupedWhile(_ < _)
res1: scala.collection.immutable.Vector[scala.collection.immutable.Vector[Int]] =
Vector(Vector(1, 2, 3, 4), Vector(1, 2, 3), Vector(1, 2), Vector(1))
有效！
唯一的问题是我们通常没有可用于数组的这些方法，因为这需要连续进行两次隐式转换。有几种方法可以解决这个问题，包括为数组编写单独的隐式转换、转换为 WrappedArray 等等。
编辑：我最喜欢的处理数组和字符串等的方法是使代码更更通用，然后使用适当的隐式转换再次使它们更具体，从而使数组工作还。在这种特殊情况下：
class GroupingCollection[A, C, D[C]](ca: C)(
implicit c2i: C => Iterable[A],
cbf: CanBuildFrom[C,C,D[C]],
cbfi: CanBuildFrom[C,A,C]
) {
def groupedWhile(p: (A,A) => Boolean): D[C] = {
val it = c2i(ca).iterator
val cca = cbf()
if (!it.hasNext) cca.result
else {
val as = cbfi()
var olda = it.next
as += olda
while (it.hasNext) {
val a = it.next
if (p(olda,a)) as += a
else { cca += as.result; as.clear; as += a }
olda = a
}
cca += as.result
}
cca.result
}
}
在这里，我们添加了一个隐式函数，它为我们提供了来自 C 的 Iterable[A]——对于大多数集合来说，这只是标识（例如，List[A] 已经是 Iterable[A]），但对于数组，它将是真正的隐式转换。因此，我们已经放弃了C[A] <: Iterable[A] 的要求——我们基本上只是明确了<% 的要求，所以我们可以随意显式使用它，而不是让编译器为我们填充它。此外，我们放宽了集合集合为C[C[A]] 的限制——取而代之的是任何D[C]，我们稍后将填写为我们想要的。因为我们稍后会填写它，所以我们将它推到了类级别而不是方法级别。否则基本一样。
现在的问题是如何使用它。对于常规收藏，我们可以：
implicit def collections_have_grouping[A, C[A]](ca: C[A])(
implicit c2i: C[A] => Iterable[A],
cbf: CanBuildFrom[C[A],C[A],C[C[A]]],
cbfi: CanBuildFrom[C[A],A,C[A]]
) = {
new GroupingCollection[A,C[A],C](ca)(c2i, cbf, cbfi)
}
现在我们将C[A] 插入C 和C[C[A]] 插入D[C]。请注意，我们在调用new GroupingCollection 时确实需要显式泛型类型，这样它就可以清楚地知道哪些类型对应于什么。感谢implicit c2i: C[A] => Iterable[A]，它会自动处理数组。
但是等等，如果我们想使用字符串呢？现在我们遇到了麻烦，因为你不能有一个“字符串”。这就是额外的抽象有帮助的地方：我们可以调用D 一些适合保存字符串的东西。让我们选择Vector，然后执行以下操作：
val vector_string_builder = (
new CanBuildFrom[String, String, Vector[String]] {
def apply() = Vector.newBuilder[String]
def apply(from: String) = this.apply()
}
)
implicit def strings_have_grouping(s: String)(
implicit c2i: String => Iterable[Char],
cbfi: CanBuildFrom[String,Char,String]
) = {
new GroupingCollection[Char,String,Vector](s)(
c2i, vector_string_builder, cbfi
)
}
我们需要一个新的CanBuildFrom 来处理字符串向量的构建（但这真的很简单，因为我们只需要调用Vector.newBuilder[String]），然后我们需要填写所有类型，以便GroupingCollection 输入得当。请注意，我们已经在 [String,Char,String] CanBuildFrom 周围浮动，所以字符串可以由字符集合组成。
让我们试试吧：
scala> List(true,false,true,true,true).groupedWhile(_ == _)
res1: List[List[Boolean]] = List(List(true), List(false), List(true, true, true))
scala> Array(1,2,5,3,5,6,7,4,1).groupedWhile(_ <= _)
res2: Array[Array[Int]] = Array(Array(1, 2, 5), Array(3, 5, 6, 7), Array(4), Array(1))
scala> "Hello there!!".groupedWhile(_.isLetter == _.isLetter)
res3: Vector[String] = Vector(Hello, , there, !!)