Spring cleaning of collection libraries.

If people think some operations can be more lazy, please provide
patches/do changes. Also brought proxies and forwarders into line.

14 files changed, 307 insertions, 137 deletions

diff --git a/src/library/scala/collection/IndexedSeqViewLike.scala b/src/library/scala/collection/IndexedSeqViewLike.scala
index 07f63ad2b0..4b829f82ac 100644
--- a/src/library/scala/collection/IndexedSeqViewLike.scala
+++ b/src/library/scala/collection/IndexedSeqViewLike.scala
@@ -27,75 +27,67 @@ trait IndexedSeqViewLike[+A,
   extends IndexedSeq[A] with IndexedSeqLike[A, This] with SeqView[A, Coll] with SeqViewLike[A, Coll, This]
 { self =>
 
-  trait Transformed[+B] extends IndexedSeqView[B, Coll] with super.Transformed[B]
+  trait Transformed[+B] extends IndexedSeqView[B, Coll] with super.Transformed[B] {
+    /** Override to use IndexedSeq's foreach; todo: see whether this is really faster */
+//    override def foreach[U](f: A =>  U)
+  }
+
+  trait Forced[B] extends Transformed[B] with super.Forced[B] {
+    override def foreach[U](f: B => U) = super[Transformed].foreach(f)
+  }
 
   trait Sliced extends Transformed[A] with super.Sliced {
-    /** Override to use IndexedSeq's foreach; todo: see whether this is really faster */
-    override def foreach[U](f: A =>  U) = super[Transformed].foreach(f)
+    override def foreach[U](f: A => U) = super[Transformed].foreach(f)
   }
 
   trait Mapped[B] extends Transformed[B] with super.Mapped[B] {
-    override def foreach[U](f: B =>  U) = super[Transformed].foreach(f)
+    override def foreach[U](f: B => U) = super[Transformed].foreach(f)
   }
 
   trait FlatMapped[B] extends Transformed[B] with super.FlatMapped[B] {
-    override def foreach[U](f: B =>  U) = super[Transformed].foreach(f)
+    override def foreach[U](f: B => U) = super[Transformed].foreach(f)
   }
 
   trait Appended[B >: A] extends Transformed[B] with super.Appended[B] {
-    override def foreach[U](f: B =>  U) = super[Transformed].foreach(f)
+    override def foreach[U](f: B => U) = super[Transformed].foreach(f)
   }
 
   trait Filtered extends Transformed[A] with super.Filtered {
-    override def foreach[U](f: A =>  U) = super[Transformed].foreach(f)
+    override def foreach[U](f: A => U) = super[Transformed].foreach(f)
   }
 
   trait TakenWhile extends Transformed[A] with super.TakenWhile {
-    override def foreach[U](f: A =>  U) = super[Transformed].foreach(f)
+    override def foreach[U](f: A => U) = super[Transformed].foreach(f)
   }
 
   trait DroppedWhile extends Transformed[A] with super.DroppedWhile {
-    override def foreach[U](f: A =>  U) = super[Transformed].foreach(f)
+    override def foreach[U](f: A => U) = super[Transformed].foreach(f)
   }
 
   trait Reversed extends Transformed[A] with super.Reversed {
-    override def foreach[U](f: A =>  U) = super[Transformed].foreach(f)
+    override def foreach[U](f: A => U) = super[Transformed].foreach(f)
   }
 
   trait Patched[B >: A] extends Transformed[B] with super.Patched[B] {
-    override def foreach[U](f: B =>  U) = super[Transformed].foreach(f)
+    override def foreach[U](f: B => U) = super[Transformed].foreach(f)
   }
 
-  trait Zipped[B] extends Transformed[(A, B)] {
-    protected[this] val other: Iterable[B]
-    /** Have to be careful here - other may be an infinite sequence. */
-    def length =
-      if (other.hasDefiniteSize) self.length min other.size
-      else other take self.length size
+  trait Zipped[B] extends Transformed[(A, B)] with super.Zipped[B] {
+    override def foreach[U](f: ((A, B)) => U) = super[Transformed].foreach(f)
+  }
 
-    def apply(idx: Int): (A, B) = (self.apply(idx), other.iterator drop idx next)
-    override def stringPrefix = self.stringPrefix+"Z"
+  trait ZippedAll[A1 >: A, B] extends Transformed[(A1, B)] with super.ZippedAll[A1, B] {
+    override def foreach[U](f: ((A1, B)) => U) = super[Transformed].foreach(f)
   }
 
-  trait ZippedAll[A1 >: A, B] extends Transformed[(A1, B)] {
-    protected[this] val other: Iterable[B]
-    val thisElem: A1
-    val thatElem: B
-    override def iterator: Iterator[(A1, B)] =
-      self.iterator.zipAll(other.iterator, thisElem, thatElem)
-
-    def length = self.length max other.size
-    def apply(idx: Int): (A1, B) = {
-      val z1 = if (idx < self.length) self.apply(idx) else thisElem
-      val z2 = if (idx < other.size) other drop idx head else thatElem
-      (z1, z2)
-    }
-    override def stringPrefix = self.stringPrefix+"Z"
+  trait Prepended[B >: A] extends Transformed[B] with super.Prepended[B] {
+    override def foreach[U](f: B => U) = super[Transformed].foreach(f)
   }
 
   /** Boilerplate method, to override in each subclass
    *  This method could be eliminated if Scala had virtual classes
    */
+  protected override def newForced[B](xs: => Seq[B]): Transformed[B] = new Forced[B] { val forced = xs }
   protected override def newAppended[B >: A](that: Traversable[B]): Transformed[B] = new Appended[B] { val rest = that }
   protected override def newMapped[B](f: A => B): Transformed[B] = new Mapped[B] { val mapping = f }
   protected override def newFlatMapped[B](f: A => Traversable[B]): Transformed[B] = new FlatMapped[B] { val mapping = f }
@@ -109,5 +101,6 @@ trait IndexedSeqViewLike[+A,
   protected override def newPatched[B >: A](_from: Int, _patch: Seq[B], _replaced: Int): Transformed[B] = new Patched[B] {
     val from = _from; val patch = _patch; val replaced = _replaced
   }
+  protected override def newPrepended[B >: A](elem: B): Transformed[B] = new Prepended[B] { protected[this] val fst = elem }
   override def stringPrefix = "IndexedSeqView"
 }
diff --git a/src/library/scala/collection/IterableLike.scala b/src/library/scala/collection/IterableLike.scala
index c82be3acbf..6f88c72ffd 100644
--- a/src/library/scala/collection/IterableLike.scala
+++ b/src/library/scala/collection/IterableLike.scala
@@ -69,9 +69,6 @@ self =>
    */
   def iterator: Iterator[A]
 
-  @deprecated("use `iterator' instead")
-  def elements = iterator
-
   /** Applies a function `f` to all elements of this $coll.
    *
    *    Note: this method underlies the implementation of most other bulk operations.
@@ -367,6 +364,9 @@ self =>
 
   override /*TraversableLike*/ def view(from: Int, until: Int) = view.slice(from, until)
 
+  @deprecated("use `iterator' instead")
+  def elements = iterator
+
   @deprecated("use `head' instead") def first: A = head
 
   /** `None` if iterable is empty.
diff --git a/src/library/scala/collection/IterableProxyLike.scala b/src/library/scala/collection/IterableProxyLike.scala
index 4400237486..fe148339b0 100644
--- a/src/library/scala/collection/IterableProxyLike.scala
+++ b/src/library/scala/collection/IterableProxyLike.scala
@@ -24,24 +24,20 @@ import mutable.Buffer
  *  @version 2.8
  *  @since   2.8
  */
-trait IterableProxyLike[+A, +This <: IterableLike[A, This] with Iterable[A]]
-    extends IterableLike[A, This]
-    with TraversableProxyLike[A, This]
+trait IterableProxyLike[+A, +Repr <: IterableLike[A, Repr] with Iterable[A]]
+    extends IterableLike[A, Repr]
+    with TraversableProxyLike[A, Repr]
 {
   override def iterator: Iterator[A] = self.iterator
-  override def foreach[U](f: A => U): Unit = self.foreach(f)
-  override def isEmpty: Boolean = self.isEmpty
-  override def foldRight[B](z: B)(op: (A, B) => B): B = self.foldRight(z)(op)
-  override def reduceRight[B >: A](op: (A, B) => B): B = self.reduceRight(op)
-  override def toIterable: Iterable[A] = self.toIterable
-  override def zip[A1 >: A, B, That](that: Iterable[B])(implicit bf: CanBuildFrom[This, (A1, B), That]): That = self.zip[A1, B, That](that)(bf)
-  override def zipAll[B, A1 >: A, That](that: Iterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[This, (A1, B), That]): That = self.zipAll(that, thisElem, thatElem)(bf)
-  override def zipWithIndex[A1 >: A, That](implicit bf: CanBuildFrom[This, (A1, Int), That]): That = self.zipWithIndex(bf)
-  override def head: A = self.head
-  override def takeRight(n: Int): This = self.takeRight(n)
-  override def dropRight(n: Int): This = self.dropRight(n)
+  override def grouped(size: Int): Iterator[Repr] = self.grouped(size)
+  override def sliding[B >: A](size: Int): Iterator[Repr] = self.sliding(size)
+  override def sliding[B >: A](size: Int, step: Int): Iterator[Repr] = self.sliding(size, step)
+  override def takeRight(n: Int): Repr = self.takeRight(n)
+  override def dropRight(n: Int): Repr = self.dropRight(n)
+  override def zip[A1 >: A, B, That](that: Iterable[B])(implicit bf: CanBuildFrom[Repr, (A1, B), That]): That = self.zip[A1, B, That](that)(bf)
+  override def zipAll[B, A1 >: A, That](that: Iterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Repr, (A1, B), That]): That = self.zipAll(that, thisElem, thatElem)(bf)
+  override def zipWithIndex[A1 >: A, That](implicit bf: CanBuildFrom[Repr, (A1, Int), That]): That = self.zipWithIndex(bf)
   override def sameElements[B >: A](that: Iterable[B]): Boolean = self.sameElements(that)
-  override def toStream: Stream[A] = self.toStream
   override def view = self.view
   override def view(from: Int, until: Int) = self.view(from, until)
 }
diff --git a/src/library/scala/collection/IterableViewLike.scala b/src/library/scala/collection/IterableViewLike.scala
index 27323294c4..09f084d92c 100644
--- a/src/library/scala/collection/IterableViewLike.scala
+++ b/src/library/scala/collection/IterableViewLike.scala
@@ -29,6 +29,10 @@ extends Iterable[A] with IterableLike[A, This] with TraversableView[A, Coll] wit
 
   trait Transformed[+B] extends IterableView[B, Coll] with super.Transformed[B]
 
+  trait Forced[B] extends Transformed[B] with super.Forced[B] {
+    override def iterator = forced.iterator
+  }
+
   trait Sliced extends Transformed[A] with super.Sliced {
     override def iterator = self.iterator slice (from, until)
   }
@@ -96,6 +100,7 @@ extends Iterable[A] with IterableLike[A, This] with TraversableView[A, Coll] wit
   /** Boilerplate method, to override in each subclass
    *  This method could be eliminated if Scala had virtual classes
    */
+  protected override def newForced[B](xs: => Seq[B]): Transformed[B] = new Forced[B] { val forced = xs }
   protected override def newAppended[B >: A](that: Traversable[B]): Transformed[B] = new Appended[B] { val rest = that }
   protected override def newMapped[B](f: A => B): Transformed[B] = new Mapped[B] { val mapping = f }
   protected override def newFlatMapped[B](f: A => Traversable[B]): Transformed[B] = new FlatMapped[B] { val mapping = f }
@@ -104,5 +109,11 @@ extends Iterable[A] with IterableLike[A, This] with TraversableView[A, Coll] wit
   protected override def newDroppedWhile(p: A => Boolean): Transformed[A] = new DroppedWhile { val pred = p }
   protected override def newTakenWhile(p: A => Boolean): Transformed[A] = new TakenWhile { val pred = p }
 
+  override def grouped(size: Int): Iterator[This] =
+    self.iterator.grouped(size).map(xs => newForced(xs).asInstanceOf[This])
+
+  override def sliding[B >: A](size: Int, step: Int): Iterator[This] =
+    self.iterator.sliding(size).map(xs => newForced(xs).asInstanceOf[This])
+
   override def stringPrefix = "IterableView"
 }
diff --git a/src/library/scala/collection/SeqLike.scala b/src/library/scala/collection/SeqLike.scala
index b1c9316f49..d9f1f5257f 100644
--- a/src/library/scala/collection/SeqLike.scala
+++ b/src/library/scala/collection/SeqLike.scala
@@ -560,7 +560,7 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] { self =>
    *                ''n'' times in `that`, then the first ''n'' occurrences of `x` will not form
    *                part of the result, but any following occurrences will.
    */
-  def diff[B >: A, That](that: Seq[B]): Repr = {
+  def diff[B >: A](that: Seq[B]): Repr = {
     val occ = occCounts(that)
     val b = newBuilder
     for (x <- this)
@@ -588,7 +588,7 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] { self =>
    *                ''n'' times in `that`, then the first ''n'' occurrences of `x` will be retained
    *                in the result, but any following occurrences will be omitted.
    */
-  def intersect[B >: A, That](that: Seq[B]): Repr = {
+  def intersect[B >: A](that: Seq[B]): Repr = {
     val occ = occCounts(that)
     val b = newBuilder
     for (x <- this)
@@ -851,6 +851,7 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] { self =>
 
   /** Returns index of the last element satisying a predicate, or -1.
    */
+  @deprecated("use `lastIndexWhere` instead")
   def findLastIndexOf(p: A => Boolean): Int = lastIndexWhere(p)
 
   /** Tests whether every element of this $coll relates to the
diff --git a/src/library/scala/collection/SeqProxyLike.scala b/src/library/scala/collection/SeqProxyLike.scala
index 7e81a8ce62..24ee0b430a 100644
--- a/src/library/scala/collection/SeqProxyLike.scala
+++ b/src/library/scala/collection/SeqProxyLike.scala
@@ -23,11 +23,10 @@ import generic._
  *  @version 2.8
  *  @since   2.8
  */
-trait SeqProxyLike[+A, +This <: SeqLike[A, This] with Seq[A]] extends SeqLike[A, This] with IterableProxyLike[A, This] {
+trait SeqProxyLike[+A, +Repr <: SeqLike[A, Repr] with Seq[A]] extends SeqLike[A, Repr] with IterableProxyLike[A, Repr] {
   override def length: Int = self.length
   override def apply(idx: Int): A = self.apply(idx)
   override def lengthCompare(len: Int): Int = self.lengthCompare(len)
-  override def size = self.size
   override def isDefinedAt(x: Int): Boolean = self.isDefinedAt(x)
   override def segmentLength(p: A => Boolean, from: Int): Int = self.segmentLength(p, from)
   override def prefixLength(p: A => Boolean) = self.prefixLength(p)
@@ -40,22 +39,34 @@ trait SeqProxyLike[+A, +This <: SeqLike[A, This] with Seq[A]] extends SeqLike[A,
   override def lastIndexOf[B >: A](elem: B, end: Int): Int = self.lastIndexWhere(elem ==, end)
   override def lastIndexWhere(p: A => Boolean): Int = self.lastIndexWhere(p, length - 1)
   override def lastIndexWhere(p: A => Boolean, end: Int): Int = self.lastIndexWhere(p)
-  override def reverse: This = self.reverse
+  override def reverse: Repr = self.reverse
+  override def reverseMap[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = self.reverseMap(f)(bf)
   override def reverseIterator: Iterator[A] = self.reverseIterator
   override def startsWith[B](that: Seq[B], offset: Int): Boolean = self.startsWith(that, offset)
   override def startsWith[B](that: Seq[B]): Boolean = self.startsWith(that)
   override def endsWith[B](that: Seq[B]): Boolean = self.endsWith(that)
   override def indexOfSlice[B >: A](that: Seq[B]): Int = self.indexOfSlice(that)
+  override def indexOfSlice[B >: A](that: Seq[B], from: Int): Int = self.indexOfSlice(that)
+  override def lastIndexOfSlice[B >: A](that: Seq[B]): Int = self.lastIndexOfSlice(that)
+  override def lastIndexOfSlice[B >: A](that: Seq[B], end: Int): Int = self.lastIndexOfSlice(that, end)
+  override def containsSlice[B](that: Seq[B]): Boolean = self.indexOfSlice(that) != -1
   override def contains(elem: Any): Boolean = self.contains(elem)
-  override def union[B >: A, That](that: Seq[B])(implicit bf: CanBuildFrom[This, B, That]): That = self.union(that)(bf)
-  override def diff[B >: A, That](that: Seq[B]): This = self.diff(that)
-  override def intersect[B >: A, That](that: Seq[B]): This = self.intersect(that)
-  override def distinct: This = self.distinct
-  override def patch[B >: A, That](from: Int, patch: Seq[B], replaced: Int)(implicit bf: CanBuildFrom[This, B, That]): That = self.patch(from, patch, replaced)(bf)
-  override def padTo[B >: A, That](len: Int, elem: B)(implicit bf: CanBuildFrom[This, B, That]): That = self.padTo(len, elem)(bf)
+  override def union[B >: A, That](that: Seq[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = self.union(that)(bf)
+  override def diff[B >: A](that: Seq[B]): Repr = self.diff(that)
+  override def intersect[B >: A](that: Seq[B]): Repr = self.intersect(that)
+  override def distinct: Repr = self.distinct
+  override def patch[B >: A, That](from: Int, patch: Seq[B], replaced: Int)(implicit bf: CanBuildFrom[Repr, B, That]): That = self.patch(from, patch, replaced)(bf)
+  override def updated[B >: A, That](index: Int, elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That = self.updated(index, elem)(bf)
+  override def +:[B >: A, That](elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That = self.+:(elem)(bf)
+  override def :+[B >: A, That](elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That = self.:+(elem)(bf)
+  override def padTo[B >: A, That](len: Int, elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That = self.padTo(len, elem)(bf)
+  override def corresponds[B](that: Seq[B])(p: (A,B) => Boolean): Boolean = self.corresponds(that)(p)
+  override def sortWith(lt: (A, A) => Boolean): Repr = self.sortWith(lt)
+  override def sortBy[B](f: A => B)(implicit ord: Ordering[B]): Repr = self.sortBy(f)(ord)
+  override def sorted[B >: A](implicit ord: Ordering[B]): Repr = self.sorted(ord)
   override def indices: Range = self.indices
   override def view = self.view
   override def view(from: Int, until: Int) = self.view(from, until)
-  override def equalsWith[B](that: Seq[B])(f: (A,B) => Boolean): Boolean = (self zip that) forall { case (x,y) => f(x,y) }
-  override def containsSlice[B](that: Seq[B]): Boolean = self.indexOfSlice(that) != -1
 }
+
+
diff --git a/src/library/scala/collection/SeqViewLike.scala b/src/library/scala/collection/SeqViewLike.scala
index 1a8cd20013..7014833a46 100644
--- a/src/library/scala/collection/SeqViewLike.scala
+++ b/src/library/scala/collection/SeqViewLike.scala
@@ -21,8 +21,8 @@ import TraversableView.NoBuilder
  * @version 2.8
  */
 trait SeqViewLike[+A,
-                           +Coll,
-                           +This <: SeqView[A, Coll] with SeqViewLike[A, Coll, This]]
+                  +Coll,
+                  +This <: SeqView[A, Coll] with SeqViewLike[A, Coll, This]]
   extends Seq[A] with SeqLike[A, This] with IterableView[A, Coll] with IterableViewLike[A, Coll, This]
 { self =>
 
@@ -31,6 +31,11 @@ trait SeqViewLike[+A,
     override def apply(idx: Int): B
   }
 
+  trait Forced[B] extends Transformed[B] with super.Forced[B] {
+    override def length = forced.length
+    override def apply(idx: Int) = forced.apply(idx)
+  }
+
   trait Sliced extends Transformed[A] with super.Sliced {
     override def length = ((until min self.length) - from) max 0
     override def apply(idx: Int): A =
@@ -104,7 +109,8 @@ trait SeqViewLike[+A,
 
   trait Zipped[B] extends Transformed[(A, B)] with super.Zipped[B] {
     protected[this] lazy val thatSeq = other.toSeq
-    override def length: Int = self.length min thatSeq.length
+    /* Have to be careful here - other may be an infinite sequence. */
+    override def length = if ((thatSeq lengthCompare self.length) <= 0) thatSeq.length else self.length
     override def apply(idx: Int) = (self.apply(idx), thatSeq.apply(idx))
   }
 
@@ -143,9 +149,20 @@ trait SeqViewLike[+A,
     override def stringPrefix = self.stringPrefix+"P"
   }
 
+  trait Prepended[B >: A] extends Transformed[B] {
+    protected[this] val fst: B
+    override def iterator: Iterator[B] = Iterator.single(fst) ++ self.iterator
+    override def length: Int = 1 + self.length
+    override def apply(idx: Int): B =
+      if (idx == 0) fst
+      else self.apply(idx - 1)
+    override def stringPrefix = self.stringPrefix+"A"
+  }
+
   /** Boilerplate method, to override in each subclass
    *  This method could be eliminated if Scala had virtual classes
    */
+  protected override def newForced[B](xs: => Seq[B]): Transformed[B] = new Forced[B] { val forced = xs }
   protected override def newAppended[B >: A](that: Traversable[B]): Transformed[B] = new Appended[B] { val rest = that }
   protected override def newMapped[B](f: A => B): Transformed[B] = new Mapped[B] { val mapping = f }
   protected override def newFlatMapped[B](f: A => Traversable[B]): Transformed[B] = new FlatMapped[B] { val mapping = f }
@@ -157,6 +174,7 @@ trait SeqViewLike[+A,
   protected override def newZippedAll[A1 >: A, B](that: Iterable[B], _thisElem: A1, _thatElem: B): Transformed[(A1, B)] = new ZippedAll[A1, B] { val other = that; val thisElem = _thisElem; val thatElem = _thatElem }
   protected def newReversed: Transformed[A] = new Reversed { }
   protected def newPatched[B >: A](_from: Int, _patch: Seq[B], _replaced: Int): Transformed[B] = new Patched[B] { val from = _from; val patch = _patch; val replaced = _replaced }
+  protected def newPrepended[B >: A](elem: B): Transformed[B] = new Prepended[B] { protected[this] val fst = elem }
 
   override def reverse: This = newReversed.asInstanceOf[This]
 
@@ -167,14 +185,35 @@ trait SeqViewLike[+A,
 //    else super.patch[B, That](from, patch, replaced)(bf)
   }
 
-  //TR TODO: updated, +: ed :+ ed
-
   override def padTo[B >: A, That](len: Int, elem: B)(implicit bf: CanBuildFrom[This, B, That]): That =
     patch(length, fill(len - length)(elem), 0)
 
   override def reverseMap[B, That](f: A => B)(implicit bf: CanBuildFrom[This, B, That]): That =
     reverse.map(f)
 
+  override def updated[B >: A, That](index: Int, elem: B)(implicit bf: CanBuildFrom[This, B, That]): That = {
+    require(0 <= index && index < length)
+    patch(index, List(elem), 1)(bf)
+  }
+
+  override def +:[B >: A, That](elem: B)(implicit bf: CanBuildFrom[This, B, That]): That =
+    newPrepended(elem).asInstanceOf[That]
+
+  override def :+[B >: A, That](elem: B)(implicit bf: CanBuildFrom[This, B, That]): That =
+    ++(Iterator.single(elem))(bf)
+
+  override def union[B >: A, That](that: Seq[B])(implicit bf: CanBuildFrom[This, B, That]): That =
+    newForced(thisSeq union that).asInstanceOf[That]
+
+  override def diff[B >: A](that: Seq[B]): This =
+    newForced(thisSeq diff that).asInstanceOf[This]
+
+  override def intersect[B >: A](that: Seq[B]): This =
+    newForced(thisSeq intersect that).asInstanceOf[This]
+
+  override def sorted[B >: A](implicit ord: Ordering[B]): This =
+    newForced(thisSeq sorted ord).asInstanceOf[This]
+
   override def stringPrefix = "SeqView"
 }
 
diff --git a/src/library/scala/collection/TraversableLike.scala b/src/library/scala/collection/TraversableLike.scala
index 5ef7b5205a..a09bba625f 100644
--- a/src/library/scala/collection/TraversableLike.scala
+++ b/src/library/scala/collection/TraversableLike.scala
@@ -518,10 +518,12 @@ self =>
    *           }}}
    *           where `x,,1,,, ..., x,,n,,` are the elements of this $coll.
    */
-  def foldRight[B](z: B)(op: (A, B) => B): B = {
+  def foldRight[B](z: B)(op: (A, B) => B): B = reversed.foldLeft(z)((x, y) => op(y, x))
+
+  private def reversed: List[A] = {
     var elems: List[A] = Nil
     for (x <- this) elems = x :: elems
-    elems.foldLeft(z)((x, y) => op(y, x))
+    elems
   }
 
   /** Applies a binary operator to all elements of this $coll and a start value, going right to left.
@@ -625,10 +627,10 @@ self =>
    * @return        collection with intermediate results
    */
   def scanLeft[B, That](z: B)(op: (B, A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {
-    val (_, b) = foldLeft(z, bf(repr) += z) { (acc, x) =>
-      val next = op(acc._1, x)
-      (next, acc._2 += next)
-    }
+    val b = bf(repr)
+    var acc = z
+    b += acc
+    for (x <- this) { acc = op(acc, x); b += acc }
     b.result
   }
 
@@ -645,14 +647,10 @@ self =>
    * @return        collection with intermediate results
    */
   def scanRight[B, That](z: B)(op: (A, B) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {
-    var lst = List(z)
-    foldRight(z) { (x, acc) =>
-      val next = op(x, acc)
-      lst ::= next
-      next
-    }
     val b = bf(repr)
-    for (elem <- lst) b += elem
+    var acc = z
+    b += acc
+    for (x <- reversed) { acc = op(x, acc); b += acc }
     b.result
   }
 
@@ -1175,7 +1173,7 @@ self =>
    */
   def view = new TraversableView[A, Repr] {
     protected lazy val underlying = self.repr
-    override def foreach[B](f: A => B) = self foreach f
+    override def foreach[U](f: A => U) = self foreach f
   }
 
   /** Creates a non-strict view of a slice of this $coll.
diff --git a/src/library/scala/collection/TraversableProxyLike.scala b/src/library/scala/collection/TraversableProxyLike.scala
index 24d6c7048d..803de9c745 100644
--- a/src/library/scala/collection/TraversableProxyLike.scala
+++ b/src/library/scala/collection/TraversableProxyLike.scala
@@ -24,23 +24,23 @@ import mutable.{Buffer, StringBuilder}
  *  @version 2.8
  *  @since   2.8
  */
-trait TraversableProxyLike[+A, +This <: TraversableLike[A, This] with Traversable[A]] extends TraversableLike[A, This] with Proxy {
-  def self: This
+trait TraversableProxyLike[+A, +Repr <: TraversableLike[A, Repr] with Traversable[A]] extends TraversableLike[A, Repr] with Proxy {
+  def self: Repr
 
   override def foreach[B](f: A => B): Unit = self.foreach(f)
   override def isEmpty: Boolean = self.isEmpty
   override def nonEmpty: Boolean = self.nonEmpty
   override def size: Int = self.size
   override def hasDefiniteSize = self.hasDefiniteSize
-  override def ++[B >: A, That](that: Traversable[B])(implicit bf: CanBuildFrom[This, B, That]): That = self.++(that)(bf)
-  override def ++[B >: A, That](that: Iterator[B])(implicit bf: CanBuildFrom[This, B, That]): That = self.++(that)(bf)
-  override def map[B, That](f: A => B)(implicit bf: CanBuildFrom[This, B, That]): That = self.map(f)(bf)
-  override def flatMap[B, That](f: A => Traversable[B])(implicit bf: CanBuildFrom[This, B, That]): That = self.flatMap(f)(bf)
-  override def partialMap[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[This, B, That]): That  = self.partialMap(pf)(bf)
-  override def filter(p: A => Boolean): This = self.filter(p)
-  override def filterNot(p: A => Boolean): This = self.filterNot(p)
-  override def partition(p: A => Boolean): (This, This) = self.partition(p)
-  override def groupBy[K](f: A => K): Map[K, This] = self.groupBy(f)
+  override def ++[B >: A, That](that: Traversable[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = self.++(that)(bf)
+  override def ++[B >: A, That](that: Iterator[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = self.++(that)(bf)
+  override def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = self.map(f)(bf)
+  override def flatMap[B, That](f: A => Traversable[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = self.flatMap(f)(bf)
+  override def filter(p: A => Boolean): Repr = self.filter(p)
+  override def filterNot(p: A => Boolean): Repr = self.filterNot(p)
+  override def partialMap[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[Repr, B, That]): That = self.partialMap(pf)(bf)
+  override def partition(p: A => Boolean): (Repr, Repr) = self.partition(p)
+  override def groupBy[K](f: A => K): Map[K, Repr] = self.groupBy(f)
   override def forall(p: A => Boolean): Boolean = self.forall(p)
   override def exists(p: A => Boolean): Boolean = self.exists(p)
   override def count(p: A => Boolean): Int = self.count(p)
@@ -53,28 +53,37 @@ trait TraversableProxyLike[+A, +This <: TraversableLike[A, This] with Traversabl
   override def reduceLeftOption[B >: A](op: (B, A) => B): Option[B] = self.reduceLeftOption(op)
   override def reduceRight[B >: A](op: (A, B) => B): B = self.reduceRight(op)
   override def reduceRightOption[B >: A](op: (A, B) => B): Option[B] = self.reduceRightOption(op)
+  override def scanLeft[B, That](z: B)(op: (B, A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = self.scanLeft(z)(op)(bf)
+  override def scanRight[B, That](z: B)(op: (A, B) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = self.scanRight(z)(op)(bf)
+  override def sum[B >: A](implicit num: Numeric[B]): B = self.sum(num)
+  override def product[B >: A](implicit num: Numeric[B]): B = self.product(num)
+  override def min[B >: A](implicit cmp: Ordering[B]): A = self.min(cmp)
+  override def max[B >: A](implicit cmp: Ordering[B]): A = self.max(cmp)
   override def head: A = self.head
   override def headOption: Option[A] = self.headOption
-  override def tail: This = self.tail
+  override def tail: Repr = self.tail
   override def last: A = self.last
   override def lastOption: Option[A] = self.lastOption
-  override def init: This = self.init
-  override def take(n: Int): This = self.take(n)
-  override def drop(n: Int): This = self.drop(n)
-  override def slice(from: Int, until: Int): This = self.slice(from, until)
-  override def takeWhile(p: A => Boolean): This = self.takeWhile(p)
-  override def dropWhile(p: A => Boolean): This = self.dropWhile(p)
-  override def span(p: A => Boolean): (This, This) = self.span(p)
-  override def splitAt(n: Int): (This, This) = self.splitAt(n)
+  override def init: Repr = self.init
+  override def take(n: Int): Repr = self.take(n)
+  override def drop(n: Int): Repr = self.drop(n)
+  override def slice(from: Int, until: Int): Repr = self.slice(from, until)
+  override def takeWhile(p: A => Boolean): Repr = self.takeWhile(p)
+  override def dropWhile(p: A => Boolean): Repr = self.dropWhile(p)
+  override def span(p: A => Boolean): (Repr, Repr) = self.span(p)
+  override def splitAt(n: Int): (Repr, Repr) = self.splitAt(n)
   override def copyToBuffer[B >: A](dest: Buffer[B]) = self.copyToBuffer(dest)
   override def copyToArray[B >: A](xs: Array[B], start: Int, len: Int) = self.copyToArray(xs, start, len)
   override def copyToArray[B >: A](xs: Array[B], start: Int) = self.copyToArray(xs, start)
+  override def copyToArray[B >: A](xs: Array[B]) = self.copyToArray(xs)
   override def toArray[B >: A: ClassManifest]: Array[B] = self.toArray
   override def toList: List[A] = self.toList
   override def toIterable: Iterable[A] = self.toIterable
   override def toSeq: Seq[A] = self.toSeq
+  override def toIndexedSeq[B >: A]: mutable.IndexedSeq[B] = self.toIndexedSeq
   override def toStream: Stream[A] = self.toStream
   override def toSet[B >: A]: immutable.Set[B] = self.toSet
+  override def toMap[T, U](implicit ev: A <:< (T, U)): immutable.Map[T, U] = self.toMap(ev)
   override def mkString(start: String, sep: String, end: String): String = self.mkString(start, sep, end)
   override def mkString(sep: String): String = self.mkString(sep)
   override def mkString: String = self.mkString
@@ -83,14 +92,18 @@ trait TraversableProxyLike[+A, +This <: TraversableLike[A, This] with Traversabl
   override def addString(b: StringBuilder): StringBuilder = self.addString(b)
   override def stringPrefix : String = self.stringPrefix
   override def view = self.view
-  override def view(from: Int, until: Int): TraversableView[A, This] = self.view(from, until)
+  override def view(from: Int, until: Int): TraversableView[A, Repr] = self.view(from, until)
 }
 
-private class TraversableProxyLikeConfirmation[+A, +This <: TraversableLike[A, This] with Traversable[A]]
+/** Martin to Paul: I'm not sure what the purpose of this class is? I assume it was to make
+ *  sure that TraversableProxyLike has all Traversable methods, but it fails at that
+ *
+private class TraversableProxyLikeConfirmation[+A, +Repr <: TraversableLike[A, Repr] with Traversable[A]]
   extends TraversableProxyLike[A, Traversable[A]]
   with interfaces.TraversableMethods[A, Traversable[A]]
 {
-  def self: This = repr.asInstanceOf[This]
+  def self: Repr = repr.asInstanceOf[Repr]
   protected[this] def newBuilder = scala.collection.Traversable.newBuilder[A]
-  // : Builder[A, This]
+  // : Builder[A, Repr]
 }
+*/
diff --git a/src/library/scala/collection/TraversableViewLike.scala b/src/library/scala/collection/TraversableViewLike.scala
index 84c33296db..4b335d1878 100644
--- a/src/library/scala/collection/TraversableViewLike.scala
+++ b/src/library/scala/collection/TraversableViewLike.scala
@@ -12,7 +12,7 @@
 package scala.collection
 
 import generic._
-import mutable.Builder
+import mutable.{Builder, ArrayBuffer}
 import TraversableView.NoBuilder
 
 /** <p>
@@ -47,16 +47,30 @@ self =>
     b.result()
   }
 
+  /** The implementation base trait of this view.
+   *  This trait and all its subtraits has to be re-implemented for each
+   *  ViewLike class.
+   */
   trait Transformed[+B] extends TraversableView[B, Coll] {
     lazy val underlying = self.underlying
   }
 
+  /** A fall back which forces everything into a vector and then applies an operation
+   *  on it. Used for those operations which do not naturally lend themselves to a view
+   */
+  trait Forced[B] extends Transformed[B] {
+    protected[this] def forced: Seq[B]
+    private[this] lazy val forcedCache = forced
+    override def foreach[U](f: B => U) = forcedCache.foreach(f)
+    override def stringPrefix = self.stringPrefix+"C"
+  }
+
   /** pre: from >= 0
    */
   trait Sliced extends Transformed[A] {
     protected[this] val from: Int
     protected[this] val until: Int
-    override def foreach[C](f: A => C) {
+    override def foreach[U](f: A => U) {
       var index = 0
       for (x <- self) {
         if (from <= index) {
@@ -73,7 +87,7 @@ self =>
 
   trait Mapped[B] extends Transformed[B] {
     protected[this] val mapping: A => B
-    override def foreach[C](f: B => C) {
+    override def foreach[U](f: B => U) {
       for (x <- self)
         f(mapping(x))
     }
@@ -82,7 +96,7 @@ self =>
 
   trait FlatMapped[B] extends Transformed[B] {
     protected[this] val mapping: A => Traversable[B]
-    override def foreach[C](f: B => C) {
+    override def foreach[U](f: B => U) {
       for (x <- self)
         for (y <- mapping(x))
           f(y)
@@ -92,7 +106,7 @@ self =>
 
   trait Appended[B >: A] extends Transformed[B] {
     protected[this] val rest: Traversable[B]
-    override def foreach[C](f: B => C) {
+    override def foreach[U](f: B => U) {
       for (x <- self) f(x)
       for (x <- rest) f(x)
     }
@@ -101,7 +115,7 @@ self =>
 
   trait Filtered extends Transformed[A] {
     protected[this] val pred: A => Boolean
-    override def foreach[C](f: A => C) {
+    override def foreach[U](f: A => U) {
       for (x <- self)
         if (pred(x)) f(x)
     }
@@ -110,7 +124,7 @@ self =>
 
   trait TakenWhile extends Transformed[A] {
     protected[this] val pred: A => Boolean
-    override def foreach[C](f: A => C) {
+    override def foreach[U](f: A => U) {
       for (x <- self) {
         if (!pred(x)) return
         f(x)
@@ -121,7 +135,7 @@ self =>
 
   trait DroppedWhile extends Transformed[A] {
     protected[this] val pred: A => Boolean
-    override def foreach[C](f: A => C) {
+    override def foreach[U](f: A => U) {
       var go = false
       for (x <- self) {
         if (!go && !pred(x)) go = true
@@ -134,6 +148,7 @@ self =>
   /** Boilerplate method, to override in each subclass
    *  This method could be eliminated if Scala had virtual classes
    */
+  protected def newForced[B](xs: => Seq[B]): Transformed[B] = new Forced[B] { val forced = xs }
   protected def newAppended[B >: A](that: Traversable[B]): Transformed[B] = new Appended[B] { val rest = that }
   protected def newMapped[B](f: A => B): Transformed[B] = new Mapped[B] { val mapping = f }
   protected def newFlatMapped[B](f: A => Traversable[B]): Transformed[B] = new FlatMapped[B] { val mapping = f }
@@ -157,6 +172,9 @@ self =>
 //    else super.map[B, That](f)(bf)
   }
 
+  override def partialMap[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[This, B, That]): That =
+    filter(pf.isDefinedAt).map(pf)(bf)
+
   override def flatMap[B, That](f: A => Traversable[B])(implicit bf: CanBuildFrom[This, B, That]): That = {
     newFlatMapped(f).asInstanceOf[That]
 // was:    val b = bf(repr)
@@ -164,7 +182,14 @@ self =>
 //    else super.flatMap[B, That](f)(bf)
   }
 
+  protected[this] def thisSeq: Seq[A] = {
+    val buf = new ArrayBuffer[A]
+    self foreach (buf +=)
+    buf.result
+  }
+
   override def filter(p: A => Boolean): This = newFiltered(p).asInstanceOf[This]
+  override def partition(p: A => Boolean): (This, This) = (filter(p), filter(!p(_)))
   override def init: This = newSliced(0, size - 1).asInstanceOf[This]
   override def drop(n: Int): This = newSliced(n max 0, Int.MaxValue).asInstanceOf[This]
   override def take(n: Int): This = newSliced(0, n).asInstanceOf[This]
@@ -173,5 +198,17 @@ self =>
   override def takeWhile(p: A => Boolean): This = newTakenWhile(p).asInstanceOf[This]
   override def span(p: A => Boolean): (This, This) = (takeWhile(p), dropWhile(p))
   override def splitAt(n: Int): (This, This) = (take(n), drop(n))
+
+  override def scanLeft[B, That](z: B)(op: (B, A) => B)(implicit bf: CanBuildFrom[This, B, That]): That =
+    newForced(thisSeq.scanLeft(z)(op)).asInstanceOf[That]
+
+  override def scanRight[B, That](z: B)(op: (A, B) => B)(implicit bf: CanBuildFrom[This, B, That]): That =
+    newForced(thisSeq.scanRight(z)(op)).asInstanceOf[That]
+
+  override def groupBy[K](f: A => K): Map[K, This] =
+    thisSeq.groupBy(f).mapValues(xs => newForced(xs).asInstanceOf[This])
+
   override def stringPrefix = "TraversableView"
 }
+
+
diff --git a/src/library/scala/collection/generic/IterableForwarder.scala b/src/library/scala/collection/generic/IterableForwarder.scala
index 9cd1ccd843..4debb19ad1 100644
--- a/src/library/scala/collection/generic/IterableForwarder.scala
+++ b/src/library/scala/collection/generic/IterableForwarder.scala
@@ -41,6 +41,6 @@ trait IterableForwarder[+A] extends Iterable[A] with TraversableForwarder[A] {
   // Iterable delegates
   // Iterable methods could be printed by  cat IterableLike.scala | sed -n '/trait Iterable/,$ p' | egrep '^  (override )?def'
 
-  override def iterator = underlying.iterator
+  override def iterator: Iterator[A] = underlying.iterator
   override def sameElements[B >: A](that: Iterable[B]): Boolean = underlying.sameElements(that)
 }
diff --git a/src/library/scala/collection/generic/SeqForwarder.scala b/src/library/scala/collection/generic/SeqForwarder.scala
index 0ecdaf4566..e5dbe4b79d 100644
--- a/src/library/scala/collection/generic/SeqForwarder.scala
+++ b/src/library/scala/collection/generic/SeqForwarder.scala
@@ -30,24 +30,31 @@ trait SeqForwarder[+A] extends Seq[A] with IterableForwarder[A] {
 
   protected override def underlying: Seq[A]
 
-  // PartialFunction delegates
-
-  override def apply(i: Int): A = underlying.apply(i)
-  override def isDefinedAt(x: Int): Boolean = underlying.isDefinedAt(x)
-
-  // Seq delegates
-  // Seq methods could be printed by  cat SeqLike.scala | sed -n '/trait Seq/,$ p' | egrep '^  (override )?def'
-
   override def length: Int = underlying.length
-  override def lengthCompare(l: Int) = underlying lengthCompare l
+  override def apply(idx: Int): A = underlying.apply(idx)
+  override def lengthCompare(len: Int): Int = underlying.lengthCompare(len)
+  override def isDefinedAt(x: Int): Boolean = underlying.isDefinedAt(x)
   override def segmentLength(p: A => Boolean, from: Int): Int = underlying.segmentLength(p, from)
   override def prefixLength(p: A => Boolean) = underlying.prefixLength(p)
+  override def indexWhere(p: A => Boolean): Int = underlying.indexWhere(p)
   override def indexWhere(p: A => Boolean, from: Int): Int = underlying.indexWhere(p, from)
+  override def findIndexOf(p: A => Boolean): Int = underlying.indexWhere(p)
+  override def indexOf[B >: A](elem: B): Int = underlying.indexOf(elem)
   override def indexOf[B >: A](elem: B, from: Int): Int = underlying.indexOf(elem, from)
+  override def lastIndexOf[B >: A](elem: B): Int = underlying.lastIndexOf(elem)
+  override def lastIndexOf[B >: A](elem: B, end: Int): Int = underlying.lastIndexOf(elem, end)
+  override def lastIndexWhere(p: A => Boolean): Int = underlying.lastIndexWhere(p)
+  override def lastIndexWhere(p: A => Boolean, end: Int): Int = underlying.lastIndexWhere(p, end)
   override def reverseIterator: Iterator[A] = underlying.reverseIterator
   override def startsWith[B](that: Seq[B], offset: Int): Boolean = underlying.startsWith(that, offset)
+  override def startsWith[B](that: Seq[B]): Boolean = underlying.startsWith(that)
   override def endsWith[B](that: Seq[B]): Boolean = underlying.endsWith(that)
   override def indexOfSlice[B >: A](that: Seq[B]): Int = underlying.indexOfSlice(that)
+  override def indexOfSlice[B >: A](that: Seq[B], from: Int): Int = underlying.indexOfSlice(that, from)
+  override def lastIndexOfSlice[B >: A](that: Seq[B]): Int = underlying.lastIndexOfSlice(that)
+  override def lastIndexOfSlice[B >: A](that: Seq[B], end: Int): Int = underlying.lastIndexOfSlice(that, end)
+  override def containsSlice[B](that: Seq[B]): Boolean = underlying.containsSlice(that)
   override def contains(elem: Any): Boolean = underlying.contains(elem)
+  override def corresponds[B](that: Seq[B])(p: (A,B) => Boolean): Boolean = underlying.corresponds(that)(p)
   override def indices: Range = underlying.indices
 }
diff --git a/src/library/scala/collection/generic/TraversableForwarder.scala b/src/library/scala/collection/generic/TraversableForwarder.scala
index bd7f751288..dcba86f3d7 100644
--- a/src/library/scala/collection/generic/TraversableForwarder.scala
+++ b/src/library/scala/collection/generic/TraversableForwarder.scala
@@ -42,33 +42,47 @@ trait TraversableForwarder[+A] extends Traversable[A] {
   /** The iterable object to which calls are forwarded */
   protected def underlying: Traversable[A]
 
-  // Iterable delegates
-  // Iterable methods could be printed by  cat TarversableLike.scala | sed -n '/trait Iterable/,$ p' | egrep '^  (override )?def'
-
-  override def isEmpty = underlying.isEmpty
-  override def nonEmpty = underlying.nonEmpty
+  override def foreach[B](f: A => B): Unit = underlying.foreach(f)
+  override def isEmpty: Boolean = underlying.isEmpty
+  override def nonEmpty: Boolean = underlying.nonEmpty
+  override def size: Int = underlying.size
   override def hasDefiniteSize = underlying.hasDefiniteSize
-  override def foreach[B](f: A => B) = underlying.foreach(f)
   override def forall(p: A => Boolean): Boolean = underlying.forall(p)
   override def exists(p: A => Boolean): Boolean = underlying.exists(p)
   override def count(p: A => Boolean): Int = underlying.count(p)
   override def find(p: A => Boolean): Option[A] = underlying.find(p)
   override def foldLeft[B](z: B)(op: (B, A) => B): B = underlying.foldLeft(z)(op)
+  override def /: [B](z: B)(op: (B, A) => B): B = underlying./:(z)(op)
   override def foldRight[B](z: B)(op: (A, B) => B): B = underlying.foldRight(z)(op)
+  override def :\ [B](z: B)(op: (A, B) => B): B = underlying.:\(z)(op)
   override def reduceLeft[B >: A](op: (B, A) => B): B = underlying.reduceLeft(op)
-  override def reduceRight[B >: A](op: (A, B) => B): B = underlying.reduceRight(op)
   override def reduceLeftOption[B >: A](op: (B, A) => B): Option[B] = underlying.reduceLeftOption(op)
+  override def reduceRight[B >: A](op: (A, B) => B): B = underlying.reduceRight(op)
   override def reduceRightOption[B >: A](op: (A, B) => B): Option[B] = underlying.reduceRightOption(op)
+  override def sum[B >: A](implicit num: Numeric[B]): B = underlying.sum(num)
+  override def product[B >: A](implicit num: Numeric[B]): B = underlying.product(num)
+  override def min[B >: A](implicit cmp: Ordering[B]): A = underlying.min(cmp)
+  override def max[B >: A](implicit cmp: Ordering[B]): A = underlying.max(cmp)
+  override def head: A = underlying.head
+  override def headOption: Option[A] = underlying.headOption
+  override def last: A = underlying.last
+  override def lastOption: Option[A] = underlying.lastOption
   override def copyToBuffer[B >: A](dest: Buffer[B]) = underlying.copyToBuffer(dest)
   override def copyToArray[B >: A](xs: Array[B], start: Int, len: Int) = underlying.copyToArray(xs, start, len)
-  override def toArray[B >: A : ClassManifest]: Array[B] = underlying.toArray
+  override def copyToArray[B >: A](xs: Array[B], start: Int) = underlying.copyToArray(xs, start)
+  override def copyToArray[B >: A](xs: Array[B]) = underlying.copyToArray(xs)
+  override def toArray[B >: A: ClassManifest]: Array[B] = underlying.toArray
   override def toList: List[A] = underlying.toList
+  override def toIterable: Iterable[A] = underlying.toIterable
   override def toSeq: Seq[A] = underlying.toSeq
+  override def toIndexedSeq[B >: A]: mutable.IndexedSeq[B] = underlying.toIndexedSeq
   override def toStream: Stream[A] = underlying.toStream
+  override def toSet[B >: A]: immutable.Set[B] = underlying.toSet
+  override def toMap[T, U](implicit ev: A <:< (T, U)): immutable.Map[T, U] = underlying.toMap(ev)
   override def mkString(start: String, sep: String, end: String): String = underlying.mkString(start, sep, end)
+  override def mkString(sep: String): String = underlying.mkString(sep)
+  override def mkString: String = underlying.mkString
   override def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder = underlying.addString(b, start, sep, end)
-
-  override def head: A = underlying.head
-  override def last: A = underlying.last
-  override def lastOption: Option[A] = underlying.lastOption
+  override def addString(b: StringBuilder, sep: String): StringBuilder = underlying.addString(b, sep)
+  override def addString(b: StringBuilder): StringBuilder = underlying.addString(b)
 }
diff --git a/src/library/scala/collection/readme-if-you-want-to-add-something.txt b/src/library/scala/collection/readme-if-you-want-to-add-something.txt
new file mode 100755
index 0000000000..8fec7648dc
--- /dev/null
+++ b/src/library/scala/collection/readme-if-you-want-to-add-something.txt
@@ -0,0 +1,50 @@
+Conventions for Collection Implementors
+
+Martin Odersky
+19 Mar 2010
+
+This note decsribes some conventions which must be followed to keep
+the collection libraries consistent.
+
+We distinguish in the following between two kinds of methods
+
+ - Accessors access some of the elements of a collection, but return a result which
+   is unrelated to the collection. 
+   Example of accessors are: head, foldLeft, indexWhere, toSeq.
+
+ - Transformers access elements of a collection and produce a new collection of related
+   type as a result. The relation might either be direct (same type as rceiver)
+   or indirect, linked by a CanBuildFrom implicit.
+   Example of transformers are: filter, map, groupBy, zip.
+
+1. Proxies
+
+Every collection type has a Proxy class that forwards all operations to
+an underlying collection. Proxy methods are all implemented in classes
+of matching the name template *ProxyLike. If you add a new method to a collection 
+class you need to add the same method to the corresponding ProxyLike class.
+
+2. Forwarders
+
+Classes Traversable, Iterable, and Seq also have forwarders, which
+forward all collection-specific accessor operations to an underlying
+collection. These are defined as classes with names matching the
+template *Forwarder in package collection.generic.  If you add a new
+accessor method to a Seq or one of its collection superclasses, you
+need to add the same method to the corresponding forwarder class.
+
+3. Views
+
+Classes Traversable, Iterable, Seq, IndexedSeq, and mutable.IndexedSeq
+support views. Their operations are all defined in classes matching
+the template *ViewLike. If you add a new transformer method to one of
+the above collection classes, you need to add the same method to the
+corresponding view class. Failure to do so will cause the
+corresponding method to fail at runtime with an exception like
+UnsupportedOperationException("coll.newBuilder"). If there is no good
+way to implement the operation in question lazily, there's a fallback
+using the newForced method. See the definition of sorted in trait
+SeqViewLike as an example.
+
+
+