Small refactoring of the collection library

20 files changed, 105 insertions, 175 deletions

diff --git a/src/library/scala/Iterable.scala b/src/library/scala/Iterable.scala
index ad1ac9c972..527ff52fa8 100644
--- a/src/library/scala/Iterable.scala
+++ b/src/library/scala/Iterable.scala
@@ -178,4 +178,9 @@ trait Iterable[+A] {
     }
     !ita.hasNext && !itb.hasNext && res
   }
+
+  /**
+   * @return a list with all the elements of this iterable object
+   */
+  def toList: List[A] = elements.toList
 }
diff --git a/src/library/scala/IterableProxy.scala b/src/library/scala/IterableProxy.scala
index 188e06c6ef..a35e7e0ecd 100644
--- a/src/library/scala/IterableProxy.scala
+++ b/src/library/scala/IterableProxy.scala
@@ -101,4 +101,6 @@ trait IterableProxy[+A] extends Iterable[A] with Proxy {
    */
   override def sameElements[B >: A](that: Iterable[B]): Boolean =
     self.sameElements(that)
+
+  override def toList: List[A] = self.toList
 }
diff --git a/src/library/scala/List.scala b/src/library/scala/List.scala
index 708fadc4a0..7a6cfbe1d0 100644
--- a/src/library/scala/List.scala
+++ b/src/library/scala/List.scala
@@ -470,6 +470,7 @@ sealed abstract class List[+a] extends Seq[a] with CaseClass {
       else {
         val result = these.head; these = these.tail; result
       }
+    override def toList: List[a] = these;
   }
 
   /** Overrides the method in Iterable for efficiency.
diff --git a/src/library/scala/Option.scala b/src/library/scala/Option.scala
index 0577e66594..1355b3ee24 100644
--- a/src/library/scala/Option.scala
+++ b/src/library/scala/Option.scala
@@ -63,7 +63,7 @@ sealed abstract class Option[+A] extends Iterable[A] with CaseClass {
     case Some(x) => Iterator.fromValues(x)
   }
 
-  def toList: List[A] = this match {
+  override def toList: List[A] = this match {
     case None => List()
     case Some(x) => List(x)
   }
diff --git a/src/library/scala/Seq.scala b/src/library/scala/Seq.scala
index f36288bc06..3dd86eb4c9 100644
--- a/src/library/scala/Seq.scala
+++ b/src/library/scala/Seq.scala
@@ -159,12 +159,6 @@ trait Seq[+A] extends AnyRef with PartialFunction[Int, A] with Iterable[A] {
     } else
       Predef.error("cannot create subsequence");
 
-  /** Transform this sequence into a list of all elements.
-   *
-   *  @return  a list which enumerates all elements of this sequence.
-   */
-  def toList: List[A] = elements.toList
-
   /** Converts this sequence to a fresh Array */
   def toArray[B >: A]: Array[B] =
     elements.copyToArray(new Array[B](length), 0)
diff --git a/src/library/scala/SeqProxy.scala b/src/library/scala/SeqProxy.scala
index b83894b3d6..f43da07aaf 100644
--- a/src/library/scala/SeqProxy.scala
+++ b/src/library/scala/SeqProxy.scala
@@ -96,9 +96,4 @@ trait SeqProxy[+A] extends Seq[A] with IterableProxy[A] {
   override def copyToArray[B >: A](xs: Array[B], start: Int): Array[B] =
     self.copyToArray(xs, start)
 
-  /** Transform this sequence into a list of all elements.
-   *
-   *  @return  a list which enumerates all elements of this sequence.
-   */
-  override def toList: List[A] = self.toList
 }
diff --git a/src/library/scala/collection/Map.scala b/src/library/scala/collection/Map.scala
index 3cc2fa8c0f..bf51e021b9 100644
--- a/src/library/scala/collection/Map.scala
+++ b/src/library/scala/collection/Map.scala
@@ -98,42 +98,6 @@ trait Map[A, +B] extends AnyRef
       def next = iter.next._2
     }
 
