Merge branch 'master' into feature/future-compat

13 files changed, 380 insertions, 552 deletions

diff --git a/src/build/genprod.scala b/src/build/genprod.scala
index 5a77c7a699..8c91128de0 100644
--- a/src/build/genprod.scala
+++ b/src/build/genprod.scala
@@ -256,10 +256,7 @@ class Function(val i: Int) extends Group("Function") with Arity {
 zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz */
 
 object Tuple {
-  val zipImports = """
-import scala.collection.{ TraversableLike => TLike, IterableLike => ILike }
-import scala.collection.generic.{ CanBuildFrom => CBF }
-"""
+  val zipImports = ""
 
   def make(i: Int) = apply(i)()
   def apply(i: Int) = i match {
@@ -285,230 +282,11 @@ object TupleTwo extends Tuple(2)
    * second element is the first element of this Tuple.
    */
   def swap: Tuple2[T2,T1] = Tuple2(_2, _1)
-
-  @deprecated("Use `zipped` instead.", "2.9.0")
-  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
-      }
-    }
-  }
 """
 }
 
 object TupleThree extends Tuple(3) {
   override def imports = Tuple.zipImports
-  override def moreMethods = """
-
-  @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
-      }
-    }
-  }
-"""
 }
 
 class Tuple(val i: Int) extends Group("Tuple") with Arity {
diff --git a/src/compiler/scala/tools/cmd/gen/AnyVals.scala b/src/compiler/scala/tools/cmd/gen/AnyVals.scala
index e8230b8ca4..83cd9c2578 100644
--- a/src/compiler/scala/tools/cmd/gen/AnyVals.scala
+++ b/src/compiler/scala/tools/cmd/gen/AnyVals.scala
@@ -15,18 +15,27 @@ trait AnyValReps {
 
     case class Op(val op : String, val doc : String)
     
-    private def companionCoercions(tos: String*) = {
+    private def companionCoercions(tos: AnyValRep*) = {
       tos.toList map (to =>
-        """implicit def %s2%s(x: %s): %s = x.to%s""".format(javaEquiv, to, name, to.capitalize, to.capitalize)
+        """implicit def @javaequiv@2%s(x: @name@): %s = x.to%s""".format(to.javaEquiv, to.name, to.name)
       )
     }
-    def implicitCoercions: List[String] = javaEquiv match {
-      case "byte"           => companionCoercions("short", "int", "long", "float", "double")
-      case "short" | "char" => companionCoercions("int", "long", "float", "double")
-      case "int"            => companionCoercions("long", "float", "double")
-      case "long"           => companionCoercions("float", "double")
-      case "float"          => companionCoercions("double")
-      case _                => Nil
+    def coercionCommentExtra = ""
+    def coercionComment = """
+  /** Language mandated coercions from @name@ to "wider" types.%s
+   */""".format(coercionCommentExtra)
+    
+    def implicitCoercions: List[String] = {
+      val coercions = this match {
+        case B     => companionCoercions(S, I, L, F, D)
+        case S | C => companionCoercions(I, L, F, D)
+        case I     => companionCoercions(L, F, D)
+        case L     => companionCoercions(F, D)
+        case F     => companionCoercions(D)
+        case _     => Nil
+      }
+      if (coercions.isEmpty) Nil
+      else coercionComment :: coercions
     }
 
     def isCardinal: Boolean = isIntegerType(this)
@@ -174,7 +183,7 @@ trait AnyValReps {
     }
     def objectLines = {
       val comp = if (isCardinal) cardinalCompanion else floatingCompanion
-      ((comp + allCompanions).trim.lines map interpolate).toList ++ implicitCoercions
+      (comp + allCompanions + "\n" + nonUnitCompanions).trim.lines.toList ++ implicitCoercions map interpolate
     }
 
     /** Makes a set of binary operations based on the given set of ops, args, and resultFn.
@@ -238,8 +247,9 @@ trait AnyValReps {
     def classDoc  = interpolate(classDocTemplate)
     def objectDoc = ""
     def mkImports = ""
-    def mkClass   = assemble("final class", "private", "AnyVal", classLines) + "\n"
-    def mkObject  = assemble("object", "", "AnyValCompanion", objectLines) + "\n"
+    
+    def mkClass       = assemble("final class " + name + " private extends AnyVal", classLines)
+    def mkObject      = assemble("object " + name + " extends AnyValCompanion", objectLines)
     def make()    = List[String](
       headerTemplate,
       mkImports,
@@ -249,11 +259,10 @@ trait AnyValReps {
       mkObject
     ) mkString ""
 
-    def assemble(what: String, ctor: String, parent: String, lines: List[String]): String = {
-      val decl = "%s %s %s extends %s ".format(what, name, ctor, parent)
-      val body = if (lines.isEmpty) "{ }\n\n" else lines map indent mkString ("{\n", "\n", "\n}\n")
+    def assemble(decl: String, lines: List[String]): String = {
+      val body = if (lines.isEmpty) " { }\n\n" else lines map indent mkString (" {\n", "\n", "\n}\n")
 
-      decl + body
+      decl + body + "\n"
     }
     override def toString = name
   }
@@ -310,6 +319,8 @@ def unbox(x: java.lang.Object): @name@ = @unboxImpl@
 override def toString = "object scala.@name@"
 """
 
