changed tuple syntax to (...)

19 files changed, 73 insertions, 73 deletions

diff --git a/src/library/scala/collection/mutable/ArrayBuffer.scala b/src/library/scala/collection/mutable/ArrayBuffer.scala
index e506e95994..f840fc3a2a 100644
--- a/src/library/scala/collection/mutable/ArrayBuffer.scala
+++ b/src/library/scala/collection/mutable/ArrayBuffer.scala
@@ -166,7 +166,7 @@ class ArrayBuffer[A] extends Buffer[A] with ResizableArray[A] {
     case that: ArrayBuffer[_] =>
       this.length == that.length &&
     elements.zip(that.elements).forall {
-      case {thiselem, thatelem} => thiselem == thatelem
+      case Pair(thiselem, thatelem) => thiselem == thatelem
     }
     case _ =>
       false
diff --git a/src/library/scala/collection/mutable/Buffer.scala b/src/library/scala/collection/mutable/Buffer.scala
index fac9603438..5d8f24393c 100644
--- a/src/library/scala/collection/mutable/Buffer.scala
+++ b/src/library/scala/collection/mutable/Buffer.scala
@@ -25,7 +25,7 @@ import Predef._
 [cloneable]
 trait Buffer[A] extends AnyRef
       with Seq[A]
-      with Scriptable[Message[{Location, A}]]
+      with Scriptable[Message[Pair[Location, A]]]
 {
 
   /** Append a single element to this buffer.
@@ -202,20 +202,20 @@ trait Buffer[A] extends AnyRef
    *
    *  @param cmd  the message to send.
    */
-  def <<(cmd: Message[{Location, A}]): Unit = cmd match {
-    case Include({l, elem}) => l match {
+  def <<(cmd: Message[Pair[Location, A]]): Unit = cmd match {
+    case Include(Pair(l, elem)) => l match {
       case Start => prepend(elem)
       case End => append(elem)
       case Index(n) => insert(n, elem)
       case _ => throw new UnsupportedOperationException("message " + cmd + " not understood")
     }
-    case Update({l, elem}) => l match {
+    case Update(Pair(l, elem)) => l match {
       case Start => update(0, elem)
       case End => update(length - 1, elem)
       case Index(n) => update(n, elem)
       case _ => throw new UnsupportedOperationException("message " + cmd + " not understood")
     }
-    case Remove({l, _}) => l match {
+    case Remove(Pair(l, _)) => l match {
       case Start => remove(0)
       case End => remove(length - 1)
       case Index(n) => remove(n)
diff --git a/src/library/scala/collection/mutable/BufferProxy.scala b/src/library/scala/collection/mutable/BufferProxy.scala
index adf7162954..5f1d60e333 100644
--- a/src/library/scala/collection/mutable/BufferProxy.scala
+++ b/src/library/scala/collection/mutable/BufferProxy.scala
@@ -142,7 +142,7 @@ trait BufferProxy[A] extends Buffer[A] with Proxy {
    *
    *  @param cmd  the message to send.
    */
-  override def <<(cmd: Message[{Location, A}]): Unit = self << cmd
+  override def <<(cmd: Message[Pair[Location, A]]): Unit = self << cmd
 
   /** Return a clone of this buffer.
    *
diff --git a/src/library/scala/collection/mutable/DefaultMapModel.scala b/src/library/scala/collection/mutable/DefaultMapModel.scala
index 9bf8b803b5..7148667849 100644
--- a/src/library/scala/collection/mutable/DefaultMapModel.scala
+++ b/src/library/scala/collection/mutable/DefaultMapModel.scala
@@ -40,6 +40,6 @@ trait DefaultMapModel[A, B] extends Map[A, B] {
     else e.value = value
   }
 
-  def elements = entries map {e => {e.key, e.value}}
+  def elements = entries map {e => Pair(e.key, e.value)}
 }
 
diff --git a/src/library/scala/collection/mutable/HashMap.scala b/src/library/scala/collection/mutable/HashMap.scala
index 59a8b8a860..863a535aef 100644
--- a/src/library/scala/collection/mutable/HashMap.scala
+++ b/src/library/scala/collection/mutable/HashMap.scala
@@ -26,7 +26,7 @@ object HashMap {
 
   /** The canonical factory for this type
    */
-  def apply[A, B](elems: {A, B}*) = empty[A, B] ++ elems
+  def apply[A, B](elems: Pair[A, B]*) = empty[A, B] ++ elems
 }
 
 [serializable]
diff --git a/src/library/scala/collection/mutable/History.scala b/src/library/scala/collection/mutable/History.scala
index dbafbf29dc..4143e6e9de 100644
--- a/src/library/scala/collection/mutable/History.scala
+++ b/src/library/scala/collection/mutable/History.scala
@@ -21,9 +21,9 @@ package scala.collection.mutable
  *  @version 1.0, 08/07/2003
  */
 [serializable]
-class History[A, B] extends AnyRef with Subscriber[A, B] with Iterable[{B, A}] {
+class History[A, B] extends AnyRef with Subscriber[A, B] with Iterable[Pair[B, A]] {
 
-  protected val log: Queue[{B, A}] = new Queue[{B, A}]
+  protected val log: Queue[Pair[B, A]] = new Queue[Pair[B, A]]
 
   val maxHistory: Int = 1000
 
@@ -35,12 +35,12 @@ class History[A, B] extends AnyRef with Subscriber[A, B] with Iterable[{B, A}] {
     if (log.length >= maxHistory) {
       val old = log.dequeue;
     }
-    log.enqueue({pub, event})
+    log.enqueue(Pair(pub, event))
   }
 
-  def elements: Iterator[{B, A}] = log.elements
+  def elements: Iterator[Pair[B, A]] = log.elements
 
-  def events: Iterator[A] = log.elements.map { case {_, e} => e }
+  def events: Iterator[A] = log.elements.map { case Pair(_, e) => e }
 
   def size: Int = log.length
 
diff --git a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala
index 9328f19629..37bbb9dce4 100644
--- a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala
+++ b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala
@@ -45,9 +45,9 @@ extends Map[A, B]
 
   override def values: Iterator[B] = imap.values
 
-  def elements: Iterator[{A, B}] = imap.elements
+  def elements: Iterator[Pair[A, B]] = imap.elements
 
-  override def toList: List[{A, B}] = imap.toList
+  override def toList: List[Pair[A, B]] = imap.toList
 
   def update(key: A, value: B): Unit = { imap = imap.update(key, value) }
 
diff --git a/src/library/scala/collection/mutable/JavaMapAdaptor.scala b/src/library/scala/collection/mutable/JavaMapAdaptor.scala
index 825758b64b..9b918836da 100644
--- a/src/library/scala/collection/mutable/JavaMapAdaptor.scala
+++ b/src/library/scala/collection/mutable/JavaMapAdaptor.scala
@@ -45,12 +45,12 @@ class JavaMapAdaptor[A, B](jmap: java.util.Map) extends Map[A, B] {
     def next = iter.next().asInstanceOf[B]
   }
 
-  def elements: Iterator[{A, B}] = new Iterator[{A, B}] {
+  def elements: Iterator[Pair[A, B]] = new Iterator[Pair[A, B]] {
     val iter = jmap.keySet().iterator()
     def hasNext = iter.hasNext()
     def next = {
       val key = iter.next().asInstanceOf[A]
-      {key, apply(key)}
+      Pair(key, apply(key))
     }
   }
 
diff --git a/src/library/scala/collection/mutable/ListBuffer.scala b/src/library/scala/collection/mutable/ListBuffer.scala
index 2f4b95f55f..55bd75d3fd 100644
--- a/src/library/scala/collection/mutable/ListBuffer.scala
+++ b/src/library/scala/collection/mutable/ListBuffer.scala
@@ -268,7 +268,7 @@ final class ListBuffer[A] extends Buffer[A] {
     case that: ListBuffer[_] =>
       (this.length == that.length &&
        elements.zip(that.elements).forall {
-         case {thiselem, thatelem} => thiselem == thatelem
+         case Pair(thiselem, thatelem) => thiselem == thatelem
        })
     case _ =>
       false
diff --git a/src/library/scala/collection/mutable/Map.scala b/src/library/scala/collection/mutable/Map.scala
index 8b0342e5d6..85b178fa82 100644
--- a/src/library/scala/collection/mutable/Map.scala
+++ b/src/library/scala/collection/mutable/Map.scala
@@ -32,13 +32,13 @@ object Map {
 
   /** The canonical factory for this type
    */
-  def apply[A, B](elems: {A, B}*) = empty[A, B] ++ elems
+  def apply[A, B](elems: Pair[A, B]*) = empty[A, B] ++ elems
 }
 
 [cloneable]
 trait Map[A, B] extends AnyRef
       with collection.Map[A, B]
-      with Scriptable[Message[{A, B}]]
+      with Scriptable[Message[Pair[A, B]]]
 {
   /** This method allows one to add a new mapping from <code>key</code>
    *  to <code>value</code> to the map. If the map already contains a
@@ -53,30 +53,30 @@ trait Map[A, B] extends AnyRef
   /** Add a key/value pair to this map.
    *  @param    kv the key/value pair.
    */
-  def += (kv: {A, B}) { update(kv._1, kv._2) }
+  def += (kv: Pair[A, B]) { update(kv._1, kv._2) }
 
   /** Add two or more key/value pairs to this map.
    *  @param    kv1 the first key/value pair.
    *  @param    kv2 the second key/value pair.
    *  @param    kvs the remaining key/value pairs.
    */
-  def += (kv1: {A, B}, kv2: {A, B}, kvs: {A, B}*) { this += kv1; this += kv2; this ++= kvs }
+  def += (kv1: Pair[A, B], kv2: Pair[A, B], kvs: Pair[A, B]*) { this += kv1; this += kv2; this ++= kvs }
 
   /** Add a sequence of key/value pairs to this map.
    *  @param    kvs the iterable object containing all key/value pairs.
    */
-  def ++= (kvs: Iterable[{A, B}]) { this ++= kvs.elements }
+  def ++= (kvs: Iterable[Pair[A, B]]) { this ++= kvs.elements }
 
   /** Add a sequence of key/value pairs to this map.
    *  @param    kvs the iterator containing all key/value pairs.
    */
-  def ++= (kvs: Iterator[{A, B}]) { kvs foreach += }
+  def ++= (kvs: Iterator[Pair[A, B]]) { kvs foreach += }
 
   /** Add a key/value pair to this map.
    *  @param    kv the key/value pair.
    *  @return   The map itself with the new binding added in place.
    */
-  def + (kv: {A, B}): Map[A, B] = { this += kv; this }
+  def + (kv: Pair[A, B]): Map[A, B] = { this += kv; this }
 
   /** Add two or more key/value pairs to this map.
    *  @param    kv1 the first key/value pair.
@@ -84,7 +84,7 @@ trait Map[A, B] extends AnyRef
    *  @param    kvs the remaining key/value pairs.
    *  @return   The map itself with the new bindings added in place.
    */
-  def + (kv1: {A, B}, kv2: {A, B}, kvs: {A, B}*): Map[A, B] = {
+  def + (kv1: Pair[A, B], kv2: Pair[A, B], kvs: Pair[A, B]*): Map[A, B] = {
     this.+=(kv1, kv2, kvs: _*); this
   }
 
@@ -92,13 +92,13 @@ trait Map[A, B] extends AnyRef
    *  @param    kvs the iterable object containing all key/value pairs.
    *  @return   The itself map with the new bindings added in place.
    */
-  def ++ (kvs: Iterable[{A, B}]): Map[A, B] = { this ++= kvs; this }
+  def ++ (kvs: Iterable[Pair[A, B]]): Map[A, B] = { this ++= kvs; this }
 
   /** Add a sequence of key/value pairs to this map.
    *  @param    kvs the iterator containing all key/value pairs.
    *  @return   The itself map with the new bindings added in place.
    */
-  def ++ (kvs: Iterator[{A, B}]): Map[A, B] = { this ++= kvs; this }
+  def ++ (kvs: Iterator[Pair[A, B]]): Map[A, B] = { this ++= kvs; this }
 
   /** Remove a key from this map, noop if key is not present.
    *  @param    key the key to be removed
@@ -161,7 +161,7 @@ trait Map[A, B] extends AnyRef
    */
   def transform(f: (A, B) => B) {
     elements foreach {
-      case {key, value} => update(key, f(key, value))
+      case Pair(key, value) => update(key, f(key, value))
     }
   }
 
@@ -171,17 +171,17 @@ trait Map[A, B] extends AnyRef
    * @param p  The test predicate
    */
   def retain(p: (A, B) => Boolean): Unit = toList foreach {
-    case {key, value} => if (!p(key, value)) -=(key)
+    case Pair(key, value) => if (!p(key, value)) -=(key)
   }
 
   /** Send a message to this scriptable object.
    *
    *  @param cmd  the message to send.
    */
-  def <<(cmd: Message[{A, B}]): Unit = cmd match {
-    case Include({k, v}) => update(k, v)
-    case Update({k, v}) => update(k, v)
-    case Remove({k, _}) => this -= k
+  def <<(cmd: Message[Pair[A, B]]): Unit = cmd match {
+    case Include(Pair(k, v)) => update(k, v)
+    case Update(Pair(k, v)) => update(k, v)
+    case Remove(Pair(k, _)) => this -= k
     case Reset() => clear
     case s: Script[_] => s.elements foreach <<
     case _ => throw new UnsupportedOperationException("message " + cmd + " not understood")
@@ -210,7 +210,7 @@ trait Map[A, B] extends AnyRef
    * @param mappings
    * @deprecated   use <code>+=</code>
    */
-  [deprecated] def incl(mappings: {A, B}*): Unit = this ++= mappings.elements
+  [deprecated] def incl(mappings: Pair[A, B]*): Unit = this ++= mappings.elements
 
   /** This method will remove all the mappings for the given sequence
    *  of keys from the map.
@@ -226,9 +226,9 @@ trait Map[A, B] extends AnyRef
    * @deprecated   use retain instead
    * @param p
    */
-  [deprecated] override def filter(p: {A, B} => Boolean): Iterable[{A, B}] = {
+  [deprecated] override def filter(p: Pair[A, B] => Boolean): Iterable[Pair[A, B]] = {
     toList foreach {
-      case kv @ {key, _} => if (!p(kv)) -=(key)
+      case kv @ Pair(key, _) => if (!p(kv)) -=(key)
     }
     this
   }
diff --git a/src/library/scala/collection/mutable/MapProxy.scala b/src/library/scala/collection/mutable/MapProxy.scala
index deea498609..431a9d5273 100644
--- a/src/library/scala/collection/mutable/MapProxy.scala
+++ b/src/library/scala/collection/mutable/MapProxy.scala
@@ -30,14 +30,14 @@ trait MapProxy[A, B] extends Map[A, B] with collection.MapProxy[A, B] {
   def self: Map[A, B]
 
   override def update(key: A, value: B): Unit = self.update(key, value)
-  override def += (kv: {A, B}) = self += kv
-  override def += (kv1: {A, B}, kv2: {A, B}, kvs: {A, B}*) = self.+=(kv1, kv2, kvs: _*)
-  override def ++= (kvs: Iterable[{A, B}]) = self ++= kvs
-  override def ++= (kvs: Iterator[{A, B}]) = self ++= kvs
-  override def + (kv: {A, B}): Map[A, B] = self + kv
-  override def + (kv1: {A, B}, kv2: {A, B}, kvs: {A, B}*): Map[A, B] = self.+(kv1, kv2, kvs: _*)
-  override def ++ (kvs: Iterable[{A, B}]): Map[A, B] = self ++ kvs
-  override def ++ (kvs: Iterator[{A, B}]): Map[A, B] = self ++ kvs
+  override def += (kv: Pair[A, B]) = self += kv
+  override def += (kv1: Pair[A, B], kv2: Pair[A, B], kvs: Pair[A, B]*) = self.+=(kv1, kv2, kvs: _*)
+  override def ++= (kvs: Iterable[Pair[A, B]]) = self ++= kvs
+  override def ++= (kvs: Iterator[Pair[A, B]]) = self ++= kvs
+  override def + (kv: Pair[A, B]): Map[A, B] = self + kv
+  override def + (kv1: Pair[A, B], kv2: Pair[A, B], kvs: Pair[A, B]*): Map[A, B] = self.+(kv1, kv2, kvs: _*)
+  override def ++ (kvs: Iterable[Pair[A, B]]): Map[A, B] = self ++ kvs
+  override def ++ (kvs: Iterator[Pair[A, B]]): Map[A, B] = self ++ kvs
   override def -= (key: A) = self -= key
   override def -= (key1: A, key2: A, keys: A*) = self.-=(key1, key2, keys: _*)
   override def --= (keys: Iterable[A]) = self --= keys
@@ -49,8 +49,8 @@ trait MapProxy[A, B] extends Map[A, B] with collection.MapProxy[A, B] {
   override def clear(): Unit = self.clear
   override def transform(f: (A, B) => B) = self transform f
   override def retain(p: (A, B) => Boolean): Unit = self retain p
-  override def <<(cmd: Message[{A, B}]): Unit = self << cmd
+  override def <<(cmd: Message[Pair[A, B]]): Unit = self << cmd
   override def clone(): Map[A, B] = self.clone()
-  [deprecated] override def incl(mappings: {A, B}*): Unit = self.incl(mappings: _*)
+  [deprecated] override def incl(mappings: Pair[A, B]*): Unit = self.incl(mappings: _*)
   [deprecated] override def excl(keys: A*): Unit = self.excl(keys: _*)
 }
diff --git a/src/library/scala/collection/mutable/ObservableBuffer.scala b/src/library/scala/collection/mutable/ObservableBuffer.scala
index 0aa15611a6..57f474f6e8 100644
--- a/src/library/scala/collection/mutable/ObservableBuffer.scala
+++ b/src/library/scala/collection/mutable/ObservableBuffer.scala
@@ -24,13 +24,13 @@ package scala.collection.mutable
  */
 trait ObservableBuffer[A, This <: ObservableBuffer[A, This]] requires This
       extends Buffer[A]
-      with Publisher[Message[{Location, A}]
+      with Publisher[Message[Pair[Location, A]]
       with Undoable, This]
 {
 
   abstract override def +(element: A): Buffer[A] = {
     super.+(element)
-    publish(new Include({End, element}) with Undoable {
+    publish(new Include(Pair(End, element)) with Undoable {
       def undo: Unit = trimEnd(1)
     })
     this
@@ -38,7 +38,7 @@ trait ObservableBuffer[A, This <: ObservableBuffer[A, This]] requires This
 
   abstract override def +:(element: A): Buffer[A] = {
     super.+:(element);
-    publish(new Include({Start, element}) with Undoable {
+    publish(new Include(Pair(Start, element)) with Undoable {
       def undo: Unit = trimStart(1)
     })
     this
@@ -49,7 +49,7 @@ trait ObservableBuffer[A, This <: ObservableBuffer[A, This]] requires This
     var i = n
     val it = iter.elements
     while (it.hasNext) {
-      publish(new Include({Index(i), it.next}) with Undoable {
+      publish(new Include(Pair(Index(i), it.next)) with Undoable {
         def undo: Unit = remove(i);
       })
       i = i + 1
@@ -59,7 +59,7 @@ trait ObservableBuffer[A, This <: ObservableBuffer[A, This]] requires This
   abstract override def update(n: Int, newelement: A): Unit = {
     val oldelement = apply(n)
     super.update(n, newelement)
-    publish(new Update({Index(n), newelement}) with Undoable {
+    publish(new Update(Pair(Index(n), newelement)) with Undoable {
       def undo: Unit = update(n, oldelement)
     })
   }
@@ -67,7 +67,7 @@ trait ObservableBuffer[A, This <: ObservableBuffer[A, This]] requires This
   abstract override def remove(n: Int): A = {
     val oldelement = apply(n)
     super.remove(n)
-    publish(new Remove({Index(n), oldelement}) with Undoable {
+    publish(new Remove(Pair(Index(n), oldelement)) with Undoable {
       def undo: Unit = insert(n, oldelement)
     })
     oldelement
diff --git a/src/library/scala/collection/mutable/ObservableMap.scala b/src/library/scala/collection/mutable/ObservableMap.scala
index 626129343c..988eaf67c6 100644
--- a/src/library/scala/collection/mutable/ObservableMap.scala
+++ b/src/library/scala/collection/mutable/ObservableMap.scala
@@ -23,19 +23,19 @@ package scala.collection.mutable
  */
 trait ObservableMap[A, B, This <: ObservableMap[A, B, This]] requires This
       extends Map[A, B]
-      with Publisher[Message[{A, B}]
+      with Publisher[Message[Pair[A, B]]
       with Undoable, This]
 {
 
   abstract override def update(key: A, value: B): Unit = get(key) match {
     case None =>
       super.update(key, value)
-      publish(new Include({key, value}) with Undoable {
+      publish(new Include(Pair(key, value)) with Undoable {
         def undo = -=(key)
       })
     case Some(old) =>
       super.update(key, value)
-      publish(new Update({key, value}) with Undoable {
+      publish(new Update(Pair(key, value)) with Undoable {
         def undo = update(key, old)
       })
   }
@@ -44,7 +44,7 @@ trait ObservableMap[A, B, This <: ObservableMap[A, B, This]] requires This
     case None =>
     case Some(old) =>
       super.-=(key)
-      publish(new Remove({key, old}) with Undoable {
+      publish(new Remove(Pair(key, old)) with Undoable {
         def undo = update(key, old)
       })
   }
diff --git a/src/library/scala/collection/mutable/PriorityQueue.scala b/src/library/scala/collection/mutable/PriorityQueue.scala
index 64a5ea0ddc..4f67392381 100644
--- a/src/library/scala/collection/mutable/PriorityQueue.scala
+++ b/src/library/scala/collection/mutable/PriorityQueue.scala
@@ -157,7 +157,7 @@ class PriorityQueue[A <% Ordered[A]] extends ResizableArray[A] {
     that.isInstanceOf[PriorityQueue[A]] &&
     { val other = that.asInstanceOf[PriorityQueue[A]]
       elements.zip(other.elements).forall {
-        case {thiselem, thatelem} => thiselem == thatelem
+        case Pair(thiselem, thatelem) => thiselem == thatelem
     }}
 
   /** The hashCode method always yields an error, since it is not
diff --git a/src/library/scala/collection/mutable/Queue.scala b/src/library/scala/collection/mutable/Queue.scala
index e2b4d8d913..7c34c1f2ae 100644
--- a/src/library/scala/collection/mutable/Queue.scala
+++ b/src/library/scala/collection/mutable/Queue.scala
@@ -167,7 +167,7 @@ class Queue[A] extends MutableList[A] {
     that.isInstanceOf[Queue[A]] &&
     { val other = that.asInstanceOf[Queue[A]]
       elements.zip(other.elements).forall {
-        case {thiselem, thatelem} => thiselem == thatelem
+        case Pair(thiselem, thatelem) => thiselem == thatelem
     }}
 
   /** The hashCode method always yields an error, since it is not
diff --git a/src/library/scala/collection/mutable/RevertableHistory.scala b/src/library/scala/collection/mutable/RevertableHistory.scala
index f9fcb635b6..9ad19dedc7 100644
--- a/src/library/scala/collection/mutable/RevertableHistory.scala
+++ b/src/library/scala/collection/mutable/RevertableHistory.scala
@@ -28,6 +28,6 @@ class RevertableHistory[A <: Undoable, B] extends History[A, B] with Undoable {
   def undo: Unit = {
     val old = log.toList.reverse
     clear
-    old.foreach { case {sub, event} => event.undo }
+    old.foreach { case Pair(sub, event) => event.undo }
   }
 }
diff --git a/src/library/scala/collection/mutable/Stack.scala b/src/library/scala/collection/mutable/Stack.scala
index 1aee74148e..e3890d22df 100644
--- a/src/library/scala/collection/mutable/Stack.scala
+++ b/src/library/scala/collection/mutable/Stack.scala
@@ -109,7 +109,7 @@ class Stack[A] extends MutableList[A] {
     that.isInstanceOf[Stack[A]] &&
     { val other = that.asInstanceOf[Stack[A]];
       elements.zip(other.elements).forall {
-        case {thiselem, thatelem} => thiselem == thatelem
+        case Pair(thiselem, thatelem) => thiselem == thatelem
       }}
 
   /** The hashCode method always yields an error, since it is not
diff --git a/src/library/scala/collection/mutable/SynchronizedBuffer.scala b/src/library/scala/collection/mutable/SynchronizedBuffer.scala
index b86f7d401b..652c6d535b 100644
--- a/src/library/scala/collection/mutable/SynchronizedBuffer.scala
+++ b/src/library/scala/collection/mutable/SynchronizedBuffer.scala
@@ -168,7 +168,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
     super.clear
   }
 
-  override def <<(cmd: Message[{Location, A}]): Unit = synchronized {
+  override def <<(cmd: Message[Pair[Location, A]]): Unit = synchronized {
     super.<<(cmd)
   }
 
diff --git a/src/library/scala/collection/mutable/SynchronizedMap.scala b/src/library/scala/collection/mutable/SynchronizedMap.scala
index da317123f0..785e061a4e 100644
--- a/src/library/scala/collection/mutable/SynchronizedMap.scala
+++ b/src/library/scala/collection/mutable/SynchronizedMap.scala
@@ -57,11 +57,11 @@ trait SynchronizedMap[A, B] extends Map[A, B] {
     super.values
   }
 
-  abstract override def elements: Iterator[{A, B}] = synchronized {
+  abstract override def elements: Iterator[Pair[A, B]] = synchronized {
     super.elements
   }
 
-  override def toList: List[{A, B}] = synchronized {
+  override def toList: List[Pair[A, B]] = synchronized {
     super.toList
   }
 
@@ -69,7 +69,7 @@ trait SynchronizedMap[A, B] extends Map[A, B] {
     super.update(key, value)
   }
 
-  override def += (kv: {A, B}): Unit = synchronized {
+  override def += (kv: Pair[A, B]): Unit = synchronized {
     super.+=(kv)
   }
 
@@ -78,19 +78,19 @@ trait SynchronizedMap[A, B] extends Map[A, B] {
    *  @param    kv2 the second key/first value pair.
    *  @param    kvs the remaining key/first value pairs.
    */
-  override def += (kv1: {A, B}, kv2: {A, B}, kvs: {A, B}*): Unit = synchronized {
+  override def += (kv1: Pair[A, B], kv2: Pair[A, B], kvs: Pair[A, B]*): Unit = synchronized {
     super.+=(kv1, kv2, kvs: _*)
   }
 
-  override def ++=(map: Iterable[{A, B}]): Unit = synchronized {
+  override def ++=(map: Iterable[Pair[A, B]]): Unit = synchronized {
     super.++=(map)
   }
 
-  override def ++=(it: Iterator[{A, B}]): Unit = synchronized {
+  override def ++=(it: Iterator[Pair[A, B]]): Unit = synchronized {
     super.++=(it)
   }
 
-  [deprecated] override def incl(mappings: {A, B}*): Unit = synchronized {
+  [deprecated] override def incl(mappings: Pair[A, B]*): Unit = synchronized {
     super.incl(mappings: _*)
   }
 
@@ -122,7 +122,7 @@ trait SynchronizedMap[A, B] extends Map[A, B] {
     super.transform(f)
   }
 
-  [deprecated] override def map[C](f: {A, B} => C) = synchronized {
+  [deprecated] override def map[C](f: Pair[A, B] => C) = synchronized {
     super.map(f)
   }
 
@@ -131,7 +131,7 @@ trait SynchronizedMap[A, B] extends Map[A, B] {
   }
 
   /** @deprecated  use retain instead */
-  [deprecated] override def filter(p: {A, B} => Boolean) = synchronized {
+  [deprecated] override def filter(p: Pair[A, B] => Boolean) = synchronized {
     super.filter(p)
   }
 
@@ -147,7 +147,7 @@ trait SynchronizedMap[A, B] extends Map[A, B] {
     super.hashCode()
   }
 
-  override def <<(cmd: Message[{A, B}]): Unit = synchronized {
+  override def <<(cmd: Message[Pair[A, B]]): Unit = synchronized {
     super.<<(cmd)
   }