-    /** Executes the given function for all (key, value) pairs
-     *  contained in this map.
-     *
-     *  @param      f   the function to execute.
-     */
-    def foreach(f: (A, B) => Unit) = {
-      val iter = elements
-      while (iter.hasNext) {
-        val Pair(key, value) = iter.next
-        f(key, value)
-      }
-    }
-
-    /** Applies the given predicate to all (key, value) mappings
-     *  contained in this map and returns true if this predicate
-     *  yields true for all mappings.
-     *
-     *  @param      p   the predicate
-     *  @return    true, iff p yields true for all mappings.
-     */
-    def forall(p: (A, B) => Boolean): Boolean = elements.forall {
-      case Pair(key, value) => p(key, value)
-    }
-
-    /** Applies the given predicate to all (key, value) mappings
-     *  contained in this map and returns true if there is at least
-     *  one mapping for which this predicate yields true.
-     *
-     *  @param     p   the predicate
-     *  @return    true, iff there is at least one mapping for which
-     *             p yields true.
-     */
-    def exists(p: (A, B) => Boolean): Boolean = elements.exists {
-      case Pair(key, value) => p(key, value)
-    }
-
     /** Compares two maps structurally; i.e. checks if all mappings
      *  contained in this map are also contained in the other map,
      *  and vice versa.
@@ -151,12 +115,6 @@ trait Map[A, +B] extends AnyRef
       case _ => false
     }
 
-    /** Returns the mappings of this map as a list.
-     *
-     *  @return    a list containing all mappings
-     */
-    def toList: List[Pair[A, B]] = elements.toList
-
     /** Creates a string representation for this map.
      *
      *  @return    a string showing all mappings
diff --git a/src/library/scala/collection/MapProxy.scala b/src/library/scala/collection/MapProxy.scala
index 59c39991f5..d780c9ed65 100644
--- a/src/library/scala/collection/MapProxy.scala
+++ b/src/library/scala/collection/MapProxy.scala
@@ -21,25 +21,22 @@ package scala.collection
  */
 trait MapProxy[A, +B] extends Map[A, B] with IterableProxy[Pair[A, B]] {
 
-    def self: Map[A, B]
+  def self: Map[A, B]
 
-    def size: Int = self.size
+  def size: Int = self.size
 
-    def get(key: A): Option[B] = self.get(key)
+  def get(key: A): Option[B] = self.get(key)
 
-    override def isEmpty: Boolean = self.isEmpty
+  override def isEmpty: Boolean = self.isEmpty
 
-    override def apply(key: A): B = self.apply(key)
+  override def apply(key: A): B = self.apply(key)
 
-    override def contains(key: A): Boolean = self.contains(key)
+  override def contains(key: A): Boolean = self.contains(key)
 
-    override def isDefinedAt(key: A) = self.isDefinedAt(key)
+  override def isDefinedAt(key: A) = self.isDefinedAt(key)
 
-    override def keys: Iterator[A] = self.keys
+  override def keys: Iterator[A] = self.keys
 
-    override def values: Iterator[B] = self.values
+  override def values: Iterator[B] = self.values
 
-    override def foreach(f: (A, B) => Unit) = self.foreach(f)
-
-    override def toList: List[Pair[A, B]] = self.toList
 }
diff --git a/src/library/scala/collection/Set.scala b/src/library/scala/collection/Set.scala
index 4f5b4f136e..e97b4369da 100644
--- a/src/library/scala/collection/Set.scala
+++ b/src/library/scala/collection/Set.scala
@@ -76,12 +76,6 @@ trait Set[A] extends AnyRef with Function1[A, Boolean] with Iterable[A] {
         false
     }
 
-    /** Returns the elements of this set as a list.
-     *
-     *  @return    a list containing all set elements.
-     */
-    def toList: List[A] = elements.toList
-
     /** Returns a string representation of this set.
      *
      *  @return a string showing all elements of this set.
diff --git a/src/library/scala/collection/SetProxy.scala b/src/library/scala/collection/SetProxy.scala
index 8988fc4795..41d2d13b35 100644
--- a/src/library/scala/collection/SetProxy.scala
+++ b/src/library/scala/collection/SetProxy.scala
@@ -21,19 +21,18 @@ package scala.collection
  */
 trait SetProxy[A] extends Set[A] with IterableProxy[A] {
 
-    def self: Set[A]
+  def self: Set[A]
 
-    def size: Int = self.size
+  def size: Int = self.size
 
-    override def isEmpty: Boolean = self.isEmpty
+  override def isEmpty: Boolean = self.isEmpty
 
-    def contains(elem: A): Boolean = self.contains(elem)
+  def contains(elem: A): Boolean = self.contains(elem)
 
-    override def subsetOf(that: Set[A]): Boolean = self.subsetOf(that)
+  override def subsetOf(that: Set[A]): Boolean = self.subsetOf(that)
 
-    override def foreach(f: A => Unit): Unit = self.foreach(f)
+  override def foreach(f: A => Unit): Unit = self.foreach(f)
 
-    override def exists(p: A => Boolean): Boolean = self.exists(p)
+  override def exists(p: A => Boolean): Boolean = self.exists(p)
 
-    override def toList: List[A] = self.toList
 }
