"Map.values" returns a sequence instead of a set.

5 files changed, 15 insertions, 17 deletions

diff --git a/src/library/scala/collection/generic/MapTemplate.scala b/src/library/scala/collection/generic/MapTemplate.scala
index 8c1112f6bc..a57bf3123c 100644
--- a/src/library/scala/collection/generic/MapTemplate.scala
+++ b/src/library/scala/collection/generic/MapTemplate.scala
@@ -113,13 +113,13 @@ self =>
   /**
    *  @return the keys of this map as a set.
    */
-  def keys: Set[A] = new DefaultKeySet
+  def keys: immutable.Set[A] = new DefaultKeySet
 
-  protected class DefaultKeySet extends Set[A] {
+  protected class DefaultKeySet extends immutable.Set[A] {
     def contains(key : A) = self.contains(key)
     def iterator = self.iterator.map(_._1)
-    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
+    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
     override def size = self.size
     override def foreach[B](f: A => B) = for ((k, v) <- self) f(k)
   }
@@ -137,11 +137,9 @@ self =>
     def next = iter.next._1
   }
 
-  /** @return the values of this map as a set.
-   *  @note  Can't return a Set[B] here because sets are non-variant.
-   *         The operation is overridden with the sharper type in MutableMapTemplate.
+  /** @return the values of this map as an iterable.
    */
-  def values: collection.Set[_ <: B] = immutable.Set.empty[B] ++ (self map (_._2))
+  def values: immutable.Sequence[B] = immutable.Sequence.empty[B] ++ (self map (_._2))
 
   /** Creates an iterator for a contained values.
    *
diff --git a/src/library/scala/collection/generic/MutableMapTemplate.scala b/src/library/scala/collection/generic/MutableMapTemplate.scala
index 9290986dfd..4f663c3e9c 100644
--- a/src/library/scala/collection/generic/MutableMapTemplate.scala
+++ b/src/library/scala/collection/generic/MutableMapTemplate.scala
@@ -194,7 +194,7 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta
   }
 
   /** @return the values of this map as a set */
-  override def values: collection.immutable.Set[B] = immutable.Set.empty[B] ++ (self map (_._2))
+  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 23b1f13dc4..36202857a3 100644
--- a/src/library/scala/collection/generic/SortedMapTemplate.scala
+++ b/src/library/scala/collection/generic/SortedMapTemplate.scala
@@ -28,13 +28,13 @@ self =>
   // XXX: implement default version
   def rangeImpl(from : Option[A], until : Option[A]) : This
 
-  protected class DefaultKeySet extends super.DefaultKeySet with SortedSet[A] {
+  protected class DefaultKeySet extends super.DefaultKeySet with immutable.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): 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] = {
+    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] = {
       val map = self.rangeImpl(from, until)
       new map.DefaultKeySet
     }
diff --git a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala
index 6f954d299b..5f97a4a256 100644
--- a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala
+++ b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala
@@ -40,11 +40,11 @@ extends Map[A, B]
 
   override def isDefinedAt(key: A) = imap.isDefinedAt(key)
 
-  override def keys: collection.Set[A] = imap.keys
+  override def keys: immutable.Set[A] = imap.keys
 
   override def keysIterator: Iterator[A] = imap.keysIterator
 
-  override def values: collection.Set[A] = imap.values
+  override def values: immutable.Sequence[B] = imap.values
 
   override def valuesIterator: Iterator[B] = imap.valuesIterator
 
diff --git a/src/library/scala/collection/mutable/SynchronizedMap.scala b/src/library/scala/collection/mutable/SynchronizedMap.scala
index 61c9b50568..1015bbb5d6 100644
--- a/src/library/scala/collection/mutable/SynchronizedMap.scala
+++ b/src/library/scala/collection/mutable/SynchronizedMap.scala
@@ -33,12 +33,12 @@ 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: collection.immutable.Set[B] = synchronized { super.values }
+  override def values: immutable.Sequence[B] = synchronized { super.values }
   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: collection.Set[A] = synchronized { super.keys }
+  override def keys: immutable.Set[A] = synchronized { super.keys }
   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) }