wip: add types

Author: SethTisue

core/src/main/scala/scala/collection/parallel/RemainsIterator.scala

@@ -465,7 +465,7 @@ self =>
     def split: Seq[IterableSplitter[S]] = self.split.map { _ map f }
   }
 
-  override def map[S](f: T => S) = new Mapped(f)
+  override def map[S](f: T => S): Mapped[S] = new Mapped[S](f)
 
   class Appended[U >: T, PI <: IterableSplitter[U]](protected val that: PI) extends IterableSplitter[U] {
     signalDelegate = self.signalDelegate
@@ -500,7 +500,7 @@ self =>
     }
   }
 
-  def zipParSeq[S](that: SeqSplitter[S]) = new Zipped(that)
+  def zipParSeq[S](that: SeqSplitter[S]): Zipped[S] = new Zipped(that)
 
   class ZippedAll[U >: T, S](protected val that: SeqSplitter[S], protected val thiselem: U, protected val thatelem: S)
   extends IterableSplitter[(U, S)] {
@@ -513,13 +513,13 @@ self =>
 
     def remaining = self.remaining max that.remaining
     def dup: IterableSplitter[(U, S)] = self.dup.zipAllParSeq(that, thiselem, thatelem)
-    def split: Seq[IterableSplitter[(U, S)]] = {
+    def split: Seq[SeqSplitter[(U, S)]] = {
       val selfrem = self.remaining
       val thatrem = that.remaining
       val thisit = if (selfrem < thatrem) self.appendParIterable[U, SeqSplitter[U]](repetition[U](thiselem, thatrem - selfrem).splitter) else self
       val thatit = if (selfrem > thatrem) that.appendParSeq(repetition(thatelem, selfrem - thatrem).splitter) else that
       val zipped = thisit zipParSeq thatit
-      zipped.split
+      zipped.split.asInstanceOf[Seq[SeqSplitter[(U, S)]]]
     }
   }
 
@@ -578,7 +578,7 @@ self =>
     def psplit(sizes: Int*): Seq[SeqSplitter[S]] = self.psplit(sizes: _*).map { _ map f }
   }
 
-  override def map[S](f: T => S) = new RemainsIteratorMapped(f)
+  override def map[S](f: T => S): RemainsIteratorMapped[S] = new RemainsIteratorMapped(f)
 
   class RemainsIteratorAppended[U >: T, PI <: SeqSplitter[U]](it: PI) extends Appended[U, PI](it) with SeqSplitter[U] {
     override def dup = super.dup.asInstanceOf[SeqSplitter[U]]
@@ -614,7 +614,7 @@ self =>
   class RemainsIteratorZipped[S](ti: SeqSplitter[S]) extends Zipped[S](ti) with SeqSplitter[(T, S)] {
     override def dup = super.dup.asInstanceOf[SeqSplitter[(T, S)]]
     override def split: Seq[SeqSplitter[(T, S)]] = super.split.asInstanceOf[Seq[SeqSplitter[(T, S)]]]
-    def psplit(szs: Int*) = (self.psplit(szs: _*) zip that.psplit(szs: _*)) map { p => p._1 zipParSeq p._2 }
+    def psplit(szs: Int*) = (self.psplit(szs: _*) zip that.psplit(szs: _*)) map { p => (p._1 zipParSeq p._2).asInstanceOf[SeqSplitter[(T, S)]] }
   }
 
   override def zipParSeq[S](that: SeqSplitter[S]) = new RemainsIteratorZipped(that)
@@ -631,11 +631,11 @@ self =>
     override def split: Seq[SeqSplitter[(U, S)]] = {
       val (thisit, thatit) = patchem
       val zipped = thisit zipParSeq thatit
-      zipped.split
+      zipped.split.asInstanceOf[Seq[SeqSplitter[(U, S)]]]
     }
     def psplit(sizes: Int*): Seq[SeqSplitter[(U, S)]] = {
       val (thisit, thatit) = patchem
-      val zipped = thisit zipParSeq thatit
+      val zipped = (thisit zipParSeq thatit).asInstanceOf[SeqSplitter[(U, S)]]
       zipped.psplit(sizes: _*)
     }
   }

core/src/main/scala/scala/collection/parallel/Tasks.scala

@@ -306,7 +306,7 @@ trait AdaptiveWorkStealingForkJoinTasks extends ForkJoinTasks with AdaptiveWorkS
     def split = body.split.map(b => newWrappedTask(b))
   }
 