+  def nonUnitCompanions = ""  // todo
+
   def cardinalCompanion = """
 /** The smallest value representable as a @name@.
  */
@@ -446,7 +457,7 @@ def ^(x: Boolean): Boolean  = sys.error("stub")
 override def getClass(): Class[Boolean] = sys.error("stub")
     """.trim.lines.toList
 
-    def objectLines = interpolate(allCompanions).lines.toList
+    def objectLines = interpolate(allCompanions + "\n" + nonUnitCompanions).lines.toList
   }
   object U extends AnyValRep("Unit", None, "void") {
     override def classDoc = """
diff --git a/src/compiler/scala/tools/nsc/interactive/tests/core/CoreTestDefs.scala b/src/compiler/scala/tools/nsc/interactive/tests/core/CoreTestDefs.scala
index 9646ee1cf0..d6102734ab 100644
--- a/src/compiler/scala/tools/nsc/interactive/tests/core/CoreTestDefs.scala
+++ b/src/compiler/scala/tools/nsc/interactive/tests/core/CoreTestDefs.scala
@@ -17,15 +17,11 @@ private[tests] trait CoreTestDefs
     extends PresentationCompilerTestDef
     with AskCompletionAt {
 
-    object MemberPrinter {
-      def apply(member: compiler.Member): String =
-        "`" + (member.sym.toString() + member.tpe.toString()).trim() + "`"
-    }
-
-    protected val marker = CompletionMarker
+    def memberPrinter(member: compiler.Member): String =
+        "[accessible: %5s] ".format(member.accessible) + "`" + (member.sym.toString() + member.tpe.toString()).trim() + "`"
 
     override def runTest() {
-      askAllSources(marker) { pos =>
+      askAllSources(CompletionMarker) { pos =>
         askCompletionAt(pos)
       } { (pos, members) =>
         withResponseDelimiter {
@@ -35,7 +31,7 @@ private[tests] trait CoreTestDefs
           reporter.println("retrieved %d members".format(members.size))
           compiler ask { () =>
             val filtered = members.filterNot(member => member.sym.name.toString == "getClass" || member.sym.isConstructor)
-            reporter.println(filtered.map(MemberPrinter(_)).sortBy(_.toString()).mkString("\n"))
+            reporter.println(filtered.map(memberPrinter).sortBy(_.toString()).mkString("\n"))
           }
         }
       }
@@ -48,10 +44,8 @@ private[tests] trait CoreTestDefs
     extends PresentationCompilerTestDef
     with AskTypeAt {
 
-    protected val marker = TypeMarker
-
     override def runTest() {
-      askAllSources(marker) { pos =>
+      askAllSources(TypeMarker) { pos =>
         askTypeAt(pos)
       } { (pos, tree) =>
         withResponseDelimiter {
@@ -69,10 +63,8 @@ private[tests] trait CoreTestDefs
     with AskTypeAt
     with AskCompletionAt {
 
-    protected val marker = HyperlinkMarker
-
     override def runTest() {
-      askAllSources(marker) { pos =>
+      askAllSources(HyperlinkMarker) { pos =>
         askTypeAt(pos)(NullReporter)
       } { (pos, tree) =>
         if(tree.symbol == compiler.NoSymbol) {
diff --git a/src/compiler/scala/tools/nsc/interactive/tests/core/PresentationCompilerTestDef.scala b/src/compiler/scala/tools/nsc/interactive/tests/core/PresentationCompilerTestDef.scala
index 390363eca8..8b8be697cc 100644
--- a/src/compiler/scala/tools/nsc/interactive/tests/core/PresentationCompilerTestDef.scala
+++ b/src/compiler/scala/tools/nsc/interactive/tests/core/PresentationCompilerTestDef.scala
@@ -5,10 +5,6 @@ import scala.tools.nsc.util.Position
 
 trait PresentationCompilerTestDef {
 
-  def compiler: Global
-
-  protected val marker: TestMarker
-
   private[tests] def runTest(): Unit
 
   protected def withResponseDelimiter(block: => Unit)(implicit reporter: Reporter) {
diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
index 91e31cae97..0a9d25af7e 100644
--- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
@@ -41,11 +41,11 @@ trait ScalaSettings extends AbsScalaSettings
   protected def optimiseSettings = List[BooleanSetting](inline, inlineHandlers, Xcloselim, Xdce)
 
   /** Internal use - syntax enhancements. */
-  private class EnableSettings[T <: Setting](val s: T) {
-    def enabling(toEnable: List[BooleanSetting]): s.type = s withPostSetHook (_ => toEnable foreach (_.value = true))
+  private class EnableSettings[T <: BooleanSetting](val s: T) {
+    def enabling(toEnable: List[BooleanSetting]): s.type = s withPostSetHook (_ => toEnable foreach (_.value = s.value))
     def andThen(f: s.T => Unit): s.type                  = s withPostSetHook (setting => f(setting.value))
   }
-  private implicit def installEnableSettings[T <: Setting](s: T) = new EnableSettings(s)
+  private implicit def installEnableSettings[T <: BooleanSetting](s: T) = new EnableSettings(s)
 
   /** Disable a setting */
   def disable(s: Setting) = allSettings -= s
diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
index 4584ba032d..0924789948 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
@@ -354,32 +354,30 @@ trait Contexts { self: Analyzer =>
 
     private def unitError(pos: Position, msg: String) =
       unit.error(pos, if (checking) "\n**** ERROR DURING INTERNAL CHECKING ****\n" + msg else msg)
-
-    def issue(err: AbsTypeError) {
+    
+    @inline private def issueCommon(err: AbsTypeError)(pf: PartialFunction[AbsTypeError, Unit]) {
       debugwarn("issue error: " + err.errMsg)
       if (settings.Yissuedebug.value) (new Exception).printStackTrace()
-      if (reportErrors) unitError(err.errPos, addDiagString(err.errMsg))
+      if (pf isDefinedAt err) pf(err)
       else if (bufferErrors) { buffer += err }
       else throw new TypeError(err.errPos, err.errMsg)
     }
 
+    def issue(err: AbsTypeError) {
+      issueCommon(err) { case _ if reportErrors =>
+        unitError(err.errPos, addDiagString(err.errMsg))
+      }
+    }
+
     def issueAmbiguousError(pre: Type, sym1: Symbol, sym2: Symbol, err: AbsTypeError) {
-      debugwarn("issue ambiguous error: " + err.errMsg)
-      if (settings.Yissuedebug.value) (new Exception).printStackTrace()
-      if (ambiguousErrors) {
+      issueCommon(err) { case _ if ambiguousErrors =>
         if (!pre.isErroneous && !sym1.isErroneous && !sym2.isErroneous)
           unitError(err.errPos, err.errMsg)
-      } else if (bufferErrors) { buffer += err }
-      else throw new TypeError(err.errPos, err.errMsg)
+      }
     }
 
     def issueAmbiguousError(err: AbsTypeError) {
-      debugwarn("issue ambiguous error: " + err.errMsg)
-      if (settings.Yissuedebug.value) (new Exception).printStackTrace()
-      if (ambiguousErrors)
-        unitError(err.errPos, addDiagString(err.errMsg))
-      else if (bufferErrors) { buffer += err }
-      else throw new TypeError(err.errPos, err.errMsg)
+      issueCommon(err) { case _ if ambiguousErrors => unitError(err.errPos, addDiagString(err.errMsg)) }
     }
 
     // TODO remove
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)
+  }
+}