Finer conversions for immutable parallel collec...

Finer conversions for immutable parallel collections.

Added some missing traits.

No review.

14 files changed, 235 insertions, 72 deletions

diff --git a/src/library/scala/collection/TraversableOnce.scala b/src/library/scala/collection/TraversableOnce.scala
index 4836f2666c..2e76bd7e29 100644
--- a/src/library/scala/collection/TraversableOnce.scala
+++ b/src/library/scala/collection/TraversableOnce.scala
@@ -513,6 +513,10 @@ trait TraversableOnce[+A] {
    * - ParSeqLike again overrides `toParSeq`
    * - ParSetLike again overrides `toParSet`
    * - ParMapLike again overrides `toParMap`
+   * - immutable.ParIterable overrides all 4 methods to have immutable return types
+   * - immutable.ParSet overrides `toParSet` to `this`
+   * - immutable.ParSeq overrides nothing yet TODO vector
+   * - immutable.ParMap overrides `toParMap` to `this`
    */
 
   def toParIterable: parallel.ParIterable[A] = toParSeq
diff --git a/src/library/scala/collection/immutable/Range.scala b/src/library/scala/collection/immutable/Range.scala
index b6d48f453e..9a0c43d6f8 100644
--- a/src/library/scala/collection/immutable/Range.scala
+++ b/src/library/scala/collection/immutable/Range.scala
@@ -220,6 +220,8 @@ extends IndexedSeq[Int]
 
   override def toParSeq = par
 
+  override def toParSet[U >: Int] = par.toParSet[U]
+
   override def equals(other: Any) = other match {
     case x: Range =>
       (x canEqual this) && (length == x.length) && (
diff --git a/src/library/scala/collection/parallel/ParIterableLike.scala b/src/library/scala/collection/parallel/ParIterableLike.scala
index caa4af10c9..ef6120b370 100644
--- a/src/library/scala/collection/parallel/ParIterableLike.scala
+++ b/src/library/scala/collection/parallel/ParIterableLike.scala
@@ -651,6 +651,14 @@ self =>
     executeAndWaitResult(new ZipAll(size max thatseq.length, thisElem, thatElem, pbf, parallelIterator, thatseq.parallelIterator) mapResult { _.result });
   } else super.zipAll(that, thisElem, thatElem)(bf)
 
+  protected def toParCollection[U >: T, That](cbf: () => Combiner[U, That]): That = {
+    executeAndWaitResult(new ToParCollection(cbf, parallelIterator) mapResult { _.result });
+  }
+
+  protected def toParMap[K, V, That](cbf: () => Combiner[(K, V), That])(implicit ev: T <:< (K, V)): That = {
+    executeAndWaitResult(new ToParMap(cbf, parallelIterator)(ev) mapResult { _.result })
+  }
+
   override def view = new ParIterableView[T, Repr, Sequential] {
     protected lazy val underlying = self.repr
     def seq = self.seq.view
@@ -683,13 +691,13 @@ self =>
 
   override def toMap[K, V](implicit ev: T <:< (K, V)): collection.immutable.Map[K, V] = seq.toMap
 
-  override def toParIterable = this.asInstanceOf[ParIterable[T]]
+  override def toParIterable: ParIterable[T] = this.asInstanceOf[ParIterable[T]]
 
-  override def toParSeq = seq.toParSeq
+  override def toParSeq: ParSeq[T] = toParCollection[T, ParSeq[T]](() => mutable.ParArrayCombiner[T]())
 
-  override def toParSet[U >: T] = seq.toParSet
+  override def toParSet[U >: T]: ParSet[U] = toParCollection[U, ParSet[U]](() => mutable.ParHashSetCombiner[U])
 
-  override def toParMap[K, V](implicit ev: T <:< (K, V)) = seq.toParMap
+  override def toParMap[K, V](implicit ev: T <:< (K, V)): ParMap[K, V] = toParMap[K, V, mutable.ParHashMap[K, V]](() => mutable.ParHashMapCombiner[K, V])
 
   /* tasks */
 
@@ -1098,6 +1106,28 @@ self =>
     override def requiresStrictSplitters = true
   }
 
+  protected[this] class ToParCollection[U >: T, That](cbf: () => Combiner[U, That], protected[this] val pit: ParIterableIterator[T])
+  extends Transformer[Combiner[U, That], ToParCollection[U, That]] {
+    var result: Result = null
+    def leaf(prev: Option[Combiner[U, That]]) {
+      result = cbf()
+      while (pit.hasNext) result += pit.next
+    }
+    protected[this] def newSubtask(p: ParIterableIterator[T]) = new ToParCollection[U, That](cbf, p)
+    override def merge(that: ToParCollection[U, That]) = result = result combine that.result
+  }
+
+  protected[this] class ToParMap[K, V, That](cbf: () => Combiner[(K, V), That], protected[this] val pit: ParIterableIterator[T])(implicit ev: T <:< (K, V))
+  extends Transformer[Combiner[(K, V), That], ToParMap[K, V, That]] {
+    var result: Result = null
+    def leaf(prev: Option[Combiner[(K, V), That]]) {
+      result = cbf()
+      while (pit.hasNext) result += pit.next
+    }
+    protected[this] def newSubtask(p: ParIterableIterator[T]) = new ToParMap[K, V, That](cbf, p)(ev)
+    override def merge(that: ToParMap[K, V, That]) = result = result combine that.result
+  }
+
   protected[this] class CreateScanTree[U >: T](from: Int, len: Int, z: U, op: (U, U) => U, protected[this] val pit: ParIterableIterator[T])
   extends Transformer[ScanTree[U], CreateScanTree[U]] {
     var result: ScanTree[U] = null
diff --git a/src/library/scala/collection/parallel/ParMap.scala b/src/library/scala/collection/parallel/ParMap.scala
index b33b27c42b..4b732e6615 100644
--- a/src/library/scala/collection/parallel/ParMap.scala
+++ b/src/library/scala/collection/parallel/ParMap.scala
@@ -26,7 +26,7 @@ self =>
 
   def mapCompanion: GenericParMapCompanion[ParMap] = ParMap
 
-  override def empty: ParMap[K, V] = new immutable.ParHashMap[K, V]
+  override def empty: ParMap[K, V] = new mutable.ParHashMap[K, V]
 
   override def stringPrefix = "ParMap"
 }
@@ -34,9 +34,9 @@ self =>
 
 
 object ParMap extends ParMapFactory[ParMap] {
-  def empty[K, V]: ParMap[K, V] = new immutable.ParHashMap[K, V]
+  def empty[K, V]: ParMap[K, V] = new mutable.ParHashMap[K, V]
 
-  def newCombiner[K, V]: Combiner[(K, V), ParMap[K, V]] = immutable.HashMapCombiner[K, V]
+  def newCombiner[K, V]: Combiner[(K, V), ParMap[K, V]] = mutable.ParHashMapCombiner[K, V]
 
   implicit def canBuildFrom[K, V]: CanCombineFrom[Coll, (K, V), ParMap[K, V]] = new CanCombineFromMap[K, V]
 
diff --git a/src/library/scala/collection/parallel/ParSet.scala b/src/library/scala/collection/parallel/ParSet.scala
index 80bc65fe43..0453b8a95e 100644
--- a/src/library/scala/collection/parallel/ParSet.scala
+++ b/src/library/scala/collection/parallel/ParSet.scala
@@ -22,7 +22,7 @@ extends Set[T]
    with ParSetLike[T, ParSet[T], Set[T]]
 {
 self =>
-  override def empty: ParSet[T] = immutable.ParHashSet[T]()
+  override def empty: ParSet[T] = mutable.ParHashSet[T]()
 
   override def companion: GenericCompanion[ParSet] with GenericParCompanion[ParSet] = ParSet
 
@@ -32,7 +32,7 @@ self =>
 
 
 object ParSet extends ParSetFactory[ParSet] {
-  def newCombiner[T]: Combiner[T, ParSet[T]] = immutable.HashSetCombiner[T]
+  def newCombiner[T]: Combiner[T, ParSet[T]] = mutable.ParHashSetCombiner[T]
 
   implicit def canBuildFrom[T]: CanCombineFrom[Coll, T, ParSet[T]] = new GenericCanCombineFrom[T]
 }
diff --git a/src/library/scala/collection/parallel/immutable/ParHashMap.scala b/src/library/scala/collection/parallel/immutable/ParHashMap.scala
index 4d9475038d..13b7670865 100644
--- a/src/library/scala/collection/parallel/immutable/ParHashMap.scala
+++ b/src/library/scala/collection/parallel/immutable/ParHashMap.scala
@@ -6,7 +6,6 @@ package scala.collection.parallel.immutable
 
 
 
-import scala.collection.parallel.ParMap
 import scala.collection.parallel.ParMapLike
 import scala.collection.parallel.Combiner
 import scala.collection.parallel.ParIterableIterator
diff --git a/src/library/scala/collection/parallel/immutable/ParHashSet.scala b/src/library/scala/collection/parallel/immutable/ParHashSet.scala
index d17b258be6..56d252f346 100644
--- a/src/library/scala/collection/parallel/immutable/ParHashSet.scala
+++ b/src/library/scala/collection/parallel/immutable/ParHashSet.scala
@@ -6,7 +6,6 @@ package scala.collection.parallel.immutable
 
 
 
-import scala.collection.parallel.ParSet
 import scala.collection.parallel.ParSetLike
 import scala.collection.parallel.Combiner
 import scala.collection.parallel.ParIterableIterator
diff --git a/src/library/scala/collection/parallel/immutable/ParIterable.scala b/src/library/scala/collection/parallel/immutable/ParIterable.scala
new file mode 100644
index 0000000000..48f2bdb439
--- /dev/null
+++ b/src/library/scala/collection/parallel/immutable/ParIterable.scala
@@ -0,0 +1,64 @@
+package scala.collection
+package parallel.immutable
+
+
+import scala.collection.generic._
+
+import scala.collection.parallel.ParIterableLike
+import scala.collection.parallel.Combiner
+
+
+/** A template trait for immutable parallel iterable collections.
+ *
+ *  $paralleliterableinfo
+ *
+ *  $sideeffects
+ *
+ *  @tparam A    the element type of the collection
+ *
+ *  @author prokopec
+ *  @since 2.8
+ */
+trait ParIterable[+T]
+extends collection.immutable.Iterable[T]
+   with collection.parallel.ParIterable[T]
+   with GenericParTemplate[T, ParIterable]
+   with ParIterableLike[T, ParIterable[T], Iterable[T]]
+{
+  override def companion: GenericCompanion[ParIterable] with GenericParCompanion[ParIterable] = ParIterable
+
+  override def toParIterable: ParIterable[T] = this
+
+  // override def toParSeq: ParSeq TODO vector
+
+  override def toParSet[U >: T]: ParSet[U] = toParCollection[U, ParHashSet[U]](() => HashSetCombiner[U])
+
+  override def toParMap[K, V](implicit ev: T <:< (K, V)): ParMap[K, V] = toParMap(() => HashMapCombiner[K, V])
+
+}
+
+/** $factoryinfo
+ */
+object ParIterable extends ParFactory[ParIterable] {
+ implicit def canBuildFrom[T]: CanCombineFrom[Coll, T, ParIterable[T]] =
+   new GenericCanCombineFrom[T]
+
+  def newBuilder[T]: Combiner[T, ParIterable[T]] = HashSetCombiner[T] // TODO vector
+
+  def newCombiner[T]: Combiner[T, ParIterable[T]] = HashSetCombiner[T] // TODO vector
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/library/scala/collection/parallel/immutable/ParMap.scala b/src/library/scala/collection/parallel/immutable/ParMap.scala
new file mode 100644
index 0000000000..c06891c459
--- /dev/null
+++ b/src/library/scala/collection/parallel/immutable/ParMap.scala
@@ -0,0 +1,65 @@
+package scala.collection
+package parallel.immutable
+
+
+
+
+
+import scala.collection.immutable.Map
+import scala.collection.generic.ParMapFactory
+import scala.collection.generic.GenericParMapTemplate
+import scala.collection.generic.GenericParMapCompanion
+import scala.collection.generic.CanCombineFrom
+import scala.collection.parallel.ParMapLike
+import scala.collection.parallel.Combiner
+
+
+
+
+trait ParMap[K, +V]
+extends Map[K, V]
+   with GenericParMapTemplate[K, V, ParMap]
+   with parallel.ParMap[K, V]
+   with ParIterable[(K, V)]
+   with ParMapLike[K, V, ParMap[K, V], Map[K, V]]
+{
+self =>
+
+  override def mapCompanion: GenericParMapCompanion[ParMap] = ParMap
+
+  override def empty: ParMap[K, V] = new ParHashMap[K, V]
+
+  override def stringPrefix = "ParMap"
+
+  override def toParMap[P, Q](implicit ev: (K, V) <:< (P, Q)): ParMap[P, Q] = this.asInstanceOf[ParMap[P, Q]]
+}
+
+
+
+object ParMap extends ParMapFactory[ParMap] {
+  def empty[K, V]: ParMap[K, V] = new ParHashMap[K, V]
+
+  def newCombiner[K, V]: Combiner[(K, V), ParMap[K, V]] = HashMapCombiner[K, V]
+
+  implicit def canBuildFrom[K, V]: CanCombineFrom[Coll, (K, V), ParMap[K, V]] = new CanCombineFromMap[K, V]
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/library/scala/collection/parallel/immutable/ParRange.scala b/src/library/scala/collection/parallel/immutable/ParRange.scala
index ec5aeefc87..ac031605fb 100644
--- a/src/library/scala/collection/parallel/immutable/ParRange.scala
+++ b/src/library/scala/collection/parallel/immutable/ParRange.scala
@@ -14,16 +14,15 @@ import scala.collection.parallel.ParIterableIterator
 @SerialVersionUID(1L)
 class ParRange(val range: Range)
 extends ParSeq[Int]
-   with Serializable {
+   with Serializable
+{
 self =>
 
   def seq = range
 
-  @inline
-  final def length = range.length
+  @inline final def length = range.length
 
-  @inline
-  final def apply(idx: Int) = range.apply(idx)
+  @inline final def apply(idx: Int) = range.apply(idx);
 
   def parallelIterator = new ParRangeIterator with SCPI
 
@@ -90,7 +89,6 @@ self =>
       }
       cb
     }
-
   }
 
 }
diff --git a/src/library/scala/collection/parallel/immutable/ParSet.scala b/src/library/scala/collection/parallel/immutable/ParSet.scala
new file mode 100644
index 0000000000..5f9e4eee8a
--- /dev/null
+++ b/src/library/scala/collection/parallel/immutable/ParSet.scala
@@ -0,0 +1,55 @@
+package scala.collection
+package parallel.immutable
+
+
+
+
+
+
+import scala.collection.immutable.Set
+import scala.collection.generic._
+import scala.collection.parallel.ParSetLike
+import scala.collection.parallel.Combiner
+
+
+
+
+trait ParSet[T]
+extends Set[T]
+   with GenericParTemplate[T, ParSet]
+   with parallel.ParSet[T]
+   with ParIterable[T]
+   with ParSetLike[T, ParSet[T], Set[T]]
+{
+self =>
+  override def empty: ParSet[T] = ParHashSet[T]()
+
+  override def companion: GenericCompanion[ParSet] with GenericParCompanion[ParSet] = ParSet
+
+  override def stringPrefix = "ParSet"
+
+  override def toParSet[U >: T] = this.asInstanceOf[ParSet[U]]
+
+}
+
+
+
+object ParSet extends ParSetFactory[ParSet] {
+  def newCombiner[T]: Combiner[T, ParSet[T]] = HashSetCombiner[T]
+
+  implicit def canBuildFrom[T]: CanCombineFrom[Coll, T, ParSet[T]] = new GenericCanCombineFrom[T]
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/library/scala/collection/parallel/immutable/ParallelIterable.scala.disabled b/src/library/scala/collection/parallel/immutable/ParallelIterable.scala.disabled
deleted file mode 100644
index c1606727c4..0000000000
--- a/src/library/scala/collection/parallel/immutable/ParallelIterable.scala.disabled
+++ /dev/null
@@ -1,53 +0,0 @@
-package scala.collection.parallel.immutable
-
-
-import scala.collection.generic._
-
-import scala.collection.parallel.ParIterableLike
-import scala.collection.parallel.Combiner
-
-
-// TODO uncomment when we add parallel vectors
-
-///** A template trait for immutable parallel iterable collections.
-// *  
-// *  $paralleliterableinfo
-// *  
-// *  $sideeffects
-// *  
-// *  @tparam A    the element type of the collection
-// *  
-// *  @author prokopec
-// *  @since 2.8
-// */
-//trait ParallelIterable[A] extends collection.immutable.Iterable[A]
-//                              with collection.parallel.ParallelIterable[A]
-//                              with GenericParallelTemplate[A, ParallelIterable]
-//                              with ParallelIterableLike[A, ParallelIterable[A], Iterable[A]] {
-//  override def companion: GenericCompanion[ParallelIterable] with GenericParallelCompanion[ParallelIterable] = ParallelIterable
-//}
-//
-///** $factoryinfo
-// */
-//object ParallelIterable extends ParallelFactory[ParallelIterable] {
-//  implicit def canBuildFrom[A]: CanBuildFromParallel[Coll, A, ParallelIterable[A]] =
-//    new GenericCanBuildFromParallel[A]
-//  
-//  def newBuilder[A]: Combiner[A, ParallelIterable[A]] = null // TODO
-//    
-//  def newCombiner[A]: Combiner[A, ParallelIterable[A]] = null // TODO
-//}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/src/library/scala/collection/parallel/mutable/ParHashMap.scala b/src/library/scala/collection/parallel/mutable/ParHashMap.scala
index d231068b6c..d0bffc10f6 100644
--- a/src/library/scala/collection/parallel/mutable/ParHashMap.scala
+++ b/src/library/scala/collection/parallel/mutable/ParHashMap.scala
@@ -281,7 +281,7 @@ self: EnvironmentPassingCombiner[(K, V), ParHashMap[K, V]] =>
 }
 
 
-private[mutable] object ParHashMapCombiner {
+private[parallel] object ParHashMapCombiner {
   private[mutable] val discriminantbits = 5
   private[mutable] val numblocks = 1 << discriminantbits
   private[mutable] val discriminantmask = ((1 << discriminantbits) - 1);
diff --git a/src/library/scala/collection/parallel/mutable/ParHashSet.scala b/src/library/scala/collection/parallel/mutable/ParHashSet.scala
index cff8eeb9c9..d2e63100fa 100644
--- a/src/library/scala/collection/parallel/mutable/ParHashSet.scala
+++ b/src/library/scala/collection/parallel/mutable/ParHashSet.scala
@@ -295,7 +295,7 @@ self: EnvironmentPassingCombiner[T, ParHashSet[T]] =>
 }
 
 
-private[mutable] object ParHashSetCombiner {
+private[parallel] object ParHashSetCombiner {
   private[mutable] val discriminantbits = 5
   private[mutable] val numblocks = 1 << discriminantbits
   private[mutable] val discriminantmask = ((1 << discriminantbits) - 1);