-  def newWrappedTask[R, Tp](b: Task[R, Tp]) = new AWSFJTWrappedTask[R, Tp](b)
+  def newWrappedTask[R, Tp](b: Task[R, Tp]): AWSFJTWrappedTask[R, Tp] = new AWSFJTWrappedTask[R, Tp](b)
 }
 
 /** An implementation of the `Tasks` that uses Scala `Future`s to compute

core/src/main/scala/scala/collection/parallel/immutable/ParHashMap.scala

@@ -94,7 +94,7 @@ self =>
     def split: Seq[IterableSplitter[(K, V)]] = if (remaining < 2) Seq(this) else triter match {
       case t: TrieIterator[_] =>
         val previousRemaining = remaining
-        val ((fst, fstlength), snd) = t.split
+        val ((fst: Iterator[(K, V @uncheckedVariance)], fstlength), snd: Iterator[(K, V @uncheckedVariance)]) = t.split
         val sndlength = previousRemaining - fstlength
         Seq(
           new ParHashMapIterator(fst, fstlength),
@@ -308,7 +308,7 @@ extends scala.collection.parallel.BucketCombiner[(K, V), ParHashMap[K, V], (K, V
       case hm1: OldHashMap.OldHashMap1[_, _] =>
         val evaledvalue = hm1.value.result()
         new OldHashMap.OldHashMap1[K, Repr](hm1.key, hm1.hash, evaledvalue, null)
-      case hmc: OldHashMap.OldHashMapCollision1[_, _] =>
+      case hmc: OldHashMap.OldHashMapCollision1[_, Combiner[V, Repr]] =>
         val evaledkvs = hmc.kvs map { p => (p._1, p._2.result()) }
         new OldHashMap.OldHashMapCollision1[K, Repr](hmc.hash, evaledkvs)
       case htm: OldHashMap.HashTrieMap[k, v] =>

core/src/main/scala/scala/collection/parallel/immutable/ParHashSet.scala

@@ -78,7 +78,7 @@ self =>
   extends IterableSplitter[T] {
     var i = 0
     def dup = triter match {
-      case t: TrieIterator[_] =>
+      case t: TrieIterator[T] =>
         dupFromIterator(t.dupIterator)
       case _ =>
         val buff = triter.toBuffer
@@ -91,7 +91,7 @@ self =>
       phit
     }
     def split: Seq[IterableSplitter[T]] = if (remaining < 2) Seq(this) else triter match {
-      case t: TrieIterator[_] =>
+      case t: TrieIterator[T] =>
         val previousRemaining = remaining
         val ((fst, fstlength), snd) = t.split
         val sndlength = previousRemaining - fstlength

core/src/main/scala/scala/collection/parallel/mutable/ParHashMap.scala

@@ -196,7 +196,7 @@ extends scala.collection.parallel.BucketCombiner[(K, V), ParHashMap[K, V], Defau
   } else {
     // construct a normal table and fill it sequentially
     // TODO parallelize by keeping separate sizemaps and merging them
-    object table extends HashTable[K, DefaultEntry[K, V], DefaultEntry[K, V]] with WithContents[K, DefaultEntry[K, V], DefaultEntry[K, V]] {
+    object newTable extends HashTable[K, DefaultEntry[K, V], DefaultEntry[K, V]] with WithContents[K, DefaultEntry[K, V], DefaultEntry[K, V]] {
       type Entry = DefaultEntry[K, V]
       def insertEntry(e: Entry): Unit = { super.findOrAddEntry(e.key, e) }
       def createNewEntry(key: K, entry: Entry): Entry = entry
@@ -205,11 +205,11 @@ extends scala.collection.parallel.BucketCombiner[(K, V), ParHashMap[K, V], Defau
     var i = 0
     while (i < ParHashMapCombiner.numblocks) {
       if (buckets(i) ne null) {
-        for (elem <- buckets(i)) table.insertEntry(elem)
+        for (elem <- buckets(i)) newTable.insertEntry(elem)
       }
       i += 1
     }
-    new ParHashMap(table.hashTableContents)
+    new ParHashMap(newTable.hashTableContents)
   }
 
   /* classes */

core/src/main/scala/scala/collection/parallel/mutable/ParTrieMap.scala

@@ -127,7 +127,7 @@ extends TrieMapIterator[K, V](lev, ct, mustInit)
   lazy val totalsize = new ParTrieMap(ct).size
   var iterated = 0
 
-  protected override def newIterator(_lev: Int, _ct: TrieMap[K, V], _mustInit: Boolean) = new ParTrieMapSplitter[K, V](_lev, _ct, _mustInit)
+  protected override def newIterator(_lev: Int, _ct: TrieMap[K, V], _mustInit: Boolean): ParTrieMapSplitter[K, V] = new ParTrieMapSplitter[K, V](_lev, _ct, _mustInit)
 
   override def shouldSplitFurther[S](coll: scala.collection.parallel.ParIterable[S], parallelismLevel: Int) = {
     val maxsplits = 3 + Integer.highestOneBit(parallelismLevel)