Merge pull request scala#40 from gkossakowski/cleanups

Cleanups

Author: gkossakowski

src/library/scala/collection/GenMapLike.scala

@@ -29,10 +29,78 @@ trait GenMapLike[A, +B, +Repr] extends GenIterableLike[(A, B), Repr] with Equals
   def +[B1 >: B](kv: (A, B1)): GenMap[A, B1]
   def - (key: A): Repr
 
+  
   // This hash code must be symmetric in the contents but ought not
   // collide trivially.
   override def hashCode() = util.MurmurHash3.symmetricHash(seq, Map.hashSeed)
+  
+  /**  Returns the value associated with a key, or a default value if the key is not contained in the map. 
+   *   @param   key      the key.
+   *   @param   default  a computation that yields a default value in case no binding for `key` is
+   *                     found in the map.
+   *   @tparam  B1       the result type of the default computation. 
+   *   @return  the value associated with `key` if it exists,
+   *            otherwise the result of the `default` computation.
+   *   @usecase def getOrElse(key: A, default: => B): B
+   */
+  def getOrElse[B1 >: B](key: A, default: => B1): B1
+  
+  /** Tests whether this map contains a binding for a key.
+   *
+   *  @param key the key
+   *  @return    `true` if there is a binding for `key` in this map, `false` otherwise.
+   */
+  def contains(key: A): Boolean
 
+  /** Tests whether this map contains a binding for a key. This method,
+   *  which implements an abstract method of trait `PartialFunction`,
+   *  is equivalent to `contains`.
+   *
+   *  @param key the key
+   *  @return    `true` if there is a binding for `key` in this map, `false` otherwise.
+   */
+  def isDefinedAt(key: A): Boolean
+  
+  def keySet: GenSet[A]
+  
+  /** Collects all keys of this map in an iterable collection.
+   *  
+   *  @return the keys of this map as an iterable.
+   */
+  def keys: GenIterable[A]
+  
+  /** Collects all values of this map in an iterable collection.
+   *  
+   *  @return the values of this map as an iterable.
+   */
+  def values: GenIterable[B]
+  
+  /** Creates an iterator for all keys.
+   *
+   *  @return an iterator over all keys.
+   */
+  def keysIterator: Iterator[A]
+  
+  /** Creates an iterator for all values in this map.
+   *
+   *  @return an iterator over all values that are associated with some key in this map.
+   */
+  def valuesIterator: Iterator[B]
+    
+  /** Filters this map by retaining only keys satisfying a predicate.
+   *  @param  p   the predicate used to test keys
+   *  @return an immutable map consisting only of those key value pairs of this map where the key satisfies
+   *          the predicate `p`. The resulting map wraps the original map without copying any elements.
+   */
+  def filterKeys(p: A => Boolean): GenMap[A, B]
+  
+  /** Transforms this map by applying a function to every retrieved value.
+   *  @param  f   the function used to transform values of this map.
+   *  @return a map view which maps every key of this map
+   *          to `f(this(key))`. The resulting map wraps the original map without copying any elements.
+   */
+  def mapValues[C](f: B => C): GenMap[A, C]
+  
   /** Compares two maps structurally; i.e. checks if all mappings
    *  contained in this map are also contained in the other map,
    *  and vice versa.
@@ -42,21 +110,21 @@ trait GenMapLike[A, +B, +Repr] extends GenIterableLike[(A, B), Repr] with Equals
    *              same mappings, `false` otherwise.
    */
   override def equals(that: Any): Boolean = that match {
-    case that: GenMap[b, _] =>
+    case that: GenMap[b, _] => 
       (this eq that) ||
       (that canEqual this) &&
       (this.size == that.size) && {
       try {
-        this forall {
+        this forall { 
           case (k, v) => that.get(k.asInstanceOf[b]) match {
             case Some(`v`) =>
               true
             case _ => false
           }
         }
-      } catch {
-        case ex: ClassCastException =>
-          false
+      } catch { 
+        case ex: ClassCastException => 
+          println("class cast "); false 
       }}
     case _ =>
       false

src/library/scala/collection/immutable/RedBlack.scala

@@ -257,7 +257,7 @@ abstract class RedBlack[A] extends Serializable {
     def last  = if (right.isEmpty) key else right.last
     def count = 1 + left.count + right.count
   }
-  class Empty extends Tree[Nothing] {
+  case object Empty extends Tree[Nothing] {
     def isEmpty = true
     def isBlack = true
     def lookup(k: A): Tree[Nothing] = this
@@ -274,7 +274,6 @@ abstract class RedBlack[A] extends Serializable {
     def last = throw new NoSuchElementException("empty map")
     def count = 0
   }
-  lazy val Empty = new Empty
   case class RedTree[+B](override val key: A,
                          override val value: B,
                          override val left: Tree[B],

src/library/scala/collection/immutable/Vector.scala

@@ -933,7 +933,7 @@ private[immutable] trait VectorPointer[T] {
 
     private[immutable] final def copyOf(a: Array[AnyRef]) = {
       //println("copy")
-//      if (a eq null) println ("NULL")
+      if (a eq null) println ("NULL")
       val b = new Array[AnyRef](a.length)
       Platform.arraycopy(a, 0, b, 0, a.length)
       b