diff --git a/src/library/scala/collection/immutable/ListMap.scala b/src/library/scala/collection/immutable/ListMap.scala
index a8c765c3ed..b4a6687cc9 100644
--- a/src/library/scala/collection/immutable/ListMap.scala
+++ b/src/library/scala/collection/immutable/ListMap.scala
@@ -62,11 +62,13 @@ class ListMap[A, B] extends AnyRef with Map[A, B] {
 
   /** This returns an iterator over key-value pairs.
    */
-  def elements: Iterator[Pair[A, B]] = toList.elements
-
-  /** This return a list of key-value pairs.
-   */
-  override def toList: List[Pair[A, B]] = Nil
+  def elements: Iterator[Pair[A,B]] = new Iterator[Pair[A,B]] {
+    var that: ListMap[A,B] = ListMap.this;
+    def hasNext = !that.isEmpty;
+    def next: Pair[A,B] =
+      if (!hasNext) error("next on empty iterator")
+      else { val res = Pair(that.key, that.value); that = that.next; res }
+  }
 
   /** Compares two maps for equality.
    *   Two maps are equal iff they contain exactly the
@@ -86,7 +88,14 @@ class ListMap[A, B] extends AnyRef with Map[A, B] {
 
   override def hashCode(): Int = 0
 
-  protected class Node(key: A, value: B) extends ListMap[A, B] {
+  protected def key: A = error("empty map");
+  protected def value: B = error("empty map");
+  protected def next: ListMap[A, B] = error("empty map");
+
+  [serializable]
+  protected class Node(override protected val key: A, override protected val value: B)
+    extends ListMap[A, B]
+  {
     /** Returns the number of mappings in this map.
      *
      *  @return number of mappings.
@@ -144,13 +153,9 @@ class ListMap[A, B] extends AnyRef with Map[A, B] {
         val tail = ListMap.this - k; new tail.Node(key, value)
       }
 
-    /** This return a list of key-value pairs.
-     */
-    override def toList: List[Pair[A, B]] =
-      Pair(key, value) :: ListMap.this.toList
-
     override def hashCode(): Int =
       (key.hashCode() ^ value.hashCode()) + ListMap.this.hashCode()
+
+    override protected def next: ListMap[A,B] = ListMap.this;
   }
 }
-
diff --git a/src/library/scala/collection/immutable/ListSet.scala b/src/library/scala/collection/immutable/ListSet.scala
index a65babd3cf..2924e4ef96 100644
--- a/src/library/scala/collection/immutable/ListSet.scala
+++ b/src/library/scala/collection/immutable/ListSet.scala
@@ -36,7 +36,9 @@ class ListSet[A] extends AnyRef with Set[A] {
    */
   def size: Int = 0
 
-  def empty = new ListSet[A]
+  override def isEmpty: Boolean = true;
+
+  def empty[B] = new ListSet[B]
 
   /** Checks if this set contains element <code>elem</code>.
    *
@@ -54,18 +56,17 @@ class ListSet[A] extends AnyRef with Set[A] {
    */
   def -(elem: A): ListSet[A] = this
 
-  /** Creates a new iterator over all elements contained in this
-   *  object.
+  /** Creates a new iterator over all elements contained in this set.
    *
    *  @return the new iterator
    */
-  def elements: Iterator[A] = toList.elements
-
-  /** Transform this set into a list of all elements.
-   *
-   *  @return  a list which enumerates all elements of this set.
-   */
-  override def toList: List[A] = Nil
+  def elements: Iterator[A] = new Iterator[A] {
+    var that: ListSet[A] = ListSet.this;
+    def hasNext = !that.isEmpty;
+    def next: A =
+      if (!hasNext) error("next on empty iterator")
+      else { val res = that.elem; that = that.next; res }
+  }
 
   /** Compares two sets for equality.
    *   Two set are equal iff they contain the same elements.
@@ -77,9 +78,11 @@ class ListSet[A] extends AnyRef with Set[A] {
     } else
       false
 
-  override def hashCode(): Int = 0
+  protected def elem: A = error("Set has no elelemnts");
+  protected def next: ListSet[A] = error("Next of an empty set");
 
-  protected class Node(elem: A) extends ListSet[A] {
+  [serializable]
+  protected class Node(override protected val elem: A) extends ListSet[A] {
     /** Returns the number of elements in this set.
      *
      *  @return number of set elements.
@@ -110,12 +113,6 @@ class ListSet[A] extends AnyRef with Set[A] {
       val tail = ListSet.this - e; new tail.Node(elem)
     }
 
-    /** Transform this set into a list of all elements.
-     *
-     *  @return  a list which enumerates all elements of this set.
-     */
-    override def toList: List[A] = elem :: ListSet.this.toList
-
-    override def hashCode(): Int = elem.hashCode() + ListSet.this.hashCode()
+    override protected def next: ListSet[A] = ListSet.this;
   }
 }
