Implementing foreach to work in parallel in Par...

Implementing foreach to work in parallel in ParIterableLike.

Doing a bunch of refactoring around in the collection framework to
ensure a parallel foreach is never called with a side-effecting method.
This still leaves other parts of the standard library and the compiler
unguarded.

No review.

29 files changed, 61 insertions, 47 deletions

diff --git a/src/library/scala/collection/IterableLike.scala b/src/library/scala/collection/IterableLike.scala
index 16d7b0f66e..062b3c207f 100644
--- a/src/library/scala/collection/IterableLike.scala
+++ b/src/library/scala/collection/IterableLike.scala
@@ -157,7 +157,7 @@ self =>
     b.sizeHintBounded(n, this)
     val lead = this.iterator drop n
     var go = false
-    for (x <- this) {
+    for (x <- this.seq) {
       if (lead.hasNext) lead.next
       else go = true
       if (go) b += x
diff --git a/src/library/scala/collection/Iterator.scala b/src/library/scala/collection/Iterator.scala
index d8a3514954..81582b7f78 100644
--- a/src/library/scala/collection/Iterator.scala
+++ b/src/library/scala/collection/Iterator.scala
@@ -251,7 +251,7 @@ import Iterator.empty
  *  @define mayNotTerminateInf
  *  Note: may not terminate for infinite iterators.
  */
-trait Iterator[+A] extends TraversableOnce[A] with Parallelizable[A, ParIterable[A]] {
+trait Iterator[+A] extends TraversableOnce[A] {
   self =>
 
   /** Tests whether this iterator can provide another element.
@@ -276,8 +276,6 @@ trait Iterator[+A] extends TraversableOnce[A] with Parallelizable[A, ParIterable
    */
   def isTraversableAgain = false
 
-  protected[this] def parCombiner = ParIterable.newCombiner[A]
-
   /** Tests whether this Iterator has a known size.
    *
    *  @return   `true` for empty Iterators, `false` otherwise.
diff --git a/src/library/scala/collection/JavaConversions.scala b/src/library/scala/collection/JavaConversions.scala
index 5493dabca6..d71208f752 100644
--- a/src/library/scala/collection/JavaConversions.scala
+++ b/src/library/scala/collection/JavaConversions.scala
@@ -620,7 +620,7 @@ object JavaConversions {
     def update(i : Int, elem : A) = underlying.set(i, elem)
     def +=:(elem : A) = { underlying.subList(0, 0).add(elem) ; this }
     def +=(elem : A): this.type = { underlying.add(elem); this }
-    def insertAll(i : Int, elems : Traversable[A]) = { val ins = underlying.subList(0, i) ;  elems.foreach(ins.add(_)) }
+    def insertAll(i : Int, elems : Traversable[A]) = { val ins = underlying.subList(0, i) ;  elems.seq.foreach(ins.add(_)) }
     def remove(i : Int) = underlying.remove(i)
     def clear = underlying.clear
     def result = this
diff --git a/src/library/scala/collection/SeqLike.scala b/src/library/scala/collection/SeqLike.scala
index 0f336dd778..fe42f25dea 100644
--- a/src/library/scala/collection/SeqLike.scala
+++ b/src/library/scala/collection/SeqLike.scala
@@ -434,7 +434,7 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with Parallelizable[A, Pa
    */
   def reverseMap[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {
     var xs: List[A] = List()
-    for (x <- this)
+    for (x <- this.seq)
       xs = x :: xs
     val b = bf(repr)
     for (x <- xs)
@@ -609,7 +609,7 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with Parallelizable[A, Pa
   def diff[B >: A](that: Seq[B]): Repr = {
     val occ = occCounts(that)
     val b = newBuilder
-    for (x <- this)
+    for (x <- this.seq)
       if (occ(x) == 0) b += x
       else occ(x) -= 1
     b.result
@@ -637,7 +637,7 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with Parallelizable[A, Pa
   def intersect[B >: A](that: Seq[B]): Repr = {
     val occ = occCounts(that)
     val b = newBuilder
-    for (x <- this)
+    for (x <- this.seq)
       if (occ(x) > 0) {
         b += x
         occ(x) -= 1
@@ -645,9 +645,9 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with Parallelizable[A, Pa
     b.result
   }
 
-  private def occCounts[B](seq: Seq[B]): mutable.Map[B, Int] = {
+  private def occCounts[B](sq: Seq[B]): mutable.Map[B, Int] = {
     val occ = new mutable.HashMap[B, Int] { override def default(k: B) = 0 }
-    for (y <- seq) occ(y) += 1
+    for (y <- sq.seq) occ(y) += 1
     occ
   }
 
@@ -659,7 +659,7 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with Parallelizable[A, Pa
   def distinct: Repr = {
     val b = newBuilder
     val seen = mutable.HashSet[A]()
-    for (x <- this) {
+    for (x <- this.seq) {
       if (!seen(x)) {
         b += x
         seen += x
@@ -850,7 +850,7 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with Parallelizable[A, Pa
     val len = this.length
     val arr = new ArraySeq[A](len)
     var i = 0
-    for (x <- this) {
+    for (x <- this.seq) {
       arr(i) = x
       i += 1
     }
diff --git a/src/library/scala/collection/TraversableLike.scala b/src/library/scala/collection/TraversableLike.scala
index 70d5c37837..950f9e65a7 100644
--- a/src/library/scala/collection/TraversableLike.scala
+++ b/src/library/scala/collection/TraversableLike.scala
@@ -553,7 +553,7 @@ trait TraversableLike[+A, +Repr] extends HasNewBuilder[A, Repr]
     var follow = false
     val b = newBuilder
     b.sizeHint(this, -1)
-    for (x <- this) {
+    for (x <- this.seq) {
       if (follow) b += lst
       else follow = true
       lst = x
@@ -598,7 +598,7 @@ trait TraversableLike[+A, +Repr] extends HasNewBuilder[A, Repr]
   private[this] def sliceInternal(from: Int, until: Int, b: Builder[A, Repr]): Repr = {
     var i = 0
     breakable {
-      for (x <- this) {
+      for (x <- this.seq) {
         if (i >= from) b += x
         i += 1
         if (i >= until) break
diff --git a/src/library/scala/collection/TraversableOnce.scala b/src/library/scala/collection/TraversableOnce.scala
index a062d5710d..0a2d851b2d 100644
--- a/src/library/scala/collection/TraversableOnce.scala
+++ b/src/library/scala/collection/TraversableOnce.scala
@@ -109,7 +109,7 @@ trait TraversableOnce[+A] {
   // for internal use
   protected[this] def reversed = {
     var elems: List[A] = Nil
-    self foreach (elems ::= _)
+    self.seq foreach (elems ::= _)
     elems
   }
 
@@ -156,7 +156,7 @@ trait TraversableOnce[+A] {
    *  @example   `Seq("a", 1, 5L).collectFirst({ case x: Int => x*10 }) = Some(10)`
    */
   def collectFirst[B](pf: PartialFunction[A, B]): Option[B] = {
-    for (x <- self.toIterator) {
+    for (x <- self.toIterator) { // make sure to use an iterator or `seq`
       if (pf isDefinedAt x)
         return Some(pf(x))
     }
@@ -221,7 +221,7 @@ trait TraversableOnce[+A] {
    */
   def foldLeft[B](z: B)(op: (B, A) => B): B = {
     var result = z
-    this foreach (x => result = op(result, x))
+    this.seq foreach (x => result = op(result, x))
     result
   }
 
diff --git a/src/library/scala/collection/generic/GenericTraversableTemplate.scala b/src/library/scala/collection/generic/GenericTraversableTemplate.scala
index d6f01718ff..46b39bbf8b 100644
--- a/src/library/scala/collection/generic/GenericTraversableTemplate.scala
+++ b/src/library/scala/collection/generic/GenericTraversableTemplate.scala
@@ -67,6 +67,8 @@ trait GenericTraversableTemplate[+A, +CC[X] <: Traversable[X]] extends HasNewBui
    */
   def genericBuilder[B]: Builder[B, CC[B]] = companion.newBuilder[B]
 
+  private def sequential: TraversableOnce[A] = this.asInstanceOf[TraversableOnce[A]].seq
+
   /** Converts this $coll of pairs into two collections of the first and second
    *  half of each pair.
    *
@@ -80,7 +82,7 @@ trait GenericTraversableTemplate[+A, +CC[X] <: Traversable[X]] extends HasNewBui
   def unzip[A1, A2](implicit asPair: A => (A1, A2)): (CC[A1], CC[A2]) = {
     val b1 = genericBuilder[A1]
     val b2 = genericBuilder[A2]
-    for (xy <- this) {
+    for (xy <- sequential) {
       val (x, y) = asPair(xy)
       b1 += x
       b2 += y
@@ -104,7 +106,7 @@ trait GenericTraversableTemplate[+A, +CC[X] <: Traversable[X]] extends HasNewBui
     val b2 = genericBuilder[A2]
     val b3 = genericBuilder[A3]
 
-    for (xyz <- this) {
+    for (xyz <- sequential) {
       val (x, y, z) = asTriple(xyz)
       b1 += x
       b2 += y
@@ -124,7 +126,7 @@ trait GenericTraversableTemplate[+A, +CC[X] <: Traversable[X]] extends HasNewBui
    */
   def flatten[B](implicit asTraversable: A => /*<:<!!!*/ TraversableOnce[B]): CC[B] = {
     val b = genericBuilder[B]
-    for (xs <- this)
+    for (xs <- sequential)
       b ++= asTraversable(xs)
     b.result
   }
@@ -149,7 +151,7 @@ trait GenericTraversableTemplate[+A, +CC[X] <: Traversable[X]] extends HasNewBui
 
     val headSize = asTraversable(head).size
     val bs: IndexedSeq[Builder[B, CC[B]]] = IndexedSeq.fill(headSize)(genericBuilder[B])
-    for (xs <- this) {
+    for (xs <- sequential) {
       var i = 0
       for (x <- asTraversable(xs)) {
         if (i >= headSize) fail
diff --git a/src/library/scala/collection/generic/Growable.scala b/src/library/scala/collection/generic/Growable.scala
index cb18be5deb..f0a70c2b88 100644
--- a/src/library/scala/collection/generic/Growable.scala
+++ b/src/library/scala/collection/generic/Growable.scala
@@ -45,7 +45,7 @@ trait Growable[-A] {
    *  @param iter  the TraversableOnce producing the elements to $add.
    *  @return  the $coll itself.
    */
-  def ++=(xs: TraversableOnce[A]): this.type = { xs foreach += ; this }
+  def ++=(xs: TraversableOnce[A]): this.type = { xs.seq foreach += ; this }
 
   /** Clears the $coll's contents. After this operation, the
    *  $coll is empty.
diff --git a/src/library/scala/collection/generic/Shrinkable.scala b/src/library/scala/collection/generic/Shrinkable.scala
index b70f51ddc5..88c7ce3a3d 100644
--- a/src/library/scala/collection/generic/Shrinkable.scala
+++ b/src/library/scala/collection/generic/Shrinkable.scala
@@ -46,7 +46,7 @@ trait Shrinkable[-A] {
    *  @param iter  the iterator producing the elements to remove.
    *  @return the $coll itself
    */
-  def --=(xs: TraversableOnce[A]): this.type = { xs foreach -= ; this }
+  def --=(xs: TraversableOnce[A]): this.type = { xs.seq foreach -= ; this }
 }
 
 
diff --git a/src/library/scala/collection/generic/TraversableFactory.scala b/src/library/scala/collection/generic/TraversableFactory.scala
index 3874429f5c..de42737e44 100644
--- a/src/library/scala/collection/generic/TraversableFactory.scala
+++ b/src/library/scala/collection/generic/TraversableFactory.scala
@@ -65,7 +65,7 @@ abstract class TraversableFactory[CC[X] <: Traversable[X] with GenericTraversabl
     if (xss forall (_.isInstanceOf[IndexedSeq[_]]))
       b.sizeHint(xss map (_.size) sum)
 
-    for (xs <- xss) b ++= xs
+    for (xs <- xss.seq) b ++= xs
     b.result
   }
 
diff --git a/src/library/scala/collection/immutable/DefaultMap.scala b/src/library/scala/collection/immutable/DefaultMap.scala
index e2b8407f71..155da0f642 100755
--- a/src/library/scala/collection/immutable/DefaultMap.scala
+++ b/src/library/scala/collection/immutable/DefaultMap.scala
@@ -49,7 +49,7 @@ trait DefaultMap[A, +B] extends Map[A, B] { self =>
    */
   override def - (key: A): Map[A, B] = {
     val b = newBuilder
-    for (kv <- this ; if kv._1 != key) b += kv
+    for (kv <- this.seq ; if kv._1 != key) b += kv
     b.result
   }
 }
diff --git a/src/library/scala/collection/mutable/ArrayStack.scala b/src/library/scala/collection/mutable/ArrayStack.scala
index 3172d296dc..13f709ba39 100644
--- a/src/library/scala/collection/mutable/ArrayStack.scala
+++ b/src/library/scala/collection/mutable/ArrayStack.scala
@@ -160,7 +160,7 @@ extends Seq[T]
    *  @param x  The source of elements to push.
    *  @return   A reference to this stack.
    */
-  override def ++=(xs: TraversableOnce[T]): this.type = { xs foreach += ; this }
+  override def ++=(xs: TraversableOnce[T]): this.type = { xs.seq foreach += ; this }
 
   /** Does the same as `push`, but returns the updated stack.
    *
diff --git a/src/library/scala/collection/mutable/MapLike.scala b/src/library/scala/collection/mutable/MapLike.scala
index 04ba8608b9..d0df44b69a 100644
--- a/src/library/scala/collection/mutable/MapLike.scala
+++ b/src/library/scala/collection/mutable/MapLike.scala
@@ -206,7 +206,7 @@ trait MapLike[A, B, +This <: MapLike[A, B, This] with Map[A, B]]
    * @param p  The test predicate
    */
   def retain(p: (A, B) => Boolean): this.type = {
-    for ((k, v) <- this ; if !p(k, v))
+    for ((k, v) <- this.seq ; if !p(k, v))
       this -= k
 
     this
diff --git a/src/library/scala/collection/mutable/Stack.scala b/src/library/scala/collection/mutable/Stack.scala
index 1433524107..0d1746b33b 100644
--- a/src/library/scala/collection/mutable/Stack.scala
+++ b/src/library/scala/collection/mutable/Stack.scala
@@ -121,7 +121,7 @@ extends Seq[A]
    *  @param xs the traversable object.
    *  @return the stack with the new elements on top.
    */
-  def pushAll(xs: TraversableOnce[A]): this.type = { xs foreach push ; this }
+  def pushAll(xs: TraversableOnce[A]): this.type = { xs.seq foreach push ; this }
 
   @deprecated("use pushAll")
   @migration(2, 8, "Stack ++= now pushes arguments on the stack from left to right.")
diff --git a/src/library/scala/collection/parallel/ParIterableLike.scala b/src/library/scala/collection/parallel/ParIterableLike.scala
index 92c7d5ac97..50a36fa8ed 100644
--- a/src/library/scala/collection/parallel/ParIterableLike.scala
+++ b/src/library/scala/collection/parallel/ParIterableLike.scala
@@ -440,7 +440,9 @@ self: ParIterableLike[T, Repr, Sequential] =>
    *  @tparam U    the result type of the function applied to each element, which is always discarded
    *  @param f     function applied to each element
    */
-  override def foreach[U](f: T => U) = iterator.foreach(f)
+  override def foreach[U](f: T => U) = {
+    executeAndWaitResult(new Foreach(f, parallelIterator))
+  }
 
   override def count(p: T => Boolean): Int = {
     executeAndWaitResult(new Count(p, parallelIterator))
diff --git a/src/library/scala/collection/parallel/ParIterableViewLike.scala b/src/library/scala/collection/parallel/ParIterableViewLike.scala
index 0548758eb5..41ba0624bb 100644
--- a/src/library/scala/collection/parallel/ParIterableViewLike.scala
+++ b/src/library/scala/collection/parallel/ParIterableViewLike.scala
@@ -54,39 +54,39 @@ self =>
   trait Sliced extends super.Sliced with Transformed[T] {
     // override def slice(from1: Int, until1: Int): This = newSliced(from1 max 0, until1 max 0).asInstanceOf[This]
     def parallelIterator: ParIterableIterator[T] = self.parallelIterator.slice(from, until)
-    def seq = self.seq.slice(from, until)
+    override def seq = self.seq.slice(from, until)
   }
 
   trait Mapped[S] extends super.Mapped[S] with Transformed[S]{
     def parallelIterator: ParIterableIterator[S] = self.parallelIterator.map(mapping)
-    def seq = self.seq.map(mapping).asInstanceOf[IterableView[S, CollSeq]]
+    override def seq = self.seq.map(mapping).asInstanceOf[IterableView[S, CollSeq]]
   }
 
   // only use if other is a ParIterable, otherwise force
   trait Appended[U >: T] extends super.Appended[U] with Transformed[U] {
     def restPar: ParIterable[U] = rest.asParIterable
     def parallelIterator: ParIterableIterator[U] = self.parallelIterator.appendParIterable[U, ParIterableIterator[U]](restPar.parallelIterator)
-    def seq = self.seq.++(rest).asInstanceOf[IterableView[U, CollSeq]]
+    override def seq = self.seq.++(rest).asInstanceOf[IterableView[U, CollSeq]]
   }
 
   trait Forced[S] extends super.Forced[S] with Transformed[S] {
     def forcedPar: ParIterable[S] = forced.asParIterable
     def parallelIterator: ParIterableIterator[S] = forcedPar.parallelIterator
-    def seq = forcedPar.seq.view.asInstanceOf[IterableView[S, CollSeq]]
+    override def seq = forcedPar.seq.view.asInstanceOf[IterableView[S, CollSeq]]
   }
 
   // only use if other is a ParSeq, otherwise force
   trait Zipped[S] extends super.Zipped[S] with Transformed[(T, S)] {
     def otherPar: ParSeq[S] = other.asParSeq
     def parallelIterator: ParIterableIterator[(T, S)] = self.parallelIterator zipParSeq otherPar.parallelIterator
-    def seq = (self.seq zip other).asInstanceOf[IterableView[(T, S), CollSeq]]
+    override def seq = (self.seq zip other).asInstanceOf[IterableView[(T, S), CollSeq]]
   }
 
   // only use if other is a ParSeq, otherwise force
   trait ZippedAll[U >: T, S] extends super.ZippedAll[U, S] with Transformed[(U, S)] {
     def otherPar: ParSeq[S] = other.asParSeq
     def parallelIterator: ParIterableIterator[(U, S)] = self.parallelIterator.zipAllParSeq(otherPar.parallelIterator, thisElem, thatElem)
-    def seq = (self.seq.zipAll(other, thisElem, thatElem)).asInstanceOf[IterableView[(U, S), CollSeq]]
+    override def seq = (self.seq.zipAll(other, thisElem, thatElem)).asInstanceOf[IterableView[(U, S), CollSeq]]
   }
 
   protected[this] def thisParSeq: ParSeq[T] = mutable.ParArray.fromTraversables(this.iterator)
diff --git a/src/library/scala/collection/parallel/ParSeqLike.scala b/src/library/scala/collection/parallel/ParSeqLike.scala
index 1e49f69753..189db237b9 100644
--- a/src/library/scala/collection/parallel/ParSeqLike.scala
+++ b/src/library/scala/collection/parallel/ParSeqLike.scala
@@ -320,7 +320,7 @@ self =>
     protected lazy val underlying = self.repr
     def length = self.length
     def apply(idx: Int) = self(idx)
-    def seq = self.seq.view
+    override def seq = self.seq.view
     def parallelIterator = self.parallelIterator
   }
 
diff --git a/src/library/scala/collection/parallel/Tasks.scala b/src/library/scala/collection/parallel/Tasks.scala
index 921223217d..f855dede19 100644
--- a/src/library/scala/collection/parallel/Tasks.scala
+++ b/src/library/scala/collection/parallel/Tasks.scala
@@ -329,6 +329,8 @@ object ThreadPoolTasks {
 
   val numCores = Runtime.getRuntime.availableProcessors
 
+  val tcount = new atomic.AtomicLong(0L)
+
   val defaultThreadPool = new ThreadPoolExecutor(
     numCores,
     Int.MaxValue,
@@ -337,6 +339,7 @@ object ThreadPoolTasks {
     new ThreadFactory {
       def newThread(r: Runnable) = {
         val t = new Thread(r)
+        t.setName("pc-thread-" + tcount.incrementAndGet)
         t.setDaemon(true)
         t
       }
diff --git a/src/library/scala/collection/parallel/immutable/ParHashMap.scala b/src/library/scala/collection/parallel/immutable/ParHashMap.scala
index 66b981e8c4..84705c33e7 100644
--- a/src/library/scala/collection/parallel/immutable/ParHashMap.scala
+++ b/src/library/scala/collection/parallel/immutable/ParHashMap.scala
@@ -66,7 +66,7 @@ self =>
 
   def parallelIterator: ParIterableIterator[(K, V)] = new ParHashMapIterator(trie.iterator, trie.size) with SCPI
 
-  def seq = trie
+  override def seq = trie
 
   def -(k: K) = new ParHashMap(trie - k)
 
diff --git a/src/library/scala/collection/parallel/immutable/ParHashSet.scala b/src/library/scala/collection/parallel/immutable/ParHashSet.scala
index bd9cefa298..29c6eb0f93 100644
--- a/src/library/scala/collection/parallel/immutable/ParHashSet.scala
+++ b/src/library/scala/collection/parallel/immutable/ParHashSet.scala
@@ -64,7 +64,7 @@ self =>
 
   def parallelIterator: ParIterableIterator[T] = new ParHashSetIterator(trie.iterator, trie.size) with SCPI
 
-  def seq = trie
+  override def seq = trie
 
   def -(e: T) = new ParHashSet(trie - e)
 
diff --git a/src/library/scala/collection/parallel/immutable/ParRange.scala b/src/library/scala/collection/parallel/immutable/ParRange.scala
index f68c7c9062..157f6746fa 100644
--- a/src/library/scala/collection/parallel/immutable/ParRange.scala
+++ b/src/library/scala/collection/parallel/immutable/ParRange.scala
@@ -39,7 +39,7 @@ extends ParSeq[Int]
 {
 self =>
 
-  def seq = range
+  override def seq = range
 
   @inline final def length = range.length
 
diff --git a/src/library/scala/collection/parallel/immutable/ParSeq.scala b/src/library/scala/collection/parallel/immutable/ParSeq.scala
index dbb37a9c69..a922642022 100644
--- a/src/library/scala/collection/parallel/immutable/ParSeq.scala
+++ b/src/library/scala/collection/parallel/immutable/ParSeq.scala
@@ -32,7 +32,7 @@ extends collection.immutable.Seq[T]
    with collection.parallel.ParSeq[T]
    with ParIterable[T]
    with GenericParTemplate[T, ParSeq]
-   with ParSeqLike[T, ParSeq[T], Seq[T]]
+   with ParSeqLike[T, ParSeq[T], collection.immutable.Seq[T]]
 {
   override def companion: GenericCompanion[ParSeq] with GenericParCompanion[ParSeq] = ParSeq
   override def toSeq: ParSeq[T] = this
diff --git a/src/library/scala/collection/parallel/immutable/ParVector.scala b/src/library/scala/collection/parallel/immutable/ParVector.scala
index f79ba2a7f9..05e057a2a4 100644
--- a/src/library/scala/collection/parallel/immutable/ParVector.scala
+++ b/src/library/scala/collection/parallel/immutable/ParVector.scala
@@ -52,13 +52,16 @@ extends ParSeq[T]
   type SCPI = SignalContextPassingIterator[ParVectorIterator]
 
   def apply(idx: Int) = vector.apply(idx)
+
   def length = vector.length
+
   def parallelIterator: ParSeqIterator[T] = {
     val pit = new ParVectorIterator(vector.startIndex, vector.endIndex) with SCPI
     vector.initIterator(pit)
     pit
   }
-  def seq: Vector[T] = vector
+
+  override def seq: Vector[T] = vector
 
   class ParVectorIterator(_start: Int, _end: Int) extends VectorIterator[T](_start, _end) with ParIterator {
   self: SCPI =>
diff --git a/src/library/scala/collection/parallel/immutable/package.scala b/src/library/scala/collection/parallel/immutable/package.scala
index 8bb0b2216d..87d5bfc9f9 100644
--- a/src/library/scala/collection/parallel/immutable/package.scala
+++ b/src/library/scala/collection/parallel/immutable/package.scala
@@ -37,7 +37,7 @@ package object immutable {
   private[parallel] class Repetition[T](elem: T, val length: Int) extends ParSeq[T] {
   self =>
     def apply(idx: Int) = if (0 <= idx && idx < length) elem else throw new IndexOutOfBoundsException
-    def seq = throw new UnsupportedOperationException
+    override def seq = throw new UnsupportedOperationException
     def update(idx: Int, elem: T) = throw new UnsupportedOperationException
 
     type SCPI = SignalContextPassingIterator[ParIterator]
diff --git a/src/library/scala/collection/parallel/mutable/ParArray.scala b/src/library/scala/collection/parallel/mutable/ParArray.scala
index bf5cbf9a1e..f976098f5e 100644
--- a/src/library/scala/collection/parallel/mutable/ParArray.scala
+++ b/src/library/scala/collection/parallel/mutable/ParArray.scala
@@ -23,7 +23,6 @@ import scala.collection.parallel.ParSeqLike
 import scala.collection.parallel.CHECK_RATE
 import scala.collection.mutable.ArraySeq
 import scala.collection.mutable.Builder
-import scala.collection.Sequentializable
 
 
 
@@ -72,7 +71,7 @@ self =>
 
   def length = arrayseq.length
 
-  def seq = arrayseq
+  override def seq = arrayseq
 
   type SCPI = SignalContextPassingIterator[ParArrayIterator]
 
diff --git a/src/library/scala/collection/parallel/mutable/ParHashMap.scala b/src/library/scala/collection/parallel/mutable/ParHashMap.scala
index 4dcf263fc5..2945bcdc61 100644
--- a/src/library/scala/collection/parallel/mutable/ParHashMap.scala
+++ b/src/library/scala/collection/parallel/mutable/ParHashMap.scala
@@ -54,12 +54,14 @@ self =>
 
   protected[this] override def newCombiner = ParHashMapCombiner[K, V]
 
-  def seq = new collection.mutable.HashMap[K, V](hashTableContents)
+  override def seq = new collection.mutable.HashMap[K, V](hashTableContents)
 
   def parallelIterator = new ParHashMapIterator(1, table.length, size, table(0).asInstanceOf[DefaultEntry[K, V]]) with SCPI
 
   override def size = tableSize
 
+  override def clear() = clearTable()
+
   def get(key: K): Option[V] = {
     val e = findEntry(key)
     if (e == null) None
diff --git a/src/library/scala/collection/parallel/mutable/ParHashSet.scala b/src/library/scala/collection/parallel/mutable/ParHashSet.scala
index d22e0e8abd..0b969d1cf0 100644
--- a/src/library/scala/collection/parallel/mutable/ParHashSet.scala
+++ b/src/library/scala/collection/parallel/mutable/ParHashSet.scala
@@ -57,7 +57,9 @@ extends ParSet[T]
 
   override def size = tableSize
 
-  def seq = new HashSet(hashTableContents)
+  override def clear() = clearTable()
+
+  override def seq = new HashSet(hashTableContents)
 
   def +=(elem: T) = {
     addEntry(elem)
diff --git a/src/library/scala/collection/parallel/mutable/ParMapLike.scala b/src/library/scala/collection/parallel/mutable/ParMapLike.scala
index 46352829aa..52e11c6db3 100644
--- a/src/library/scala/collection/parallel/mutable/ParMapLike.scala
+++ b/src/library/scala/collection/parallel/mutable/ParMapLike.scala
@@ -37,5 +37,7 @@ extends collection.mutable.MapLike[K, V, Repr]
 
   // note: should not override toMap
 
+  override def clear(): Unit = throw new UnsupportedOperationException("Must be reimplemented for parallel map implementations.")
+
 }
 
diff --git a/src/library/scala/collection/parallel/mutable/ParSeq.scala b/src/library/scala/collection/parallel/mutable/ParSeq.scala
index 1b2b9f9854..26320c1bc3 100644
--- a/src/library/scala/collection/parallel/mutable/ParSeq.scala
+++ b/src/library/scala/collection/parallel/mutable/ParSeq.scala
@@ -33,7 +33,7 @@ trait ParSeq[T] extends collection.mutable.Seq[T]
                    with ParIterable[T]
                    with collection.parallel.ParSeq[T]
                    with GenericParTemplate[T, ParSeq]
-                   with ParSeqLike[T, ParSeq[T], Seq[T]] {
+                   with ParSeqLike[T, ParSeq[T], collection.mutable.Seq[T]] {
   self =>
   override def companion: GenericCompanion[ParSeq] with GenericParCompanion[ParSeq] = ParSeq
 
@@ -41,6 +41,7 @@ trait ParSeq[T] extends collection.mutable.Seq[T]
 
   override def toSeq: ParSeq[T] = this
 
+  override def transform(f: T => T): this.type = throw new UnsupportedOperationException("Not supported for parallel sequences.")
 }