Optimization of Predef implicits.

All those wildcards in a default-scoped implicit are expensive,
they each lead to a typevar on every search.  Restructured the
Tuple2/Tuple3 Zipped classes, they're better this way anyway.
This also gets all that Tuple[23] code out of genprod.

7 files changed, 330 insertions, 277 deletions

diff --git a/src/library/scala/Function0.scala b/src/library/scala/Function0.scala
index e1e9ddb3fb..3690a0e65b 100644
--- a/src/library/scala/Function0.scala
+++ b/src/library/scala/Function0.scala
@@ -6,7 +6,7 @@
 **                          |/                                          **
 \*                                                                      */
 // GENERATED CODE: DO NOT EDIT.
-// genprod generated these sources at: Sat Apr 28 12:59:55 PDT 2012
+// genprod generated these sources at: Mon Apr 30 07:46:11 PDT 2012
 
 package scala
 
diff --git a/src/library/scala/Predef.scala b/src/library/scala/Predef.scala
index b84fcc4126..9eb1e6a11b 100644
--- a/src/library/scala/Predef.scala
+++ b/src/library/scala/Predef.scala
@@ -307,42 +307,36 @@ object Predef extends LowPriorityImplicits {
 
   // views --------------------------------------------------------------
 
-  implicit def exceptionWrapper(exc: Throwable) = new runtime.RichException(exc)
-
-  implicit def zipped2ToTraversable[El1, El2](zz: Tuple2[_, _]#Zipped[_, El1, _, El2]): Traversable[(El1, El2)] =
-    new collection.AbstractTraversable[(El1, El2)] {
-      def foreach[U](f: ((El1, El2)) => U): Unit = zz foreach Function.untupled(f)
-    }
-
-  implicit def zipped3ToTraversable[El1, El2, El3](zz: Tuple3[_, _, _]#Zipped[_, El1, _, El2, _, El3]): Traversable[(El1, El2, El3)] =
-    new collection.AbstractTraversable[(El1, El2, El3)] {
-      def foreach[U](f: ((El1, El2, El3)) => U): Unit = zz foreach Function.untupled(f)
-    }
-
-  implicit def genericArrayOps[T](xs: Array[T]): ArrayOps[T] = xs match {
-    case x: Array[AnyRef]  => refArrayOps[AnyRef](x).asInstanceOf[ArrayOps[T]]
-    case x: Array[Int]     => intArrayOps(x).asInstanceOf[ArrayOps[T]]
-    case x: Array[Double]  => doubleArrayOps(x).asInstanceOf[ArrayOps[T]]
-    case x: Array[Long]    => longArrayOps(x).asInstanceOf[ArrayOps[T]]
-    case x: Array[Float]   => floatArrayOps(x).asInstanceOf[ArrayOps[T]]
-    case x: Array[Char]    => charArrayOps(x).asInstanceOf[ArrayOps[T]]
-    case x: Array[Byte]    => byteArrayOps(x).asInstanceOf[ArrayOps[T]]
-    case x: Array[Short]   => shortArrayOps(x).asInstanceOf[ArrayOps[T]]
-    case x: Array[Boolean] => booleanArrayOps(x).asInstanceOf[ArrayOps[T]]
-    case x: Array[Unit]    => unitArrayOps(x).asInstanceOf[ArrayOps[T]]
+  implicit def exceptionWrapper(exc: Throwable)                                 = new runtime.RichException(exc)
+  implicit def tuple2ToZippedOps[T1, T2](x: (T1, T2))                           = new runtime.Tuple2Zipped.Ops(x)
+  implicit def tuple3ToZippedOps[T1, T2, T3](x: (T1, T2, T3))                   = new runtime.Tuple3Zipped.Ops(x)
+  implicit def seqToCharSequence(xs: collection.IndexedSeq[Char]): CharSequence = new runtime.SeqCharSequence(xs)
+  implicit def arrayToCharSequence(xs: Array[Char]): CharSequence               = new runtime.ArrayCharSequence(xs)
+
+  implicit def genericArrayOps[T](xs: Array[T]): ArrayOps[T] = (xs match {
+    case x: Array[AnyRef]  => refArrayOps[AnyRef](x)
+    case x: Array[Boolean] => booleanArrayOps(x)
+    case x: Array[Byte]    => byteArrayOps(x)
+    case x: Array[Char]    => charArrayOps(x)
+    case x: Array[Double]  => doubleArrayOps(x)
+    case x: Array[Float]   => floatArrayOps(x)
+    case x: Array[Int]     => intArrayOps(x)
+    case x: Array[Long]    => longArrayOps(x)
+    case x: Array[Short]   => shortArrayOps(x)
+    case x: Array[Unit]    => unitArrayOps(x)
     case null              => null
-  }
+  }).asInstanceOf[ArrayOps[T]]
 
-  implicit def refArrayOps[T <: AnyRef](xs: Array[T]): ArrayOps[T] = new ArrayOps.ofRef[T](xs)
-  implicit def intArrayOps(xs: Array[Int]): ArrayOps[Int] = new ArrayOps.ofInt(xs)
-  implicit def doubleArrayOps(xs: Array[Double]): ArrayOps[Double] = new ArrayOps.ofDouble(xs)
-  implicit def longArrayOps(xs: Array[Long]): ArrayOps[Long] = new ArrayOps.ofLong(xs)
-  implicit def floatArrayOps(xs: Array[Float]): ArrayOps[Float] = new ArrayOps.ofFloat(xs)
-  implicit def charArrayOps(xs: Array[Char]): ArrayOps[Char] = new ArrayOps.ofChar(xs)
-  implicit def byteArrayOps(xs: Array[Byte]): ArrayOps[Byte] = new ArrayOps.ofByte(xs)
-  implicit def shortArrayOps(xs: Array[Short]): ArrayOps[Short] = new ArrayOps.ofShort(xs)
   implicit def booleanArrayOps(xs: Array[Boolean]): ArrayOps[Boolean] = new ArrayOps.ofBoolean(xs)
-  implicit def unitArrayOps(xs: Array[Unit]): ArrayOps[Unit] = new ArrayOps.ofUnit(xs)
+  implicit def byteArrayOps(xs: Array[Byte]): ArrayOps[Byte]          = new ArrayOps.ofByte(xs)
+  implicit def charArrayOps(xs: Array[Char]): ArrayOps[Char]          = new ArrayOps.ofChar(xs)
+  implicit def doubleArrayOps(xs: Array[Double]): ArrayOps[Double]    = new ArrayOps.ofDouble(xs)
+  implicit def floatArrayOps(xs: Array[Float]): ArrayOps[Float]       = new ArrayOps.ofFloat(xs)
+  implicit def intArrayOps(xs: Array[Int]): ArrayOps[Int]             = new ArrayOps.ofInt(xs)
+  implicit def longArrayOps(xs: Array[Long]): ArrayOps[Long]          = new ArrayOps.ofLong(xs)
+  implicit def refArrayOps[T <: AnyRef](xs: Array[T]): ArrayOps[T]    = new ArrayOps.ofRef[T](xs)
+  implicit def shortArrayOps(xs: Array[Short]): ArrayOps[Short]       = new ArrayOps.ofShort(xs)
+  implicit def unitArrayOps(xs: Array[Unit]): ArrayOps[Unit]          = new ArrayOps.ofUnit(xs)
 
   // Primitive Widenings --------------------------------------------------------------
 
@@ -406,29 +400,17 @@ object Predef extends LowPriorityImplicits {
 
   // Strings and CharSequences --------------------------------------------------------------
 
-  implicit def any2stringadd(x: Any) = new runtime.StringAdd(x)
   @inline implicit def any2stringfmt(x: Any) = new runtime.StringFormat(x)
   @inline implicit def augmentString(x: String): StringOps = new StringOps(x)
+  implicit def any2stringadd(x: Any) = new runtime.StringAdd(x)
   implicit def unaugmentString(x: StringOps): String = x.repr
 
-  implicit def stringCanBuildFrom: CanBuildFrom[String, Char, String] =
-    new CanBuildFrom[String, Char, String] {
-      def apply(from: String) = apply()
-      def apply() = mutable.StringBuilder.newBuilder
-    }
-
-  implicit def seqToCharSequence(xs: collection.IndexedSeq[Char]): CharSequence = new CharSequence {
-    def length: Int = xs.length
-    def charAt(index: Int): Char = xs(index)
-    def subSequence(start: Int, end: Int): CharSequence = seqToCharSequence(xs.slice(start, end))
-    override def toString: String = xs.mkString("")
-  }
+  @deprecated("Use StringCanBuildFrom", "2.10.0")
+  def stringCanBuildFrom: CanBuildFrom[String, Char, String] = StringCanBuildFrom
 
-  implicit def arrayToCharSequence(xs: Array[Char]): CharSequence = new CharSequence {
-    def length: Int = xs.length
-    def charAt(index: Int): Char = xs(index)
-    def subSequence(start: Int, end: Int): CharSequence = arrayToCharSequence(xs.slice(start, end))
-    override def toString: String = xs.mkString("")
+  implicit val StringCanBuildFrom: CanBuildFrom[String, Char, String] = new CanBuildFrom[String, Char, String] {
+    def apply(from: String) = apply()
+    def apply()             = mutable.StringBuilder.newBuilder
   }
 
   // Type Constraints --------------------------------------------------------------
diff --git a/src/library/scala/Tuple2.scala b/src/library/scala/Tuple2.scala
index 58638f440f..5e77127080 100644
--- a/src/library/scala/Tuple2.scala
+++ b/src/library/scala/Tuple2.scala
@@ -9,9 +9,6 @@
 
 package scala
 
-import scala.collection.{ TraversableLike => TLike, IterableLike => ILike }
-import scala.collection.generic.{ CanBuildFrom => CBF }
-
 
 /** A tuple of 2 elements; the canonical representation of a [[scala.Product2]].
  *
@@ -30,106 +27,4 @@ case class Tuple2[@specialized(Int, Long, Double, Char, Boolean, AnyRef) +T1, @s
    */
   def swap: Tuple2[T2,T1] = Tuple2(_2, _1)
 
-  @deprecated("Use `zipped` instead.", "2.9.0")
-  @annotation.unspecialized
-  def zip[Repr1, El1, El2, To](implicit w1:   T1 => TLike[El1, Repr1],
-                                        w2:   T2 => Iterable[El2],
-                                        cbf1: CBF[Repr1, (El1, El2), To]): To = {
-    zipped map ((x, y) => ((x, y)))
-  }
-
-  /** Wraps a tuple in a `Zipped`, which supports 2-ary generalisations of `map`, `flatMap`, `filter`, etc.
-   * Note that there must be an implicit value to convert this tuple's types into a [[scala.collection.TraversableLike]]
-   * or [[scala.collection.IterableLike]].
-   * {{{
-   * scala> val tuple = (List(1,2,3),List('a','b','c'))
-   * tuple: (List[Int], List[Char]) = (List(1, 2, 3),List(a, b, c))
-   *
-   * scala> tuple.zipped map { (x,y) => x + ":" + y }
-   * res6: List[java.lang.String] = List(1:a, 2:b, 3:c)
-   * }}}
-   *
-   * @see Zipped
-   * Note: will not terminate for infinite-sized collections.
-   */
-  def zipped[Repr1, El1, Repr2, El2](implicit w1: T1 => TLike[El1, Repr1], w2: T2 => ILike[El2, Repr2]): Zipped[Repr1, El1, Repr2, El2]
-    = new Zipped[Repr1, El1, Repr2, El2](_1, _2)
-
-  class Zipped[+Repr1, +El1, +Repr2, +El2](coll1: TLike[El1, Repr1], coll2: ILike[El2, Repr2]) { // coll2: ILike for filter
-    def map[B, To](f: (El1, El2) => B)(implicit cbf: CBF[Repr1, B, To]): To = {
-      val b = cbf(coll1.repr)
-      b.sizeHint(coll1)
-      val elems2 = coll2.iterator
-
-      for (el1 <- coll1) {
-        if (elems2.hasNext)
-          b += f(el1, elems2.next)
-        else
-          return b.result
-      }
-
-      b.result
-    }
-
-    def flatMap[B, To](f: (El1, El2) => TraversableOnce[B])(implicit cbf: CBF[Repr1, B, To]): To = {
-      val b = cbf(coll1.repr)
-      val elems2 = coll2.iterator
-
-      for (el1 <- coll1) {
-        if (elems2.hasNext)
-          b ++= f(el1, elems2.next)
-        else
-          return b.result
-      }
-
-      b.result
-    }
-
-    def filter[To1, To2](f: (El1, El2) => Boolean)(implicit cbf1: CBF[Repr1, El1, To1], cbf2: CBF[Repr2, El2, To2]): (To1, To2) = {
-      val b1 = cbf1(coll1.repr)
-      val b2 = cbf2(coll2.repr)
-      val elems2 = coll2.iterator
-
-      for (el1 <- coll1) {
-        if (elems2.hasNext) {
-          val el2 = elems2.next
-          if (f(el1, el2)) {
-            b1 += el1
-            b2 += el2
-          }
-        }
-        else return (b1.result, b2.result)
-      }
-
-      (b1.result, b2.result)
-    }
-
-    def exists(f: (El1, El2) => Boolean): Boolean = {
-      val elems2 = coll2.iterator
-
-      for (el1 <- coll1) {
-        if (elems2.hasNext) {
-          if (f(el1, elems2.next))
-            return true
-        }
-        else return false
-      }
-      false
-    }
-
-    def forall(f: (El1, El2) => Boolean): Boolean =
-      !exists((x, y) => !f(x, y))
-
-    def foreach[U](f: (El1, El2) => U): Unit = {
-      val elems2 = coll2.iterator
-
-      for (el1 <- coll1) {
-        if (elems2.hasNext)
-          f(el1, elems2.next)
-        else
-          return
-      }
-    }
-  }
-
 }
diff --git a/src/library/scala/Tuple3.scala b/src/library/scala/Tuple3.scala
index 0d5399308b..5ed13602e3 100644
--- a/src/library/scala/Tuple3.scala
+++ b/src/library/scala/Tuple3.scala
@@ -9,9 +9,6 @@
 
 package scala
 
-import scala.collection.{ TraversableLike => TLike, IterableLike => ILike }
-import scala.collection.generic.{ CanBuildFrom => CBF }
-
 
 /** A tuple of 3 elements; the canonical representation of a [[scala.Product3]].
  *
@@ -25,121 +22,4 @@ case class Tuple3[+T1, +T2, +T3](_1: T1, _2: T2, _3: T3)
 {
   override def toString() = "(" + _1 + "," + _2 + "," + _3 + ")"
   
-
-  @deprecated("Use `zipped` instead.", "2.9.0")
-  def zip[Repr1, El1, El2, El3, To](implicit w1:   T1 => TLike[El1, Repr1],
-                                             w2:   T2 => Iterable[El2],
-                                             w3:   T3 => Iterable[El3],
-                                             cbf1: CBF[Repr1, (El1, El2, El3), To]): To = {
-    zipped map ((x, y, z) => ((x, y, z)))
-  }
-
-  /** Wraps a tuple in a `Zipped`, which supports 3-ary generalisations of `map`, `flatMap`, `filter`, etc.
-   * Note that there must be an implicit value to convert this tuple's types into a [[scala.collection.TraversableLike]]
-   * or [[scala.collection.IterableLike]].
-   * {{{
-   * scala> val tuple = (List(1,2,3),List('a','b','c'),List("x","y","z"))
-   * tuple: (List[Int], List[Char], List[java.lang.String]) = (List(1, 2, 3),List(a, b, c),List(x, y, z))
-   *
-   * scala> tuple.zipped map { (x,y,z) => x + ":" + y + ":" + z}
-   * res8: List[java.lang.String] = List(1:a:x, 2:b:y, 3:c:z)
-   * }}}
-   *
-   * @see Zipped
-   * Note: will not terminate for infinite-sized collections.
-   */
-  def zipped[Repr1, El1, Repr2, El2, Repr3, El3](implicit w1: T1 => TLike[El1, Repr1],
-                                                          w2: T2 => ILike[El2, Repr2],
-                                                          w3: T3 => ILike[El3, Repr3]): Zipped[Repr1, El1, Repr2, El2, Repr3, El3]
-    = new Zipped[Repr1, El1, Repr2, El2, Repr3, El3](_1, _2, _3)
-
-  class Zipped[+Repr1, +El1, +Repr2, +El2, +Repr3, +El3](coll1: TLike[El1, Repr1],
-                                                         coll2: ILike[El2, Repr2],
-                                                         coll3: ILike[El3, Repr3]) {
-    def map[B, To](f: (El1, El2, El3) => B)(implicit cbf: CBF[Repr1, B, To]): To = {
-      val b = cbf(coll1.repr)
-      val elems2 = coll2.iterator
-      val elems3 = coll3.iterator
-
-      for (el1 <- coll1) {
-        if (elems2.hasNext && elems3.hasNext)
-          b += f(el1, elems2.next, elems3.next)
-        else
-          return b.result
-      }
-      b.result
-    }
-
-    def flatMap[B, To](f: (El1, El2, El3) => TraversableOnce[B])(implicit cbf: CBF[Repr1, B, To]): To = {
-      val b = cbf(coll1.repr)
-      val elems2 = coll2.iterator
-      val elems3 = coll3.iterator
-
-      for (el1 <- coll1) {
-        if (elems2.hasNext && elems3.hasNext)
-          b ++= f(el1, elems2.next, elems3.next)
-        else
-          return b.result
-      }
-      b.result
-    }
-
-    def filter[To1, To2, To3](f: (El1, El2, El3) => Boolean)(
-                 implicit cbf1: CBF[Repr1, El1, To1],
-                          cbf2: CBF[Repr2, El2, To2],
-                          cbf3: CBF[Repr3, El3, To3]): (To1, To2, To3) = {
-      val b1 = cbf1(coll1.repr)
-      val b2 = cbf2(coll2.repr)
-      val b3 = cbf3(coll3.repr)
-      val elems2 = coll2.iterator
-      val elems3 = coll3.iterator
-      def result = (b1.result, b2.result, b3.result)
-
-      for (el1 <- coll1) {
-        if (elems2.hasNext && elems3.hasNext) {
-          val el2 = elems2.next
-          val el3 = elems3.next
-
-          if (f(el1, el2, el3)) {
-            b1 += el1
-            b2 += el2
-            b3 += el3
-          }
-        }
-        else return result
-      }
-
-      result
-    }
-
-    def exists(f: (El1, El2, El3) => Boolean): Boolean = {
-      val elems2 = coll2.iterator
-      val elems3 = coll3.iterator
-
-      for (el1 <- coll1) {
-        if (elems2.hasNext && elems3.hasNext) {
-          if (f(el1, elems2.next, elems3.next))
-            return true
-        }
-        else return false
-      }
-      false
-    }
-
-    def forall(f: (El1, El2, El3) => Boolean): Boolean =
-      !exists((x, y, z) => !f(x, y, z))
-
-    def foreach[U](f: (El1, El2, El3) => U): Unit = {
-      val elems2 = coll2.iterator
-      val elems3 = coll3.iterator
-
-      for (el1 <- coll1) {
-        if (elems2.hasNext && elems3.hasNext)
-          f(el1, elems2.next, elems3.next)
-        else
-          return
-      }
-    }
-  }
-
 }
diff --git a/src/library/scala/runtime/SeqCharSequence.scala b/src/library/scala/runtime/SeqCharSequence.scala
new file mode 100644
index 0000000000..7f7bca789f
--- /dev/null
+++ b/src/library/scala/runtime/SeqCharSequence.scala
@@ -0,0 +1,25 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2002-2011, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala.runtime
+
+import java.util.Arrays.copyOfRange
+
+final class SeqCharSequence(val xs: collection.IndexedSeq[Char]) extends CharSequence {
+  def length: Int                                     = xs.length
+  def charAt(index: Int): Char                        = xs(index)
+  def subSequence(start: Int, end: Int): CharSequence = new SeqCharSequence(xs.slice(start, end))
+  override def toString = xs.mkString("")
+}
+
+final class ArrayCharSequence(val xs: Array[Char]) extends CharSequence {
+  def length: Int                                     = xs.length
+  def charAt(index: Int): Char                        = xs(index)
+  def subSequence(start: Int, end: Int): CharSequence = new ArrayCharSequence(copyOfRange(xs, math.max(0, start), math.min(xs.length, end)))
+  override def toString = xs.mkString("")
+}
diff --git a/src/library/scala/runtime/Tuple2Zipped.scala b/src/library/scala/runtime/Tuple2Zipped.scala
new file mode 100644
index 0000000000..5ad364c8a5
--- /dev/null
+++ b/src/library/scala/runtime/Tuple2Zipped.scala
@@ -0,0 +1,130 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2002-2011, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala.runtime
+
+import scala.collection.{ TraversableLike, IterableLike }
+import scala.collection.generic.{ CanBuildFrom => CBF }
+
+/** This interface is intended as a minimal interface, not complicated
+ *  by the requirement to resolve type constructors, for implicit search (which only
+ *  needs to find an implicit conversion to Traversable for our purposes.)
+ */
+trait ZippedTraversable2[+El1, +El2] {
+  def foreach[U](f: (El1, El2) => U): Unit
+}
+object ZippedTraversable2 {
+  implicit def zippedTraversable2ToTraversable[El1, El2](zz: ZippedTraversable2[El1, El2]): Traversable[(El1, El2)] = {
+    new collection.AbstractTraversable[(El1, El2)] {
+      def foreach[U](f: ((El1, El2)) => U): Unit = zz foreach Function.untupled(f)
+    }
+  }
+}
+
+class Tuple2Zipped[El1, Repr1, El2, Repr2](
+  coll1: TraversableLike[El1, Repr1],
+  coll2: IterableLike[El2, Repr2]
+) extends ZippedTraversable2[El1, El2] {
+  def map[B, To](f: (El1, El2) => B)(implicit cbf: CBF[Repr1, B, To]): To = {
+    val b = cbf(coll1.repr)
+    b.sizeHint(coll1)
+    val elems2 = coll2.iterator
+
+    for (el1 <- coll1) {
+      if (elems2.hasNext)
+        b += f(el1, elems2.next)
+      else
+        return b.result
+    }
+
+    b.result
+  }
+
+  def flatMap[B, To](f: (El1, El2) => TraversableOnce[B])(implicit cbf: CBF[Repr1, B, To]): To = {
+    val b = cbf(coll1.repr)
+    val elems2 = coll2.iterator
+
+    for (el1 <- coll1) {
+      if (elems2.hasNext)
+        b ++= f(el1, elems2.next)
+      else
+        return b.result
+    }
+
+    b.result
+  }
+
+  def filter[To1, To2](f: (El1, El2) => Boolean)(implicit cbf1: CBF[Repr1, El1, To1], cbf2: CBF[Repr2, El2, To2]): (To1, To2) = {
+    val b1 = cbf1(coll1.repr)
+    val b2 = cbf2(coll2.repr)
+    val elems2 = coll2.iterator
+
+    for (el1 <- coll1) {
+      if (elems2.hasNext) {
+        val el2 = elems2.next
+        if (f(el1, el2)) {
+          b1 += el1
+          b2 += el2
+        }
+      }
+      else return (b1.result, b2.result)
+    }
+
+    (b1.result, b2.result)
+  }
+
+  def exists(f: (El1, El2) => Boolean): Boolean = {
+    val elems2 = coll2.iterator
+
+    for (el1 <- coll1) {
+      if (elems2.hasNext) {
+        if (f(el1, elems2.next))
+          return true
+      }
+      else return false
+    }
+    false
+  }
+
+  def forall(f: (El1, El2) => Boolean): Boolean =
+    !exists((x, y) => !f(x, y))
+
+  def foreach[U](f: (El1, El2) => U): Unit = {
+    val elems2 = coll2.iterator
+
+    for (el1 <- coll1) {
+      if (elems2.hasNext)
+        f(el1, elems2.next)
+      else
+        return
+    }
+  }
+}
+
+object Tuple2Zipped {
+  class Ops[T1, T2](x: (T1, T2)) {
+    def invert[El1, CC1[X] <: TraversableOnce[X], El2, CC2[X] <: TraversableOnce[X], That]
+      (implicit w1: T1 <:< CC1[El1],
+                w2: T2 <:< CC2[El2],
+                bf: collection.generic.CanBuildFrom[CC1[_], (El1, El2), That]
+      ): That = {
+        val buf = bf(x._1)
+        val it1 = x._1.toIterator
+        val it2 = x._2.toIterator
+        while (it1.hasNext && it2.hasNext)
+          buf += ((it1.next, it2.next))
+        
+        buf.result
+      }
+
+    def zipped[El1, Repr1, El2, Repr2]
+      (implicit w1: T1 => TraversableLike[El1, Repr1],
+                w2: T2 => IterableLike[El2, Repr2]
+      ): Tuple2Zipped[El1, Repr1, El2, Repr2] = new Tuple2Zipped(x._1, x._2)
+  }
+}
diff --git a/src/library/scala/runtime/Tuple3Zipped.scala b/src/library/scala/runtime/Tuple3Zipped.scala
new file mode 100644
index 0000000000..4e9c542c58
--- /dev/null
+++ b/src/library/scala/runtime/Tuple3Zipped.scala
@@ -0,0 +1,141 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2002-2011, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala.runtime
+
+import scala.collection.{ TraversableLike, IterableLike }
+import scala.collection.generic.{ CanBuildFrom => CBF }
+
+/** See comment on ZippedTraversable2. */
+trait ZippedTraversable3[+El1, +El2, +El3] {
+  def foreach[U](f: (El1, El2, El3) => U): Unit
+}
+object ZippedTraversable3 {
+  implicit def zippedTraversable3ToTraversable[El1, El2, El3](zz: ZippedTraversable3[El1, El2, El3]): Traversable[(El1, El2, El3)] = {
+    new collection.AbstractTraversable[(El1, El2, El3)] {
+      def foreach[U](f: ((El1, El2, El3)) => U): Unit = zz foreach Function.untupled(f)
+    }
+  }
+}
+
+class Tuple3Zipped[El1, Repr1, El2, Repr2, El3, Repr3](
+  coll1: TraversableLike[El1, Repr1],
+  coll2: IterableLike[El2, Repr2],
+  coll3: IterableLike[El3, Repr3]
+) extends ZippedTraversable3[El1, El2, El3] {
+  def map[B, To](f: (El1, El2, El3) => B)(implicit cbf: CBF[Repr1, B, To]): To = {
+    val b = cbf(coll1.repr)
+    val elems2 = coll2.iterator
+    val elems3 = coll3.iterator
+
+    for (el1 <- coll1) {
+      if (elems2.hasNext && elems3.hasNext)
+        b += f(el1, elems2.next, elems3.next)
+      else
+        return b.result
+    }
+    b.result
+  }
+
+  def flatMap[B, To](f: (El1, El2, El3) => TraversableOnce[B])(implicit cbf: CBF[Repr1, B, To]): To = {
+    val b = cbf(coll1.repr)
+    val elems2 = coll2.iterator
+    val elems3 = coll3.iterator
+
+    for (el1 <- coll1) {
+      if (elems2.hasNext && elems3.hasNext)
+        b ++= f(el1, elems2.next, elems3.next)
+      else
+        return b.result
+    }
+    b.result
+  }
+
+  def filter[To1, To2, To3](f: (El1, El2, El3) => Boolean)(
+               implicit cbf1: CBF[Repr1, El1, To1],
+                        cbf2: CBF[Repr2, El2, To2],
+                        cbf3: CBF[Repr3, El3, To3]): (To1, To2, To3) = {
+    val b1 = cbf1(coll1.repr)
+    val b2 = cbf2(coll2.repr)
+    val b3 = cbf3(coll3.repr)
+    val elems2 = coll2.iterator
+    val elems3 = coll3.iterator
+    def result = (b1.result, b2.result, b3.result)
+
+    for (el1 <- coll1) {
+      if (elems2.hasNext && elems3.hasNext) {
+        val el2 = elems2.next
+        val el3 = elems3.next
+
+        if (f(el1, el2, el3)) {
+          b1 += el1
+          b2 += el2
+          b3 += el3
+        }
+      }
+      else return result
+    }
+
+    result
+  }
+
+  def exists(f: (El1, El2, El3) => Boolean): Boolean = {
+    val elems2 = coll2.iterator
+    val elems3 = coll3.iterator
+
+    for (el1 <- coll1) {
+      if (elems2.hasNext && elems3.hasNext) {
+        if (f(el1, elems2.next, elems3.next))
+          return true
+      }
+      else return false
+    }
+    false
+  }
+
+  def forall(f: (El1, El2, El3) => Boolean): Boolean =
+    !exists((x, y, z) => !f(x, y, z))
+
+  def foreach[U](f: (El1, El2, El3) => U): Unit = {
+    val elems2 = coll2.iterator
+    val elems3 = coll3.iterator
+
+    for (el1 <- coll1) {
+      if (elems2.hasNext && elems3.hasNext)
+        f(el1, elems2.next, elems3.next)
+      else
+        return
+    }
+  }
+}
+
+object Tuple3Zipped {
+  class Ops[T1, T2, T3](x: (T1, T2, T3)) {
+    def invert[El1, CC1[X] <: TraversableOnce[X], El2, CC2[X] <: TraversableOnce[X], El3, CC3[X] <: TraversableOnce[X], That]
+      (implicit w1: T1 <:< CC1[El1],
+                w2: T2 <:< CC2[El2],
+                w3: T3 <:< CC3[El3],
+                bf: collection.generic.CanBuildFrom[CC1[_], (El1, El2, El3), That]
+      ): That = {
+        val buf = bf(x._1)
+        val it1 = x._1.toIterator
+        val it2 = x._2.toIterator
+        val it3 = x._3.toIterator
+        while (it1.hasNext && it2.hasNext && it3.hasNext)
+          buf += ((it1.next, it2.next, it3.next))
+        
+        buf.result
+      }
+    
+    def zipped[El1, Repr1, El2, Repr2, El3, Repr3]
+      (implicit w1: T1 => TraversableLike[El1, Repr1],
+                w2: T2 => IterableLike[El2, Repr2],
+                w3: T3 => IterableLike[El3, Repr3]
+      ): Tuple3Zipped[El1, Repr1, El2, Repr2, El3, Repr3] = new Tuple3Zipped(x._1, x._2, x._3)
+  }
+}