massive new collections checkin.

1 files changed, 68 insertions, 1 deletions

diff --git a/src/library/scala/Tuple2.scala b/src/library/scala/Tuple2.scala
index e04a1b11c8..ccf8f189d5 100644
--- a/src/library/scala/Tuple2.scala
+++ b/src/library/scala/Tuple2.scala
@@ -1,7 +1,7 @@
 
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2002-2009, LAMP/EPFL             **
+**    / __/ __// _ | / /  / _ |    (c) 2002-2008, LAMP/EPFL             **
 **  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
@@ -13,6 +13,73 @@
 
 package scala
 
+import annotation.unchecked.uncheckedVariance
+
+object Tuple2 {
+
+  import collection.generic._
+/* !!! todo: enable
+  class IterableOps[CC[+B] <: Iterable[B] with IterableTemplate[CC, B @uncheckedVariance], A1, A2](tuple: (CC[A1], Iterable[A2])) {
+    def zip: CC[(A1, A2)] = {
+      val elems1 = tuple._1.elements
+      val elems2 = tuple._2.elements
+      val b = (tuple._1: IterableTemplate[CC, A1]).newBuilder[(A1, A2)]
+        // : needed because otherwise it picks Iterable's builder.
+      while (elems1.hasNext && elems2.hasNext)
+        b += ((elems1.next, elems2.next))
+      b.result
+    }
+    def map[B](f: (A1, A2) => B): CC[B] = {
+      val elems1 = tuple._1.elements
+      val elems2 = tuple._2.elements
+      val b = (tuple._1: IterableTemplate[CC, A1]).newBuilder[B]
+      while (elems1.hasNext && elems2.hasNext)
+        b += f(elems1.next, elems2.next)
+      b.result
+    }
+    def flatMap[B](f: (A1, A2) => CC[B]): CC[B] = {
+      val elems1 = tuple._1.elements
+      val elems2 = tuple._2.elements
+      val b = (tuple._1: IterableTemplate[CC, A1]).newBuilder[B]
+      while (elems1.hasNext && elems2.hasNext)
+        b ++= f(elems1.next, elems2.next)
+      b.result
+    }
+    def foreach(f: (A1, A2) => Unit) {
+      val elems1 = tuple._1.elements
+      val elems2 = tuple._2.elements
+      while (elems1.hasNext && elems2.hasNext)
+        f(elems1.next, elems2.next)
+    }
+    def forall(p: (A1, A2) => Boolean): Boolean = {
+      val elems1 = tuple._1.elements
+      val elems2 = tuple._2.elements
+      while (elems1.hasNext && elems2.hasNext)
+        if (!p(elems1.next, elems2.next)) return false
+      true
+    }
+    def exists(p: (A1, A2) => Boolean): Boolean = {
+      val elems1 = tuple._1.elements
+      val elems2 = tuple._2.elements
+      while (elems1.hasNext && elems2.hasNext)
+        if (p(elems1.next, elems2.next)) return true
+      false
+    }
+  }
+  implicit def tupleOfIterableWrapper[CC[+B] <: Iterable[B] with IterableTemplate[CC, B], A1, A2](tuple: (CC[A1], Iterable[A2])) =
+    new IterableOps[CC, A1, A2](tuple)
+
+
+/* A more general version which will probably not work.
+  implicit def tupleOfIterableWrapper[CC[+B] <: Iterable[B] with IterableTemplate[CC, B], A1, A2, B1 <: CC[A1]](tuple: B1, Iterable[A2]) =
+    new IterableOps[CC, A1, A2](tuple)
+*/
+
+  // Adriaan: If you drop the type parameters it will infer the wrong types.
+  tupleOfIterableWrapper[collection.immutable.List, Int, Int]((collection.immutable.Nil, collection.immutable.Nil)) forall (_ + _ < 10)
+*/
+}
+
 /** Tuple2 is the canonical representation of a @see Product2
  *
  */