changed tuple syntax to (...)

47 files changed, 241 insertions, 233 deletions

diff --git a/src/library/scala/BigInt.scala b/src/library/scala/BigInt.scala
index 4fcbfd82ce..9be8a45dbd 100644
--- a/src/library/scala/BigInt.scala
+++ b/src/library/scala/BigInt.scala
@@ -175,9 +175,9 @@ class BigInt(val bigInteger: BigInteger) extends runtime.BoxedNumber {
 
   /** Returns a pair of two BigInts containing (this / that) and (this % that).
    */
-  def /% (that: BigInt): {BigInt, BigInt} = {
+  def /% (that: BigInt): Pair[BigInt, BigInt] = {
     val dr = this.bigInteger.divideAndRemainder(that.bigInteger)
-    {new BigInt(dr(0)), new BigInt(dr(1))}
+    Pair(new BigInt(dr(0)), new BigInt(dr(1)))
   }
 
   /** Leftshift of BigInt
diff --git a/src/library/scala/Console.scala b/src/library/scala/Console.scala
index 488e091390..ea2968fc03 100644
--- a/src/library/scala/Console.scala
+++ b/src/library/scala/Console.scala
@@ -272,9 +272,9 @@ object Console {
    *  @param format ...
    *  @return ...
    */
-  def readf2(format: String): {Any, Any} = {
+  def readf2(format: String): Pair[Any, Any] = {
     val res = readf(format)
-    {res.head, res.tail.head}
+    Pair(res.head, res.tail.head)
   }
 
   /** Read in some structured input, specified by a format specifier.
@@ -287,7 +287,7 @@ object Console {
    */
   def readf3(format: String): Triple[Any, Any, Any] = {
     val res = readf(format)
-    {res.head, res.tail.head, res.tail.tail.head}
+    Triple(res.head, res.tail.head, res.tail.tail.head)
   }
 
   private def textComponents(a: Array[AnyRef]): List[Any] = {
diff --git a/src/library/scala/Iterator.scala b/src/library/scala/Iterator.scala
index 528fd68635..00e40ab5b9 100644
--- a/src/library/scala/Iterator.scala
+++ b/src/library/scala/Iterator.scala
@@ -348,9 +348,9 @@ trait Iterator[+A] {
    *              and <code>b<sub>i</sub></code> are the elements from iterator
    *              <code>that</code>.
    */
-  def zip[B](that: Iterator[B]) = new Iterator[{A, B}] {
+  def zip[B](that: Iterator[B]) = new Iterator[Pair[A, B]] {
     def hasNext = Iterator.this.hasNext && that.hasNext
-    def next = {Iterator.this.next, that.next}
+    def next = Pair(Iterator.this.next, that.next)
   }
 
   /** Return an iterator that pairs each element of this iterator
@@ -361,11 +361,11 @@ trait Iterator[+A] {
    *               {a<sub>1</sub>,1}...</code> where <code>a<sub>i</sub></code>
    *               are the elements from this iterator.
    */
-  def zipWithIndex = new Iterator[{A, int}] {
+  def zipWithIndex = new Iterator[Pair[A, int]] {
     var idx = 0
     def hasNext = Iterator.this.hasNext
     def next = {
-      val ret = {Iterator.this.next, idx}
+      val ret = Pair(Iterator.this.next, idx)
       idx = idx + 1
       ret
     }
@@ -541,7 +541,7 @@ trait Iterator[+A] {
    *
    *  @return a pair of iterators
    */
-  def duplicate: {Iterator[A], Iterator[A]} = {
+  def duplicate: Pair[Iterator[A], Iterator[A]] = {
     var xs: List[A] = Nil
     var ahead: Iterator[A] = null
     class Partner extends Iterator[A] {
@@ -571,7 +571,7 @@ trait Iterator[+A] {
       }
     }
     ahead = new Partner
-    {ahead, new Partner}
+    Pair(ahead, new Partner)
   }
 
   /** Fills the given array <code>xs</code> with the elements of
diff --git a/src/library/scala/List.scala b/src/library/scala/List.scala
index 25b7032ca9..4e01ee2107 100644
--- a/src/library/scala/List.scala
+++ b/src/library/scala/List.scala
@@ -140,7 +140,7 @@ object List {
    *  @param xs the list of pairs to unzip
    *  @return a pair of lists: the first list in the pair contains the list
    */
-  def unzip[a,b](xs: List[{a,b}]): {List[a], List[b]} = {
+  def unzip[a,b](xs: List[Pair[a,b]]): Pair[List[a], List[b]] = {
     val b1 = new ListBuffer[a]
     val b2 = new ListBuffer[b]
     var xc = xs
@@ -149,7 +149,7 @@ object List {
       b2 += xc.head._2
       xc = xc.tail
     }
-    {b1.toList, b2.toList}
+    Pair(b1.toList, b2.toList)
   }
 
   /** Converts an iterator to a list
@@ -590,7 +590,7 @@ sealed abstract class List[+a] extends Seq[a] {
    *  @return a pair of lists composed of the first <code>n</code>
    *          elements, and the other elements.
    */
-  def splitAt(n: Int): {List[a], List[a]} = {
+  def splitAt(n: Int): Pair[List[a], List[a]] = {
     val b = new ListBuffer[a]
     var i = 0
     var these = this
@@ -599,7 +599,7 @@ sealed abstract class List[+a] extends Seq[a] {
       b += these.head
       these = these.tail
     }
-    {b.toList, these}
+    Pair(b.toList, these)
   }
 
   /** Returns the longest prefix of this list whose elements satisfy
@@ -637,19 +637,19 @@ sealed abstract class List[+a] extends Seq[a] {
    *  @return  a pair consisting of the longest prefix of the list whose
    *           elements all satisfy <code>p</code>, and the rest of the list.
    */
-  def span(p: a => Boolean): {List[a], List[a]} = {
+  def span(p: a => Boolean): Pair[List[a], List[a]] = {
     val b = new ListBuffer[a]
     var these = this
     while (!these.isEmpty && p(these.head)) {
       b += these.head
       these = these.tail
     }
-    {b.toList, these}
+    Pair(b.toList, these)
   }
 
   /** Like <code>span</code> but with the predicate inverted.
    */
-  def break(p: a => Boolean): {List[a], List[a]} = span { x => !p(x) }
+  def break(p: a => Boolean): Pair[List[a], List[a]] = span { x => !p(x) }
 
   /** Returns the <code>n</code>-th element of this list. The first element
    *  (head of the list) is at position 0.
@@ -752,7 +752,7 @@ sealed abstract class List[+a] extends Seq[a] {
    *           The relative order of the elements in the sub-lists is the
    *           same as in the original list.
    */
-  def partition(p: a => Boolean): {List[a], List[a]} = {
+  def partition(p: a => Boolean): Pair[List[a], List[a]] = {
     val btrue = new ListBuffer[a]
     val bfalse = new ListBuffer[a]
     var these = this
@@ -760,7 +760,7 @@ sealed abstract class List[+a] extends Seq[a] {
       (if (p(these.head)) btrue else bfalse) += these.head
       these = these.tail
     }
-    {btrue.toList, bfalse.toList}
+    Pair(btrue.toList, bfalse.toList)
   }
 
   /** <p>
@@ -804,7 +804,7 @@ sealed abstract class List[+a] extends Seq[a] {
           else y::z::x::acc
         case hd1::hd2::hd3::tail => {
           val List(x, y, z) = sort_1(hd1::hd2::hd3::Nil, Nil)
-          val {small, large} = tail.partition((e2) => lt(e2, y))
+          val Pair(small, large) = tail.partition((e2) => lt(e2, y))
           sort_1(x::small, y::sort_1(z::large, acc))
         }
       }
@@ -828,7 +828,7 @@ sealed abstract class List[+a] extends Seq[a] {
         else y::z::x::Nil
       case hd1::hd2::hd3::tail => {
         val List(x, y, z) = sort_1(hd1::hd2::hd3::Nil, Nil)
-        val {small,large} =  tail.partition((e2) => lt(e2, y))
+        val Pair(small,large) =  tail.partition((e2) => lt(e2, y))
         sort_1(x::small, y::sort_1(z::large, Nil));
       }
     }
@@ -999,12 +999,12 @@ sealed abstract class List[+a] extends Seq[a] {
    *              <code>List(a<sub>0</sub>, ..., a<sub>m</sub>)
    *              zip List(b<sub>0</sub>, ..., b<sub>n</sub>)</code> is invoked.
    */
-  def zip[b](that: List[b]): List[{a,b}] = {
-    val b = new ListBuffer[{a, b}]
+  def zip[b](that: List[b]): List[Pair[a,b]] = {
+    val b = new ListBuffer[Pair[a, b]]
     var these = this
     var those = that
     while (!these.isEmpty && !those.isEmpty) {
-      b += {these.head, those.head}
+      b += Pair(these.head, those.head)
       these = these.tail
       those = those.tail
     }
@@ -1018,12 +1018,12 @@ sealed abstract class List[+a] extends Seq[a] {
    *               where <code>a<sub>i</sub></code> are the elements of this list.
    */
   def zipWithIndex = {
-    val b = new ListBuffer[{a,int}]
+    val b = new ListBuffer[Pair[a,int]]
     var these = this
     var idx = 0
 
     while(!these.isEmpty) {
-      b += {these.head, idx}
+      b += Pair(these.head, idx)
       these = these.tail
       idx = idx + 1
     }
@@ -1050,21 +1050,21 @@ sealed abstract class List[+a] extends Seq[a] {
    *                  [b<sub>0</sub>, ..., b<sub>m</sub>]</code> is
    *                  invoked where <code>m &gt; n</code>.
    */
-  def zipAll[b, c >: a, d >: b](that: List[b], thisElem: c, thatElem: d): List[{c,d}] = {
-    val b = new ListBuffer[{c, d}]
+  def zipAll[b, c >: a, d >: b](that: List[b], thisElem: c, thatElem: d): List[Pair[c,d]] = {
+    val b = new ListBuffer[Pair[c, d]]
     var these = this
     var those = that
     while (!these.isEmpty && !those.isEmpty) {
-      b += {these.head, those.head}
+      b += Pair(these.head, those.head)
       these = these.tail
       those = those.tail
     }
     while (!these.isEmpty) {
-      b += {these.head, thatElem}
+      b += Pair(these.head, thatElem)
       these = these.tail
     }
     while (!those.isEmpty) {
-      b += {thisElem, those.head}
+      Pair(thisElem, those.head)
       those = those.tail
     }
     b.toList
diff --git a/src/library/scala/Stream.scala b/src/library/scala/Stream.scala
index db02cd89d8..fe140f2598 100644
--- a/src/library/scala/Stream.scala
+++ b/src/library/scala/Stream.scala
@@ -13,7 +13,7 @@ package scala
 
 
 import compat.StringBuilder
-import Predef.{NoSuchElementException, UnsupportedOperationException}
+import Predef.{NoSuchElementException, UnsupportedOperationException,Pair}
 
 /**
  * The object <code>Stream</code> provides helper functions
@@ -53,11 +53,11 @@ object Stream {
       }
     }
 
-    def unapply[a](str: Stream[a]): Option[{a,Stream[a]}] =
+    def unapply[a](str: Stream[a]): Option[Pair[a,Stream[a]]] =
       if(str.isEmpty)
         None
       else
-        Some{str.head, str.tail}
+        Some(Pair(str.head, str.tail))
   }
 
   /** A stream containing all elements of a given iterator, in the order they are produced.
diff --git a/src/library/scala/collection/Map.scala b/src/library/scala/collection/Map.scala
index 45f45a110b..c02c195086 100644
--- a/src/library/scala/collection/Map.scala
+++ b/src/library/scala/collection/Map.scala
@@ -35,7 +35,7 @@ import Predef._
  *  @author  Martin Odersky
  *  @version 1.2, 31/12/2006
  */
-trait Map[A, +B] extends PartialFunction[A, B] with Iterable[{A, B}] {
+trait Map[A, +B] extends PartialFunction[A, B] with Iterable[Pair[A, B]] {
 
   /** Compute the number of key-to-value mappings.
    *
@@ -125,7 +125,7 @@ trait Map[A, +B] extends PartialFunction[A, B] with Iterable[{A, B}] {
   override def equals(that: Any): Boolean = that match {
     case other: Map[a, b] =>
       this.size == other.size && this.elements.forall {
-        case {key, value} => other.get(key.asInstanceOf[a]) match {
+        case Pair(key, value) => other.get(key.asInstanceOf[a]) match {
           case None => false
           case Some(otherval) => value == otherval
         }
diff --git a/src/library/scala/collection/MapProxy.scala b/src/library/scala/collection/MapProxy.scala
index 142d2c5ba0..2585f24c7d 100644
--- a/src/library/scala/collection/MapProxy.scala
+++ b/src/library/scala/collection/MapProxy.scala
@@ -20,7 +20,7 @@ package scala.collection
  *  @author  Matthias Zenger
  *  @version 1.0, 21/07/2003
  */
-trait MapProxy[A, +B] extends Map[A, B] with IterableProxy[{A, B}] {
+trait MapProxy[A, +B] extends Map[A, B] with IterableProxy[Pair[A, B]] {
 
   def self: Map[A, B]
 
diff --git a/src/library/scala/collection/immutable/EmptyMap.scala b/src/library/scala/collection/immutable/EmptyMap.scala
index fbf8c10c1a..127781f2d5 100755
--- a/src/library/scala/collection/immutable/EmptyMap.scala
+++ b/src/library/scala/collection/immutable/EmptyMap.scala
@@ -12,6 +12,8 @@
 
 package scala.collection.immutable
 
+import Predef.Pair
+
 /** This class implements empty immutable maps
  *  @author  Martin Oderskty
  *  @version 1.0, 019/01/2007
@@ -23,7 +25,7 @@ class EmptyMap[A, +B] extends Map[A, B] {
 
   def get(key: A): Option[B] = None
 
-  def elements: Iterator[{A, B}] = Iterator.empty
+  def elements: Iterator[Pair[A, B]] = Iterator.empty
 
   def empty[C]: Map[A, C] = new EmptyMap[A, C]
 
diff --git a/src/library/scala/collection/immutable/HashMap.scala b/src/library/scala/collection/immutable/HashMap.scala
index 3cda6cf08b..57fc4b8ed9 100755
--- a/src/library/scala/collection/immutable/HashMap.scala
+++ b/src/library/scala/collection/immutable/HashMap.scala
@@ -25,7 +25,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]
@@ -92,7 +92,7 @@ class HashMap[A, B] extends Map[A,B] with mutable.HashTable[A] {
 
   def elements = {
     makeCopyIfUpdated()
-    entries map {e => {e.key, getValue(e)}}
+    entries map {e => Pair(e.key, getValue(e))}
   }
 
   private def getValue(e: Entry) =
diff --git a/src/library/scala/collection/immutable/ListMap.scala b/src/library/scala/collection/immutable/ListMap.scala
index 4ce9c4cc39..c3fdfe1a80 100644
--- a/src/library/scala/collection/immutable/ListMap.scala
+++ b/src/library/scala/collection/immutable/ListMap.scala
@@ -24,7 +24,7 @@ object ListMap {
 
   /** 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
 }
 
 /** This class implements immutable maps using a list-based data
@@ -79,13 +79,13 @@ class ListMap[A, +B] extends Map[A, B] {
 
   /** Returns an iterator over key-value pairs.
    */
-  def elements: Iterator[{A,B}] =
-    new Iterator[{A,B}] {
+  def elements: Iterator[Pair[A,B]] =
+    new Iterator[Pair[A,B]] {
       var self: ListMap[A,B] = ListMap.this
       def hasNext = !self.isEmpty
-      def next: {A,B} =
+      def next: Pair[A,B] =
         if (!hasNext) throw new NoSuchElementException("next on empty iterator")
-        else { val res = {self.key, self.value}; self = self.next; res }
+        else { val res = Pair(self.key, self.value); self = self.next; res }
     }.toList.reverse.elements
 
   protected def key: A = throw new NoSuchElementException("empty map")
diff --git a/src/library/scala/collection/immutable/Map.scala b/src/library/scala/collection/immutable/Map.scala
index 5cc326c031..108cb07f44 100644
--- a/src/library/scala/collection/immutable/Map.scala
+++ b/src/library/scala/collection/immutable/Map.scala
@@ -41,7 +41,7 @@ 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
 }
 
 trait Map[A, +B] extends collection.Map[A, B] {
@@ -68,7 +68,7 @@ trait Map[A, +B] extends collection.Map[A, B] {
    *  @param    kv the key/value pair.
    *  @return   A new map with the new binding added to this map
    */
-  def + [B1 >: B] (kv: {A, B1}): Map[A, B1] = update(kv._1, kv._2)
+  def + [B1 >: B] (kv: Pair[A, B1]): Map[A, B1] = update(kv._1, kv._2)
 
   /** Add two or more key/value pairs to this map.
    *  @param    kv1 the first key/value pair.
@@ -76,21 +76,21 @@ trait Map[A, +B] extends collection.Map[A, B] {
    *  @param    kvs the remaining key/value pairs.
    *  @return   A new map with the new bindings added
    */
-  def + [B1 >: B] (kv1: {A, B1}, kv2: {A, B1}, kvs: {A, B1}*): Map[A, B1] =
+  def + [B1 >: B] (kv1: Pair[A, B1], kv2: Pair[A, B1], kvs: Pair[A, B1]*): Map[A, B1] =
     this + kv1 + kv2 ++ kvs
 
   /** Add a sequence of key/value pairs to this map.
    *  @param    kvs the iterable object containing all key/value pairs.
    *  @return   A new map with the new bindings added
    */
-  def ++ [B1 >: B] (kvs: Iterable[{A, B1}]): Map[A, B1] =
+  def ++ [B1 >: B] (kvs: Iterable[Pair[A, B1]]): Map[A, B1] =
     ((this: Map[A, B1]) /: kvs) ((m, kv) => m + kv)
 
   /** Add a sequence of key/value pairs to this map.
    *  @param    kvs the iterator containing all key/value pairs.
    *  @return   A new map with the new bindings added
    */
-  def ++ [B1 >: B] (kvs: Iterator[{A, B1}]): Map[A, B1] =
+  def ++ [B1 >: B] (kvs: Iterator[Pair[A, B1]]): Map[A, B1] =
     ((this: Map[A, B1]) /: kvs) ((m, kv) => m + kv)
 
   /** Remove a key from this map
@@ -140,7 +140,7 @@ trait Map[A, +B] extends collection.Map[A, B] {
    */
   def transform[C](f: (A, B) => C): Map[A, C] = {
     var res = empty[C]
-    foreach { case {key, value} => res = res.update(key, f(key, value)) }
+    foreach { case Pair(key, value) => res = res.update(key, f(key, value)) }
     res
   }
 
@@ -150,10 +150,10 @@ trait Map[A, +B] extends collection.Map[A, B] {
    *  @param p A prediacte over key-value pairs
    *  @return  the updated map
    */
-  override def filter(p: {A, B} => Boolean): Map[A, B] = {
+  override def filter(p: Pair[A, B] => Boolean): Map[A, B] = {
     var res = this
     foreach {
-      case kv @ {key, _} => if (!p(kv)) { res = res - key }
+      case kv @ Pair(key, _) => if (!p(kv)) { res = res - key }
     }
     res
   }
@@ -178,7 +178,7 @@ trait Map[A, +B] extends collection.Map[A, B] {
    *  @return         ...
    *  @deprecated   use <code>+</code> instead
    */
-  [deprecated] def incl[B1 >: B](mappings: {A, B1}*): Map[A, B1] = incl(mappings)
+  [deprecated] def incl[B1 >: B](mappings: Pair[A, B1]*): Map[A, B1] = incl(mappings)
 
   /** <code>incl</code> can be used to add many mappings at the same time
    *  to the map. The method assumes that each mapping is represented
@@ -187,11 +187,11 @@ trait Map[A, +B] extends collection.Map[A, B] {
    *
    *  @deprecated    use <code>++</code> instead
    */
-  [deprecated] def incl[B1 >: B](map: Iterable[{A, B1}]): Map[A, B1] = {
+  [deprecated] def incl[B1 >: B](map: Iterable[Pair[A, B1]]): Map[A, B1] = {
     val iter = map.elements
     var res: Map[A, B1] = this
     while (iter.hasNext) {
-      val {key, value} = iter.next
+      val Pair(key, value) = iter.next
       res = res.update(key, value)
     }
     res
@@ -227,7 +227,7 @@ trait Map[A, +B] extends collection.Map[A, B] {
    *  @param p ...
    *  @return  the string representation of a map entry
    */
-  [deprecated] def mappingToString[B1 >: B](p: {A, B1}) = p._1.toString() + " -> " + p._2
+  [deprecated] def mappingToString[B1 >: B](p: Pair[A, B1]) = p._1.toString() + " -> " + p._2
 
   /** @deprecated    use <code>+({A, B})</code> instead
    */
diff --git a/src/library/scala/collection/immutable/Map1.scala b/src/library/scala/collection/immutable/Map1.scala
index 22a2e05b09..edd8dc11fc 100755
--- a/src/library/scala/collection/immutable/Map1.scala
+++ b/src/library/scala/collection/immutable/Map1.scala
@@ -12,6 +12,8 @@
 
 package scala.collection.immutable
 
+import Predef.Pair
+
 /** This class implements empty immutable maps
  *  @author  Martin Oderskty
  *  @version 1.0, 019/01/2007
@@ -24,7 +26,7 @@ class Map1[A, +B](key1: A, value1: B) extends Map[A, B] {
   def get(key: A): Option[B] =
     if (key == key1) Some(value1) else None
 
-  def elements = Iterator.single({key1, value1})
+  def elements = Iterator.single(Pair(key1, value1))
 
   def empty[B]: Map[A, B] = new EmptyMap[A, B]
 
diff --git a/src/library/scala/collection/immutable/Map2.scala b/src/library/scala/collection/immutable/Map2.scala
index fbadfaa68d..02d4651d03 100755
--- a/src/library/scala/collection/immutable/Map2.scala
+++ b/src/library/scala/collection/immutable/Map2.scala
@@ -12,6 +12,8 @@
 
 package scala.collection.immutable
 
+import Predef.Pair
+
 /** This class implements empty immutable maps
  *  @author  Martin Oderskty
  *  @version 1.0, 019/01/2007
@@ -27,7 +29,7 @@ class Map2[A, +B](key1: A, value1: B, key2: A, value2: B) extends Map[A, B] {
     else None
 
   def elements = Iterator.fromValues(
-    {key1, value1}, {key2, value2})
+    Pair(key1, value1), Pair(key2, value2))
 
   def empty[C]: Map[A, C] = new EmptyMap[A, C]
 
diff --git a/src/library/scala/collection/immutable/Map3.scala b/src/library/scala/collection/immutable/Map3.scala
index 38198bbc71..b7c4a506f8 100755
--- a/src/library/scala/collection/immutable/Map3.scala
+++ b/src/library/scala/collection/immutable/Map3.scala
@@ -12,6 +12,8 @@
 
 package scala.collection.immutable
 
+import Predef.Pair
+
 /** This class implements empty immutable maps
  *  @author  Martin Oderskty
  *  @version 1.0, 019/01/2007
@@ -28,7 +30,7 @@ class Map3[A, +B](key1: A, value1: B, key2: A, value2: B, key3: A, value3: B) ex
     else None
 
   def elements = Iterator.fromValues(
-    {key1, value1}, {key2, value2}, {key3, value3})
+    Pair(key1, value1), Pair(key2, value2), Pair(key3, value3))
 
   def empty[C]: Map[A, C] = new EmptyMap[A, C]
 
diff --git a/src/library/scala/collection/immutable/Map4.scala b/src/library/scala/collection/immutable/Map4.scala
index 3596008109..1582123c18 100755
--- a/src/library/scala/collection/immutable/Map4.scala
+++ b/src/library/scala/collection/immutable/Map4.scala
@@ -29,7 +29,7 @@ class Map4[A, +B](key1: A, value1: B, key2: A, value2: B, key3: A, value3: B, ke
     else None
 
   def elements = Iterator.fromValues(
-    {key1, value1}, {key2, value2}, {key3, value3}, {key4, value4})
+    Pair(key1, value1), Pair(key2, value2), Pair(key3, value3), Pair(key4, value4))
 
   def empty[C]: Map[A, C] = new EmptyMap[A, C]
 
diff --git a/src/library/scala/collection/immutable/Queue.scala b/src/library/scala/collection/immutable/Queue.scala
index c88bbbdb27..c40777b417 100644
--- a/src/library/scala/collection/immutable/Queue.scala
+++ b/src/library/scala/collection/immutable/Queue.scala
@@ -100,12 +100,12 @@ class Queue[+A](elem: A*) extends Seq[A] {
    *  @throws Predef.NoSuchElementException
    *  @return the first element of the queue.
    */
-  def dequeue: {A, Queue[A]} = {
-    val {newOut, newIn} =
-      if (out.isEmpty) {in.reverse, Nil}
-      else {out, in};
+  def dequeue: Pair[A, Queue[A]] = {
+    val Pair(newOut, newIn) =
+      if (out.isEmpty) Pair(in.reverse, Nil)
+      else Pair(out, in)
     if (newOut.isEmpty) throw new NoSuchElementException("queue empty")
-    else {newOut.head, mkQueue(newIn, newOut.tail)}
+    else Pair(newOut.head, mkQueue(newIn, newOut.tail))
   }
 
   /** Returns the first element in the queue, or throws an error if there
@@ -155,7 +155,7 @@ class Queue[+A](elem: A*) extends Seq[A] {
   override def hashCode(): Int =
     if (isEmpty) 0
     else {
-      val q: {A,Queue[A]} = dequeue;
+      val q: Pair[A,Queue[A]] = dequeue;
       q._1.hashCode() + q._2.hashCode()
     }
 }
diff --git a/src/library/scala/collection/immutable/RedBlack.scala b/src/library/scala/collection/immutable/RedBlack.scala
index cd0fd432f9..dd3c7ebc94 100755
--- a/src/library/scala/collection/immutable/RedBlack.scala
+++ b/src/library/scala/collection/immutable/RedBlack.scala
@@ -19,7 +19,7 @@ abstract class RedBlack[A] {
     def lookup(x: A): Tree[B]
     def update[B1 >: B](k: A, v: B1): Tree[B1] = blacken(upd(k, v))
     def delete(k: A): Tree[B] = del(k)
-    def elements: Iterator[{A, B}]
+    def elements: Iterator[Pair[A, B]]
     def upd[B1 >: B](k: A, v: B1): Tree[B1]
     def del(k: A): Tree[B]
     def smallest: NonEmpty[B]
@@ -67,8 +67,8 @@ abstract class RedBlack[A] {
       }
     }
     def smallest: NonEmpty[B] = if (left.isEmpty) this else left.smallest
-    def elements: Iterator[{A, B}] =
-      left.elements append Iterator.single({key, value}) append right.elements
+    def elements: Iterator[Pair[A, B]] =
+      left.elements append Iterator.single(Pair(key, value)) append right.elements
   }
   [serializable]
   case object Empty extends Tree[Nothing] {
@@ -78,7 +78,7 @@ abstract class RedBlack[A] {
     def upd[B](k: A, v: B): Tree[B] = RedTree(k, v, Empty, Empty)
     def del(k: A): Tree[Nothing] = this
     def smallest: NonEmpty[Nothing] = throw new NoSuchElementException("empty map")
-    def elements: Iterator[{A, Nothing}] = Iterator.empty
+    def elements: Iterator[Pair[A, Nothing]] = Iterator.empty
   }
   [serializable]
   case class RedTree[+B](override val key: A,
diff --git a/src/library/scala/collection/immutable/Tree.scala b/src/library/scala/collection/immutable/Tree.scala
index bc69b7c4db..eef8842e39 100644
--- a/src/library/scala/collection/immutable/Tree.scala
+++ b/src/library/scala/collection/immutable/Tree.scala
@@ -235,7 +235,7 @@ private case class INode[A <% Ordered[A],B](t1: GBTree[A,B],
   def insertRight(key: A, value: B, smaller: GBTree[A,B]) =
     balance_p(GBNode(key, value, smaller, t1),smaller);
   protected def balance_p(t:GBTree[A,B],subtree:GBTree[A,B]):InsertTree[A,B] = {
-    val {subHeight, subSize} = subtree.count
+    val Pair(subHeight, subSize) = subtree.count
     val totalHeight = 2 * compat.Math.max(height, subHeight)
     val totalSize = size + subSize + 1
     val BalanceHeight = totalSize * totalSize
@@ -260,13 +260,13 @@ protected abstract class GBTree[A <% Ordered[A],B] extends AnyRef {
   /** Calculates 2^h, and size, where h is the height of the tree
   *   and size is the number of nodes in the tree.
   */
-  def count: {Int,Int}
+  def count: Pair[Int,Int]
   def isDefinedAt(Key: A): Boolean
   def get(key: A): Option[B]
   def apply(key: A): B
   def update(key: A, value: B): aNode
   def insert(key: A, value: B, size: Int): anInsertTree
-  def toList(acc: List[{A,B}]): List[{A,B}]
+  def toList(acc: List[Pair[A,B]]): List[Pair[A,B]]
   def mk_iter(iter_tail: List[aNode]): List[aNode]
   def delete(key: A): aNode
   def merge(t: aNode): aNode
@@ -275,7 +275,7 @@ protected abstract class GBTree[A <% Ordered[A],B] extends AnyRef {
 }
 
 private case class GBLeaf[A <% Ordered[A],B]() extends GBTree[A,B] {
-  def count = {1, 0}
+  def count = Pair(1, 0)
   def isDefinedAt(key: A) = false
   def get(_key: A) = None
   def apply(key: A) = throw new NoSuchElementException("key " + key + " not found")
@@ -286,7 +286,7 @@ private case class GBLeaf[A <% Ordered[A],B]() extends GBTree[A,B] {
     else
       ITree(GBNode(key, value, this, this))
   }
-  def toList(acc: List[{A,B}]): List[{A,B}] = acc
+  def toList(acc: List[Pair[A,B]]): List[Pair[A,B]] = acc
   def mk_iter(iter_tail: List[GBTree[A,B]]) = iter_tail
   def merge(larger: GBTree[A,B]) = larger
   def takeSmallest: Triple[A,B, GBTree[A,B]] =
@@ -301,14 +301,14 @@ private case class GBNode[A <% Ordered[A],B](key: A,
                                              smaller: GBTree[A,B],
                                              bigger: GBTree[A,B])
              extends GBTree[A,B] {
-  def count: {Int,Int} = {
-    val {sHeight, sSize} = smaller.count
-    val {bHeight, bSize} = bigger.count
+  def count: Pair[Int,Int] = {
+    val Pair(sHeight, sSize) = smaller.count
+    val Pair(bHeight, bSize) = bigger.count
     val mySize = sSize + bSize + 1
     if (mySize == 1)
-      {1, mySize}
+      Pair(1, mySize)
     else
-      {2 * compat.Math.max(sHeight, bHeight), mySize}
+      Pair(2 * compat.Math.max(sHeight, bHeight), mySize)
   }
 
   def isDefinedAt(sKey: A): Boolean =
@@ -343,8 +343,8 @@ private case class GBNode[A <% Ordered[A],B](key: A,
       throw new NoSuchElementException("Key exists: " + newKey)
   }
 
-  def toList(acc: List[{A,B}]): List[{A,B}] =
-    smaller.toList({key, value} :: bigger.toList(acc))
+  def toList(acc: List[Pair[A,B]]): List[Pair[A,B]] =
+    smaller.toList(Pair(key, value) :: bigger.toList(acc))
 
   def mk_iter(iter_tail:List[aNode]):List[aNode] =
     smaller.mk_iter(this :: iter_tail)
@@ -362,16 +362,16 @@ private case class GBNode[A <% Ordered[A],B](key: A,
     case GBLeaf() =>
       this
     case _ =>
-      val {key1, value1, larger1} = larger.takeSmallest
+      val Triple(key1, value1, larger1) = larger.takeSmallest
       GBNode(key1, value1, this, larger1)
   }
 
   def takeSmallest: Triple[A, B, aNode] = smaller match {
     case GBLeaf() =>
-      {key, value, bigger}
+      Triple(key, value, bigger)
     case _ =>
-      val {key1, value1, smaller1} = smaller.takeSmallest
-      {key1, value1, GBNode(key, value, smaller1, bigger)}
+      val Triple(key1, value1, smaller1) = smaller.takeSmallest
+      Triple(key1, value1, GBNode(key, value, smaller1, bigger))
   }
 
   /**
@@ -381,22 +381,22 @@ private case class GBNode[A <% Ordered[A],B](key: A,
   def balance(s: int): GBTree[A,B] =
     balance_list(toList(scala.Nil), s)
 
-  protected def balance_list(list: List[{A,B}], s: int): GBTree[A,B] = {
+  protected def balance_list(list: List[Pair[A,B]], s: int): GBTree[A,B] = {
     val empty = GBLeaf[A,B]();
-    def bal(list: List[{A,B}], s: Int): {aNode, List[{A,B}]} = {
+    def bal(list: List[Pair[A,B]], s: Int): Pair[aNode, List[Pair[A,B]]] = {
       if (s > 1) {
         val sm = s - 1
         val s2 = sm / 2
         val s1 = sm - s2
-        val {t1, {k, v} :: l1} = bal(list, s1)
-        val {t2, l2} = bal(l1, s2)
+        val Pair(t1, Pair(k, v) :: l1) = bal(list, s1)
+        val Pair(t2, l2) = bal(l1, s2)
         val t = GBNode(k, v, t1, t2)
-        {t, l2}
+        Pair(t, l2)
       } else if (s == 1) {
-        val {k,v} :: rest = list
-        {GBNode(k, v, empty, empty), rest}
+        val Pair(k,v) :: rest = list
+        Pair(GBNode(k, v, empty, empty), rest)
       } else
-        {empty, list}
+        Pair(empty, list)
     }
     bal(list, s)._1
   }
diff --git a/src/library/scala/collection/immutable/TreeMap.scala b/src/library/scala/collection/immutable/TreeMap.scala
index 22664f1e20..9e43f092df 100644
--- a/src/library/scala/collection/immutable/TreeMap.scala
+++ b/src/library/scala/collection/immutable/TreeMap.scala
@@ -25,7 +25,7 @@ object TreeMap {
 
   /** The canonical factory for this type
    */
-  def apply[A <% Ordered[A], B](elems: {A, B}*) = empty[A, B] ++ elems
+  def apply[A <% Ordered[A], B](elems: Pair[A, B]*) = empty[A, B] ++ elems
 }
 
 /** This class implements immutable maps using a tree.
@@ -104,7 +104,7 @@ extends RedBlack[A] with Map[A, B] {
    *
    *  @return the new iterator
    */
-  def elements: Iterator[{A, B}] = tree.elements
+  def elements: Iterator[Pair[A, B]] = tree.elements
 }
 
 
diff --git a/src/library/scala/collection/immutable/UnbalancedTreeMap.scala b/src/library/scala/collection/immutable/UnbalancedTreeMap.scala
index dabc3a11cf..965c4729c6 100755
--- a/src/library/scala/collection/immutable/UnbalancedTreeMap.scala
+++ b/src/library/scala/collection/immutable/UnbalancedTreeMap.scala
@@ -20,7 +20,7 @@ object UnbalancedTreeMap {
 
   /** The canonical factory for this type
    */
-  def apply[A<% Ordered[A], B](elems: {A, B}*) = empty[A, B] ++ elems
+  def apply[A<% Ordered[A], B](elems: Pair[A, B]*) = empty[A, B] ++ elems
 }
 
 /** This class implements immutable maps using a tree.
@@ -95,7 +95,7 @@ class UnbalancedTreeMap[A <% Ordered[A], +B] extends Map[A, B] {
    *
    *  @return the new iterator
    */
-  def elements: Iterator[{A, B}] = Iterator.empty
+  def elements: Iterator[Pair[A, B]] = Iterator.empty
 
   protected class Node[+B](override protected val key: A,
                            override protected val value: B,
@@ -133,8 +133,8 @@ class UnbalancedTreeMap[A <% Ordered[A], +B] extends Map[A, B] {
       }
     }
 
-    override def elements: Iterator[{A, B}] =
-      left.elements append Iterator.single({key, value}) append right.elements
+    override def elements: Iterator[Pair[A, B]] =
+      left.elements append Iterator.single(Pair(key, value)) append right.elements
   }
 }
 
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)
   }
 
diff --git a/src/library/scala/concurrent/MailBox.scala b/src/library/scala/concurrent/MailBox.scala
index b6ba205fa2..e1399e9e58 100644
--- a/src/library/scala/concurrent/MailBox.scala
+++ b/src/library/scala/concurrent/MailBox.scala
@@ -58,7 +58,7 @@ class MailBox extends AnyRef with ListQueueCreator {
   private def scanSentMsgs[a](receiver: Receiver[a]): unit = synchronized {
     messageQueue.extractFirst(sent, msg => receiver.isDefinedAt(msg)) match {
       case None => receivers = receiverQueue.append(receivers, receiver)
-      case Some{msg, withoutMsg} => {
+      case Some(Pair(msg, withoutMsg)) => {
         sent = withoutMsg
         receiver.msg = msg
       }
@@ -73,7 +73,7 @@ class MailBox extends AnyRef with ListQueueCreator {
   def send(msg: Message): unit = synchronized {
     receiverQueue.extractFirst(receivers, r => r.isDefinedAt(msg)) match {
       case None => sent = messageQueue.append(sent, msg)
-      case Some{receiver, withoutReceiver} => {
+      case Some(Pair(receiver, withoutReceiver)) => {
         receivers = withoutReceiver
         receiver.msg = msg
         receiver synchronized { receiver.notify() }
@@ -116,7 +116,7 @@ trait QueueModule[a] {
   /** Append an element to a queue. */
   def append(l: t, x: a): t
   /** Extract an element satisfying a predicate from a queue. */
-  def extractFirst(l: t, p: a => boolean): Option[{a, t}]
+  def extractFirst(l: t, p: a => boolean): Option[Pair[a, t]]
 }
 
 /** Inefficient but simple queue module creator. */
@@ -125,16 +125,16 @@ trait ListQueueCreator {
     type t = List[a]
     def make: t = Nil
     def append(l: t, x: a): t = l ::: x :: Nil
-    def extractFirst(l: t, p: a => boolean): Option[{a, t}] =
+    def extractFirst(l: t, p: a => boolean): Option[Pair[a, t]] =
       l match {
         case Nil => None
         case head :: tail =>
           if (p(head))
-            Some{head, tail}
+            Some(Pair(head, tail))
           else
             extractFirst(tail, p) match {
               case None => None
-              case Some{x, without_x} => Some{x, head :: without_x}
+              case Some(Pair(x, without_x)) => Some(Pair(x, head :: without_x))
             }
       }
   }
@@ -144,17 +144,17 @@ trait ListQueueCreator {
 trait LinkedListQueueCreator {
   import scala.collection.mutable.LinkedList
   def queueCreate[a >: Null <: AnyRef]: QueueModule[a] = new QueueModule[a] {
-    type t = {LinkedList[a], LinkedList[a]} // fst = the list, snd = last elem
+    type t = Pair[LinkedList[a], LinkedList[a]] // fst = the list, snd = last elem
     def make: t = {
       val l = new LinkedList[a](null, null)
-      {l, l}
+      Pair(l, l)
     }
     def append(l: t, x: a): t = {
       val atTail = new LinkedList(x, null)
       l._2 append atTail;
-      {l._1, atTail}
+      Pair(l._1, atTail)
     }
-    def extractFirst(l: t, p: a => boolean): Option[{a, t}] = {
+    def extractFirst(l: t, p: a => boolean): Option[Pair[a, t]] = {
       var xs = l._1
       var xs1 = xs.next
       while ((xs1 ne null) && !p(xs1.elem)) {
@@ -166,7 +166,7 @@ trait LinkedListQueueCreator {
         if (xs.next eq null)
           Some(Pair(xs1.elem, Pair(l._1, xs)))
         else
-          Some{xs1.elem, l}
+          Some(Pair(xs1.elem, l))
       }
       else
         None
diff --git a/src/library/scala/concurrent/Process.scala b/src/library/scala/concurrent/Process.scala
index 3e8589e7ef..6aa2e5ff53 100644
--- a/src/library/scala/concurrent/Process.scala
+++ b/src/library/scala/concurrent/Process.scala
@@ -68,7 +68,7 @@ class Process(body: => Unit) extends Actor() {
     }
 
   private def signal(s: MailBox#Message) =
-    links.foreach { p: Process => p.send({'EXIT, this, s}) }
+    links.foreach { p: Process => p.send(Triple('EXIT, this, s)) }
 
   def !(msg: MailBox#Message) =
     send(msg)
diff --git a/src/library/scala/concurrent/jolib.scala b/src/library/scala/concurrent/jolib.scala
index afa23c0cb3..d26190da20 100644
--- a/src/library/scala/concurrent/jolib.scala
+++ b/src/library/scala/concurrent/jolib.scala
@@ -28,7 +28,7 @@ object jolib {
 
   class Join {
 
-    private var ruls: List[{Pattern, Rule}] = null
+    private var ruls: List[Pair[Pattern, Rule]] = null
 
     def canMatch(p: Pattern) =
       p forall { s => !s.queue.isEmpty }
@@ -36,13 +36,13 @@ object jolib {
     def values(p: Pattern): List[Any] =
       p map { s => s.queue.dequeue: Any }
 
-    def rules(rs: {Pattern, Rule}*) =
-      ruls = rs.asInstanceOf[List[{Pattern, Rule}]]
+    def rules(rs: Pair[Pattern, Rule]*) =
+      ruls = rs.asInstanceOf[List[Pair[Pattern, Rule]]]
 
     def tryMatch =
-      (ruls find { case {p, _} => canMatch(p) }) match {
+      ruls find { case Pair(p, _) => canMatch(p) } match {
         case None => () => ()
-        case Some{p, r} => {
+        case Some(Pair(p, r)) => {
           val args = values(p)
           () => concurrent.ops.spawn(r(args))
         }
diff --git a/src/library/scala/concurrent/ops.scala b/src/library/scala/concurrent/ops.scala
index 1c5b0e1713..73cfedc676 100644
--- a/src/library/scala/concurrent/ops.scala
+++ b/src/library/scala/concurrent/ops.scala
@@ -44,10 +44,10 @@ object ops {
    *  @param yp ...
    *  @return   ...
    */
-  def par[a, b](xp: => a, yp: => b): {a, b} = {
+  def par[a, b](xp: => a, yp: => b): Pair[a, b] = {
     val y = new SyncVar[b]
     spawn { y set yp }
-    {xp, y.get}
+    Pair(xp, y.get)
   }
 
   /**
diff --git a/src/library/scala/concurrent/pilib.scala b/src/library/scala/concurrent/pilib.scala
index bc76821884..449eb4f0fc 100644
--- a/src/library/scala/concurrent/pilib.scala
+++ b/src/library/scala/concurrent/pilib.scala
@@ -157,13 +157,13 @@ object pilib {
    *  @param gs2 ...
    *  @return    ...
    */
-  private def matches(gs1: List[UGP], gs2: List[UGP]): Option[{() => unit, () => Any, () => Any}] =
-    {gs1, gs2} match {
-      case {Nil, _} => None
-      case {_, Nil} => None
-      case {UGP(a1, d1, v1, c1) :: rest1, UGP(a2, d2, v2, c2) :: rest2} =>
+  private def matches(gs1: List[UGP], gs2: List[UGP]): Option[Triple[() => unit, () => Any, () => Any]] =
+    Pair(gs1, gs2) match {
+      case Pair(Nil, _) => None
+      case Pair(_, Nil) => None
+      case Pair(UGP(a1, d1, v1, c1) :: rest1, UGP(a2, d2, v2, c2) :: rest2) =>
         if (a1 == a2 && d1 == !d2)
-          Some{(() => if (d1) a1.log(v2) else a1.log(v1)), (() => c1(v2)), (() => c2(v1))}
+          Some(Triple((() => if (d1) a1.log(v2) else a1.log(v1)), (() => c1(v2)), (() => c2(v1))))
         else matches(gs1, rest2) match {
           case None => matches(rest1, gs2)
           case Some(t) => Some(t)
@@ -183,7 +183,7 @@ object pilib {
       case Nil => ss ::: List(s1)
       case s2 :: rest => matches(s1.gs, s2.gs) match {
         case None => s2 :: compare(s1, rest)
-        case Some{log, c1, c2} =>
+        case Some(Triple(log, c1, c2)) =>
           log()
           s1.set(c1)
           s2.set(c2)
diff --git a/src/library/scala/mobile/Code.scala b/src/library/scala/mobile/Code.scala
index 2f2b6c3832..e90d7015a3 100644
--- a/src/library/scala/mobile/Code.scala
+++ b/src/library/scala/mobile/Code.scala
@@ -158,17 +158,17 @@ class Code(clazz: java.lang.Class) {
   ////////////////////// private functions ///////////////////////
 
   private def boxValue(value: Any) = value match {
-    case x: Byte    => {new java.lang.Byte(x),      java.lang.Byte.TYPE}
-    case x: Boolean => {new java.lang.Boolean(x),   java.lang.Boolean.TYPE}
-    case x: Char    => {new java.lang.Character(x), java.lang.Character.TYPE}
-    case x: Short   => {new java.lang.Short(x),     java.lang.Short.TYPE}
-    case x: Int     => {new java.lang.Integer(x),   java.lang.Integer.TYPE}
-    case x: Long    => {new java.lang.Long(x),      java.lang.Long.TYPE}
-    case x: Float   => {new java.lang.Float(x),     java.lang.Float.TYPE}
-    case x: Double  => {new java.lang.Double(x),    java.lang.Double.TYPE}
+    case x: Byte    => Pair(new java.lang.Byte(x),      java.lang.Byte.TYPE)
+    case x: Boolean => Pair(new java.lang.Boolean(x),   java.lang.Boolean.TYPE)
+    case x: Char    => Pair(new java.lang.Character(x), java.lang.Character.TYPE)
+    case x: Short   => Pair(new java.lang.Short(x),     java.lang.Short.TYPE)
+    case x: Int     => Pair(new java.lang.Integer(x),   java.lang.Integer.TYPE)
+    case x: Long    => Pair(new java.lang.Long(x),      java.lang.Long.TYPE)
+    case x: Float   => Pair(new java.lang.Float(x),     java.lang.Float.TYPE)
+    case x: Double  => Pair(new java.lang.Double(x),    java.lang.Double.TYPE)
     case _          =>
       val x = value.asInstanceOf[JObject]
-      {x, x.getClass()}
+      Pair(x, x.getClass())
   }
 
   private def isConstructorName(methName: String) = {
diff --git a/src/library/scala/reflect/Type.scala b/src/library/scala/reflect/Type.scala
index fb1acbc650..de5dc52479 100644
--- a/src/library/scala/reflect/Type.scala
+++ b/src/library/scala/reflect/Type.scala
@@ -41,7 +41,7 @@ case class TypeBounds(lo: Type, hi: Type) extends Type
 case class MethodType(formals: List[Type], restpe: Type) extends Type
 
 /**  */
-case class PolyType(typeParams: List[Symbol], typeBounds: List[{Type, Type}], resultType: Type) extends Type
+case class PolyType(typeParams: List[Symbol], typeBounds: List[Pair[Type, Type]], resultType: Type) extends Type
 
 /**  */
 class ImplicitMethodType(formals: List[Type], restpe: Type)
diff --git a/src/library/scala/text/Document.scala b/src/library/scala/text/Document.scala
index 4818c342fd..70e7bc8fc7 100644
--- a/src/library/scala/text/Document.scala
+++ b/src/library/scala/text/Document.scala
@@ -50,20 +50,20 @@ abstract class Document {
         false
       case List() =>
         true
-      case {_, _, DocNil} :: z =>
+      case Triple(_, _, DocNil) :: z =>
         fits(w, z)
-      case {i, b, DocCons(h, t)} :: z =>
-        fits(w, {i,b,h} :: {i,b,t} :: z)
-      case {_, _, DocText(t)} :: z =>
+      case Triple(i, b, DocCons(h, t)) :: z =>
+        fits(w, Triple(i,b,h) :: Triple(i,b,t) :: z)
+      case Triple(_, _, DocText(t)) :: z =>
         fits(w - t.length(), z)
-      case {i, b, DocNest(ii, d)} :: z =>
-        fits(w, {i + ii, b, d} :: z)
-      case {_, false, DocBreak} :: z =>
+      case Triple(i, b, DocNest(ii, d)) :: z =>
+        fits(w, Triple(i + ii, b, d) :: z)
+      case Triple(_, false, DocBreak) :: z =>
         fits(w - 1, z)
-      case {_, true, DocBreak} :: z =>
+      case Triple(_, true, DocBreak) :: z =>
         true
-      case {i, _, DocGroup(d)} :: z =>
-        fits(w, {i, false, d} :: z)
+      case Triple(i, _, DocGroup(d)) :: z =>
+        fits(w, Triple(i, false, d) :: z)
     }
 
     def spaces(n: Int): Unit = {
@@ -77,28 +77,28 @@ abstract class Document {
 
     def fmt(k: Int, state: List[FmtState]): Unit = state match {
       case List() => ()
-      case {_, _, DocNil} :: z =>
+      case Triple(_, _, DocNil) :: z =>
         fmt(k, z)
-      case {i, b, DocCons(h, t)} :: z =>
-        fmt(k, {i, b, h} :: {i, b, t} :: z)
-      case {i, _, DocText(t)} :: z =>
+      case Triple(i, b, DocCons(h, t)) :: z =>
+        fmt(k, Triple(i, b, h) :: Triple(i, b, t) :: z)
+      case Triple(i, _, DocText(t)) :: z =>
         writer write t
         fmt(k + t.length(), z)
-      case {i, b, DocNest(ii, d)} :: z =>
-        fmt(k, {i + ii, b, d} :: z)
-      case {i, true, DocBreak} :: z =>
+      case Triple(i, b, DocNest(ii, d)) :: z =>
+        fmt(k, Triple(i + ii, b, d) :: z)
+      case Triple(i, true, DocBreak) :: z =>
         writer write "\n"
         spaces(i);
         fmt(i, z)
-      case {i, false, DocBreak} :: z =>
+      case Triple(i, false, DocBreak) :: z =>
         writer write " "
         fmt(k + 1, z)
-      case {i, b, DocGroup(d)} :: z =>
-        val fitsFlat = fits(width - k, {i, false, d} :: z)
-        fmt(k, {i, !fitsFlat, d} :: z)
+      case Triple(i, b, DocGroup(d)) :: z =>
+        val fitsFlat = fits(width - k, Triple(i, false, d) :: z)
+        fmt(k, Triple(i, !fitsFlat, d) :: z)
     }
 
-    fmt(0, {0, false, DocGroup(this)} :: Nil)
+    fmt(0, Triple(0, false, DocGroup(this)) :: Nil)
   }
 }