1 files changed, 20 insertions, 76 deletions
diff --git a/src/library/scala/SeqProxy.scala b/src/library/scala/SeqProxy.scala
index f43da07aaf..d346060e50 100644
--- a/src/library/scala/SeqProxy.scala
+++ b/src/library/scala/SeqProxy.scala
@@ -12,88 +12,32 @@
 package scala
 
 
-/** Class <code>Seq[A]</code> represents finite sequences of elements
- *  of type <code>A</code>.
+/** This class implements a proxy for sequences. It forwards
+ *  all calls to a different sequence object.
  *
  *  @author  Martin Odersky
  *  @author  Matthias Zenger
- *  @version 1.0, 16/07/2003
+ *  @version 2.0, 31/12/2006
  */
 trait SeqProxy[+A] extends Seq[A] with IterableProxy[A] {
 
   def self: Seq[A]
 
-  /** Returns the length of the sequence.
-   *
-   *  @return the sequence length.
-   */
-  def length: Int = self.length
-
-  /** Access element number <code>n</code>.
-   *
-   *  @return  the element at index <code>n</code>.
-   */
-  def apply(n: Int): A = self.apply(n)
-
-  /** Is this partial function defined for the index <code>x</code>?
-   *
-   *  @return true, iff <code>x</code> is a legal sequence index.
-   */
-  override def isDefinedAt(y: Int): Boolean = self.isDefinedAt(y)
-
-  /** Returns the index of the first occurence of the specified
-   *  object in this sequence.
-   *
-   *  @param  elem  element to search for.
-   *  @return the index in this sequence of the first occurence of the
-   *          specified element, or -1 if the sequence does not contain
-   *          this element.
-   */
-  override def indexOf[B >: A](elem: B): Int = self.indexOf(elem)
-
-  /** Returns the index of the last occurence of the specified
-   *  element in this sequence, or -1 if the sequence does not
-   *  contain this element.
-   *
-   *  @param  elem   element to search for.
-   *  @return the index in this sequence of the last occurence of the
-   *          specified  element, or -1 if the sequence does not contain
-   *          this element.
-   */
-  override def lastIndexOf[B >: A](elem: B): Int = self.lastIndexOf(elem)
-
-  /** Returns the sub-sequence starting from index <code>n</code>.
-   *
-   *  @param n ...
-   *  @return ...
-   */
-  override def take(n: Int): Seq[A] = self.take(n)
-
-  /** Returns a new sub-sequence that drops the first <code>n</code>
-   *  elements of this sequence.
-   *
-   *  @param n ...
-   *  @return ...
-   */
-  override def drop(n: Int): Seq[A] = self.drop(n)
-
-  /** Returns a subsequence starting from index <code>from</code>
-   *  consisting of <code>len</code> elements.
-   *
-   *  @param from ...
-   *  @param len ...
-   */
-  override def subseq(from: Int, len: Int): Seq[A] = self.subseq(from, len)
-
-  /** Fills the given array <code>xs</code> with the elements of
-   *  this sequence starting at position <code>start</code>.
-   *
-   *  @param  xs the array to fill.
-   *  @param  start starting index.
-   *  @return the given array <code>xs</code> filled with the elements
-   *          of this sequence.
-   */
-  override def copyToArray[B >: A](xs: Array[B], start: Int): Array[B] =
-    self.copyToArray(xs, start)
-
+  override def length: Int = self.length
+  override def isEmpty: Boolean = self.isEmpty
+  override def concat [B >: A](that: Iterable[B]): Seq[B] = self concat that
+  override def isDefinedAt(x: Int): Boolean = self isDefinedAt x
+  override def lastIndexOf[B >: A](elem: B): Int = self lastIndexOf elem
+  override def map[B](f: A => B): Seq[B] = self map f
+  override def flatMap[B](f: A => Iterable[B]): Seq[B] = self flatMap f
+  override def filter(p: A => Boolean): Seq[A] = self filter p
+  override def take(n: Int): Seq[A] = self take n
+  override def drop(n: Int): Seq[A] = self drop n
+  override def takeWhile(p: A => Boolean): Seq[A] = self takeWhile p
+  override def dropWhile(p: A => Boolean): Seq[A] = self dropWhile p
+  override def reverse: Seq[A] = self.reverse
+  override def contains(elem: Any): Boolean = self contains elem
+  override def slice(from: Int, len: Int): Seq[A] = self.slice(from, len)
+  override def toArray[B >: A]: Array[B] = self.toArray
+  override def copyToArray[B >: A](xs: Array[B], start: Int): Unit = self.copyToArray(xs, start)
 }