diff options
| author | Martin Odersky <odersky@gmail.com> | 2009-10-02 17:57:16 +0000 |
|---|---|---|
| committer | Martin Odersky <odersky@gmail.com> | 2009-10-02 17:57:16 +0000 |
| commit | 83b67aa805fd1329d6bcc54b1c1fa16416437b6f (patch) | |
| tree | 3fcc59ba0523f644bceef4676f7a6689f9949417 /src | |
| parent | 84146e2f53fb1f5e8abbc521121078e932cf82e7 (diff) | |
| download | scala-83b67aa805fd1329d6bcc54b1c1fa16416437b6f.tar.gz scala-83b67aa805fd1329d6bcc54b1c1fa16416437b6f.tar.bz2 scala-83b67aa805fd1329d6bcc54b1c1fa16416437b6f.zip | |
Sequence->Seq
Diffstat (limited to 'src')
66 files changed, 248 insertions, 244 deletions
diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index 56b8253fa7..ff795d446e 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -822,6 +822,8 @@ class Global(var settings: Settings, var reporter: Reporter) extends SymbolTable advancePhase } + println(narrowCount+" narrowings") + if (settings.Xshowcls.value != "") showDef(newTermName(settings.Xshowcls.value), false) if (settings.Xshowobj.value != "") diff --git a/src/compiler/scala/tools/nsc/doc/DocUtil.scala b/src/compiler/scala/tools/nsc/doc/DocUtil.scala index dbb6f94386..c01d9566f8 100644 --- a/src/compiler/scala/tools/nsc/doc/DocUtil.scala +++ b/src/compiler/scala/tools/nsc/doc/DocUtil.scala @@ -92,7 +92,7 @@ object DocUtil else xs.head ++ sep ++ interleave(xs.tail, sep) def mkXML(begin: NodeSeq, separator: NodeSeq, end: NodeSeq)(f: T => NodeSeq): NodeSeq = - begin ++ interleave(list.toSequence map f, separator) ++ end + begin ++ interleave(list.toSeq map f, separator) ++ end def mkXML(begin: String, separator: String, end: String)(f: T => NodeSeq): NodeSeq = this.mkXML(Text(begin), Text(separator), Text(end))(f) diff --git a/src/compiler/scala/tools/nsc/io/Path.scala b/src/compiler/scala/tools/nsc/io/Path.scala index ed750e5b11..37cc64cf75 100644 --- a/src/compiler/scala/tools/nsc/io/Path.scala +++ b/src/compiler/scala/tools/nsc/io/Path.scala @@ -9,7 +9,7 @@ import java.io.{ FileInputStream, FileOutputStream, BufferedReader, BufferedWriter, InputStreamReader, OutputStreamWriter, BufferedInputStream, BufferedOutputStream, File => JFile } import java.net.{ URI, URL } -import collection.{ Sequence, Traversable } +import collection.{ Seq, Traversable } import PartialFunction._ import scala.util.Random.nextASCIIString diff --git a/src/compiler/scala/tools/nsc/io/ZipArchive.scala b/src/compiler/scala/tools/nsc/io/ZipArchive.scala index 54deec939e..e75f68ca92 100644 --- a/src/compiler/scala/tools/nsc/io/ZipArchive.scala +++ b/src/compiler/scala/tools/nsc/io/ZipArchive.scala @@ -301,6 +301,6 @@ final class URLZipArchive(url: URL) extends AbstractFile with ZipContainer val minusOne = (-1).toByte val buf = new BufferedInputStream(in) val bytes = Iterator continually in.read().toByte takeWhile (_ != minusOne) - new ByteArrayInputStream(bytes.toSequence.toArray) + new ByteArrayInputStream(bytes.toSeq.toArray) } } diff --git a/src/compiler/scala/tools/nsc/symtab/Definitions.scala b/src/compiler/scala/tools/nsc/symtab/Definitions.scala index 71e9725944..9c2df4a6cb 100644 --- a/src/compiler/scala/tools/nsc/symtab/Definitions.scala +++ b/src/compiler/scala/tools/nsc/symtab/Definitions.scala @@ -168,8 +168,8 @@ trait Definitions { def Iterable_next = getMember(IterableClass, nme.next) def Iterable_hasNext = getMember(IterableClass, nme.hasNext) - lazy val SeqClass = getClass2("scala.Seq", "scala.collection.Sequence") - lazy val SeqModule = getModule2("scala.Seq", "scala.collection.Sequence") + lazy val SeqClass = getClass2("scala.Seq", "scala.collection.Seq") + lazy val SeqModule = getModule2("scala.Seq", "scala.collection.Seq") def Seq_length = getMember(SeqClass, nme.length) lazy val RandomAccessSeqMutableClass = getMember( getModule2("scala.RandomAccessSeq", "scala.collection.Vector"), nme.Mutable) diff --git a/src/compiler/scala/tools/nsc/symtab/Scopes.scala b/src/compiler/scala/tools/nsc/symtab/Scopes.scala index 8a09d361cb..281981e344 100644 --- a/src/compiler/scala/tools/nsc/symtab/Scopes.scala +++ b/src/compiler/scala/tools/nsc/symtab/Scopes.scala @@ -50,7 +50,7 @@ trait Scopes { // Martin: This code contains a lot of stuff for the old Eclipse plugin. // Now it's just needless complexity, which should be eleminated. // We should make the elems list doubly-linked, - // and have scopes inherit from LinearSequence, + // and have scopes inherit from LinearSeq, // that way, we need to do way fewer toList than before. /** diff --git a/src/compiler/scala/tools/nsc/symtab/StdNames.scala b/src/compiler/scala/tools/nsc/symtab/StdNames.scala index 867b13b243..19cce08224 100644 --- a/src/compiler/scala/tools/nsc/symtab/StdNames.scala +++ b/src/compiler/scala/tools/nsc/symtab/StdNames.scala @@ -331,7 +331,7 @@ trait StdNames { val tail = newTermName("tail") val toArray = newTermName("toArray") val toList = newTermName("toList") - val toSequence = newTermName("toSequence") + val toSeq = newTermName("toSeq") val toString_ = newTermName("toString") val clone_ = newTermName("clone") val this_ = newTermName("this") diff --git a/src/compiler/scala/tools/nsc/symtab/Types.scala b/src/compiler/scala/tools/nsc/symtab/Types.scala index 9fdb446ad8..47ede4228e 100644 --- a/src/compiler/scala/tools/nsc/symtab/Types.scala +++ b/src/compiler/scala/tools/nsc/symtab/Types.scala @@ -4780,7 +4780,7 @@ A type's typeSymbol should never be inspected directly. val shorthands = Set( "scala.collection.immutable.List", "scala.collection.immutable.Nil", - "scala.collection.Sequence", + "scala.collection.Seq", "scala.collection.Traversable", "scala.collection.Iterable", "scala.collection.mutable.StringBuilder", diff --git a/src/library/scala/Array.scala b/src/library/scala/Array.scala index afd6f7bb9b..249d80653c 100644 --- a/src/library/scala/Array.scala +++ b/src/library/scala/Array.scala @@ -368,10 +368,10 @@ object Array extends FallbackArrayBuilding { b.result } - /** This method is called in a pattern match { case Sequence(...) => }. + /** This method is called in a pattern match { case Seq(...) => }. * * @param x the selector value - * @return sequence wrapped in an option, if this is a Sequence, otherwise none + * @return sequence wrapped in an option, if this is a Seq, otherwise none */ def unapplySeq[T](x: Array[T]): Option[Vector[T]] = if (x == null) None else Some(x.toVector) diff --git a/src/library/scala/collection/IterableLike.scala b/src/library/scala/collection/IterableLike.scala index 7a00d7933e..1a6b9d7aaf 100644 --- a/src/library/scala/collection/IterableLike.scala +++ b/src/library/scala/collection/IterableLike.scala @@ -364,8 +364,6 @@ self => /** <code>None</code> if iterable is empty. */ @deprecated("use `headOption' instead") def firstOption: Option[A] = headOption - @deprecated("use `toSequence' instead") def toSeq: Sequence[A] = toSequence - /** * returns a projection that can be used to call non-strict <code>filter</code>, * <code>map</code>, and <code>flatMap</code> methods that build projections diff --git a/src/library/scala/collection/Iterator.scala b/src/library/scala/collection/Iterator.scala index 5b6d13d152..5c7e2b6c3b 100644 --- a/src/library/scala/collection/Iterator.scala +++ b/src/library/scala/collection/Iterator.scala @@ -752,7 +752,7 @@ trait Iterator[+A] { self => * understand) this method takes the way one might expect, leaving * the original iterator with 'size' fewer elements. */ - private def takeDestructively(size: Int): Sequence[A] = { + private def takeDestructively(size: Int): Seq[A] = { val buf = new ArrayBuffer[A] var i = 0 while (self.hasNext && i < size) { @@ -763,12 +763,12 @@ trait Iterator[+A] { self => } /** A flexible iterator for transforming an <code>Iterator[A]</code> into an - * Iterator[Sequence[A]], with configurable sequence size, step, and + * Iterator[Seq[A]], with configurable sequence size, step, and * strategy for dealing with elements which don't fit evenly. * * Typical uses can be achieved via methods `grouped' and `sliding'. */ - class GroupedIterator[B >: A](self: Iterator[A], size: Int, step: Int) extends Iterator[Sequence[B]] { + class GroupedIterator[B >: A](self: Iterator[A], size: Int, step: Int) extends Iterator[Seq[B]] { require(size >= 1 && step >= 1) private[this] var buffer: ArrayBuffer[B] = ArrayBuffer() // the buffer @@ -1008,7 +1008,7 @@ trait Iterator[+A] { self => * * @return A sequence which enumerates all elements of this iterator. */ - def toSequence: Sequence[A] = { + def toSeq: Seq[A] = { val buffer = new ArrayBuffer[A] this copyToBuffer buffer buffer @@ -1096,8 +1096,8 @@ trait Iterator[+A] { self => * * @return a sequence which enumerates all elements of this iterator. */ - @deprecated("use toSequence instead") - def collect: Sequence[A] = toSequence + @deprecated("use toSeq instead") + def collect: Seq[A] = toSeq /** Returns a counted iterator from this iterator. */ diff --git a/src/library/scala/collection/LinearSequence.scala b/src/library/scala/collection/LinearSeq.scala index fbd85ed544..4793d36aba 100644 --- a/src/library/scala/collection/LinearSequence.scala +++ b/src/library/scala/collection/LinearSeq.scala @@ -19,7 +19,7 @@ import mutable.Builder * For such sequences <code>isEmpty</code>, <code>head</code> and * <code>tail</code> are guaranteed to be efficient constant time (or near so) * operations.<br/> - * It does not add any methods to <code>Sequence</code> but overrides several + * It does not add any methods to <code>Seq</code> but overrides several * methods with optimized implementations. * </p> * @@ -28,16 +28,16 @@ import mutable.Builder * @version 1.0, 16/07/2003 * @since 2.8 */ -trait LinearSequence[+A] extends Sequence[A] - with GenericTraversableTemplate[A, LinearSequence] - with LinearSequenceLike[A, LinearSequence[A]] { - override def companion: GenericCompanion[LinearSequence] = LinearSequence +trait LinearSeq[+A] extends Seq[A] + with GenericTraversableTemplate[A, LinearSeq] + with LinearSeqLike[A, LinearSeq[A]] { + override def companion: GenericCompanion[LinearSeq] = LinearSeq } /** * @since 2.8 */ -object LinearSequence extends SequenceFactory[LinearSequence] { - implicit def builderFactory[A]: BuilderFactory[A, LinearSequence[A], Coll] = new VirtualBuilderFactory[A] - def newBuilder[A]: Builder[A, LinearSequence[A]] = immutable.LinearSequence.newBuilder[A] +object LinearSeq extends SeqFactory[LinearSeq] { + implicit def builderFactory[A]: BuilderFactory[A, LinearSeq[A], Coll] = new VirtualBuilderFactory[A] + def newBuilder[A]: Builder[A, LinearSeq[A]] = immutable.LinearSeq.newBuilder[A] } diff --git a/src/library/scala/collection/LinearSequenceLike.scala b/src/library/scala/collection/LinearSeqLike.scala index 131ce2624b..ed1f5329c5 100644 --- a/src/library/scala/collection/LinearSequenceLike.scala +++ b/src/library/scala/collection/LinearSeqLike.scala @@ -18,7 +18,7 @@ import scala.util.control.Breaks._ /** Class <code>Linear[A]</code> represents linear sequences of elements. * For such sequences `isEmpty`, `head` and `tail` are guaranteed to be * efficient constant time (or near so) operations. - * It does not add any methods to <code>Sequence</code> but overrides + * It does not add any methods to <code>Seq</code> but overrides * several methods with optimized implementations. * * @author Martin Odersky @@ -26,10 +26,10 @@ import scala.util.control.Breaks._ * @version 1.0, 16/07/2003 * @since 2.8 */ -trait LinearSequenceLike[+A, +Repr <: LinearSequenceLike[A, Repr]] extends SequenceLike[A, Repr] { self: Repr => +trait LinearSeqLike[+A, +Repr <: LinearSeqLike[A, Repr]] extends SeqLike[A, Repr] { self: Repr => - override protected[this] def thisCollection: LinearSequence[A] = this.asInstanceOf[LinearSequence[A]] - override protected[this] def toCollection(repr: Repr): LinearSequence[A] = repr.asInstanceOf[LinearSequence[A]] + override protected[this] def thisCollection: LinearSeq[A] = this.asInstanceOf[LinearSeq[A]] + override protected[this] def toCollection(repr: Repr): LinearSeq[A] = repr.asInstanceOf[LinearSeq[A]] /** Abstract method to be implemented in a subclass */ def isEmpty: Boolean @@ -318,7 +318,7 @@ trait LinearSequenceLike[+A, +Repr <: LinearSequenceLike[A, Repr]] extends Seque * @param that the other linear sequence */ override def sameElements[B >: A](that: Iterable[B]): Boolean = that match { - case that1: LinearSequence[_] => + case that1: LinearSeq[_] => var these = this var those = that1 while (!these.isEmpty && !those.isEmpty && these.head == those.head) { @@ -330,7 +330,7 @@ trait LinearSequenceLike[+A, +Repr <: LinearSequenceLike[A, Repr]] extends Seque super.sameElements(that) } - // Overridden methods from Sequence + // Overridden methods from Seq /** Result of comparing <code>length</code> with operand <code>len</code>. * returns <code>x</code> where diff --git a/src/library/scala/collection/Sequence.scala b/src/library/scala/collection/Seq.scala index b9439c909b..6e5f084a06 100644 --- a/src/library/scala/collection/Sequence.scala +++ b/src/library/scala/collection/Seq.scala @@ -15,7 +15,7 @@ import generic._ import mutable.Builder /** <p> - * Class <code>Sequence[A]</code> represents sequences of elements + * Class <code>Seq[A]</code> represents sequences of elements * of type <code>A</code>.<br/> * It adds the following methods to class <code>Iterable</code>: * <code>length</code>, <code>lengthCompare</code>, <code>apply</code>, @@ -30,33 +30,33 @@ import mutable.Builder * @author Matthias Zenger * @version 1.0, 16/07/2003 */ -trait Sequence[+A] extends PartialFunction[Int, A] +trait Seq[+A] extends PartialFunction[Int, A] with Iterable[A] - with GenericTraversableTemplate[A, Sequence] - with SequenceLike[A, Sequence[A]] { - override def companion: GenericCompanion[Sequence] = Sequence + with GenericTraversableTemplate[A, Seq] + with SeqLike[A, Seq[A]] { + override def companion: GenericCompanion[Seq] = Seq } -/** Factory object for <code>Sequence</code> trait. +/** Factory object for <code>Seq</code> trait. * * @author Martin Odersky * @version 2.8 */ -object Sequence extends SequenceFactory[Sequence] { +object Seq extends SeqFactory[Seq] { - private[collection] val hashSeed = "Sequence".hashCode + private[collection] val hashSeed = "Seq".hashCode - implicit def builderFactory[A]: BuilderFactory[A, Sequence[A], Coll] = new VirtualBuilderFactory[A] - def newBuilder[A]: Builder[A, Sequence[A]] = immutable.Sequence.newBuilder[A] + implicit def builderFactory[A]: BuilderFactory[A, Seq[A], Coll] = new VirtualBuilderFactory[A] + def newBuilder[A]: Builder[A, Seq[A]] = immutable.Seq.newBuilder[A] @deprecated("use View instead") - type Projection[A] = SequenceView[A, Coll] + type Projection[A] = SeqView[A, Coll] - @deprecated("use Sequence(value) instead") - def singleton[A](value: A) = Sequence(value) + @deprecated("use Seq(value) instead") + def singleton[A](value: A) = Seq(value) /** Builds a singleton sequence. */ - @deprecated("use <code>Sequence(x)</code> instead.") + @deprecated("use <code>Seq(x)</code> instead.") def single[A](x: A) = singleton(x) } diff --git a/src/library/scala/collection/SequenceLike.scala b/src/library/scala/collection/SeqLike.scala index 20f0c20f57..50ea0c3a5a 100644 --- a/src/library/scala/collection/SequenceLike.scala +++ b/src/library/scala/collection/SeqLike.scala @@ -21,7 +21,7 @@ import generic._ * @author paulp * @since 2.8 */ -object SequenceLike { +object SeqLike { private def KMP[B](S: Seq[B], W: Seq[B]): Option[Int] = { // trivial cases @@ -95,7 +95,7 @@ object SequenceLike { } } -/** Class <code>Sequence[A]</code> represents sequences of elements +/** Class <code>Seq[A]</code> represents sequences of elements * of type <code>A</code>. * It adds the following methods to class Iterable: * `length`, `lengthCompare`, `apply`, `isDefinedAt`, `segmentLength`, `prefixLength`, @@ -108,10 +108,10 @@ object SequenceLike { * @version 1.0, 16/07/2003 * @since 2.8 */ -trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => +trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] { self => - override protected[this] def thisCollection: Sequence[A] = this.asInstanceOf[Sequence[A]] - override protected[this] def toCollection(repr: Repr): Sequence[A] = repr.asInstanceOf[Sequence[A]] + override protected[this] def thisCollection: Seq[A] = this.asInstanceOf[Seq[A]] + override protected[this] def toCollection(repr: Repr): Seq[A] = repr.asInstanceOf[Seq[A]] import Traversable.breaks._ @@ -304,7 +304,7 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => * * @see String.startsWith */ - def startsWith[B](that: Sequence[B], offset: Int): Boolean = { + def startsWith[B](that: Seq[B], offset: Int): Boolean = { val i = this.iterator drop offset val j = that.iterator while (j.hasNext && i.hasNext) @@ -320,12 +320,12 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => * @return true if <code>that</code> is a prefix of <code>this</code>, * otherwise false */ - def startsWith[B](that: Sequence[B]): Boolean = startsWith(that, 0) + def startsWith[B](that: Seq[B]): Boolean = startsWith(that, 0) /** @return true if this sequence end with that sequence * @see String.endsWith */ - def endsWith[B](that: Sequence[B]): Boolean = { + def endsWith[B](that: Seq[B]): Boolean = { val i = this.iterator.drop(length - that.length) val j = that.iterator while (i.hasNext && j.hasNext) @@ -338,14 +338,14 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => /** @return -1 if <code>that</code> not contained in this, otherwise the * first index where <code>that</code> is contained. */ - def indexOfSeq[B >: A](that: Sequence[B]): Int = indexOfSeq(that, 0) + def indexOfSeq[B >: A](that: Seq[B]): Int = indexOfSeq(that, 0) - def indexOfSeq[B >: A](that: Sequence[B], fromIndex: Int): Int = + def indexOfSeq[B >: A](that: Seq[B], fromIndex: Int): Int = if (this.hasDefiniteSize && that.hasDefiniteSize) - SequenceLike.indexOf(thisCollection, 0, length, that, 0, that.length, fromIndex) + SeqLike.indexOf(thisCollection, 0, length, that, 0, that.length, fromIndex) else { var i = fromIndex - var s: Sequence[A] = thisCollection drop i + var s: Seq[A] = thisCollection drop i while (!s.isEmpty) { if (s startsWith that) return i @@ -360,12 +360,12 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => * last index where <code>that</code> is contained. * @note may not terminate for infinite-sized collections. */ - def lastIndexOfSeq[B >: A](that: Sequence[B]): Int = lastIndexOfSeq(that, that.length) + def lastIndexOfSeq[B >: A](that: Seq[B]): Int = lastIndexOfSeq(that, that.length) // since there's no way to find the last index in an infinite sequence, // we just document it may not terminate and assume it will. - def lastIndexOfSeq[B >: A](that: Sequence[B], fromIndex: Int): Int = - SequenceLike.lastIndexOf(thisCollection, 0, length, that, 0, that.length, fromIndex) + def lastIndexOfSeq[B >: A](that: Seq[B], fromIndex: Int): Int = + SeqLike.lastIndexOf(thisCollection, 0, length, that, 0, that.length, fromIndex) /** Tests if the given value <code>elem</code> is a member of this * sequence. @@ -390,7 +390,7 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => * @return a sequence containing the elements of this * sequence and those of the given sequence <code>that</code>. */ - def union[B >: A, That](that: Sequence[B])(implicit bf: BuilderFactory[B, That, Repr]): That = + def union[B >: A, That](that: Seq[B])(implicit bf: BuilderFactory[B, That, Repr]): That = this ++ that /** <p> @@ -412,7 +412,7 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => * <i>m</i> copies of each element present in both sequences, * where <i>m</i> is defined as above. */ - def diff[B >: A, That](that: Sequence[B]): Repr = { + def diff[B >: A, That](that: Seq[B]): Repr = { val occ = occCounts(that) val b = newBuilder for (x <- this) @@ -438,7 +438,7 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => * @return the sequence of elements contained both in this sequence and * in the given sequence <code>that</code>. */ - def intersect[B >: A, That](that: Sequence[B]): Repr = { + def intersect[B >: A, That](that: Seq[B]): Repr = { val occ = occCounts(that) val b = newBuilder for (x <- this) @@ -449,7 +449,7 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => b.result } - private def occCounts[B](seq: Sequence[B]): mutable.Map[B, Int] = { + private def occCounts[B](seq: Seq[B]): mutable.Map[B, Int] = { val occ = new mutable.HashMap[B, Int] { override def default(k: B) = 0 } for (y <- seq) occ(y) += 1 occ @@ -474,7 +474,7 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => * except that `replaced` elements starting from `from` are replaced * by `patch`. */ - def patch[B >: A, That](from: Int, patch: Sequence[B], replaced: Int)(implicit bf: BuilderFactory[B, That, Repr]): That = { + def patch[B >: A, That](from: Int, patch: Seq[B], replaced: Int)(implicit bf: BuilderFactory[B, That, Repr]): That = { val b = bf(repr) val (prefix, rest) = this.splitAt(from) b ++= toCollection(prefix) @@ -532,13 +532,13 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => * * @return the sequence itself */ - override def toSequence: Sequence[A] = thisCollection + override def toSeq: Seq[A] = thisCollection /** The range of all indices of this sequence. */ def indices: Range = 0 until length - override def view = new SequenceView[A, Repr] { + override def view = new SeqView[A, Repr] { protected lazy val underlying = self.repr override def iterator = self.iterator override def length = self.length @@ -547,10 +547,10 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => override def view(from: Int, until: Int) = view.slice(from, until) - override def hashCode() = (Sequence.hashSeed /: this)(_ * 41 + _.hashCode) + override def hashCode() = (Seq.hashSeed /: this)(_ * 41 + _.hashCode) override def equals(that: Any): Boolean = that match { - case that: Sequence[_] => (that canEqual this) && (this sameElements that) + case that: Seq[_] => (that canEqual this) && (this sameElements that) case _ => false } @@ -569,10 +569,10 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => * @throws IndexOutOfBoundsException if <code>from < 0</code> */ @deprecated("use `drop' instead") - def slice(from: Int): Sequence[A] = toCollection(slice(from, length)) + def slice(from: Int): Seq[A] = toCollection(slice(from, length)) @deprecated("Should be replaced by <code>(s1, s2) forall { case (x, y) => f(x, y) }</code>") - def equalsWith[B](that: Sequence[B])(f: (A,B) => Boolean): Boolean = { + def equalsWith[B](that: Seq[B])(f: (A,B) => Boolean): Boolean = { val i = this.iterator val j = that.iterator while (i.hasNext && j.hasNext) @@ -584,7 +584,7 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => /** Is <code>that</code> a slice in this? */ @deprecated("Should be replaced by <code>indexOfSeq(that) != -1</code>") - def containsSlice[B](that: Sequence[B]): Boolean = indexOfSeq(that) != -1 + def containsSlice[B](that: Seq[B]): Boolean = indexOfSeq(that) != -1 /** * returns a projection that can be used to call non-strict <code>filter</code>, diff --git a/src/library/scala/collection/SequenceProxy.scala b/src/library/scala/collection/SeqProxy.scala index ffa956faf1..d2e4c0a7b7 100644 --- a/src/library/scala/collection/SequenceProxy.scala +++ b/src/library/scala/collection/SeqProxy.scala @@ -18,4 +18,4 @@ package scala.collection * @version 2.8 * @since 2.8 */ -trait SequenceProxy[+A] extends Sequence[A] with SequenceProxyLike[A, Sequence[A]] +trait SeqProxy[+A] extends Seq[A] with SeqProxyLike[A, Seq[A]] diff --git a/src/library/scala/collection/SequenceProxyLike.scala b/src/library/scala/collection/SeqProxyLike.scala index d2c846fb58..4ea57a2e99 100644 --- a/src/library/scala/collection/SequenceProxyLike.scala +++ b/src/library/scala/collection/SeqProxyLike.scala @@ -13,7 +13,7 @@ package scala.collection import generic._ -// Methods could be printed by cat SequenceLike.scala | egrep '^ (override )?def' +// Methods could be printed by cat SeqLike.scala | egrep '^ (override )?def' /** This trait implements a proxy for sequences. It forwards @@ -23,7 +23,7 @@ import generic._ * @version 2.8 * @since 2.8 */ -trait SequenceProxyLike[+A, +This <: SequenceLike[A, This] with Sequence[A]] extends SequenceLike[A, This] with IterableProxyLike[A, This] { +trait SeqProxyLike[+A, +This <: SeqLike[A, This] with Seq[A]] extends SeqLike[A, This] with IterableProxyLike[A, This] { override def length: Int = self.length override def apply(idx: Int): A = self.apply(idx) override def lengthCompare(len: Int): Int = self.lengthCompare(len) @@ -42,22 +42,22 @@ trait SequenceProxyLike[+A, +This <: SequenceLike[A, This] with Sequence[A]] ext override def lastIndexWhere(p: A => Boolean, end: Int): Int = self.lastIndexWhere(p) override def reverse: This = self.reverse override def reverseIterator: Iterator[A] = self.reverseIterator - override def startsWith[B](that: Sequence[B], offset: Int): Boolean = self.startsWith(that, offset) - override def startsWith[B](that: Sequence[B]): Boolean = self.startsWith(that) - override def endsWith[B](that: Sequence[B]): Boolean = self.endsWith(that) - override def indexOfSeq[B >: A](that: Sequence[B]): Int = self.indexOfSeq(that) + 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 indexOfSeq[B >: A](that: Seq[B]): Int = self.indexOfSeq(that) override def contains(elem: Any): Boolean = self.contains(elem) - override def union[B >: A, That](that: Sequence[B])(implicit bf: BuilderFactory[B, That, This]): That = self.union(that)(bf) - override def diff[B >: A, That](that: Sequence[B]): This = self.diff(that) - override def intersect[B >: A, That](that: Sequence[B]): This = self.intersect(that) + override def union[B >: A, That](that: Seq[B])(implicit bf: BuilderFactory[B, That, This]): 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 removeDuplicates: This = self.removeDuplicates - override def patch[B >: A, That](from: Int, patch: Sequence[B], replaced: Int)(implicit bf: BuilderFactory[B, That, This]): That = self.patch(from, patch, replaced)(bf) + override def patch[B >: A, That](from: Int, patch: Seq[B], replaced: Int)(implicit bf: BuilderFactory[B, That, This]): That = self.patch(from, patch, replaced)(bf) override def padTo[B >: A, That](len: Int, elem: B)(implicit bf: BuilderFactory[B, That, This]): That = self.padTo(len, elem)(bf) override def indices: Range = self.indices override def view = self.view override def view(from: Int, until: Int) = self.view(from, until) override def findLastIndexOf(p: A => Boolean): Int = self.lastIndexWhere(p) - override def slice(from: Int): Sequence[A] = self.drop(from) - override def equalsWith[B](that: Sequence[B])(f: (A,B) => Boolean): Boolean = (self zip that) forall { case (x,y) => f(x,y) } - override def containsSlice[B](that: Sequence[B]): Boolean = self.indexOfSeq(that) != -1 + override def slice(from: Int): Seq[A] = self.drop(from) + 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.indexOfSeq(that) != -1 } diff --git a/src/library/scala/collection/SequenceView.scala b/src/library/scala/collection/SeqView.scala index 3a03493932..40e1022754 100644 --- a/src/library/scala/collection/SequenceView.scala +++ b/src/library/scala/collection/SeqView.scala @@ -19,10 +19,10 @@ import TraversableView.NoBuilder * @author Martin Odersky * @version 2.8 */ -trait SequenceView[+A, +Coll] extends SequenceViewLike[A, Coll, SequenceView[A, Coll]] +trait SeqView[+A, +Coll] extends SeqViewLike[A, Coll, SeqView[A, Coll]] -object SequenceView { +object SeqView { type Coll = TraversableView[_, C] forSome {type C <: Traversable[_]} - implicit def builderFactory[A]: BuilderFactory[A, SequenceView[A, Sequence[_]], Coll] = new BuilderFactory[A, SequenceView[A, Sequence[_]], Coll] { def apply(from: Coll) = new NoBuilder } + implicit def builderFactory[A]: BuilderFactory[A, SeqView[A, Seq[_]], Coll] = new BuilderFactory[A, SeqView[A, Seq[_]], Coll] { def apply(from: Coll) = new NoBuilder } } diff --git a/src/library/scala/collection/SequenceViewLike.scala b/src/library/scala/collection/SeqViewLike.scala index c57985e044..471d447a15 100644 --- a/src/library/scala/collection/SequenceViewLike.scala +++ b/src/library/scala/collection/SeqViewLike.scala @@ -12,7 +12,7 @@ package scala.collection import generic._ -import Sequence.fill +import Seq.fill import TraversableView.NoBuilder /** A non-strict projection of an iterable. @@ -20,13 +20,13 @@ import TraversableView.NoBuilder * @author Martin Odersky * @version 2.8 */ -trait SequenceViewLike[+A, +trait SeqViewLike[+A, +Coll, - +This <: SequenceView[A, Coll] with SequenceViewLike[A, Coll, This]] - extends Sequence[A] with SequenceLike[A, This] with IterableView[A, Coll] with IterableViewLike[A, Coll, This] + +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 => - trait Transformed[+B] extends SequenceView[B, Coll] with super.Transformed[B] { + trait Transformed[+B] extends SeqView[B, Coll] with super.Transformed[B] { override def length: Int override def apply(idx: Int): B } @@ -60,12 +60,12 @@ trait SequenceViewLike[+A, override def length = index(self.length) override def apply(idx: Int) = { val row = findRow(idx, 0, self.length - 1) - mapping(self(row)).toSequence(idx - index(row)) + mapping(self(row)).toSeq(idx - index(row)) } } trait Appended[B >: A] extends Transformed[B] with super.Appended[B] { - lazy val restSeq = rest.toSequence + lazy val restSeq = rest.toSeq override def length = self.length + restSeq.length override def apply(idx: Int) = if (idx < self.length) self(idx) else restSeq(idx - self.length) @@ -111,7 +111,7 @@ trait SequenceViewLike[+A, trait Patched[B >: A] extends Transformed[B] { protected[this] val from: Int - protected[this] val patch: Sequence[B] + protected[this] val patch: Seq[B] protected[this] val replaced: Int private lazy val plen = patch.length override def iterator: Iterator[B] = self.iterator patch (from, patch.iterator, replaced) @@ -134,13 +134,13 @@ trait SequenceViewLike[+A, 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 } protected def newReversed: Transformed[A] = new Reversed { } - protected def newPatched[B >: A](_from: Int, _patch: Sequence[B], _replaced: Int): Transformed[B] = new Patched[B] { + 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 } override def reverse: This = newReversed.asInstanceOf[This] - override def patch[B >: A, That](from: Int, patch: Sequence[B], replaced: Int)(implicit bf: BuilderFactory[B, That, This]): That = { + override def patch[B >: A, That](from: Int, patch: Seq[B], replaced: Int)(implicit bf: BuilderFactory[B, That, This]): That = { newPatched(from, patch, replaced).asInstanceOf[That] // was: val b = bf(repr) // if (b.isInstanceOf[NoBuilder[_]]) newPatched(from, patch, replaced).asInstanceOf[That] @@ -150,7 +150,7 @@ trait SequenceViewLike[+A, override def padTo[B >: A, That](len: Int, elem: B)(implicit bf: BuilderFactory[B, That, This]): That = patch(length, fill(len - length)(elem), 0) - override def stringPrefix = "SequenceView" + override def stringPrefix = "SeqView" } diff --git a/src/library/scala/collection/Traversable.scala b/src/library/scala/collection/Traversable.scala index 432acfac62..a5d4c6b18a 100644 --- a/src/library/scala/collection/Traversable.scala +++ b/src/library/scala/collection/Traversable.scala @@ -79,7 +79,7 @@ trait Traversable[+A] extends TraversableLike[A, Traversable[A]] override def toArray[B >: A : ClassManifest]: Array[B] override def toList: List[A] override def toIterable: Iterable[A] - override def toSequence: Sequence[A] + override def toSeq: Seq[A] override def toStream: Stream[A] // override def sortWith(lt : (A,A) => Boolean): Traversable[A] override def mkString(start: String, sep: String, end: String): String diff --git a/src/library/scala/collection/TraversableLike.scala b/src/library/scala/collection/TraversableLike.scala index b87dff042d..9f4bdbac7f 100644 --- a/src/library/scala/collection/TraversableLike.scala +++ b/src/library/scala/collection/TraversableLike.scala @@ -718,7 +718,7 @@ self => /** Returns a sequence with all elements in this traversable object. * @note Will not terminate for infinite-sized collections. */ - def toSequence: Sequence[A] = toList + def toSeq: Seq[A] = toList /** Returns a vector with all elements in this traversable object. * @note Will not terminate for infinite-sized collections. diff --git a/src/library/scala/collection/TraversableProxyLike.scala b/src/library/scala/collection/TraversableProxyLike.scala index ee50105bae..34ebc667c6 100644 --- a/src/library/scala/collection/TraversableProxyLike.scala +++ b/src/library/scala/collection/TraversableProxyLike.scala @@ -72,7 +72,7 @@ trait TraversableProxyLike[+A, +This <: TraversableLike[A, This] with Traversabl 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 toSequence: Sequence[A] = self.toSequence + override def toSeq: Seq[A] = self.toSeq override def toStream: Stream[A] = self.toStream override def toSet[B >: A]: immutable.Set[B] = self.toSet override def mkString(start: String, sep: String, end: String): String = self.mkString(start, sep, end) diff --git a/src/library/scala/collection/Vector.scala b/src/library/scala/collection/Vector.scala index 93ca11427c..cf802ca095 100644 --- a/src/library/scala/collection/Vector.scala +++ b/src/library/scala/collection/Vector.scala @@ -27,13 +27,13 @@ import mutable.{Builder, ArrayBuffer} * @version 2.8 * @since 2.8 */ -trait Vector[+A] extends Sequence[A] +trait Vector[+A] extends Seq[A] with GenericTraversableTemplate[A, Vector] with VectorLike[A, Vector[A]] { override def companion: GenericCompanion[Vector] = Vector } -object Vector extends SequenceFactory[Vector] { +object Vector extends SeqFactory[Vector] { implicit def builderFactory[A]: BuilderFactory[A, Vector[A], Coll] = new VirtualBuilderFactory[A] def newBuilder[A]: Builder[A, Vector[A]] = mutable.Vector.newBuilder[A] } diff --git a/src/library/scala/collection/VectorLike.scala b/src/library/scala/collection/VectorLike.scala index 901d99972e..d4b2ca1d4c 100644 --- a/src/library/scala/collection/VectorLike.scala +++ b/src/library/scala/collection/VectorLike.scala @@ -15,7 +15,7 @@ import generic._ import mutable.ArrayBuffer /** Sequences that support O(1) element access and O(1) length computation. - * This class does not add any methods to Sequence but overrides several + * This class does not add any methods to Seq but overrides several * methods with optimized implementations. * * @author Sean McDirmid @@ -23,7 +23,7 @@ import mutable.ArrayBuffer * @version 2.8 * @since 2.8 */ -trait VectorLike[+A, +Repr] extends SequenceLike[A, Repr] { self => +trait VectorLike[+A, +Repr] extends SeqLike[A, Repr] { self => override protected[this] def thisCollection: Vector[A] = this.asInstanceOf[Vector[A]] override protected[this] def toCollection(repr: Repr): Vector[A] = repr.asInstanceOf[Vector[A]] @@ -177,7 +177,7 @@ trait VectorLike[+A, +Repr] extends SequenceLike[A, Repr] { self => } - // Overridden methods from Sequence + // Overridden methods from Seq override def lengthCompare(len: Int): Int = length - len @@ -223,7 +223,7 @@ trait VectorLike[+A, +Repr] extends SequenceLike[A, Repr] { self => } else Iterator.empty.next } - override def startsWith[B](that: Sequence[B], offset: Int): Boolean = that match { + override def startsWith[B](that: Seq[B], offset: Int): Boolean = that match { case that: Vector[_] => var i = offset var j = 0 @@ -247,7 +247,7 @@ trait VectorLike[+A, +Repr] extends SequenceLike[A, Repr] { self => !thatElems.hasNext } - override def endsWith[B](that: Sequence[B]): Boolean = that match { + override def endsWith[B](that: Seq[B]): Boolean = that match { case that: Vector[_] => var i = length - 1 var j = that.length - 1 diff --git a/src/library/scala/collection/VectorViewLike.scala b/src/library/scala/collection/VectorViewLike.scala index 3a1527f13a..dfaa0f4752 100644 --- a/src/library/scala/collection/VectorViewLike.scala +++ b/src/library/scala/collection/VectorViewLike.scala @@ -6,7 +6,7 @@ ** |/ ** \* */ -// $Id: Sequence.scala 16092 2008-09-12 10:37:06Z nielsen $ +// $Id: Seq.scala 16092 2008-09-12 10:37:06Z nielsen $ package scala.collection @@ -24,7 +24,7 @@ import TraversableView.NoBuilder trait VectorViewLike[+A, +Coll, +This <: VectorView[A, Coll] with VectorViewLike[A, Coll, This]] - extends Vector[A] with VectorLike[A, This] with SequenceView[A, Coll] with SequenceViewLike[A, Coll, This] + extends Vector[A] with VectorLike[A, This] with SeqView[A, Coll] with SeqViewLike[A, Coll, This] { self => trait Transformed[+B] extends VectorView[B, Coll] with super.Transformed[B] @@ -100,7 +100,7 @@ trait VectorViewLike[+A, 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 } protected override def newReversed: Transformed[A] = new Reversed { } - protected override def newPatched[B >: A](_from: Int, _patch: Sequence[B], _replaced: Int): Transformed[B] = new Patched[B] { + 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 newZipped[B](that: Iterable[B]): Transformed[(A, B)] = new Zipped[B] { diff --git a/src/library/scala/collection/generic/IterableForwarder.scala b/src/library/scala/collection/generic/IterableForwarder.scala index 09903ae26a..600104938d 100644 --- a/src/library/scala/collection/generic/IterableForwarder.scala +++ b/src/library/scala/collection/generic/IterableForwarder.scala @@ -39,7 +39,7 @@ trait IterableForwarder[+A] extends Iterable[A] with TraversableForwarder[A] { protected def underlying: Iterable[A] // Iterable delegates - // Iterable methods could be printed by cat IterableTemplate.scala | sed -n '/trait Iterable/,$ p' | egrep '^ (override )?def' + // Iterable methods could be printed by cat IterableLike.scala | sed -n '/trait Iterable/,$ p' | egrep '^ (override )?def' override def iterator = underlying.iterator override def sameElements[B >: A](that: Iterable[B]): Boolean = underlying.sameElements(that) diff --git a/src/library/scala/collection/generic/SequenceFactory.scala b/src/library/scala/collection/generic/SeqFactory.scala index 3c2d36b1fd..fabffa0151 100644 --- a/src/library/scala/collection/generic/SequenceFactory.scala +++ b/src/library/scala/collection/generic/SeqFactory.scala @@ -12,16 +12,16 @@ package scala.collection package generic -/** A template for companion objects of Sequence and subclasses thereof. +/** A template for companion objects of Seq and subclasses thereof. * * @since 2.8 */ -abstract class SequenceFactory[CC[X] <: Sequence[X] with GenericTraversableTemplate[X, CC]] extends TraversableFactory[CC] { +abstract class SeqFactory[CC[X] <: Seq[X] with GenericTraversableTemplate[X, CC]] extends TraversableFactory[CC] { - /** This method is called in a pattern match { case Sequence(...) => }. + /** This method is called in a pattern match { case Seq(...) => }. * * @param x the selector value - * @return sequence wrapped in an option, if this is a Sequence, otherwise none + * @return sequence wrapped in an option, if this is a Seq, otherwise none */ def unapplySeq[A](x: CC[A]): Some[CC[A]] = Some(x) } diff --git a/src/library/scala/collection/generic/SequenceForwarder.scala b/src/library/scala/collection/generic/SeqForwarder.scala index f21a02605c..0472b901a5 100644 --- a/src/library/scala/collection/generic/SequenceForwarder.scala +++ b/src/library/scala/collection/generic/SeqForwarder.scala @@ -16,26 +16,26 @@ import scala.collection._ * all calls to a different sequence object except for * * - toString, hashCode, equals, stringPrefix - * - newBuilder, view, toSequence + * - newBuilder, view, toSeq * - all calls creating a new sequence of the same kind * - * The above methods are forwarded by subclass SequenceProxy + * The above methods are forwarded by subclass SeqProxy * * @author Martin Odersky * @version 2.8 * @since 2.8 */ -trait SequenceForwarder[+A] extends Sequence[A] with IterableForwarder[A] { +trait SeqForwarder[+A] extends Seq[A] with IterableForwarder[A] { - protected override def underlying: Sequence[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) - // Sequence delegates - // Sequence methods could be printed by cat SequenceTemplate.scala | sed -n '/trait Seq/,$ p' | egrep '^ (override )?def' + // 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 @@ -44,9 +44,9 @@ trait SequenceForwarder[+A] extends Sequence[A] with IterableForwarder[A] { override def indexWhere(p: A => Boolean, from: Int): Int = underlying.indexWhere(p, from) override def indexOf[B >: A](elem: B, from: Int): Int = underlying.indexOf(elem, from) override def reverseIterator: Iterator[A] = underlying.reverseIterator - override def startsWith[B](that: Sequence[B], offset: Int): Boolean = underlying.startsWith(that, offset) - override def endsWith[B](that: Sequence[B]): Boolean = underlying.endsWith(that) - override def indexOfSeq[B >: A](that: Sequence[B]): Int = underlying.indexOfSeq(that) + override def startsWith[B](that: Seq[B], offset: Int): Boolean = underlying.startsWith(that, offset) + override def endsWith[B](that: Seq[B]): Boolean = underlying.endsWith(that) + override def indexOfSeq[B >: A](that: Seq[B]): Int = underlying.indexOfSeq(that) override def contains(elem: Any): Boolean = underlying.contains(elem) 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 50652e9343..5e24f2b367 100644 --- a/src/library/scala/collection/generic/TraversableForwarder.scala +++ b/src/library/scala/collection/generic/TraversableForwarder.scala @@ -42,7 +42,7 @@ trait TraversableForwarder[+A] extends Traversable[A] { protected def underlying: Traversable[A] // Iterable delegates - // Iterable methods could be printed by cat IterableTemplate.scala | sed -n '/trait Iterable/,$ p' | egrep '^ (override )?def' + // 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 @@ -62,7 +62,7 @@ trait TraversableForwarder[+A] extends Traversable[A] { 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 toList: List[A] = underlying.toList - override def toSequence: Sequence[A] = underlying.toSequence + override def toSeq: Seq[A] = underlying.toSeq override def toStream: Stream[A] = underlying.toStream override def mkString(start: String, sep: String, end: String): String = underlying.mkString(start, sep, end) override def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder = underlying.addString(b, start, sep, end) diff --git a/src/library/scala/collection/immutable/LinearSequence.scala b/src/library/scala/collection/immutable/LinearSeq.scala index acfe7e826e..09ef071ca4 100644 --- a/src/library/scala/collection/immutable/LinearSequence.scala +++ b/src/library/scala/collection/immutable/LinearSeq.scala @@ -15,22 +15,22 @@ package immutable import generic._ import mutable.Builder -/** A subtrait of <code>collection.Sequence</code> which represents sequences +/** A subtrait of <code>collection.Seq</code> which represents sequences * that cannot be mutated. * * @since 2.8 */ -trait LinearSequence[+A] extends Sequence[A] - with scala.collection.LinearSequence[A] - with GenericTraversableTemplate[A, LinearSequence] - with LinearSequenceLike[A, LinearSequence[A]] { - override def companion: GenericCompanion[LinearSequence] = LinearSequence +trait LinearSeq[+A] extends Seq[A] + with scala.collection.LinearSeq[A] + with GenericTraversableTemplate[A, LinearSeq] + with LinearSeqLike[A, LinearSeq[A]] { + override def companion: GenericCompanion[LinearSeq] = LinearSeq } /** * @since 2.8 */ -object LinearSequence extends SequenceFactory[LinearSequence] { - implicit def builderFactory[A]: BuilderFactory[A, LinearSequence[A], Coll] = new VirtualBuilderFactory[A] - def newBuilder[A]: Builder[A, LinearSequence[A]] = new mutable.ListBuffer +object LinearSeq extends SeqFactory[LinearSeq] { + implicit def builderFactory[A]: BuilderFactory[A, LinearSeq[A], Coll] = new VirtualBuilderFactory[A] + def newBuilder[A]: Builder[A, LinearSeq[A]] = new mutable.ListBuffer } diff --git a/src/library/scala/collection/immutable/List.scala b/src/library/scala/collection/immutable/List.scala index cea5753e18..b7a2908536 100644 --- a/src/library/scala/collection/immutable/List.scala +++ b/src/library/scala/collection/immutable/List.scala @@ -26,13 +26,13 @@ import annotation.tailrec * @version 2.8 * @since 2.8 */ -sealed abstract class List[+A] extends LinearSequence[A] +sealed abstract class List[+A] extends LinearSeq[A] with Product with GenericTraversableTemplate[A, List] - with LinearSequenceLike[A, List[A]] { + with LinearSeqLike[A, List[A]] { override def companion: GenericCompanion[List] = List - import scala.collection.{Iterable, Traversable, Sequence, Vector} + import scala.collection.{Iterable, Traversable, Seq, Vector} /** Returns true if the list does not contain any elements. * @return <code>true</code>, iff the list is empty. @@ -450,7 +450,7 @@ case object Nil extends List[Nothing] { throw new NoSuchElementException("tail of empty list") // Removal of equals method here might lead to an infinite recusion similar to IntMap.equals. override def equals(that: Any) = that match { - case that1: Sequence[_] => that1.isEmpty + case that1: Seq[_] => that1.isEmpty case _ => false } } @@ -498,9 +498,9 @@ final case class ::[B](private var hd: B, private[scala] var tl: List[B]) extend * @version 2.8 * @since 2.8 */ -object List extends SequenceFactory[List] { +object List extends SeqFactory[List] { - import scala.collection.{Iterable, Sequence, Vector} + import scala.collection.{Iterable, Seq, Vector} implicit def builderFactory[A]: BuilderFactory[A, List[A], Coll] = new VirtualBuilderFactory[A] def newBuilder[A]: Builder[A, List[A]] = new ListBuffer[A] diff --git a/src/library/scala/collection/immutable/Queue.scala b/src/library/scala/collection/immutable/Queue.scala index 80c7285be8..2d5b05778b 100644 --- a/src/library/scala/collection/immutable/Queue.scala +++ b/src/library/scala/collection/immutable/Queue.scala @@ -30,7 +30,7 @@ object Queue { @SerialVersionUID(-7622936493364270175L) class Queue[+A] protected( protected val in: List[A], - protected val out: List[A]) extends Sequence[A] + protected val out: List[A]) extends Seq[A] { /** Returns the <code>n</code>-th element of this queue. * The first element is at position 0. diff --git a/src/library/scala/collection/immutable/Sequence.scala b/src/library/scala/collection/immutable/Seq.scala index 7127b3fc9d..6091971ffd 100644 --- a/src/library/scala/collection/immutable/Sequence.scala +++ b/src/library/scala/collection/immutable/Seq.scala @@ -15,22 +15,22 @@ package immutable import generic._ import mutable.Builder -/** A subtrait of collection.Sequence which represents sequences +/** A subtrait of collection.Seq which represents sequences * that cannot be mutated. * * @since 2.8 */ -trait Sequence[+A] extends Iterable[A] - with scala.collection.Sequence[A] - with GenericTraversableTemplate[A, Sequence] - with SequenceLike[A, Sequence[A]] { - override def companion: GenericCompanion[Sequence] = Sequence +trait Seq[+A] extends Iterable[A] + with scala.collection.Seq[A] + with GenericTraversableTemplate[A, Seq] + with SeqLike[A, Seq[A]] { + override def companion: GenericCompanion[Seq] = Seq } /** * @since 2.8 */ -object Sequence extends SequenceFactory[Sequence] { - implicit def builderFactory[A]: BuilderFactory[A, Sequence[A], Coll] = new VirtualBuilderFactory[A] - def newBuilder[A]: Builder[A, Sequence[A]] = new mutable.ListBuffer +object Seq extends SeqFactory[Seq] { + implicit def builderFactory[A]: BuilderFactory[A, Seq[A], Coll] = new VirtualBuilderFactory[A] + def newBuilder[A]: Builder[A, Seq[A]] = new mutable.ListBuffer } diff --git a/src/library/scala/collection/immutable/Stack.scala b/src/library/scala/collection/immutable/Stack.scala index a7b3e8a614..2813bc6656 100644 --- a/src/library/scala/collection/immutable/Stack.scala +++ b/src/library/scala/collection/immutable/Stack.scala @@ -33,7 +33,7 @@ object Stack { * @since 1 */ @serializable @SerialVersionUID(1976480595012942526L) -class Stack[+A] protected (protected val elems: List[A]) extends Sequence[A] { +class Stack[+A] protected (protected val elems: List[A]) extends Seq[A] { def this() = this(Nil) diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala index 01530294e0..bcf8076a1c 100644 --- a/src/library/scala/collection/immutable/Stream.scala +++ b/src/library/scala/collection/immutable/Stream.scala @@ -38,13 +38,13 @@ import scala.annotation.tailrec * @version 1.1 08/08/03 * @since 2.8 */ -abstract class Stream[+A] extends LinearSequence[A] +abstract class Stream[+A] extends LinearSeq[A] with GenericTraversableTemplate[A, Stream] - with LinearSequenceLike[A, Stream[A]] { + with LinearSeqLike[A, Stream[A]] { self => override def companion: GenericCompanion[Stream] = Stream - import scala.collection.{Traversable, Iterable, Sequence, Vector} + import scala.collection.{Traversable, Iterable, Seq, Vector} /** is this stream empty? */ def isEmpty: Boolean @@ -317,7 +317,7 @@ self => these } - // there's nothing we can do about dropRight, so we just keep the definition in LinearSequence + // there's nothing we can do about dropRight, so we just keep the definition in LinearSeq /** Returns the longest prefix of this stream whose elements satisfy * the predicate <code>p</code>. @@ -398,7 +398,7 @@ self => * @version 1.1 08/08/03 * @since 2.8 */ -object Stream extends SequenceFactory[Stream] { +object Stream extends SeqFactory[Stream] { /** The factory for streams. * @note Methods such as map/flatMap will not invoke the Builder factory, @@ -415,7 +415,7 @@ object Stream extends SequenceFactory[Stream] { /** Creates a new builder for a stream */ def newBuilder[A]: Builder[A, Stream[A]] = new StreamBuilder[A] - import scala.collection.{Iterable, Sequence, Vector} + import scala.collection.{Iterable, Seq, Vector} /** A builder for streams * @note: This builder is lazy only in the sense that it does not go downs the spine diff --git a/src/library/scala/collection/immutable/StringLike.scala b/src/library/scala/collection/immutable/StringLike.scala index 3d4a0b8fb9..c1aa03a16c 100644 --- a/src/library/scala/collection/immutable/StringLike.scala +++ b/src/library/scala/collection/immutable/StringLike.scala @@ -235,7 +235,7 @@ self => * @throws java.lang.IllegalArgumentException */ def format(args : Any*) : String = - java.lang.String.format(toString, args.asInstanceOf[Seq[AnyRef]]: _*) + java.lang.String.format(toString, args.asInstanceOf[scala.collection.Seq[AnyRef]]: _*) /** <p> * Like format(args*) but takes an initial Locale parameter @@ -252,6 +252,6 @@ self => * @throws java.lang.IllegalArgumentException */ def format(l: java.util.Locale, args: Any*): String = - java.lang.String.format(l, toString, args.asInstanceOf[Seq[AnyRef]]: _*) + java.lang.String.format(l, toString, args.asInstanceOf[scala.collection.Seq[AnyRef]]: _*) } diff --git a/src/library/scala/collection/immutable/Vector.scala b/src/library/scala/collection/immutable/Vector.scala index 3bc8955194..7e76549f7e 100644 --- a/src/library/scala/collection/immutable/Vector.scala +++ b/src/library/scala/collection/immutable/Vector.scala @@ -20,7 +20,7 @@ import mutable.{Builder, ArrayBuffer} * * @since 2.8 */ -trait Vector[+A] extends Sequence[A] +trait Vector[+A] extends Seq[A] with scala.collection.Vector[A] with GenericTraversableTemplate[A, Vector] with VectorLike[A, Vector[A]] { @@ -30,7 +30,7 @@ trait Vector[+A] extends Sequence[A] /** * @since 2.8 */ -object Vector extends SequenceFactory[Vector] { +object Vector extends SeqFactory[Vector] { // todo: insert better vector implementation here @serializable @SerialVersionUID(7129304555082767876L) class Impl[A](buf: ArrayBuffer[A]) extends Vector[A] { diff --git a/src/library/scala/collection/interfaces/SequenceMethods.scala b/src/library/scala/collection/interfaces/SeqMethods.scala index ee91d33648..a595d101fa 100644 --- a/src/library/scala/collection/interfaces/SequenceMethods.scala +++ b/src/library/scala/collection/interfaces/SeqMethods.scala @@ -16,43 +16,43 @@ import scala.reflect.ClassManifest /** * @since 2.8 */ -trait SequenceMethods[+A, +This <: SequenceLike[A, This] with Sequence[A]] extends IterableMethods[A, This] +trait SeqMethods[+A, +This <: SeqLike[A, This] with Seq[A]] extends IterableMethods[A, This] { // abstract def apply(idx: Int): A def length: Int def contains(elem: Any): Boolean - def diff[B >: A, That](that: Sequence[B]): This - def endsWith[B](that: Sequence[B]): Boolean - def indexOfSeq[B >: A](that: Sequence[B]): Int - def indexOfSeq[B >: A](that: Sequence[B], fromIndex: Int): Int + def diff[B >: A, That](that: Seq[B]): This + def endsWith[B](that: Seq[B]): Boolean + def indexOfSeq[B >: A](that: Seq[B]): Int + def indexOfSeq[B >: A](that: Seq[B], fromIndex: Int): Int def indexOf[B >: A](elem: B): Int def indexOf[B >: A](elem: B, from: Int): Int def indexWhere(p: A => Boolean): Int def indexWhere(p: A => Boolean, from: Int): Int def indices: Range - def intersect[B >: A, That](that: Sequence[B]): This + def intersect[B >: A, That](that: Seq[B]): This def isDefinedAt(x: Int): Boolean - def lastIndexOfSeq[B >: A](that: Sequence[B]): Int - def lastIndexOfSeq[B >: A](that: Sequence[B], fromIndex: Int): Int + def lastIndexOfSeq[B >: A](that: Seq[B]): Int + def lastIndexOfSeq[B >: A](that: Seq[B], fromIndex: Int): Int def lastIndexOf[B >: A](elem: B): Int def lastIndexOf[B >: A](elem: B, end: Int): Int def lastIndexWhere(p: A => Boolean): Int def lastIndexWhere(p: A => Boolean, end: Int): Int def lengthCompare(len: Int): Int def padTo[B >: A, That](len: Int, elem: B)(implicit bf: BuilderFactory[B, That, This]): That - def patch[B >: A, That](from: Int, patch: Sequence[B], replaced: Int)(implicit bf: BuilderFactory[B, That, This]): That + def patch[B >: A, That](from: Int, patch: Seq[B], replaced: Int)(implicit bf: BuilderFactory[B, That, This]): That def prefixLength(p: A => Boolean): Int def removeDuplicates: This def reverse: This def reverseIterator: Iterator[A] def segmentLength(p: A => Boolean, from: Int): Int - def slice(from: Int): Sequence[A] - def startsWith[B](that: Sequence[B]): Boolean - def startsWith[B](that: Sequence[B], offset: Int): Boolean - def union[B >: A, That](that: Sequence[B])(implicit bf: BuilderFactory[B, That, This]): That + def slice(from: Int): Seq[A] + def startsWith[B](that: Seq[B]): Boolean + def startsWith[B](that: Seq[B], offset: Int): Boolean + def union[B >: A, That](that: Seq[B])(implicit bf: BuilderFactory[B, That, This]): That - override def view: SequenceView[A, This] - override def view(from: Int, until: Int): SequenceView[A, This] + override def view: SeqView[A, This] + override def view(from: Int, until: Int): SeqView[A, This] } diff --git a/src/library/scala/collection/interfaces/TraversableMethods.scala b/src/library/scala/collection/interfaces/TraversableMethods.scala index 4e8cdf6ec7..ffedb10476 100644 --- a/src/library/scala/collection/interfaces/TraversableMethods.scala +++ b/src/library/scala/collection/interfaces/TraversableMethods.scala @@ -37,7 +37,7 @@ trait TraversableMethods[+A, +This <: TraversableLike[A, This] with Traversable[ def toArray[B >: A : ClassManifest]: Array[B] def toIterable: Iterable[A] def toList: List[A] - def toSequence: Sequence[A] + def toSeq: Seq[A] def toSet[B >: A]: immutable.Set[B] def toStream: Stream[A] def toVector[B >: A]: mutable.Vector[B] diff --git a/src/library/scala/collection/mutable/ArrayBuffer.scala b/src/library/scala/collection/mutable/ArrayBuffer.scala index f0a52d9f26..6c2f092505 100644 --- a/src/library/scala/collection/mutable/ArrayBuffer.scala +++ b/src/library/scala/collection/mutable/ArrayBuffer.scala @@ -167,7 +167,7 @@ class ArrayBuffer[A](override protected val initialSize: Int) * @version 2.8 * @since 2.8 */ -object ArrayBuffer extends SequenceFactory[ArrayBuffer] { +object ArrayBuffer extends SeqFactory[ArrayBuffer] { implicit def builderFactory[A]: BuilderFactory[A, ArrayBuffer[A], Coll] = new VirtualBuilderFactory[A] def newBuilder[A]: Builder[A, ArrayBuffer[A]] = new ArrayBuffer[A] diff --git a/src/library/scala/collection/mutable/ArrayStack.scala b/src/library/scala/collection/mutable/ArrayStack.scala index 5e2f5e2b1a..0059d5ff6b 100644 --- a/src/library/scala/collection/mutable/ArrayStack.scala +++ b/src/library/scala/collection/mutable/ArrayStack.scala @@ -37,7 +37,7 @@ private object Utils { */ @cloneable class ArrayStack[T] private(private var table : Array[AnyRef], - private var index : Int) extends scala.collection.Sequence[T] with Cloneable[ArrayStack[T]] { + private var index : Int) extends scala.collection.Seq[T] with Cloneable[ArrayStack[T]] { def this() = this(new Array[AnyRef](1), 0) /** Retrieve n'th element from stack, where top of stack has index 0 */ diff --git a/src/library/scala/collection/mutable/Buffer.scala b/src/library/scala/collection/mutable/Buffer.scala index a11ef77fef..59da5bbd83 100644 --- a/src/library/scala/collection/mutable/Buffer.scala +++ b/src/library/scala/collection/mutable/Buffer.scala @@ -25,7 +25,7 @@ import generic._ * @since 1 */ @cloneable -trait Buffer[A] extends Sequence[A] +trait Buffer[A] extends Seq[A] with GenericTraversableTemplate[A, Buffer] with BufferLike[A, Buffer[A]] { override def companion: GenericCompanion[Buffer] = Buffer @@ -33,7 +33,7 @@ trait Buffer[A] extends Sequence[A] /** Factory object for <code>Buffer</code> trait. */ -object Buffer extends SequenceFactory[Buffer] { +object Buffer extends SeqFactory[Buffer] { implicit def builderFactory[A]: BuilderFactory[A, Buffer[A], Coll] = new VirtualBuilderFactory[A] def newBuilder[A]: Builder[A, Buffer[A]] = new ArrayBuffer } diff --git a/src/library/scala/collection/mutable/BufferLike.scala b/src/library/scala/collection/mutable/BufferLike.scala index 428b5b7aa9..a1506ce6ed 100644 --- a/src/library/scala/collection/mutable/BufferLike.scala +++ b/src/library/scala/collection/mutable/BufferLike.scala @@ -33,7 +33,7 @@ trait BufferLike[A, +This <: BufferLike[A, This] with Buffer[A]] with Addable[A, This] with Subtractable[A, This] with Cloneable[This] - with SequenceLike[A, This] + with SeqLike[A, This] { self => import scala.collection.{Iterable, Traversable} @@ -329,7 +329,7 @@ trait BufferLike[A, +This <: BufferLike[A, This] with Buffer[A]] repr } - def readOnly: scala.collection.Sequence[A] = toSequence + def readOnly: scala.collection.Seq[A] = toSeq } diff --git a/src/library/scala/collection/mutable/DoubleLinkedList.scala b/src/library/scala/collection/mutable/DoubleLinkedList.scala index 3534e4727b..1c5d7211c0 100644 --- a/src/library/scala/collection/mutable/DoubleLinkedList.scala +++ b/src/library/scala/collection/mutable/DoubleLinkedList.scala @@ -23,7 +23,7 @@ import generic._ * @since 1 */ @serializable @SerialVersionUID(419155950203746706L) -class DoubleLinkedList[A](_elem: A, _next: DoubleLinkedList[A]) extends LinearSequence[A] +class DoubleLinkedList[A](_elem: A, _next: DoubleLinkedList[A]) extends LinearSeq[A] with GenericTraversableTemplate[A, DoubleLinkedList] with DoubleLinkedListLike[A, DoubleLinkedList[A]] { elem = _elem @@ -31,7 +31,7 @@ class DoubleLinkedList[A](_elem: A, _next: DoubleLinkedList[A]) extends LinearSe override def companion: GenericCompanion[DoubleLinkedList] = DoubleLinkedList } -object DoubleLinkedList extends SequenceFactory[DoubleLinkedList] { +object DoubleLinkedList extends SeqFactory[DoubleLinkedList] { implicit def builderFactory[A]: BuilderFactory[A, DoubleLinkedList[A], Coll] = //new BuilderFactory[A, DoubleLinkedList[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } new VirtualBuilderFactory[A] def newBuilder[A]: Builder[A, DoubleLinkedList[A]] = diff --git a/src/library/scala/collection/mutable/DoubleLinkedListLike.scala b/src/library/scala/collection/mutable/DoubleLinkedListLike.scala index 2297d40209..65b0621b6b 100644 --- a/src/library/scala/collection/mutable/DoubleLinkedListLike.scala +++ b/src/library/scala/collection/mutable/DoubleLinkedListLike.scala @@ -21,7 +21,7 @@ package mutable * @version 1.0, 08/07/2003 * @since 2.8 */ -trait DoubleLinkedListLike[A, This >: Null <: LinearSequence[A] with DoubleLinkedListLike[A, This]] extends LinkedListLike[A, This] { self => +trait DoubleLinkedListLike[A, This >: Null <: LinearSeq[A] with DoubleLinkedListLike[A, This]] extends LinkedListLike[A, This] { self => var prev: This = _ diff --git a/src/library/scala/collection/mutable/GenericArray.scala b/src/library/scala/collection/mutable/GenericArray.scala index 106eedc766..9194d7f39c 100644 --- a/src/library/scala/collection/mutable/GenericArray.scala +++ b/src/library/scala/collection/mutable/GenericArray.scala @@ -54,7 +54,7 @@ extends Vector[A] /** Copy all elements to a buffer * @param The buffer to which elements are copied override def copyToBuffer[B >: A](dest: Buffer[B]) { - dest ++= (array: Sequence[AnyRef]).asInstanceOf[Sequence[B]] + dest ++= (array: Seq[AnyRef]).asInstanceOf[Seq[B]] } */ @@ -67,7 +67,7 @@ extends Vector[A] } } -object GenericArray extends SequenceFactory[GenericArray] { +object GenericArray extends SeqFactory[GenericArray] { implicit def builderFactory[A]: BuilderFactory[A, GenericArray[A], Coll] = new VirtualBuilderFactory[A] def newBuilder[A]: Builder[A, GenericArray[A]] = new ArrayBuffer[A] mapResult { buf => diff --git a/src/library/scala/collection/mutable/LinearSequence.scala b/src/library/scala/collection/mutable/LinearSeq.scala index 75da5021c3..285dc7721d 100644 --- a/src/library/scala/collection/mutable/LinearSequence.scala +++ b/src/library/scala/collection/mutable/LinearSeq.scala @@ -14,19 +14,19 @@ package mutable import generic._ -/** A subtrait of <code>collection.Sequence</code> which represents sequences +/** A subtrait of <code>collection.Seq</code> which represents sequences * that cannot be mutated. * * @since 2.8 */ -trait LinearSequence[A] extends Sequence[A] - with scala.collection.LinearSequence[A] - with GenericTraversableTemplate[A, LinearSequence] - with LinearSequenceLike[A, LinearSequence[A]] { - override def companion: GenericCompanion[LinearSequence] = LinearSequence +trait LinearSeq[A] extends Seq[A] + with scala.collection.LinearSeq[A] + with GenericTraversableTemplate[A, LinearSeq] + with LinearSeqLike[A, LinearSeq[A]] { + override def companion: GenericCompanion[LinearSeq] = LinearSeq } -object LinearSequence extends SequenceFactory[LinearSequence] { - implicit def builderFactory[A]: BuilderFactory[A, LinearSequence[A], Coll] = new VirtualBuilderFactory[A] - def newBuilder[A]: Builder[A, LinearSequence[A]] = new MutableList[A] +object LinearSeq extends SeqFactory[LinearSeq] { + implicit def builderFactory[A]: BuilderFactory[A, LinearSeq[A], Coll] = new VirtualBuilderFactory[A] + def newBuilder[A]: Builder[A, LinearSeq[A]] = new MutableList[A] } diff --git a/src/library/scala/collection/mutable/LinkedList.scala b/src/library/scala/collection/mutable/LinkedList.scala index cc171c07de..a881902a67 100644 --- a/src/library/scala/collection/mutable/LinkedList.scala +++ b/src/library/scala/collection/mutable/LinkedList.scala @@ -23,7 +23,7 @@ import generic._ * @since 1 */ @serializable -class LinkedList[A](_elem: A, _next: LinkedList[A]) extends LinearSequence[A] +class LinkedList[A](_elem: A, _next: LinkedList[A]) extends LinearSeq[A] with GenericTraversableTemplate[A, LinkedList] with LinkedListLike[A, LinkedList[A]] { elem = _elem @@ -31,7 +31,7 @@ class LinkedList[A](_elem: A, _next: LinkedList[A]) extends LinearSequence[A] override def companion: GenericCompanion[LinkedList] = LinkedList } -object LinkedList extends SequenceFactory[LinkedList] { +object LinkedList extends SeqFactory[LinkedList] { implicit def builderFactory[A]: BuilderFactory[A, LinkedList[A], Coll] = new VirtualBuilderFactory[A] def newBuilder[A]: Builder[A, LinkedList[A]] = diff --git a/src/library/scala/collection/mutable/LinkedListLike.scala b/src/library/scala/collection/mutable/LinkedListLike.scala index 9ce8284772..e26735ed23 100644 --- a/src/library/scala/collection/mutable/LinkedListLike.scala +++ b/src/library/scala/collection/mutable/LinkedListLike.scala @@ -24,7 +24,7 @@ import annotation.tailrec * @version 2.8 * @since 2.8 */ -trait LinkedListLike[A, This >: Null <: Sequence[A] with LinkedListLike[A, This]] extends SequenceLike[A, This] { self => +trait LinkedListLike[A, This >: Null <: Seq[A] with LinkedListLike[A, This]] extends SeqLike[A, This] { self => var elem: A = _ var next: This = _ diff --git a/src/library/scala/collection/mutable/ListBuffer.scala b/src/library/scala/collection/mutable/ListBuffer.scala index 7d40719b02..fa8d777977 100644 --- a/src/library/scala/collection/mutable/ListBuffer.scala +++ b/src/library/scala/collection/mutable/ListBuffer.scala @@ -28,7 +28,7 @@ final class ListBuffer[A] with GenericTraversableTemplate[A, ListBuffer] with BufferLike[A, ListBuffer[A]] with Builder[A, List[A]] - with SequenceForwarder[A] + with SeqForwarder[A] { override def companion: GenericCompanion[ListBuffer] = ListBuffer @@ -39,7 +39,7 @@ final class ListBuffer[A] private var exported: Boolean = false private var len = 0 - protected def underlying: immutable.Sequence[A] = start + protected def underlying: immutable.Seq[A] = start /** The current length of the buffer */ @@ -328,7 +328,7 @@ final class ListBuffer[A] * @author Martin Odersky * @version 2.8 */ -object ListBuffer extends SequenceFactory[ListBuffer] { +object ListBuffer extends SeqFactory[ListBuffer] { implicit def builderFactory[A]: BuilderFactory[A, ListBuffer[A], Coll] = new VirtualBuilderFactory[A] def newBuilder[A]: Builder[A, ListBuffer[A]] = diff --git a/src/library/scala/collection/mutable/MutableList.scala b/src/library/scala/collection/mutable/MutableList.scala index dcf163bcb2..d85dde71da 100644 --- a/src/library/scala/collection/mutable/MutableList.scala +++ b/src/library/scala/collection/mutable/MutableList.scala @@ -27,8 +27,8 @@ import generic._ * @since 1 */ @serializable @SerialVersionUID(5938451523372603072L) -class MutableList[A] extends LinearSequence[A] - with LinearSequenceLike[A, MutableList[A]] +class MutableList[A] extends LinearSeq[A] + with LinearSeqLike[A, MutableList[A]] with Builder[A, MutableList[A]] { override protected[this] def newBuilder = new MutableList[A] diff --git a/src/library/scala/collection/mutable/Queue.scala b/src/library/scala/collection/mutable/Queue.scala index 1c9e98b1f0..6316b2d5c6 100644 --- a/src/library/scala/collection/mutable/Queue.scala +++ b/src/library/scala/collection/mutable/Queue.scala @@ -80,9 +80,9 @@ class Queue[A] extends MutableList[A] with Cloneable[Queue[A]] { * @return a sequence of all elements in the queue for which * p yields true. */ - def dequeueAll(p: A => Boolean): Sequence[A] = { + def dequeueAll(p: A => Boolean): Seq[A] = { if (first0 eq null) - Sequence.empty + Seq.empty else { val res = new ArrayBuffer[A] while ((first0 ne null) && p(first0.elem)) { diff --git a/src/library/scala/collection/mutable/ResizableArray.scala b/src/library/scala/collection/mutable/ResizableArray.scala index 2f45881307..25a41b278e 100644 --- a/src/library/scala/collection/mutable/ResizableArray.scala +++ b/src/library/scala/collection/mutable/ResizableArray.scala @@ -63,7 +63,7 @@ trait ResizableArray[A] extends Vector[A] /** Copy all elements to a buffer * @param The buffer to which elements are copied override def copyToBuffer[B >: A](dest: Buffer[B]) { - dest ++= (array: Sequence[AnyRef]).asInstanceOf[Sequence[B]] + dest ++= (array: Seq[AnyRef]).asInstanceOf[Seq[B]] } */ @@ -114,7 +114,7 @@ trait ResizableArray[A] extends Vector[A] } } -object ResizableArray extends SequenceFactory[ResizableArray] { +object ResizableArray extends SeqFactory[ResizableArray] { implicit def builderFactory[A]: BuilderFactory[A, ResizableArray[A], Coll] = new VirtualBuilderFactory[A] def newBuilder[A]: Builder[A, ResizableArray[A]] = new ArrayBuffer[A] } diff --git a/src/library/scala/collection/mutable/Sequence.scala b/src/library/scala/collection/mutable/Seq.scala index 961c144338..e6a9acf84a 100644 --- a/src/library/scala/collection/mutable/Sequence.scala +++ b/src/library/scala/collection/mutable/Seq.scala @@ -14,28 +14,28 @@ package mutable import generic._ -/** A subtrait of <code>collection.Sequence</code> which represents sequences +/** A subtrait of <code>collection.Seq</code> which represents sequences * that can be mutated. - * The class adds an <code>update</code> method to <code>collection.Sequence</code>. + * The class adds an <code>update</code> method to <code>collection.Seq</code>. * * @since 2.8 */ -trait Sequence[A] extends Iterable[A] - with scala.collection.Sequence[A] - with GenericTraversableTemplate[A, Sequence] - with SequenceLike[A, Sequence[A]] { - override def companion: GenericCompanion[Sequence] = Sequence +trait Seq[A] extends Iterable[A] + with scala.collection.Seq[A] + with GenericTraversableTemplate[A, Seq] + with SeqLike[A, Seq[A]] { + override def companion: GenericCompanion[Seq] = Seq def update(idx: Int, elem: A) } -/** A factory object for the trait <code>Sequence</code>. +/** A factory object for the trait <code>Seq</code>. * * @author Martin Odersky * @version 2.8 * @since 2.8 */ -object Sequence extends SequenceFactory[Sequence] { - implicit def builderFactory[A]: BuilderFactory[A, Sequence[A], Coll] = new VirtualBuilderFactory[A] - def newBuilder[A]: Builder[A, Sequence[A]] = new ArrayBuffer +object Seq extends SeqFactory[Seq] { + implicit def builderFactory[A]: BuilderFactory[A, Seq[A], Coll] = new VirtualBuilderFactory[A] + def newBuilder[A]: Builder[A, Seq[A]] = new ArrayBuffer } diff --git a/src/library/scala/collection/mutable/Stack.scala b/src/library/scala/collection/mutable/Stack.scala index 8790a81767..ee66c2a2a3 100644 --- a/src/library/scala/collection/mutable/Stack.scala +++ b/src/library/scala/collection/mutable/Stack.scala @@ -23,7 +23,7 @@ import generic._ * @since 1 */ @serializable @cloneable -class Stack[A] private (var elems: List[A]) extends scala.collection.Sequence[A] with Cloneable[Stack[A]] { +class Stack[A] private (var elems: List[A]) extends scala.collection.Seq[A] with Cloneable[Stack[A]] { def this() = this(Nil) diff --git a/src/library/scala/collection/mutable/StringBuilder.scala b/src/library/scala/collection/mutable/StringBuilder.scala index 6bebc430a7..2f062b4b94 100644 --- a/src/library/scala/collection/mutable/StringBuilder.scala +++ b/src/library/scala/collection/mutable/StringBuilder.scala @@ -35,6 +35,8 @@ final class StringBuilder(initCapacity: Int, private val initValue: String) require(initCapacity >= 0) + import scala.collection.Seq + /** The value is used for character storage. */ private var array = new Array[Char](initCapacity + initValue.length) diff --git a/src/library/scala/collection/mutable/Vector.scala b/src/library/scala/collection/mutable/Vector.scala index cb81aab03b..42fb62fccd 100644 --- a/src/library/scala/collection/mutable/Vector.scala +++ b/src/library/scala/collection/mutable/Vector.scala @@ -17,14 +17,14 @@ import generic._ /** A subtrait of <code>collection.Vector</code> which represents sequences * that can be mutated. */ -trait Vector[A] extends Sequence[A] +trait Vector[A] extends Seq[A] with scala.collection.Vector[A] with GenericTraversableTemplate[A, Vector] with VectorLike[A, Vector[A]] { override def companion: GenericCompanion[Vector] = Vector } -object Vector extends SequenceFactory[Vector] { +object Vector extends SeqFactory[Vector] { implicit def builderFactory[A]: BuilderFactory[A, Vector[A], Coll] = new VirtualBuilderFactory[A] def newBuilder[A]: Builder[A, Vector[A]] = new ArrayBuffer } diff --git a/src/library/scala/package.scala b/src/library/scala/package.scala index c894e1e9ad..a4a14ccdf5 100644 --- a/src/library/scala/package.scala +++ b/src/library/scala/package.scala @@ -16,8 +16,10 @@ package object scala { @deprecated("use Iterable instead") type Collection[+A] = Iterable[A] @deprecated("use Iterable instead") val Collection = Iterable - type Seq[+A] = scala.collection.Sequence[A] - val Seq = scala.collection.Sequence + type Seq[+A] = scala.collection.Seq[A] + val Seq = scala.collection.Seq + + @deprecated("use Seq instead") type Sequence[+A] = scala.collection.Seq[A] type RandomAccessSeq[+A] = scala.collection.Vector[A] val RandomAccessSeq = scala.collection.Vector diff --git a/src/library/scala/runtime/BoxedArray.scala b/src/library/scala/runtime/BoxedArray.scala index dd0f5ddf94..7293cff319 100644 --- a/src/library/scala/runtime/BoxedArray.scala +++ b/src/library/scala/runtime/BoxedArray.scala @@ -14,7 +14,7 @@ package scala.runtime import Predef._ import scala.reflect.ClassManifest import collection.mutable._ -import collection.Sequence +import collection.Seq /** * <p>A class representing <code>Array[T]</code></p> diff --git a/src/library/scala/runtime/ScalaRunTime.scala b/src/library/scala/runtime/ScalaRunTime.scala index 158e83b582..89096e0e6f 100644 --- a/src/library/scala/runtime/ScalaRunTime.scala +++ b/src/library/scala/runtime/ScalaRunTime.scala @@ -12,7 +12,7 @@ package scala.runtime import scala.reflect.ClassManifest -import scala.collection.Sequence +import scala.collection.Seq import scala.collection.mutable._ /* The object <code>ScalaRunTime</code> provides ... @@ -55,7 +55,7 @@ object ScalaRunTime { dest } - def toArray[T](xs: scala.collection.Sequence[T]) = { + def toArray[T](xs: scala.collection.Seq[T]) = { val arr = new Array[AnyRef](xs.length) var i = 0 for (x <- xs) arr(i) = x.asInstanceOf[AnyRef] diff --git a/src/library/scala/util/Random.scala b/src/library/scala/util/Random.scala index ac01b9172c..0cf2490c81 100644 --- a/src/library/scala/util/Random.scala +++ b/src/library/scala/util/Random.scala @@ -107,13 +107,13 @@ class Random(val self: java.util.Random) { */ object Random extends Random { - import collection.Sequence + import collection.Seq /** Returns a new sequence in random order. * @param seq the sequence to shuffle * @return the shuffled sequence */ - def shuffle[T: ClassManifest](seq: Sequence[T]): Sequence[T] = { + def shuffle[T: ClassManifest](seq: Seq[T]): Seq[T] = { // It would be better if this preserved the shape of its container, but I have // again been defeated by the lack of higher-kinded type inference. I can // only make it work that way if it's called like @@ -132,11 +132,11 @@ object Random extends Random swap(n - 1, k) } - buf.toSequence + buf.toSeq } /** I was consumed by weeping when I discovered how easy this - * is to implement in SequenceTemplate rather than trying to + * is to implement in SeqLike rather than trying to * accomplish the inference from the outside. For reference * here is the shape-preserving implementation. */ diff --git a/src/library/scala/util/control/Exception.scala b/src/library/scala/util/control/Exception.scala index 70c34015ac..bf53eed251 100644 --- a/src/library/scala/util/control/Exception.scala +++ b/src/library/scala/util/control/Exception.scala @@ -201,7 +201,7 @@ object Exception } /** Private **/ - private def wouldMatch(x: Throwable, classes: collection.Sequence[Class[_]]): Boolean = + private def wouldMatch(x: Throwable, classes: collection.Seq[Class[_]]): Boolean = classes exists (_ isAssignableFrom x.getClass) private def pfFromExceptions(exceptions: Class[_]*) = diff --git a/src/library/scala/xml/NodeSeq.scala b/src/library/scala/xml/NodeSeq.scala index 8f2e3a994d..bd9999ab3c 100644 --- a/src/library/scala/xml/NodeSeq.scala +++ b/src/library/scala/xml/NodeSeq.scala @@ -12,7 +12,7 @@ package scala.xml import collection.immutable -import collection.SequenceLike +import collection.SeqLike import collection.mutable.{Builder, ListBuffer} import collection.generic.BuilderFactory @@ -38,7 +38,7 @@ object NodeSeq { * @author Burak Emir * @version 1.0 */ -abstract class NodeSeq extends immutable.Sequence[Node] with SequenceLike[Node, NodeSeq] { +abstract class NodeSeq extends immutable.Seq[Node] with SeqLike[Node, NodeSeq] { import NodeSeq.seqToNodeSeq // import view magic for NodeSeq wrappers /** Creates a list buffer as builder for this class */ diff --git a/src/library/scala/xml/transform/BasicTransformer.scala b/src/library/scala/xml/transform/BasicTransformer.scala index f3a4d10a33..301f2e23a5 100644 --- a/src/library/scala/xml/transform/BasicTransformer.scala +++ b/src/library/scala/xml/transform/BasicTransformer.scala @@ -31,7 +31,7 @@ abstract class BasicTransformer extends Function1[Node,Node] * to NodeBuffer. */ def transform(it: Iterator[Node], nb: NodeBuffer): Seq[Node] = - it.foldLeft(nb)(_ ++= transform(_)).toSequence + it.foldLeft(nb)(_ ++= transform(_)).toSeq /** Call transform(Node) to each node in ns, yield ns if nothing changes, * otherwise a new sequence of concatenated results. diff --git a/src/swing/scala/swing/ListView.scala b/src/swing/scala/swing/ListView.scala index 9dbd14fcbe..49b69396fe 100644 --- a/src/swing/scala/swing/ListView.scala +++ b/src/swing/scala/swing/ListView.scala @@ -203,8 +203,8 @@ class ListView[A] extends Component { /** * The currently selected items. */ - object items extends scala.collection.SequenceProxy[A] { - def self = peer.getSelectedValues.toSequence.map(_.asInstanceOf[A]) + object items extends scala.collection.SeqProxy[A] { + def self = peer.getSelectedValues.toSeq.map(_.asInstanceOf[A]) def leadIndex: Int = peer.getSelectionModel.getLeadSelectionIndex def anchorIndex: Int = peer.getSelectionModel.getAnchorSelectionIndex } diff --git a/src/swing/scala/swing/Table.scala b/src/swing/scala/swing/Table.scala index 729d0c344c..d31325863d 100644 --- a/src/swing/scala/swing/Table.scala +++ b/src/swing/scala/swing/Table.scala @@ -199,7 +199,7 @@ class Table extends Component with Scrollable.Wrapper { } def cells: Set[(Int, Int)] = - new SelectionSet[(Int, Int)]((for(r <- selection.rows; c <- selection.columns) yield (r,c)).toSequence) { outer => + new SelectionSet[(Int, Int)]((for(r <- selection.rows; c <- selection.columns) yield (r,c)).toSeq) { outer => def -=(n: (Int, Int)) = { peer.removeRowSelectionInterval(n._1,n._1) peer.removeColumnSelectionInterval(n._2,n._2) |