From e6c140fecd361fdec9ad1d3c1579b8bbd3e9f007 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 18 Jun 2009 15:22:12 +0000
Subject: (1) some changes to interactive compiler interf...

(1) some changes to interactive compiler interface. 2) added
(symbol.hasTypeAt 3) Added flatten/transpose/unzip to TraversableClass
---
 src/library/scala/Tuple2.scala                     | 20 ++++++++---
 .../collection/generic/TraversableClass.scala      | 41 ++++++++++++++++++++--
 2 files changed, 55 insertions(+), 6 deletions(-)

(limited to 'src/library')

diff --git a/src/library/scala/Tuple2.scala b/src/library/scala/Tuple2.scala
index bcf30e58aa..7edea7db15 100644
--- a/src/library/scala/Tuple2.scala
+++ b/src/library/scala/Tuple2.scala
@@ -82,10 +82,22 @@ object Tuple2 {
 /** Tuple2 is the canonical representation of a @see Product2
  *
  */
-case class Tuple2[+T1, +T2](_1:T1,_2:T2)
-  extends Product2[T1, T2]
-{
-  override def toString() = "(" + _1 + "," + _2 + ")"
+case class Tuple2[+T1, +T2](_1:T1, _2:T2) extends Product2[T1, T2]  {
+/*
+  def map[CC[X] <: Traversable[X], A1, A2, B](implicit fst: T1 => CC[A1], snd: T2 => Traversable[A2]) = (f: (A1, A2) => B) => {
+    val b = fst(_1).genericBuilder[B]
+    val it1 = _1.iterator
+    val it2 = _2.iterator
+    while (it1.hasNext && it2.hasNext)
+      b += f(it1.next, it2.next)
+    b.result
+  }
+*/
+  override def toString() = {
+     val sb = new StringBuilder
+     sb.append('(').append(_1).append(',').append(_2).append(')')
+     sb.toString
+   }
 
   /** Swap the elements of the tuple */
   def swap: Tuple2[T2,T1] = Tuple2(_2, _1)
diff --git a/src/library/scala/collection/generic/TraversableClass.scala b/src/library/scala/collection/generic/TraversableClass.scala
index c107bddd0d..04c61dc413 100644
--- a/src/library/scala/collection/generic/TraversableClass.scala
+++ b/src/library/scala/collection/generic/TraversableClass.scala
@@ -11,16 +11,53 @@
 
 package scala.collection.generic
 
+import annotation.unchecked.uncheckedVariance
+
 trait TraversableClass[+A, +CC[X] <: Traversable[X]] {
 
-  /** The factory companion object that builds instances of class CC */
+  def foreach[U](f: A => U): Unit
+  def head: A
+  def isEmpty: Boolean
 
+  /** The factory companion object that builds instances of class CC */
   def companion: Companion[CC]
-  /** The builder that builds instances of CC[A] */
 
+  /** The builder that builds instances of CC[A] */
   protected[this] def newBuilder: Builder[A, CC[A]] = companion.newBuilder[A]
 
   /** The generic builder that builds instances of CC at arbitrary element types. */
   def genericBuilder[B]: Builder[B, CC[B]] = companion.newBuilder[B]
+
+  def unzip[A1, A2](implicit toPair: A => (A1, A2)): (CC[A1], CC[A2]) = {
+    val b1 = genericBuilder[A1]
+    val b2 = genericBuilder[A2]
+    for (xy <- this) {
+      val (x, y) = toPair(xy)
+      b1 += x
+      b2 += y
+    }
+    (b1.result, b2.result)
+  }
+
+  def flatten[B](implicit toTraversable: A => Traversable[B]): CC[B] = {
+    val b = genericBuilder[B]
+    for (xs <- this)
+      b ++= toTraversable(xs)
+    b.result
+  }
+
+  def transpose[B](implicit toTraversable: A => Traversable[B]): CC[CC[B] @uncheckedVariance] = {
+    val bs: Array[Builder[B, CC[B]]] = head.map(_ => genericBuilder[B]).toArray
+    for (xs <- this) {
+      var i = 0
+      for (x <- toTraversable(xs)) {
+        bs(i) += x
+        i += 1
+      }
+    }
+    val bb = genericBuilder[CC[B]]
+    for (b <- bs) bb += b.result
+    bb.result
+  }
 }
 
-- 
cgit v1.2.3