Use `keySet' and `valueIterable' to get keys an...

Use `keySet' and `valueIterable' to get keys and values from a map as
non-iterator collections.

9 files changed, 52 insertions, 31 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
index 822c3ba4d9..564d4ea36b 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
@@ -507,7 +507,7 @@ abstract class GenICode extends SubComponent  {
             tmp = ctx.makeLocal(tree.pos, tree.tpe, "tmp")
           }
           def duplicateFinalizer =
-            (new DuplicateLabels(ctx.labels.keys))(ctx, finalizer)
+            (new DuplicateLabels(ctx.labels.keySet))(ctx, finalizer)
 
           var handlers = for (CaseDef(pat, _, body) <- catches.reverse)
             yield pat match {
diff --git a/src/compiler/scala/tools/nsc/doc/DefaultDocDriver.scala b/src/compiler/scala/tools/nsc/doc/DefaultDocDriver.scala
index adc48f6943..a7d38d8245 100644
--- a/src/compiler/scala/tools/nsc/doc/DefaultDocDriver.scala
+++ b/src/compiler/scala/tools/nsc/doc/DefaultDocDriver.scala
@@ -109,7 +109,7 @@ abstract class DefaultDocDriver extends DocDriver with ModelFrames with ModelToX
       for (pp <- d.sym.tpe.parents) subClasses(pp.typeSymbol) += d
     }
     copyResources