diff --git a/src/library/scala/collection/immutable/Map.scala b/src/library/scala/collection/immutable/Map.scala
index a98e859b36..3841681a71 100644
--- a/src/library/scala/collection/immutable/Map.scala
+++ b/src/library/scala/collection/immutable/Map.scala
@@ -101,25 +101,24 @@ trait Map[A, B] extends AnyRef with collection.Map[A, B] {
   /** This function transforms all the values of mappings contained
    *  in this map with function <code>f</code>.
    *
-   *  @param f ...
+   *  @param f A function over key-value pairs
    */
-  def map[C](f: (A, B) => C): Map[A, C] = {
+  def map[C](f: Pair[A, B] => C): Map[A, C] = {
     var res = empty[C]
-    elements foreach {
-      case Pair(key, value) => res = res.update(key, f(key, value))
-    }
+    foreach {
+      case kv @ Pair(key, _) => res = res.update(key, f(kv)) }
     res
   }
 
   /** This method removes all the mappings for which the predicate
    *  <code>p</code> returns <code>false</code>.
    *
-   *  @param p ...
+   *  @param p A prediacte over key-value pairs
    */
-  def filter(p: (A, B) => Boolean): Map[A, B] = {
+  def filter(p: Pair[A, B] => Boolean): Map[A, B] = {
     var res = this
-    toList foreach {
-      case Pair(key, value) => if (!p(key, value)) { res = res.excl(key) }
+    foreach {
+      case kv @ Pair(key, _) => if (!p(kv)) { res = res.excl(key) }
     }
     res
   }
diff --git a/src/library/scala/collection/immutable/Set.scala b/src/library/scala/collection/immutable/Set.scala
index 1880636594..6450a371b2 100644
--- a/src/library/scala/collection/immutable/Set.scala
+++ b/src/library/scala/collection/immutable/Set.scala
@@ -30,9 +30,9 @@ trait Set[A] extends AnyRef with collection.Set[A] {
    */
   def +(elem: A): Set[A]
 
-  /** @return an empty set of the same type as this set
+  /** @return an empty set of arbitrary type
    */
-  def empty: Set[A]
+  def empty[B]: Set[B]
 
   /** <code>incl</code> can be used to add many elements to the set
    *  at the same time.
@@ -44,11 +44,8 @@ trait Set[A] extends AnyRef with collection.Set[A] {
    *
    *  @param that ...
    */
-  def incl(that: Iterable[A]): Set[A] = {
-    var res = this
-    that.elements.foreach(elem => res = res + elem)
-    res
-  }
+  def incl(that: Iterable[A]): Set[A] =
+    that.foldLeft(this)((set, elem) => set + elem)
 
   /** <code>-</code> can be used to remove a single element from
    *  a set.
@@ -62,35 +59,29 @@ trait Set[A] extends AnyRef with collection.Set[A] {
   /** This method removes all the elements provided by an iterator
    *  of the iterable object <code>that</code> from the set.
    */
-  def excl(that: Iterable[A]): Set[A] = {
-    var res = this
-    that.elements.foreach(elem => res = res - elem)
-    res
-  }
+  def excl(that: Iterable[A]): Set[A] =
+    that.foldLeft(this)((set, elem) => set - elem)
 
   /** This method computes an intersection with set <code>that</code>.
    *  It removes all the elements that are not present in <code>that</code>.
    *
    *  @param that ...
    */
-  def intersect(that: scala.collection.Set[A]): Set[A] = filter(that.contains)
+  def intersect(that: collection.Set[A]): Set[A] = filter(that.contains)
+
+  def map[B](f: A => B): Set[B] =
+    foldLeft(empty[B])((set: Set[B], elem: A) => set + f(elem))
 
   /** Method <code>filter</code> removes all elements from the set for
    *  which the predicate <code>p</code> yields the value <code>false</code>.
    *
    *  @param p ...
    */
-  def filter(p: A => Boolean): Set[A] = {
-    var res = this
-    toList foreach {
-      elem => if (!p(elem)) res = res - elem
-    }
-    res
-  }
+  def filter(p: A => Boolean): Set[A] =
+    foldLeft(this)((set, elem) => if (p(elem)) set else set - elem)
 
   /** hashcode for this set */
   override def hashCode() =
-    elements.foldLeft(0)((hash: Int, e: A) => hash + e.hashCode())
+    foldLeft(0)((hash: Int, e: A) => hash + e.hashCode())
 
 }
-
diff --git a/src/library/scala/collection/immutable/Stack.scala b/src/library/scala/collection/immutable/Stack.scala
index cb53a74d2e..b61c3ba16a 100644
--- a/src/library/scala/collection/immutable/Stack.scala
+++ b/src/library/scala/collection/immutable/Stack.scala
@@ -13,7 +13,7 @@ package scala.collection.immutable
 
 
 object Stack {
-  def Empty[A] = new Stack[A]
+  val Empty = new Stack[Nothing]
 }
 
 /** This class implements immutable stacks using a list-based data
@@ -53,11 +53,8 @@ class Stack[+A] extends Seq[A] {
    *  @param   elems      the iterable object.
    *  @return the stack with the new elements on top.
    */
-  def +[B >: A](elems: Iterable[B]): Stack[B] = {
-    var res: Stack[B] = this
-    elems.elements.foreach { elem => res = res + elem }
-    res
-  }
+  def +[B >: A](elems: Iterable[B]): Stack[B] =
+    elems.foldLeft(this: Stack[B]){ (stack, elem) => stack + elem }
 
   /** Push a sequence of elements onto the stack. The last element
    *  of the sequence will be on top of the new stack.
@@ -94,13 +91,13 @@ class Stack[+A] extends Seq[A] {
    *
    *  @return an iterator over all stack elements.
    */
-  def elements: Iterator[A] = toList.elements
-
-  /** Creates a list of all stack elements in LIFO order.
-   *
-   *  @return the created list.
-   */
-  override def toList: List[A] = Nil
+  def elements: Iterator[A] = new Iterator[A] {
+    var that: Stack[A] = Stack.this;
+    def hasNext = !that.isEmpty;
+    def next =
+      if (!hasNext) error("next on empty iterator")
+      else { val res = that.top; that = that.pop; res }
+  }
 
   /** Compares this stack with the given object.
    *
@@ -108,10 +105,7 @@ class Stack[+A] extends Seq[A] {
    *          same elements in the same order.
    */
   override def equals(obj: Any): Boolean =
-    if (obj.isInstanceOf[Stack[A]])
-      toList.equals((obj.asInstanceOf[Stack[A]]).toList)
-    else
-      false
+    obj.isInstanceOf[Stack[A]] && sameElements(obj.asInstanceOf[Stack[A]])
 
   /** Returns the hash code for this stack.
    *
@@ -129,12 +123,9 @@ class Stack[+A] extends Seq[A] {
   protected class Node[+B >: A](elem: B) extends Stack[B] {
     override def isEmpty: Boolean = false
     override def length: Int = Stack.this.length + 1
-    override def +[C >: B](elem: C): Stack[C] = new Node(elem)
-    override def +[C >: B](elems: Iterable[C]): Stack[C] = super.+(elems)
     override def top: B = elem
     override def pop: Stack[B] = Stack.this
     override def apply(n: Int): B = if (n > 0) Stack.this(n - 1) else elem
-    override def toList: List[B] = elem :: Stack.this.toList
     override def hashCode(): Int = elem.hashCode() + Stack.this.hashCode()
   }
 
diff --git a/src/library/scala/collection/immutable/TreeSet.scala b/src/library/scala/collection/immutable/TreeSet.scala
index 01258ee0f3..768eda6e8b 100644
--- a/src/library/scala/collection/immutable/TreeSet.scala
+++ b/src/library/scala/collection/immutable/TreeSet.scala
@@ -44,7 +44,9 @@ class TreeSet[A <% Ordered[A]]() extends Tree[A, A] with Set[A] {
    */
   def +(elem: A): TreeSet[A] = updateOrAdd(elem, elem)
 
-  override def empty: Set[A] = New(0, GBLeaf[A,A]())
+  override def empty[B]: Set[B] = ListSet.Empty
+
+  def emptyTreeSet: TreeSet[A] = New(0, GBLeaf[A,A]())
 
   /** <code>-</code> can be used to remove a single element from
    *  a set.
diff --git a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala
index 29e1e36161..d3e37df238 100644
--- a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala
+++ b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala
@@ -44,7 +44,7 @@ extends Map[A, B]
 
     def elements: Iterator[Pair[A, B]] = imap.elements;
 
-    override def foreach(f: (A, B) => Unit) = imap.foreach(f);
+    override def foreach(f: Pair[A, B] => Unit) = imap.foreach(f);
 
     override def toList: List[Pair[A, B]] = imap.toList;
 
@@ -56,9 +56,9 @@ extends Map[A, B]
 
     override def clear: Unit = { imap = imap.empty; }
 
-    override def map(f: (A, B) => B): Unit = { imap = imap.map(f); }
+    override def map(f: Pair[A, B] => B): Unit = { imap = imap.map(f); }
 
-    override def filter(p: (A, B) => Boolean): Unit = { imap = imap.filter(p); }
+    override def filter(p: Pair[A, B] => Boolean): Unit = { imap = imap.filter(p); }
 
     override def mappingToString(p: Pair[A, B]) = imap.mappingToString(p);
 }
diff --git a/src/library/scala/collection/mutable/Map.scala b/src/library/scala/collection/mutable/Map.scala
index 1b7bd844fc..0cd019aa44 100644
--- a/src/library/scala/collection/mutable/Map.scala
+++ b/src/library/scala/collection/mutable/Map.scala
@@ -104,8 +104,8 @@ trait Map[A, B] extends AnyRef
    *
    * @param f
    */
-  def map(f: (A, B) => B): Unit = elements foreach {
-    case Pair(key, value) => update(key, f(key, value));
+  def map(f: Pair[A, B] => B): Unit = elements foreach {
+    case kv @ Pair(key, _) => update(key, f(kv));
   }
 
   /** This method removes all the mappings for which the predicate
@@ -113,8 +113,8 @@ trait Map[A, B] extends AnyRef
    *
    * @param p
    */
-  def filter(p: (A, B) => Boolean): Unit = toList foreach {
-    case Pair(key, value) => if (!p(key, value)) -=(key);
+  def filter(p: Pair[A, B] => Boolean): Unit = toList foreach {
+    case kv @ Pair(key, _) => if (!p(kv)) -=(key);
   }
 
   /** Send a message to this scriptable object.
diff --git a/src/library/scala/collection/mutable/MapProxy.scala b/src/library/scala/collection/mutable/MapProxy.scala
index 44e1e482a1..1b1c38e804 100644
--- a/src/library/scala/collection/mutable/MapProxy.scala
+++ b/src/library/scala/collection/mutable/MapProxy.scala
@@ -41,9 +41,9 @@ trait MapProxy[A, B] extends Map[A, B] with collection.MapProxy[A, B] {
 
     override def clear: Unit = self.clear;
 
-    override def map(f: (A, B) => B): Unit = self.map(f);
+    override def map(f: Pair[A, B] => B): Unit = self.map(f);
 
-    override def filter(p: (A, B) => Boolean): Unit = self.filter(p);
+    override def filter(p: Pair[A, B] => Boolean): Unit = self.filter(p);
 
     override def toString() = self.toString();
 
diff --git a/src/library/scala/collection/mutable/SynchronizedMap.scala b/src/library/scala/collection/mutable/SynchronizedMap.scala
index 1eb02241dd..b024e36eeb 100644
--- a/src/library/scala/collection/mutable/SynchronizedMap.scala
+++ b/src/library/scala/collection/mutable/SynchronizedMap.scala
@@ -52,7 +52,7 @@ trait SynchronizedMap[A, B] extends Map[A, B] {
         super.values;
     }
 
-    override def foreach(f: (A, B) => Unit) = synchronized {
+    override def foreach(f: Pair[A, B] => Unit) = synchronized {
         super.foreach(f);
     }
 
@@ -96,11 +96,11 @@ trait SynchronizedMap[A, B] extends Map[A, B] {
         super.clear;
     }
 
-    override def map(f: (A, B) => B): Unit = synchronized {
+    override def map(f: Pair[A, B] => B): Unit = synchronized {
         super.map(f);
     }
 
-    override def filter(p: (A, B) => Boolean): Unit = synchronized {
+    override def filter(p: Pair[A, B] => Boolean): Unit = synchronized {
         super.filter(p);
     }