Refactoring the collections api to support diff...

Refactoring the collections api to support differentiation between
referring to a sequential collection and a parallel collection, and to
support referring to both types of collections.

New set of traits Gen* are now superclasses of both their * and Par* subclasses. For example, GenIterable is a superclass of both Iterable and ParIterable. Iterable and ParIterable are not in a subclassing relation. The new class hierarchy is illustrated below (simplified, not all relations and classes are shown):

TraversableOnce --> GenTraversableOnce
  ^                    ^
  |                    |
Traversable     --> GenTraversable
  ^                    ^
  |                    |
Iterable        --> GenIterable        <-- ParIterable
  ^                    ^                      ^
  |                    |                      |
Seq             --> GenSeq             <-- ParSeq

(the *Like, *View and *ViewLike traits have a similar hierarchy)

General views extract common view functionality from parallel and
sequential collections.

This design also allows for more flexible extensions to the collections
framework. It also allows slowly factoring out common functionality up
into Gen* traits.

From now on, it is possible to write this:

import collection._

val p = parallel.ParSeq(1, 2, 3)
val g: GenSeq[Int] = p // meaning a General Sequence
val s = g.seq // type of s is Seq[Int]

for (elem <- g) {
  // do something without guarantees on sequentiality of foreach
  // this foreach may be executed in parallel
}

for (elem <- s) {
  // do something with a guarantee that foreach is executed in order, sequentially
}

for (elem <- p) {
  // do something concurrently, in parallel
}

This also means that some signatures had to be changed. For example,
method `flatMap` now takes `A => GenTraversableOnce[B]`, and `zip` takes
a `GenIterable[B]`.

Also, there are mutable & immutable Gen* trait variants. They have
generic companion functionality.

1 files changed, 9 insertions, 9 deletions

diff --git a/src/library/scala/collection/parallel/mutable/ParArray.scala b/src/library/scala/collection/parallel/mutable/ParArray.scala
index 0ac009d58c..a1eb3beb0c 100644
--- a/src/library/scala/collection/parallel/mutable/ParArray.scala
+++ b/src/library/scala/collection/parallel/mutable/ParArray.scala
@@ -23,6 +23,7 @@ import scala.collection.parallel.ParSeqLike
 import scala.collection.parallel.CHECK_RATE
 import scala.collection.mutable.ArraySeq
 import scala.collection.mutable.Builder
+import scala.collection.GenTraversableOnce
 
 
 
@@ -75,7 +76,7 @@ self =>
 
   type SCPI = SignalContextPassingIterator[ParArrayIterator]
 
-  def parallelIterator: ParArrayIterator = {
+  protected[parallel] def splitter: ParArrayIterator = {
     val pit = new ParArrayIterator with SCPI
     pit
   }
@@ -178,7 +179,7 @@ self =>
 
     override def fold[U >: T](z: U)(op: (U, U) => U): U = foldLeft[U](z)(op)
 
-    def aggregate[S](z: S)(seqop: (S, T) => S, combop: (S, S) => S): S = foldLeft[S](z)(seqop)
+    override def aggregate[S](z: S)(seqop: (S, T) => S, combop: (S, S) => S): S = foldLeft[S](z)(seqop)
 
     override def sum[U >: T](implicit num: Numeric[U]): U = {
       var s = sum_quick(num, arr, until, i, num.zero)
@@ -409,12 +410,12 @@ self =>
       }
     }
 
-    override def flatmap2combiner[S, That](f: T => TraversableOnce[S], cb: Combiner[S, That]): Combiner[S, That] = {
+    override def flatmap2combiner[S, That](f: T => GenTraversableOnce[S], cb: Combiner[S, That]): Combiner[S, That] = {
       //val cb = pbf(self.repr)
       while (i < until) {
         val traversable = f(arr(i).asInstanceOf[T])
         if (traversable.isInstanceOf[Iterable[_]]) cb ++= traversable.asInstanceOf[Iterable[S]].iterator
-        else cb ++= traversable
+        else cb ++= traversable.seq
         i += 1
       }
       cb
@@ -592,7 +593,7 @@ self =>
     (new ParArray[S](targarrseq)).asInstanceOf[That]
   } else super.map(f)(bf)
 
-  override def scan[U >: T, That](z: U)(op: (U, U) => U)(implicit cbf: CanCombineFrom[ParArray[T], U, That]): That =
+  override def scan[U >: T, That](z: U)(op: (U, U) => U)(implicit cbf: CanBuildFrom[ParArray[T], U, That]): That =
     if (parallelismLevel > 1 && buildsArray(cbf(repr))) {
       // reserve an array
       val targarrseq = new ArraySeq[U](length + 1)
@@ -600,7 +601,7 @@ self =>
       targetarr(0) = z
 
       // do a parallel prefix scan
-      if (length > 0) executeAndWaitResult(new CreateScanTree[U](0, size, z, op, parallelIterator) mapResult {
+      if (length > 0) executeAndWaitResult(new CreateScanTree[U](0, size, z, op, splitter) mapResult {
         tree => executeAndWaitResult(new ScanToArray(tree, z, op, targetarr))
       })
 
@@ -710,11 +711,10 @@ object ParArray extends ParFactory[ParArray] {
     handoff(newarr)
   }
 
-  def fromTraversables[T](xss: TraversableOnce[T]*) = {
+  def fromTraversables[T](xss: GenTraversableOnce[T]*) = {
     val cb = ParArrayCombiner[T]()
     for (xs <- xss) {
-      val it = xs.toIterator
-      while (it.hasNext) cb += it.next
+      cb ++= xs.seq
     }
     cb.result
   }