-    lazy val packages0 = sort(allClasses.keys)
+    lazy val packages0 = sort(allClasses.keySet)
     new AllPackagesFrame     with Frame { def packages = packages0 }
     new PackagesContentFrame with Frame { def packages = packages0 }
     new NavigationFrame      with Frame { }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index 74a0a6c464..7d0268c6af 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -471,7 +471,7 @@ self: Analyzer =>
       if (best == NoImplicitInfo) SearchFailure
       else {
         /** The list of all applicable infos which are not improved upon by `best`. */
-        val competing = applicable.keys dropWhile (alt => best == alt || improves(best, alt))
+        val competing = applicable.keySet dropWhile (alt => best == alt || improves(best, alt))
         if (!competing.isEmpty) ambiguousImplicitError(best, competing.iterator.next, "both", "and", "") // !!! streamline when new collection is there
 
         // Also check that applicable infos that did not get selected are not
diff --git a/src/library/scala/collection/Iterable.scala b/src/library/scala/collection/Iterable.scala
index 3e886f6d5e..826248bf2a 100644
--- a/src/library/scala/collection/Iterable.scala
+++ b/src/library/scala/collection/Iterable.scala
@@ -17,7 +17,7 @@ import generic._
 /** A template trait for iterable collections.
  *
  *  Collection classes mixing in this trait provide a method
- *  <code>elements</code> which returns an iterator over all the
+ *  <code>iterator</code> which returns an iterator over all the
  *  elements contained in the collection. They also provide a method `newBuilder`
  *  which creates a builder for collections of the same kind.
  *
diff --git a/src/library/scala/collection/generic/MapTemplate.scala b/src/library/scala/collection/generic/MapTemplate.scala
index a57bf3123c..96fd1018f5 100644
--- a/src/library/scala/collection/generic/MapTemplate.scala
+++ b/src/library/scala/collection/generic/MapTemplate.scala
@@ -110,23 +110,18 @@ self =>
    */
   def isDefinedAt(key: A) = contains(key)
 
-  /**
-   *  @return the keys of this map as a set.
-   */
-  def keys: immutable.Set[A] = new DefaultKeySet
+  /** @return the keys of this map as a set. */
+  def keySet: Set[A] = new DefaultKeySet
 
-  protected class DefaultKeySet extends immutable.Set[A] {
+  protected class DefaultKeySet extends Set[A] {
     def contains(key : A) = self.contains(key)
     def iterator = self.iterator.map(_._1)
-    def + (elem: A): immutable.Set[A] = (immutable.Set[A]() ++ this + elem).asInstanceOf[immutable.Set[A]] // !!! concrete overrides abstract problem
-    def - (elem: A): immutable.Set[A] = (immutable.Set[A]() ++ this - elem).asInstanceOf[immutable.Set[A]] // !!! concrete overrides abstract problem
+    def + (elem: A): Set[A] = (Set[A]() ++ this + elem).asInstanceOf[Set[A]] // !!! concrete overrides abstract problem
+    def - (elem: A): Set[A] = (Set[A]() ++ this - elem).asInstanceOf[Set[A]] // !!! concrete overrides abstract problem
     override def size = self.size
-    override def foreach[B](f: A => B) = for ((k, v) <- self) f(k)
+    override def foreach[C](f: A => C) = for ((k, v) <- self) f(k)
   }
 
-  /** @return the keys of this map as a set. */
-  @deprecated("use `keys' instead") def keySet: collection.Set[A] = new DefaultKeySet
-
   /** Creates an iterator for all keys.
    *
    *  @return an iterator over all keys.
@@ -137,9 +132,22 @@ self =>
     def next = iter.next._1
   }
 
+  /** Creates an iterator for all keys.
+   *
+   *  @return an iterator over all keys.
+   */
+  @deprecated("use `keysIterator' instead")
+  def keys: Iterator[A] = keysIterator
+
   /** @return the values of this map as an iterable.
    */
-  def values: immutable.Sequence[B] = immutable.Sequence.empty[B] ++ (self map (_._2))
+  def valueIterable: Iterable[B] = new DefaultValuesIterable
+
+  protected class DefaultValuesIterable extends Iterable[B] {
+    def iterator = self.iterator.map(_._2)
+    override def size = self.size
+    override def foreach[C](f: B => C) = for ((k, v) <- self) f(v)
+  }
 
   /** Creates an iterator for a contained values.
    *
@@ -151,6 +159,13 @@ self =>
     def next = iter.next._2
   }
 
+  /** Creates an iterator for a contained values.
+   *
+   *  @return an iterator over all values.
+   */
+  @deprecated("use `valuesIterator' instead")
+  def values: Iterator[B] = valuesIterator
+
   /** The default value for the map, returned when a key is not found
    *  The method implemented here yields an error,
    *  but it might be overridden in subclasses.
diff --git a/src/library/scala/collection/generic/MutableMapTemplate.scala b/src/library/scala/collection/generic/MutableMapTemplate.scala
index 4f663c3e9c..8ca38afbe9 100644
--- a/src/library/scala/collection/generic/MutableMapTemplate.scala
+++ b/src/library/scala/collection/generic/MutableMapTemplate.scala
@@ -193,9 +193,6 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta
     this
   }
 
-  /** @return the values of this map as a set */
-  override def values: immutable.Sequence[B] = immutable.Sequence.empty[B] ++ (self map (_._2))
-
   override def clone(): This =
     empty ++= thisCollection
 
diff --git a/src/library/scala/collection/generic/SortedMapTemplate.scala b/src/library/scala/collection/generic/SortedMapTemplate.scala
index 36202857a3..03b0c983de 100644
--- a/src/library/scala/collection/generic/SortedMapTemplate.scala
+++ b/src/library/scala/collection/generic/SortedMapTemplate.scala
@@ -28,20 +28,20 @@ self =>
   // XXX: implement default version
   def rangeImpl(from : Option[A], until : Option[A]) : This
 
-  protected class DefaultKeySet extends super.DefaultKeySet with immutable.SortedSet[A] {
+  override def keySet : SortedSet[A] = new DefaultKeySortedSet
+
+  protected class DefaultKeySortedSet extends super.DefaultKeySet with SortedSet[A] {
     def ordering = self.ordering;
     /** We can't give an implementation of +/- here because we do not have a generic sorted set implementation
      */
-    override def + (elem: A): immutable.SortedSet[A] = throw new UnsupportedOperationException("keySet.+")
-    override def - (elem: A): immutable.SortedSet[A] = throw new UnsupportedOperationException("keySet.-")
-    override def rangeImpl(from : Option[A], until : Option[A]) : immutable.SortedSet[A] = {
+    override def + (elem: A): SortedSet[A] = throw new UnsupportedOperationException("keySet.+")
+    override def - (elem: A): SortedSet[A] = throw new UnsupportedOperationException("keySet.-")
+    override def rangeImpl(from : Option[A], until : Option[A]) : SortedSet[A] = {
       val map = self.rangeImpl(from, until)
-      new map.DefaultKeySet
+      new map.DefaultKeySortedSet
     }
   }
 
-  override def keySet : SortedSet[A] = new DefaultKeySet
-
   /** Add a key/value pair to this map.
    *  @param    key the key
    *  @param    value the value
diff --git a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala
index 5f97a4a256..91da716f9d 100644
--- a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala
+++ b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala
@@ -40,17 +40,24 @@ extends Map[A, B]
 
   override def isDefinedAt(key: A) = imap.isDefinedAt(key)
 
-  override def keys: immutable.Set[A] = imap.keys
+  override def keySet: Set[A] = imap.keys
 
   override def keysIterator: Iterator[A] = imap.keysIterator
 
-  override def values: immutable.Sequence[B] = imap.values
+  @deprecated("use `keysIterator' instead")
+  override def keys: Iterator[A] = imap.keysIterator
+
+  override def valueIterable: Iterable[B] = imap.valueIterable
 
   override def valuesIterator: Iterator[B] = imap.valuesIterator
 
+  @deprecated("use `valuesIterator' instead")
+  override def values: Iterator[B] = imap.valuesIterator
+
   def iterator: Iterator[(A, B)] = imap.iterator
 
-  @deprecated("use `iterator' instead") def elements = iterator
+  @deprecated("use `iterator' instead")
+  def elements = iterator
 
   override def toList: List[(A, B)] = imap.toList
 
diff --git a/src/library/scala/collection/mutable/SynchronizedMap.scala b/src/library/scala/collection/mutable/SynchronizedMap.scala
index 1015bbb5d6..3a1e310cce 100644
--- a/src/library/scala/collection/mutable/SynchronizedMap.scala
+++ b/src/library/scala/collection/mutable/SynchronizedMap.scala
@@ -33,12 +33,14 @@ trait SynchronizedMap[A, B] extends Map[A, B] {
   override def getOrElseUpdate(key: A, default: => B): B = synchronized { super.getOrElseUpdate(key, default) }
   override def transform(f: (A, B) => B): this.type = synchronized[this.type] { super.transform(f) }
   override def retain(p: (A, B) => Boolean): this.type = synchronized[this.type] { super.retain(p) }
-  override def values: immutable.Sequence[B] = synchronized { super.values }
+  override def valueIterable: collection.Iterable[B] = synchronized { super.valueIterable }
+  @deprecated("Use `valuesIterator' instead") override def values: Iterator[B] = synchronized { super.valuesIterator }
   override def valuesIterator: Iterator[B] = synchronized { super.valuesIterator }
   override def clone() = synchronized { super.clone() }
   override def foreach[U](f: ((A, B)) => U) = synchronized { super.foreach(f) }
   override def apply(key: A): B = synchronized { super.apply(key) }
-  override def keys: immutable.Set[A] = synchronized { super.keys }
+  override def keySet: collection.Set[A] = synchronized { super.keySet }
+  @deprecated("Use `keysIterator' instead") override def keys: Iterator[A] = synchronized { super.keysIterator }
   override def keysIterator: Iterator[A] = synchronized { super.keysIterator }
   override def isEmpty: Boolean = synchronized { super.isEmpty }
   override def contains(key: A): Boolean = synchronized {super.contains(key) }