deprecate Pair and Triple

14 files changed, 118 insertions, 118 deletions

diff --git a/docs/examples/fors.scala b/docs/examples/fors.scala
index b937e53fcd..29616b61b1 100644
--- a/docs/examples/fors.scala
+++ b/docs/examples/fors.scala
@@ -83,7 +83,7 @@ object fors {
          if b1 != b2;
          Elem(_, "author", _, _, Text(a1)) <- b1.toList;
          Elem(_, "author", _, _, Text(a2)) <- b2.toList;
-         if a1 == a2) yield Pair(a1, a2))
+         if a1 == a2) yield (a1, a2))
 
   def removeDuplicates[a](xs: List[a]): List[a] =
     if (xs.isEmpty)
diff --git a/docs/examples/iterators.scala b/docs/examples/iterators.scala
index e2e5e050a0..9ddb141d61 100644
--- a/docs/examples/iterators.scala
+++ b/docs/examples/iterators.scala
@@ -15,8 +15,8 @@ object iterators {
   def findGreater(xs: Array[Double], limit: Double) =
     xs.iterator
       .zip(Iterator.from(0))
-      .filter{case Pair(x, i) => x > limit }
-      .map{case Pair(x, i) => i}
+      .filter{case (x, i) => x > limit }
+      .map{case (x, i) => i}
 
   def main(args: Array[String]) {
     val ar = Array/*[Double]*/(6, 2, 8, 5, 1)
diff --git a/docs/examples/jolib/Ref.scala b/docs/examples/jolib/Ref.scala
index 32952b4351..099a3c2df2 100644
--- a/docs/examples/jolib/Ref.scala
+++ b/docs/examples/jolib/Ref.scala
@@ -12,20 +12,20 @@ import concurrent.SyncVar;
 import concurrent.jolib._;
 
 class Ref[a](init: a) extends Join {
-  
+
   object get extends Synchr[a](this) { case class C() extends SyncVar[a]; }
   object set extends Synchr[unit](this) { case class C(x: a) extends SyncVar[unit]; }
   object state extends Asynchr(this) { case class C(x: a); }
 
   rules (
-    Pair(List(get, state), { case List(g @ get.C(), state.C(x) ) =>
+    (List(get, state), { case List(g @ get.C(), state.C(x) ) =>
       { g.set(x); state(state.C(x)) } }),
-    Pair(List(set, state), { case List(s @ set.C(x), state.C(y) ) =>
+    (List(set, state), { case List(s @ set.C(x), state.C(y) ) =>
       { s.set(()); state(state.C(x)) } })
   );
 
   state(state.C(init));
-  
+
   def Get: a = get(get.C());
   def Set(x: a): unit = set(set.C(x));
 }
diff --git a/docs/examples/jolib/parallelOr.scala b/docs/examples/jolib/parallelOr.scala
index fb8288c5b2..a0305c56bf 100644
--- a/docs/examples/jolib/parallelOr.scala
+++ b/docs/examples/jolib/parallelOr.scala
@@ -13,27 +13,27 @@ import concurrent.SyncVar;
 
 /** Implementation in the join-calculus of a parallel OR. */
 object or extends Join {
-  
+
   object res extends Synchr[boolean](this) { case class C() extends SyncVar[boolean] };
   object res1 extends Asynchr(this) { case class C(b: boolean); }
   object res2 extends Asynchr(this) { case class C(b: boolean); }
   object res1False extends Synchr[boolean](this) { case class C() extends SyncVar[boolean] };
   object res2False extends Synchr[boolean](this) { case class C() extends SyncVar[boolean] };
-  
+
   rules(
-    Pair(List(res, res1), { case List(r @ res.C(), res1.C(b)) =>
+    (List(res, res1), { case List(r @ res.C(), res1.C(b)) =>
       if (b) r.set(b) else r.set(res1False(res1False.C())) }),
-    
-    Pair(List(res, res2), { case List(r @ res.C(), res2.C(b)) =>
+
+    (List(res, res2), { case List(r @ res.C(), res2.C(b)) =>
       if (b) r.set(b) else r.set(res2False(res2False.C())) }),
-    
-    Pair(List(res1False, res2),  { case List(r @ res1False.C(), res2.C(b)) =>
+
+    (List(res1False, res2),  { case List(r @ res1False.C(), res2.C(b)) =>
       r.set(b) }),
-    
-    Pair(List(res2False, res1),  { case List(r @ res2False.C(), res1.C(b)) =>
+
+    (List(res2False, res1),  { case List(r @ res2False.C(), res1.C(b)) =>
       r.set(b) })
   );
-  
+
   def apply(b1: => boolean, b2: => boolean): boolean = {
     concurrent.ops.spawn(res1(res1.C(b1)));
     concurrent.ops.spawn(res2(res2.C(b2)));
@@ -42,7 +42,7 @@ object or extends Join {
 }
 */
 object parallelOr {
-  
+
   def main(args: Array[String]): unit = {
     def loop: boolean = { while (true) {}; true };
 /*
diff --git a/docs/examples/monads/callccInterpreter.scala b/docs/examples/monads/callccInterpreter.scala
index 5b556bd8fa..b5008c4c1b 100644
--- a/docs/examples/monads/callccInterpreter.scala
+++ b/docs/examples/monads/callccInterpreter.scala
@@ -14,7 +14,7 @@ object callccInterpreter {
 
   def showM(m: M[Value]): String = (m in id).toString();
 
-  def callCC[A](h: (A => M[A]) => M[A]) = 
+  def callCC[A](h: (A => M[A]) => M[A]) =
     M[A](c => h(a => M[A](d => c(a))) in c);
 
   type Name = String;
@@ -30,7 +30,7 @@ object callccInterpreter {
   trait Value;
   case object Wrong extends Value {
    override def toString() = "wrong"
-  } 
+  }
   case class Num(n: Int) extends Value {
     override def toString() = n.toString();
   }
@@ -38,15 +38,15 @@ object callccInterpreter {
     override def toString() = "<function>"
   }
 
-  type Environment = List[Pair[Name, Value]];
+  type Environment = List[Tuple2[Name, Value]];
 
   def lookup(x: Name, e: Environment): M[Value] = e match {
     case List() => unitM(Wrong)
-    case Pair(y, b) :: e1 => if (x == y) unitM(b) else lookup(x, e1)
+    case (y, b) :: e1 => if (x == y) unitM(b) else lookup(x, e1)
   }
 
-  def add(a: Value, b: Value): M[Value] = Pair(a, b) match {
-    case Pair(Num(m), Num(n)) => unitM(Num(m + n))
+  def add(a: Value, b: Value): M[Value] = (a, b) match {
+    case (Num(m), Num(n)) => unitM(Num(m + n))
     case _ => unitM(Wrong)
   }
 
@@ -62,15 +62,15 @@ object callccInterpreter {
 			   b <- interp(r, e);
 			   c <- add(a, b))
                       yield c
-    case Lam(x, t) => unitM(Fun(a => interp(t, Pair(x, a) :: e)))
+    case Lam(x, t) => unitM(Fun(a => interp(t, (x, a) :: e)))
     case App(f, t) => for (a <- interp(f, e);
 			   b <- interp(t, e);
 			   c <- apply(a, b))
 		      yield c
-    case Ccc(x, t) => callCC(k => interp(t, Pair(x, Fun(k)) :: e))
+    case Ccc(x, t) => callCC(k => interp(t, (x, Fun(k)) :: e))
   }
 
-  def test(t: Term): String = 
+  def test(t: Term): String =
     showM(interp(t, List()));
 
   val term0 = App(Lam("x", Add(Var("x"), Var("x"))), Add(Con(10), Con(11)));
diff --git a/docs/examples/monads/directInterpreter.scala b/docs/examples/monads/directInterpreter.scala
index 06fffba8e2..d8ca8ccfa7 100644
--- a/docs/examples/monads/directInterpreter.scala
+++ b/docs/examples/monads/directInterpreter.scala
@@ -20,15 +20,15 @@ object directInterpreter {
     case Fun(f) => "<function>"
   }
 
-  type Environment = List[Pair[Name, Value]];
+  type Environment = List[Tuple2[Name, Value]];
 
   def lookup(x: Name, e: Environment): Value = e match {
     case List() => Wrong
-    case Pair(y, b) :: e1 => if (x == y) b else lookup(x, e1)
+    case (y, b) :: e1 => if (x == y) b else lookup(x, e1)
   }
 
-  def add(a: Value, b: Value): Value = Pair(a, b) match {
-    case Pair(Num(m), Num(n)) => Num(m + n)
+  def add(a: Value, b: Value): Value = (a, b) match {
+    case (Num(m), Num(n)) => Num(m + n)
     case _ => Wrong
   }
 
@@ -41,15 +41,15 @@ object directInterpreter {
     case Var(x) => lookup(x, e)
     case Con(n) => Num(n)
     case Add(l, r) => add(interp(l, e), interp(r, e))
-    case Lam(x, t) => Fun(a => interp(t, Pair(x, a) :: e))
+    case Lam(x, t) => Fun(a => interp(t, (x, a) :: e))
     case App(f, t) => apply(interp(f, e), interp(t, e))
   }
 
-  def test(t: Term): String = 
+  def test(t: Term): String =
     showval(interp(t, List()));
 
   val term0 = App(Lam("x", Add(Var("x"), Var("x"))), Add(Con(10), Con(11)));
 
-  def main(args: Array[String]) = 
+  def main(args: Array[String]) =
     System.out.println(test(term0));
 }
diff --git a/docs/examples/monads/errorInterpreter.scala b/docs/examples/monads/errorInterpreter.scala
index d3cc45627d..c15e1041e2 100644
--- a/docs/examples/monads/errorInterpreter.scala
+++ b/docs/examples/monads/errorInterpreter.scala
@@ -41,15 +41,15 @@ object errorInterpreter {
     override def toString() = "<function>"
   }
 
-  type Environment = List[Pair[Name, Value]]
+  type Environment = List[Tuple2[Name, Value]]
 
   def lookup(x: Name, e: Environment): M[Value] = e match {
     case List() => errorM("unbound variable: " + x);
-    case Pair(y, b) :: e1 => if (x == y) unitM(b) else lookup(x, e1)
+    case (y, b) :: e1 => if (x == y) unitM(b) else lookup(x, e1)
   }
 
-  def add(a: Value, b: Value): M[Value] = Pair(a, b) match {
-    case Pair(Num(m), Num(n)) => unitM(Num(m + n))
+  def add(a: Value, b: Value): M[Value] = (a, b) match {
+    case (Num(m), Num(n)) => unitM(Num(m + n))
     case _ => errorM("should be numbers: " + a + "," + b)
   }
 
@@ -65,7 +65,7 @@ object errorInterpreter {
                            b <- interp(r, e);
                            c <- add(a, b))
                       yield c
-    case Lam(x, t) => unitM(Fun(a => interp(t, Pair(x, a) :: e)))
+    case Lam(x, t) => unitM(Fun(a => interp(t, (x, a) :: e)))
     case App(f, t) => for (a <- interp(f, e);
                            b <- interp(t, e);
                            c <- apply(a, b))
diff --git a/docs/examples/monads/simpleInterpreter.scala b/docs/examples/monads/simpleInterpreter.scala
index cde3a92dbb..64636749ff 100644
--- a/docs/examples/monads/simpleInterpreter.scala
+++ b/docs/examples/monads/simpleInterpreter.scala
@@ -22,7 +22,7 @@ object simpleInterpreter {
   trait Value;
   case object Wrong extends Value {
    override def toString() = "wrong"
-  } 
+  }
   case class Num(n: Int) extends Value {
     override def toString() = n.toString();
   }
@@ -30,15 +30,15 @@ object simpleInterpreter {
     override def toString() = "<function>"
   }
 
-  type Environment = List[Pair[Name, Value]];
+  type Environment = List[Tuple2[Name, Value]];
 
   def lookup(x: Name, e: Environment): M[Value] = e match {
     case List() => unitM(Wrong)
-    case Pair(y, b) :: e1 => if (x == y) unitM(b) else lookup(x, e1)
+    case (y, b) :: e1 => if (x == y) unitM(b) else lookup(x, e1)
   }
 
-  def add(a: Value, b: Value): M[Value] = Pair(a, b) match {
-    case Pair(Num(m), Num(n)) => unitM(Num(m + n))
+  def add(a: Value, b: Value): M[Value] = (a, b) match {
+    case (Num(m), Num(n)) => unitM(Num(m + n))
     case _ => unitM(Wrong)
   }
 
@@ -54,14 +54,14 @@ object simpleInterpreter {
 			   b <- interp(r, e);
 			   c <- add(a, b))
                       yield c
-    case Lam(x, t) => unitM(Fun(a => interp(t, Pair(x, a) :: e)))
+    case Lam(x, t) => unitM(Fun(a => interp(t, (x, a) :: e)))
     case App(f, t) => for (a <- interp(f, e);
 			   b <- interp(t, e);
 			   c <- apply(a, b))
 		      yield c
   }
 
-  def test(t: Term): String = 
+  def test(t: Term): String =
     showM(interp(t, List()));
 
   val term0 = App(Lam("x", Add(Var("x"), Var("x"))), Add(Con(10), Con(11)));
diff --git a/docs/examples/monads/stateInterpreter.scala b/docs/examples/monads/stateInterpreter.scala
index 97f3335dab..e13e9049da 100644
--- a/docs/examples/monads/stateInterpreter.scala
+++ b/docs/examples/monads/stateInterpreter.scala
@@ -4,20 +4,20 @@ object stateInterpreter {
 
   type State = Int;
 
-  val tickS = new M(s => Pair((), s + 1));
+  val tickS = new M(s => ((), s + 1));
 
-  case class M[A](in: State => Pair[A, State]) {
-    def bind[B](k: A => M[B]) = M[B]{ s0 => 
-      val Pair(a, s1) = this in s0; k(a) in s1
+  case class M[A](in: State => Tuple2[A, State]) {
+    def bind[B](k: A => M[B]) = M[B]{ s0 =>
+      val (a, s1) = this in s0; k(a) in s1
     }
     def map[B](f: A => B): M[B]        = bind(x => unitM(f(x)));
     def flatMap[B](f: A => M[B]): M[B] = bind(f);
   }
 
-  def unitM[A](a: A) = M[A](s => Pair(a, s));
+  def unitM[A](a: A) = M[A](s => (a, s));
 
   def showM(m: M[Value]): String = {
-    val Pair(a, s1) = m in 0;
+    val (a, s1) = m in 0;
     "Value: " + a + "; Count: " + s1
   }
 
@@ -41,15 +41,15 @@ object stateInterpreter {
     override def toString() = "<function>"
   }
 
-  type Environment = List[Pair[Name, Value]];
+  type Environment = List[Tuple2[Name, Value]];
 
   def lookup(x: Name, e: Environment): M[Value] = e match {
     case List() => unitM(Wrong)
-    case Pair(y, b) :: e1 => if (x == y) unitM(b) else lookup(x, e1)
+    case (y, b) :: e1 => if (x == y) unitM(b) else lookup(x, e1)
   }
 
-  def add(a: Value, b: Value): M[Value] = Pair(a, b) match {
-    case Pair(Num(m), Num(n)) => for (_ <- tickS) yield Num(m + n)
+  def add(a: Value, b: Value): M[Value] = (a, b) match {
+    case (Num(m), Num(n)) => for (_ <- tickS) yield Num(m + n)
     case _ => unitM(Wrong)
   }
 
@@ -65,14 +65,14 @@ object stateInterpreter {
 			   b <- interp(r, e);
 			   c <- add(a, b))
                       yield c
-    case Lam(x, t) => unitM(Fun(a => interp(t, Pair(x, a) :: e)))
+    case Lam(x, t) => unitM(Fun(a => interp(t, (x, a) :: e)))
     case App(f, t) => for (a <- interp(f, e);
 			   b <- interp(t, e);
 			   c <- apply(a, b))
 		      yield c
   }
 
-  def test(t: Term): String = 
+  def test(t: Term): String =
     showM(interp(t, List()));
 
   val term0 = App(Lam("x", Add(Var("x"), Var("x"))), Add(Con(10), Con(11)));
diff --git a/docs/examples/patterns.scala b/docs/examples/patterns.scala
index 738deabc66..d082fcc3de 100644
--- a/docs/examples/patterns.scala
+++ b/docs/examples/patterns.scala
@@ -13,17 +13,17 @@ object patterns {
     case Leaf(x) => x
   }
 
-  def find[a,b](it: Iterator[Pair[a, b]], x: a): Option[b] = {
+  def find[a,b](it: Iterator[Tuple2[a, b]], x: a): Option[b] = {
     var result: Option[b] = None
     var found = false
     while (it.hasNext && !found) {
-      val Pair(x1, y) = it.next
+      val (x1, y) = it.next
       if (x == x1) { found = true; result = Some(y) }
     }
     result
   }
 
-  def printFinds[a](xs: List[Pair[a, String]], x: a) =
+  def printFinds[a](xs: List[Tuple2[a, String]], x: a) =
     find(xs.iterator, x) match {
       case Some(y) => System.out.println(y)
       case None => System.out.println("no match")
@@ -31,6 +31,6 @@ object patterns {
 
   def main(args: Array[String]) {
     println("sum of leafs=" + sumLeaves(tree1))
-    printFinds(List(Pair(3, "three"), Pair(4, "four")), 4)
+    printFinds(List((3, "three"), (4, "four")), 4)
   }
 }
diff --git a/docs/examples/pilib/elasticBuffer.scala b/docs/examples/pilib/elasticBuffer.scala
index 5fec96ab6c..c173735dbb 100644
--- a/docs/examples/pilib/elasticBuffer.scala
+++ b/docs/examples/pilib/elasticBuffer.scala
@@ -8,7 +8,7 @@ object elasticBuffer {
    * Recursive type for channels that carry a "String" channel and
    * an object of the type we define.
    */
-  class MetaChan extends Chan[Pair[Chan[String], MetaChan]]
+  class MetaChan extends Chan[Tuple2[Chan[String], MetaChan]]
 
   def Buffer(put: Chan[String], get: Chan[String]): Unit = {
 
@@ -18,19 +18,19 @@ object elasticBuffer {
     def Bl(i:Chan[String], l: MetaChan,
            o: Chan[String], r: MetaChan): unit =
       choice (
-        l(Pair(o,r)) * (System.out.println("Removed one cell.")),
+        l((o,r)) * (System.out.println("Removed one cell.")),
         i * (inp => Cl(i, l, o, r, inp))
       )
 
     /**
      * A buffer cell containing a value, ready to receive (o,r) from the right.
      */
-    def Cl(i: Chan[String], l: MetaChan, 
+    def Cl(i: Chan[String], l: MetaChan,
            o: Chan[String], r: MetaChan, content: String): Unit =
       choice (
         o(content) * (Bl(i,l,o,r)),
         i * (inp => Dl(i,l,o,r,content, inp)),
-        r * ( { case Pair(newo, newr) => Cl(i,l,newo,newr,content) })
+        r * ( { case (newo, newr) => Cl(i,l,newo,newr,content) })
       )
 
     /**
diff --git a/docs/examples/pilib/handover.scala b/docs/examples/pilib/handover.scala
index c9b6156c2c..4e9a5670a0 100644
--- a/docs/examples/pilib/handover.scala
+++ b/docs/examples/pilib/handover.scala
@@ -13,14 +13,14 @@ object handoverRecursive {
    * Recursive type for channels that carry a channel "unit" and
    * an object of the type we define.
    */
-  class Switch extends Chan[Pair[Chan[unit], Switch]]
+  class Switch extends Chan[Tuple2[Chan[unit], Switch]]
 
   /**
    * Car.
    */
   def Car(talk: Chan[unit], switch: Switch): unit =
     choice (
-      switch * ({ case Pair(t,s) => Car(t, s) }),
+      switch * ({ case (t,s) => Car(t, s) }),
       talk(()) * ( {
         Thread.sleep(1 + random.nextInt(1000));
         System.out.println("Car emitted a message.");
@@ -32,20 +32,20 @@ object handoverRecursive {
    * Control center.
    */
   def Control(talk1: Chan[unit], switch1: Switch,
-              gain1: Switch, lose1: Switch, 
+              gain1: Switch, lose1: Switch,
               talk2: Chan[unit], switch2: Switch,
               gain2: Switch, lose2: Switch): unit
   = {
     def Control1: unit= {
       Thread.sleep(1 + random.nextInt(1000));
-      lose1.write(Pair(talk2, switch2));
-      gain2.write(Pair(talk2, switch2));
+      lose1.write((talk2, switch2));
+      gain2.write((talk2, switch2));
       Control2
     }
     def Control2: unit = {
       Thread.sleep(1 + random.nextInt(1000));
-      lose2.write(Pair(talk1, switch1));
-      gain1.write(Pair(talk1, switch1));
+      lose2.write((talk1, switch1));
+      gain1.write((talk1, switch1));
       Control1
     }
     Control1
@@ -62,8 +62,8 @@ object handoverRecursive {
         System.out.println(id + " received a message.")
         ActiveTransmitter(id, talk, switch, gain, lose)
       }),
-      lose * ({ case Pair(t, s) => {
-        switch.write(Pair(t, s))
+      lose * ({ case (t, s) => {
+        switch.write((t, s))
         IdleTransmitter(id, gain, lose)
       }})
     );
@@ -72,7 +72,7 @@ object handoverRecursive {
    * Idle transmitter.
    */
   def IdleTransmitter(id: String, gain: Switch, lose: Switch): unit = {
-    val Pair(t, s) = gain.read;
+    val (t, s) = gain.read;
     ActiveTransmitter(id, t, s, gain, lose)
   }
 
@@ -108,7 +108,7 @@ object handoverCast {
   def Car(talk: Chan[Any], switch: Chan[Any]): unit =
     choice (
       switch * (o => {
-        val Pair(t,s) = o.asInstanceOf[Pair[Chan[Any],Chan[Any]]]; 
+        val (t,s) = o.asInstanceOf[Tuple2[Chan[Any],Chan[Any]]];
         Car(t, s)
       }),
       talk(()) * ( {
@@ -122,20 +122,20 @@ object handoverCast {
   * Control center.
   */
   def Control(talk1: Chan[Any], switch1: Chan[Any],
-              gain1: Chan[Any], lose1: Chan[Any], 
+              gain1: Chan[Any], lose1: Chan[Any],
               talk2: Chan[Any], switch2: Chan[Any],
               gain2: Chan[Any], lose2: Chan[Any]): unit
   = {
     def Control1: unit = {
       Thread.sleep(1 + random.nextInt(1000));
-      lose1.write(Pair(talk2, switch2));
-      gain2.write(Pair(talk2, switch2));
+      lose1.write((talk2, switch2));
+      gain2.write((talk2, switch2));
       Control2
     }
     def Control2: unit = {
       Thread.sleep(1 + random.nextInt(1000));
-      lose2.write(Pair(talk1, switch1));
-      gain1.write(Pair(talk1, switch1));
+      lose2.write((talk1, switch1));
+      gain1.write((talk1, switch1));
       Control1
     }
     Control1
@@ -153,8 +153,8 @@ object handoverCast {
         ActiveTransmitter(id, talk, switch, gain, lose)
       }),
       lose * (o => {
-        val Pair(t, s) = o.asInstanceOf[Pair[Chan[Any],Chan[Any]]]
-        switch.write(Pair(t, s))
+        val (t, s) = o.asInstanceOf[Tuple2[Chan[Any],Chan[Any]]]
+        switch.write((t, s))
         IdleTransmitter(id, gain, lose)
       })
     )
@@ -163,7 +163,7 @@ object handoverCast {
   * Idle transmitter.
   */
   def IdleTransmitter(id: String, gain: Chan[Any], lose: Chan[Any]): unit = {
-    val Pair(t, s) = gain.read.asInstanceOf[Pair[Chan[Any],Chan[Any]]]
+    val (t, s) = gain.read.asInstanceOf[Tuple2[Chan[Any],Chan[Any]]]
     ActiveTransmitter(id, t, s, gain, lose)
   }
 
diff --git a/docs/examples/pilib/piNat.scala b/docs/examples/pilib/piNat.scala
index a1a0e682e1..c6d9bdaf5c 100644
--- a/docs/examples/pilib/piNat.scala
+++ b/docs/examples/pilib/piNat.scala
@@ -4,23 +4,23 @@ import scala.concurrent.pilib._
 
 /** Church encoding of naturals in the Pi-calculus */
 object piNat extends Application {
- 
+
   /** Locations of Pi-calculus natural */
-  class NatChan extends Chan[Triple[Chan[Unit], Chan[NatChan], Chan[NatChan]]]
+  class NatChan extends Chan[Tuple3[Chan[Unit], Chan[NatChan], Chan[NatChan]]]
 
   /** Zero */
   def Z(l: NatChan): Unit = choice (
-    l * { case Triple(z, sd, d) => z.write(()) }
+    l * { case (z, sd, d) => z.write(()) }
   )
 
   /** Successor of Double */
   def SD(n: NatChan, l: NatChan): Unit = choice (
-    l * { case Triple(z, sd, d) => sd.write(n) }
+    l * { case (z, sd, d) => sd.write(n) }
   )
 
   /** Double */
   def D(n: NatChan, l: NatChan): Unit = choice (
-    l * { case Triple(z, sd, d) => d.write(n) }
+    l * { case (z, sd, d) => d.write(n) }
   )
 
   /** Make "l" a location representing the natural "n" */
@@ -34,7 +34,7 @@ object piNat extends Application {
     val z = new Chan[Unit]
     val sd = new Chan[NatChan]
     val d = new Chan[NatChan]
-    spawn < m.write(Triple(z, sd, d)) >;
+    spawn < m.write((z, sd, d)) >;
     choice (
       z  * { x => make(1, n) },
       sd * { m1 => { val n1 = new NatChan; spawn < D(n1, n) >; Succ(m1, n1) } },
@@ -47,7 +47,7 @@ object piNat extends Application {
     val z = new Chan[Unit]
     val sd = new Chan[NatChan]
     val d = new Chan[NatChan]
-    spawn < l.write(Triple(z, sd, d)) >;
+    spawn < l.write((z, sd, d)) >;
     choice (
       z  * { x => spawn < Z(m) >; Z(n)  },
       sd * { l1 => { val m1 = new NatChan; val n1 = new NatChan;
@@ -64,7 +64,7 @@ object piNat extends Application {
     val z = new Chan[Unit]
     val sd = new Chan[NatChan]
     val d = new Chan[NatChan]
-    spawn < n.write(Triple(z, sd, d)) >;
+    spawn < n.write((z, sd, d)) >;
     choice (
       z  * { x => 0  },
       sd * { n1 => 2 * value(n1) + 1 },
diff --git a/docs/examples/typeinf.scala b/docs/examples/typeinf.scala
index d4bc8bf3e1..ac6cc35f6b 100644
--- a/docs/examples/typeinf.scala
+++ b/docs/examples/typeinf.scala
@@ -53,11 +53,11 @@ object typeInfer {
       (emptySubst /: tyvars) ((s, tv) => s.extend(tv, newTyvar())) (tpe)
   }
 
-  type Env = List[Pair[String, TypeScheme]]
+  type Env = List[Tuple2[String, TypeScheme]]
 
   def lookup(env: Env, x: String): TypeScheme = env match {
     case List() => null
-    case Pair(y, t) :: env1 => if (x == y) t else lookup(env1, x)
+    case (y, t) :: env1 => if (x == y) t else lookup(env1, x)
   }
 
   def gen(env: Env, t: Type): TypeScheme =
@@ -69,22 +69,22 @@ object typeInfer {
     case Tycon(k, ts) => (List[Tyvar]() /: ts) ((tvs, t) => tvs union tyvars(t))
   }
 
-  def tyvars(ts: TypeScheme): List[Tyvar] = 
+  def tyvars(ts: TypeScheme): List[Tyvar] =
     tyvars(ts.tpe) diff ts.tyvars;
 
   def tyvars(env: Env): List[Tyvar] =
     (List[Tyvar]() /: env) ((tvs, nt) => tvs union tyvars(nt._2))
 
-  def mgu(t: Type, u: Type, s: Subst): Subst = Pair(s(t), s(u)) match {
-    case Pair(Tyvar(a), Tyvar(b)) if (a == b) => 
+  def mgu(t: Type, u: Type, s: Subst): Subst = (s(t), s(u)) match {
+    case (Tyvar(a), Tyvar(b)) if (a == b) =>
       s
-    case Pair(Tyvar(a), _) if !(tyvars(u) contains a) =>
+    case (Tyvar(a), _) if !(tyvars(u) contains a) =>
       s.extend(Tyvar(a), u)
-    case Pair(_, Tyvar(a)) =>
+    case (_, Tyvar(a)) =>
       mgu(u, t, s)
-    case Pair(Arrow(t1, t2), Arrow(u1, u2)) =>
+    case (Arrow(t1, t2), Arrow(u1, u2)) =>
       mgu(t1, u1, mgu(t2, u2, s))
-    case Pair(Tycon(k1, ts), Tycon(k2, us)) if (k1 == k2) =>
+    case (Tycon(k1, ts), Tycon(k2, us)) if (k1 == k2) =>
       (s /: (ts zip us)) ((s, tu) => mgu(tu._1, tu._2, s))
     case _ =>
       throw new TypeError("cannot unify " + s(t) + " with " + s(u))
@@ -103,7 +103,7 @@ object typeInfer {
       case Lam(x, e1) =>
         val a, b = newTyvar()
         val s1 = mgu(t, Arrow(a, b), s)
-        val env1 = Pair(x, TypeScheme(List(), a)) :: env
+        val env1 = (x, TypeScheme(List(), a)) :: env
         tp(env1, e1, b, s1)
 
       case App(e1, e2) =>
@@ -114,7 +114,7 @@ object typeInfer {
       case Let(x, e1, e2) =>
         val a = newTyvar()
         val s1 = tp(env, e1, a, s)
-        tp(Pair(x, gen(env, s1(a))) :: env, e2, t, s1)
+        tp((x, gen(env, s1(a))) :: env, e2, t, s1)
     }
   }
   var current: Term = null
@@ -134,18 +134,18 @@ object typeInfer {
     private val a = typeInfer.newTyvar()
     val env = List(
 /*
-      Pair("true", gen(booleanType)),
-      Pair("false", gen(booleanType)),
-      Pair("if", gen(Arrow(booleanType, Arrow(a, Arrow(a, a))))),
-      Pair("zero", gen(intType)),
-      Pair("succ", gen(Arrow(intType, intType))),
-      Pair("nil", gen(listType(a))),
-      Pair("cons", gen(Arrow(a, Arrow(listType(a), listType(a))))),
-      Pair("isEmpty", gen(Arrow(listType(a), booleanType))),
-      Pair("head", gen(Arrow(listType(a), a))),
-      Pair("tail", gen(Arrow(listType(a), listType(a)))),
+      ("true", gen(booleanType)),
+      ("false", gen(booleanType)),
+      ("if", gen(Arrow(booleanType, Arrow(a, Arrow(a, a))))),
+      ("zero", gen(intType)),
+      ("succ", gen(Arrow(intType, intType))),
+      ("nil", gen(listType(a))),
+      ("cons", gen(Arrow(a, Arrow(listType(a), listType(a))))),
+      ("isEmpty", gen(Arrow(listType(a), booleanType))),
+      ("head", gen(Arrow(listType(a), a))),
+      ("tail", gen(Arrow(listType(a), listType(a)))),
 */
-      Pair("fix", gen(Arrow(Arrow(a, a), a)))
+      ("fix", gen(Arrow(Arrow(a, a), a)))
     )
   }
 
@@ -181,7 +181,7 @@ object typeInfer {
         yield Lam(x, t): Term )
       |||
       ( for (
-          letid <- id if letid == "let"; 
+          letid <- id if letid == "let";
           x <- ident;
           _ <- wschr('=');
           t <- term;
@@ -220,7 +220,7 @@ object typeInfer {
     val input = 0
     def any = new Parser[char] {
       def apply(in: int): Parser[char]#Result =
-        if (in < s.length()) Some(Pair(s charAt in, in + 1)) else None
+        if (in < s.length()) Some((s charAt in, in + 1)) else None
     }
   }
 
@@ -239,7 +239,7 @@ object typeInfer {
       if (args.length == 1) {
         val ps = new ParseString(args(0)) with MiniMLParsers
         ps.all(ps.input) match {
-          case Some(Pair(term, _)) =>
+          case Some((term, _)) =>
             "" + term + ": " + showType(term)
           case None =>
             "syntax error"