Rex*_*err 92 collections scala enrich-my-library
一个Scala中最强大的模式是充实,我的图书馆*模式,它采用隐式转换为出现添加方法,以现有的类,而不需要动态方法解析.例如,如果我们希望所有字符串都有spaces计算他们有多少个空格字符的方法,我们可以:
class SpaceCounter(s: String) {
def spaces = s.count(_.isWhitespace)
}
implicit def string_counts_spaces(s: String) = new SpaceCounter(s)
scala> "How many spaces do I have?".spaces
res1: Int = 5
不幸的是,这种模式在处理泛型集合时遇到了麻烦.例如,已经询问了许多关于按顺序对项目进行分组的问题.没有内置的东西可以一次性工作,所以这似乎是使用泛型集合C和泛型元素类型的rich-my-library模式的理想候选者A:
class SequentiallyGroupingCollection[A, C[A] <: Seq[A]](ca: C[A]) {
def groupIdentical: C[C[A]] = {
if (ca.isEmpty) C.empty[C[A]]
else {
val first = ca.head
val (same,rest) = ca.span(_ == first)
same +: (new SequentiallyGroupingCollection(rest)).groupIdentical
}
}
}
当然,除了它不起作用.REPL告诉我们:
<console>:12: error: not found: value C
if (ca.isEmpty) C.empty[C[A]]
^
<console>:16: error: type mismatch;
found : Seq[Seq[A]]
required: C[C[A]]
same +: (new SequentiallyGroupingCollection(rest)).groupIdentical
^
有两个问题:我们如何C[C[A]]从一个空C[A]列表(或从空气中)获得一个？我们如何C[C[A]]从same +:线上取代而不是Seq[Seq[A]]？
*以前称为pimp-my-library.
Rex*_*err 74
理解这个问题的关键是要意识到在集合库中有两种不同的方法来构建和使用集合.一个是公共集合界面及其所有不错的方法.另外,这是在广泛使用创建的集合库,但几乎从未在其外部使用,是建设者.
我们在丰富方面的问题与集合库本身在尝试返回相同类型的集合时所面临的问题完全相同.也就是说,我们想要构建集合,但是当一般地工作时,我们没有办法引用"集合已经存在的相同类型".所以我们需要建设者.
现在的问题是:我们从哪里获得建筑商？显而易见的地方来自收藏品本身. 这不起作用.在转向通用集合时,我们已经决定忘记集合的类型.因此,即使集合可以返回一个构建器,该构建器将生成我们想要的类型的更多集合,但它不知道该类型是什么.
相反,我们让我们的建设者摆脱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]]所有组合在一起.因此,我们需要两个构建器,一个A构建C[A]s 并构建s,另一个C[A]构建C[C[A]]s 并构建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
}
}
在这里,我们添加了一个隐式,它给了我们一个Iterable[A]from C- 对于大多数集合,这只是身份(例如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, !!)
Mil*_*bin 29
在此提交中,"充实"Scala集合要比Rex给出的出色答案要容易得多.对于简单的情况,它可能看起来像这样,
import scala.collection.generic.{ CanBuildFrom, FromRepr, HasElem }
import language.implicitConversions
class FilterMapImpl[A, Repr](val r : Repr)(implicit hasElem : HasElem[Repr, A]) {
def filterMap[B, That](f : A => Option[B])
(implicit cbf : CanBuildFrom[Repr, B, That]) : That = r.flatMap(f(_).toSeq)
}
implicit def filterMap[Repr : FromRepr](r : Repr) = new FilterMapImpl(r)
它filterMap为所有GenTraversableLikes 增加了一个"相同的结果类型" ,
scala> val l = List(1, 2, 3, 4, 5)
l: List[Int] = List(1, 2, 3, 4, 5)
scala> l.filterMap(i => if(i % 2 == 0) Some(i) else None)
res0: List[Int] = List(2, 4)
scala> val a = Array(1, 2, 3, 4, 5)
a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a.filterMap(i => if(i % 2 == 0) Some(i) else None)
res1: Array[Int] = Array(2, 4)
scala> val s = "Hello World"
s: String = Hello World
scala> s.filterMap(c => if(c >= 'A' && c <= 'Z') Some(c) else None)
res2: String = HW
对于问题的例子,解决方案现在看起来像,
class GroupIdenticalImpl[A, Repr : FromRepr](val r: Repr)
(implicit hasElem : HasElem[Repr, A]) {
def groupIdentical[That](implicit cbf: CanBuildFrom[Repr,Repr,That]): That = {
val builder = cbf(r)
def group(r: Repr) : Unit = {
val first = r.head
val (same, rest) = r.span(_ == first)
builder += same
if(!rest.isEmpty)
group(rest)
}
if(!r.isEmpty) group(r)
builder.result
}
}
implicit def groupIdentical[Repr : FromRepr](r: Repr) = new GroupIdenticalImpl(r)
示例REPL会话,
scala> val l = List(1, 1, 2, 2, 3, 3, 1, 1)
l: List[Int] = List(1, 1, 2, 2, 3, 3, 1, 1)
scala> l.groupIdentical
res0: List[List[Int]] = List(List(1, 1),List(2, 2),List(3, 3),List(1, 1))
scala> val a = Array(1, 1, 2, 2, 3, 3, 1, 1)
a: Array[Int] = Array(1, 1, 2, 2, 3, 3, 1, 1)
scala> a.groupIdentical
res1: Array[Array[Int]] = Array(Array(1, 1),Array(2, 2),Array(3, 3),Array(1, 1))
scala> val s = "11223311"
s: String = 11223311
scala> s.groupIdentical
res2: scala.collection.immutable.IndexedSeq[String] = Vector(11, 22, 33, 11)
同样,请注意,已经观察到相同的结果类型原则,其方式与groupIdentical直接定义的方式完全相同GenTraversableLike.
在这个提交中,魔术咒语与Miles给出的出色答案略有不同.
以下作品,但它是规范的吗？我希望其中一个经典能够纠正它.(或者说,大炮,大枪之一.)如果视图绑定是上限,则会丢失对Array和String的应用程序.如果绑定是GenTraversableLike或TraversableLike似乎并不重要; 但IsTraversableLike为您提供了GenTraversableLike.
import language.implicitConversions
import scala.collection.{ GenTraversable=>GT, GenTraversableLike=>GTL, TraversableLike=>TL }
import scala.collection.generic.{ CanBuildFrom=>CBF, IsTraversableLike=>ITL }
class GroupIdenticalImpl[A, R <% GTL[_,R]](val r: GTL[A,R]) {
def groupIdentical[That](implicit cbf: CBF[R, R, That]): That = {
val builder = cbf(r.repr)
def group(r: GTL[_,R]) {
val first = r.head
val (same, rest) = r.span(_ == first)
builder += same
if (!rest.isEmpty) group(rest)
}
if (!r.isEmpty) group(r)
builder.result
}
}
implicit def groupIdentical[A, R <% GTL[_,R]](r: R)(implicit fr: ITL[R]):
GroupIdenticalImpl[fr.A, R] =
new GroupIdenticalImpl(fr conversion r)
只有一种方法可以让有九条生命的猫皮肤美化.这个版本说,一旦我的源转换为GenTraversableLike,只要我可以从GenTraversable构建结果,就这样做.我对我的旧Repr不感兴趣.
class GroupIdenticalImpl[A, R](val r: GTL[A,R]) {
def groupIdentical[That](implicit cbf: CBF[GT[A], GT[A], That]): That = {
val builder = cbf(r.toTraversable)
def group(r: GT[A]) {
val first = r.head
val (same, rest) = r.span(_ == first)
builder += same
if (!rest.isEmpty) group(rest)
}
if (!r.isEmpty) group(r.toTraversable)
builder.result
}
}
implicit def groupIdentical[A, R](r: R)(implicit fr: ITL[R]):
GroupIdenticalImpl[fr.A, R] =
new GroupIdenticalImpl(fr conversion r)
第一次尝试包括将Repr转换为GenTraversableLike.
import language.implicitConversions
import scala.collection.{ GenTraversableLike }
import scala.collection.generic.{ CanBuildFrom, IsTraversableLike }
type GT[A, B] = GenTraversableLike[A, B]
type CBF[A, B, C] = CanBuildFrom[A, B, C]
type ITL[A] = IsTraversableLike[A]
class FilterMapImpl[A, Repr](val r: GenTraversableLike[A, Repr]) {
def filterMap[B, That](f: A => Option[B])(implicit cbf : CanBuildFrom[Repr, B, That]): That =
r.flatMap(f(_).toSeq)
}
implicit def filterMap[A, Repr](r: Repr)(implicit fr: ITL[Repr]): FilterMapImpl[fr.A, Repr] =
new FilterMapImpl(fr conversion r)
class GroupIdenticalImpl[A, R](val r: GT[A,R])(implicit fr: ITL[R]) {
def groupIdentical[That](implicit cbf: CBF[R, R, That]): That = {
val builder = cbf(r.repr)
def group(r0: R) {
val r = fr conversion r0
val first = r.head
val (same, other) = r.span(_ == first)
builder += same
val rest = fr conversion other
if (!rest.isEmpty) group(rest.repr)
}
if (!r.isEmpty) group(r.repr)
builder.result
}
}
implicit def groupIdentical[A, R](r: R)(implicit fr: ITL[R]):
GroupIdenticalImpl[fr.A, R] =
new GroupIdenticalImpl(fr conversion r)
| 归档时间： |
|
| 查看次数： |
6354 次 |
| 最近记录： |