diff options
author | Paul Phillips <paulp@improving.org> | 2009-05-08 18:24:05 +0000 |
---|---|---|
committer | Paul Phillips <paulp@improving.org> | 2009-05-08 18:24:05 +0000 |
commit | f3c0640e3d7270795cc15dc923d811074c0836d7 (patch) | |
tree | c88f2c71c1ecd831c228f8e12171d07f3ea6aee0 /src | |
parent | 75d487d831dfa388c4c3683eedd0db16491a048a (diff) | |
download | scala-f3c0640e3d7270795cc15dc923d811074c0836d7.tar.gz scala-f3c0640e3d7270795cc15dc923d811074c0836d7.tar.bz2 scala-f3c0640e3d7270795cc15dc923d811074c0836d7.zip |
4 out of 5 spelling bee champs say: Traversable
Diffstat (limited to 'src')
72 files changed, 409 insertions, 409 deletions
diff --git a/src/compiler/scala/tools/nsc/symtab/Types.scala b/src/compiler/scala/tools/nsc/symtab/Types.scala index 84d34f62c4..f66cc96e38 100644 --- a/src/compiler/scala/tools/nsc/symtab/Types.scala +++ b/src/compiler/scala/tools/nsc/symtab/Types.scala @@ -4479,7 +4479,7 @@ A type's typeSymbol should never be inspected directly. "scala.collection.immutable.List", "scala.collection.immutable.Nil", "scala.collection.Sequence", - "scala.collection.Traversible", + "scala.collection.Traversable", "scala.collection.Iterable", "scala.collection.mutable.StringBuilder", "scala.collection.Vector", diff --git a/src/library/scala/collection/Iterable.scala b/src/library/scala/collection/Iterable.scala index 502e7d95f4..501f08b15b 100755 --- a/src/library/scala/collection/Iterable.scala +++ b/src/library/scala/collection/Iterable.scala @@ -21,19 +21,19 @@ import generic._ * elements contained in the collection. They also provide a method `newBuilder` * which creates a builder for collections of the same kind. * - * This trait implements Traversible's `foreach` method by stepping through + * This trait implements Traversable's `foreach` method by stepping through * all elements. Subclasses of `Iterable` should re-implement `foreach` with * something more efficient, if possible. * * This trait adds methods `elements`, `zip`, `zipAll`, `zipWithIndex`, `sameElements`, - * `takeRight`, `dropRight` to the methods inherited from trait `Traversible`. + * `takeRight`, `dropRight` to the methods inherited from trait `Traversable`. * * @author Martin Odersky * @version 2.8 */ -trait Iterable[+A] extends Traversible[A] with IterableTemplate[A, Iterable[A]] { +trait Iterable[+A] extends Traversable[A] with IterableTemplate[A, Iterable[A]] { override protected[this] def newBuilder = Iterable.newBuilder - override def traversibleBuilder[B]: Builder[B, Iterable[B], Any] = Iterable.newBuilder[B] + override def traversableBuilder[B]: Builder[B, Iterable[B], Any] = Iterable.newBuilder[B] /* The following methods are inherited from trait IterableTemplate * @@ -46,11 +46,11 @@ trait Iterable[+A] extends Traversible[A] with IterableTemplate[A, Iterable[A]] */ } -/** Factory methods and utilities for instances of type Traversible */ -object Iterable extends TraversibleFactory[Iterable] { +/** Factory methods and utilities for instances of type Traversable */ +object Iterable extends TraversableFactory[Iterable] { type Coll = Iterable[_] - implicit def builderFactory[A]: BuilderFactory[A, Iterable[A], Coll] = new BuilderFactory[A, Iterable[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, Iterable[A], Coll] = new BuilderFactory[A, Iterable[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def newBuilder[A]: Builder[A, Iterable[A], Any] = immutable.Iterable.newBuilder[A] def fromOld[A](it: scala.Iterable[A]): Iterable[A] = new Iterable[A] { diff --git a/src/library/scala/collection/JavaConversions.scala b/src/library/scala/collection/JavaConversions.scala index d28959d857..efe3148851 100644 --- a/src/library/scala/collection/JavaConversions.scala +++ b/src/library/scala/collection/JavaConversions.scala @@ -48,7 +48,7 @@ package scala.collection */ object JavaConversions { import java.{ lang => jl, util => ju } - import scala.collection.{ generic, immutable, mutable, Traversible } + import scala.collection.{ generic, immutable, mutable, Traversable } import scala.reflect.Manifest // Scala => Java @@ -356,7 +356,7 @@ object JavaConversions { def update(i : Int, elem : A) = underlying.set(i, elem) def +:(elem : A) = { underlying.subList(0, 0).add(elem) ; this } def +=(elem : A) = underlying.add(elem) - def insertAll(i : Int, elems : Traversible[A]) = { val ins = underlying.subList(0, i) ; elems.foreach(ins.add(_)) } + def insertAll(i : Int, elems : Traversable[A]) = { val ins = underlying.subList(0, i) ; elems.foreach(ins.add(_)) } def remove(i : Int) = underlying.remove(i) def clear = underlying.clear def result = this diff --git a/src/library/scala/collection/LinearSequence.scala b/src/library/scala/collection/LinearSequence.scala index fc8d5e9a07..e6504376dc 100755 --- a/src/library/scala/collection/LinearSequence.scala +++ b/src/library/scala/collection/LinearSequence.scala @@ -28,11 +28,11 @@ import util.control.Breaks._ */ trait LinearSequence[+A] extends Sequence[A] with LinearSequenceTemplate[A, LinearSequence[A]] { override protected[this] def newBuilder = LinearSequence.newBuilder - override def traversibleBuilder[B]: Builder[B, LinearSequence[B], Any] = LinearSequence.newBuilder[B] + override def traversableBuilder[B]: Builder[B, LinearSequence[B], Any] = LinearSequence.newBuilder[B] } object LinearSequence extends SequenceFactory[LinearSequence] { type Coll = LinearSequence[_] - implicit def builderFactory[A]: BuilderFactory[A, LinearSequence[A], Coll] = new BuilderFactory[A, LinearSequence[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, LinearSequence[A], Coll] = new BuilderFactory[A, LinearSequence[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def newBuilder[A]: Builder[A, LinearSequence[A], Any] = immutable.LinearSequence.newBuilder[A] } diff --git a/src/library/scala/collection/Sequence.scala b/src/library/scala/collection/Sequence.scala index 18f17d0513..8e099a2d63 100755 --- a/src/library/scala/collection/Sequence.scala +++ b/src/library/scala/collection/Sequence.scala @@ -30,13 +30,13 @@ import util.control.Breaks._ */ trait Sequence[+A] extends PartialFunction[Int, A] with Iterable[A] with SequenceTemplate[A, Sequence[A]] { override protected[this] def newBuilder = Sequence.newBuilder - override def traversibleBuilder[B]: Builder[B, Sequence[B], Any] = Sequence.newBuilder[B] + override def traversableBuilder[B]: Builder[B, Sequence[B], Any] = Sequence.newBuilder[B] } object Sequence extends SequenceFactory[Sequence] { type Coll = Sequence[_] - implicit def builderFactory[A]: BuilderFactory[A, Sequence[A], Coll] = new BuilderFactory[A, Sequence[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, Sequence[A], Coll] = new BuilderFactory[A, Sequence[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def newBuilder[A]: Builder[A, Sequence[A], Any] = immutable.Sequence.newBuilder[A] /** @deprecated use View instead diff --git a/src/library/scala/collection/Set.scala b/src/library/scala/collection/Set.scala index 691953bdf1..44d6c159f3 100644 --- a/src/library/scala/collection/Set.scala +++ b/src/library/scala/collection/Set.scala @@ -23,14 +23,14 @@ import generic._ */ trait Set[A] extends (A => Boolean) with Iterable[A] with SetTemplate[A, Set[A]] { def empty = Set.empty - override def traversibleBuilder[B]: Builder[B, Set[B], Any] = Set.newBuilder[B] + override def traversableBuilder[B]: Builder[B, Set[B], Any] = Set.newBuilder[B] } /* Factory object for `Set` class */ object Set extends SetFactory[Set] { def empty[A]: Set[A] = immutable.Set.empty[A] type Coll = Set[_] - implicit def builderFactory[A]: BuilderFactory[A, Set[A], Coll] = new BuilderFactory[A, Set[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, Set[A], Coll] = new BuilderFactory[A, Set[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } } /* !!! what to do about this? diff --git a/src/library/scala/collection/Traversible.scala b/src/library/scala/collection/Traversable.scala index 886fd1c767..dc29ee4945 100755 --- a/src/library/scala/collection/Traversible.scala +++ b/src/library/scala/collection/Traversable.scala @@ -6,7 +6,7 @@ ** |/ ** \* */ -// $Id: Traversible.scala 15188 2008-05-24 15:01:02Z stepancheg $ +// $Id: Traversable.scala 15188 2008-05-24 15:01:02Z stepancheg $ package scala.collection // import immutable.{List, Stream, Nil} @@ -14,7 +14,7 @@ import mutable.{Buffer, ArrayBuffer, ListBuffer} import util.control.Breaks._ import generic._ -/** A template trait for traversible collections. +/** A template trait for traversable collections. * * Collection classes mixing in this trait provide a method * <code>foreach</code> which traverses all the @@ -25,23 +25,23 @@ import generic._ * @author Martin Odersky * @version 2.8 */ -trait Traversible[+A] extends TraversibleTemplate[A, Traversible[A]] { - protected[this] def newBuilder = Traversible.newBuilder - def traversibleBuilder[B]: Builder[B, Traversible[B], Any] = Traversible.newBuilder[B] +trait Traversable[+A] extends TraversableTemplate[A, Traversable[A]] { + protected[this] def newBuilder = Traversable.newBuilder + def traversableBuilder[B]: Builder[B, Traversable[B], Any] = Traversable.newBuilder[B] - /* The following methods are inherited from TraversibleTemplate + /* The following methods are inherited from TraversableTemplate * override def isEmpty: Boolean override def size: Int override def hasDefiniteSize - override def ++[B >: A, That](that: Traversible[B])(implicit bf: BuilderFactory[B, That, Traversible[A]]): That - override def ++[B >: A, That](that: Iterator[B])(implicit bf: BuilderFactory[B, That, Traversible[A]]): That - override def map[B, That](f: A => B)(implicit bf: BuilderFactory[B, That, Traversible[A]]): That - override def flatMap[B, That](f: A => Traversible[B])(implicit bf: BuilderFactory[B, That, Traversible[A]]): That - override def filter(p: A => Boolean): Traversible[A] - override def remove(p: A => Boolean): Traversible[A] - override def partition(p: A => Boolean): (Traversible[A], Traversible[A]) - override def groupBy[K](f: A => K): Map[K, Traversible[A]] + override def ++[B >: A, That](that: Traversable[B])(implicit bf: BuilderFactory[B, That, Traversable[A]]): That + override def ++[B >: A, That](that: Iterator[B])(implicit bf: BuilderFactory[B, That, Traversable[A]]): That + override def map[B, That](f: A => B)(implicit bf: BuilderFactory[B, That, Traversable[A]]): That + override def flatMap[B, That](f: A => Traversable[B])(implicit bf: BuilderFactory[B, That, Traversable[A]]): That + override def filter(p: A => Boolean): Traversable[A] + override def remove(p: A => Boolean): Traversable[A] + override def partition(p: A => Boolean): (Traversable[A], Traversable[A]) + override def groupBy[K](f: A => K): Map[K, Traversable[A]] override def foreach(f: A => Unit): Unit override def forall(p: A => Boolean): Boolean override def exists(p: A => Boolean): Boolean @@ -57,17 +57,17 @@ trait Traversible[+A] extends TraversibleTemplate[A, Traversible[A]] { override def reduceRightOpt[B >: A](op: (A, B) => B): Option[B] override def head: A override def headOption: Option[A] - override def tail: Traversible[A] + override def tail: Traversable[A] override def last: A override def lastOption: Option[A] - override def init: Traversible[A] - override def take(n: Int): Traversible[A] - override def drop(n: Int): Traversible[A] - override def slice(from: Int, until: Int): Traversible[A] - override def takeWhile(p: A => Boolean): Traversible[A] - override def dropWhile(p: A => Boolean): Traversible[A] - override def span(p: A => Boolean): (Traversible[A], Traversible[A]) - override def splitAt(n: Int): (Traversible[A], Traversible[A]) + override def init: Traversable[A] + override def take(n: Int): Traversable[A] + override def drop(n: Int): Traversable[A] + override def slice(from: Int, until: Int): Traversable[A] + override def takeWhile(p: A => Boolean): Traversable[A] + override def dropWhile(p: A => Boolean): Traversable[A] + override def span(p: A => Boolean): (Traversable[A], Traversable[A]) + override def splitAt(n: Int): (Traversable[A], Traversable[A]) override def copyToBuffer[B >: A](dest: Buffer[B]) override def copyToArray[B >: A](xs: Array[B], start: Int, len: Int) override def copyToArray[B >: A](xs: Array[B], start: Int) @@ -76,7 +76,7 @@ trait Traversible[+A] extends TraversibleTemplate[A, Traversible[A]] { override def toIterable: Iterable[A] override def toSequence: Sequence[A] override def toStream: Stream[A] -// override def sortWith(lt : (A,A) => Boolean): Traversible[A] +// override def sortWith(lt : (A,A) => Boolean): Traversable[A] override def mkString(start: String, sep: String, end: String): String override def mkString(sep: String): String override def mkString: String @@ -86,20 +86,20 @@ trait Traversible[+A] extends TraversibleTemplate[A, Traversible[A]] { override def toString override def stringPrefix : String override def view - override def view(from: Int, until: Int): TraversibleView[A, Traversible[A]] + override def view(from: Int, until: Int): TraversableView[A, Traversable[A]] */ } -/** Factory methods and utilities for instances of type Traversible */ -object Traversible extends TraversibleFactory[Traversible] { self => +/** Factory methods and utilities for instances of type Traversable */ +object Traversable extends TraversableFactory[Traversable] { self => - type Coll = Traversible[_] - implicit def builderFactory[A]: BuilderFactory[A, Traversible[A], Coll] = new BuilderFactory[A, Traversible[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } - def newBuilder[A]: Builder[A, Traversible[A], Any] = immutable.Traversible.newBuilder[A] + type Coll = Traversable[_] + implicit def builderFactory[A]: BuilderFactory[A, Traversable[A], Coll] = new BuilderFactory[A, Traversable[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } + def newBuilder[A]: Builder[A, Traversable[A], Any] = immutable.Traversable.newBuilder[A] /** A wrapper class which adds `min` and `max` methods to iterables of an element type that has an Ordering. */ - class ComparableTraversibleOps[A](self: Traversible[A], cmp: Ordering[A]) { + class ComparableTraversableOps[A](self: Traversable[A], cmp: Ordering[A]) { /** Returns the minimal element of the wrapped iterable `self` with respect to the given ordering `cmp` */ def min: A = { @@ -122,7 +122,7 @@ object Traversible extends TraversibleFactory[Traversible] { self => /** A wrapper class which adds `sum` and `product` methods to iterables of an element type that is `Numeric`. */ - class NumericTraversibleOps[A](self: Traversible[A], num: Numeric[A]) { + class NumericTraversableOps[A](self: Traversable[A], num: Numeric[A]) { /** Returns the sum of all elements of the wrapped iterable `self` with respect to the numeric operations in `num` */ def sum: A = { @@ -141,7 +141,7 @@ object Traversible extends TraversibleFactory[Traversible] { self => /** A wrapper class which adds `flatten` and `transpose` methods to iterables or iterable element type`. */ - class TraversibleTraversibleOps[This <: Traversible[Traversible[A]], A](self: This) { + class TraversableTraversableOps[This <: Traversable[Traversable[A]], A](self: This) { /** Returns the concatenation of all elements of the wrapped iterable `self` */ def flatten[That](implicit bf: BuilderFactory[A, That, This]): That = { @@ -154,7 +154,7 @@ object Traversible extends TraversibleFactory[Traversible] { self => /** Returns the transposition of the wrapped iterable `self`: rows become columns and columns become rows. */ def transpose[Row, That](implicit bf: BuilderFactory[A, Row, This], bbf: BuilderFactory[Row, That, This]): That = { - val bs: Array[Builder[A, Row, This]] = self.head.map(_ => bf(self))(Traversible.builderFactory[Builder[A, Row, This]]).toArray + val bs: Array[Builder[A, Row, This]] = self.head.map(_ => bf(self))(Traversable.builderFactory[Builder[A, Row, This]]).toArray for (xs <- self) { var i = 0 for (x <- xs) { @@ -170,7 +170,7 @@ object Traversible extends TraversibleFactory[Traversible] { self => /** A wrapper class which adds an `unzip` method to iterable whose elements are pairs. */ - class PairTraversibleOps[This <: Traversible[(A1, A2)], A1, A2](self: This) { + class PairTraversableOps[This <: Traversable[(A1, A2)], A1, A2](self: This) { /** Returns a pair of iterables consisting of the first, respectively second, component of all * elements in the wrapped iterable `self`. @@ -187,27 +187,27 @@ object Traversible extends TraversibleFactory[Traversible] { self => } /** Implicit wrapper conversion of iterables with elements admitting comparison. - * @see ComparableTraversibleOps + * @see ComparableTraversableOps */ - implicit def comparableTraversibleWrapper[A](self: Traversible[A])(implicit cmp: Ordering[A]) = - new ComparableTraversibleOps(self, cmp) + implicit def comparableTraversableWrapper[A](self: Traversable[A])(implicit cmp: Ordering[A]) = + new ComparableTraversableOps(self, cmp) /** Implicit wrapper conversion of iterables with numeric elements. - * @see NumericTraversibleOps + * @see NumericTraversableOps */ - implicit def numericTraversibleWrapper[A](self: Traversible[A])(implicit num: Numeric[A]) = - new NumericTraversibleOps(self, num) + implicit def numericTraversableWrapper[A](self: Traversable[A])(implicit num: Numeric[A]) = + new NumericTraversableOps(self, num) /** Implicit wrapper conversion of iterables with iterable elements. - * @see TraversibleTraversibleOps + * @see TraversableTraversableOps */ - implicit def traversibleTraversibleWrapper[This <: Traversible[Traversible[A]], A](self: This) = - new TraversibleTraversibleOps[This, A](self) // !!! error if type parameters are omitted + implicit def traversableTraversableWrapper[This <: Traversable[Traversable[A]], A](self: This) = + new TraversableTraversableOps[This, A](self) // !!! error if type parameters are omitted /** Implicit wrapper conversion of iterables with pairs as elements. - * @see PairTraversibleOps + * @see PairTraversableOps */ - implicit def pairTraversibleWrapper[This <: Traversible[(A1, A2)], A1, A2](self: This) = - new PairTraversibleOps[This, A1, A2](self) + implicit def pairTraversableWrapper[This <: Traversable[(A1, A2)], A1, A2](self: This) = + new PairTraversableOps[This, A1, A2](self) } diff --git a/src/library/scala/collection/TraversibleProxy.scala b/src/library/scala/collection/TraversableProxy.scala index edff865af2..d452ab709d 100644 --- a/src/library/scala/collection/TraversibleProxy.scala +++ b/src/library/scala/collection/TraversableProxy.scala @@ -16,10 +16,10 @@ import generic._ // Methods could be printed by cat TraversibeTemplate.scala | egrep '^ (override )?def' -/** This trait implements a proxy for traversible objects. It forwards - * all calls to a different traversible object +/** This trait implements a proxy for traversable objects. It forwards + * all calls to a different traversable object * * @author Martin Odersky * @version 2.8 */ -trait TraversibleProxy[+A] extends Traversible[A] with TraversibleProxyTemplate[A, Traversible[A]] +trait TraversableProxy[+A] extends Traversable[A] with TraversableProxyTemplate[A, Traversable[A]] diff --git a/src/library/scala/collection/Vector.scala b/src/library/scala/collection/Vector.scala index fea38a774e..9010f01a1e 100755 --- a/src/library/scala/collection/Vector.scala +++ b/src/library/scala/collection/Vector.scala @@ -23,11 +23,11 @@ import mutable.ArrayBuffer */ trait Vector[+A] extends Sequence[A] with VectorTemplate[A, Vector[A]] { override protected[this] def newBuilder = Vector.newBuilder - override def traversibleBuilder[B]: Builder[B, Vector[B], Any] = Vector.newBuilder[B] + override def traversableBuilder[B]: Builder[B, Vector[B], Any] = Vector.newBuilder[B] } object Vector extends SequenceFactory[Vector] { type Coll = Vector[_] - implicit def builderFactory[A]: BuilderFactory[A, Vector[A], Coll] = new BuilderFactory[A, Vector[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, Vector[A], Coll] = new BuilderFactory[A, Vector[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def newBuilder[A]: Builder[A, Vector[A], Any] = mutable.Vector.newBuilder[A] } diff --git a/src/library/scala/collection/generic/Addable.scala b/src/library/scala/collection/generic/Addable.scala index ea45be91f3..21215cefac 100755 --- a/src/library/scala/collection/generic/Addable.scala +++ b/src/library/scala/collection/generic/Addable.scala @@ -46,7 +46,7 @@ trait Addable[A, +This <: Addable[A, This]] { self => * * @param iter the iterable object. */ - def ++ (iter: Traversible[A]): This = (thisCollection /: iter) (_ + _) + def ++ (iter: Traversable[A]): This = (thisCollection /: iter) (_ + _) /** Adds a number of elements provided by an iterator * via its <code>elements</code> method and returns diff --git a/src/library/scala/collection/generic/BufferTemplate.scala b/src/library/scala/collection/generic/BufferTemplate.scala index a946c2bdb3..139d5f7316 100755 --- a/src/library/scala/collection/generic/BufferTemplate.scala +++ b/src/library/scala/collection/generic/BufferTemplate.scala @@ -33,7 +33,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]] with SequenceTemplate[A, This] { self => - import collection.{Iterable, Traversible} + import collection.{Iterable, Traversable} // Abstract methods from Vector: @@ -87,7 +87,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]] * @param iter the iterable object providing all elements to insert. * @throws IndexOutofBoundsException if the index is not valid */ - def insertAll(n: Int, iter: Traversible[A]) + def insertAll(n: Int, iter: Traversable[A]) /** Removes the element on a given index position. @@ -136,7 +136,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]] * * @param iter the iterable object. */ - def ++:(iter: Traversible[A]): This = { for (x <- iter) x +: this; thisCollection } + def ++:(iter: Traversable[A]): This = { for (x <- iter) x +: this; thisCollection } /** Prepends a number of elements provided by an iterator * The identity of the buffer is returned. @@ -157,7 +157,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]] * * @param iter the iterable object. */ - def appendAll(iter: Traversible[A]) { this ++= iter } + def appendAll(iter: Traversable[A]) { this ++= iter } /** Prepend given elements to this list. * @@ -171,7 +171,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]] * * @param iter the iterable object. */ - def prependAll(iter: Traversible[A]) { iter ++: this } + def prependAll(iter: Traversable[A]) { iter ++: this } /** Prepends a number of elements provided by an iterable object * via its <code>elements</code> method. The identity of the diff --git a/src/library/scala/collection/generic/Builder.scala b/src/library/scala/collection/generic/Builder.scala index 675596da2b..686e684cf3 100755 --- a/src/library/scala/collection/generic/Builder.scala +++ b/src/library/scala/collection/generic/Builder.scala @@ -45,7 +45,7 @@ trait Builder[-Elem, +To, -From] extends Growable[Elem] { def +=(x: Elem) = self += x def clear() = self.clear() override def ++=(xs: Iterator[Elem]) = self ++= xs - override def ++=(xs: Traversible[Elem]) = self ++= xs + override def ++=(xs: Traversable[Elem]) = self ++= xs def result: NewTo = f(self.result) } } diff --git a/src/library/scala/collection/generic/GenericSequenceFactory.scala.disabled b/src/library/scala/collection/generic/GenericSequenceFactory.scala.disabled index 70451741f8..7edfc3b25e 100755 --- a/src/library/scala/collection/generic/GenericSequenceFactory.scala.disabled +++ b/src/library/scala/collection/generic/GenericSequenceFactory.scala.disabled @@ -2,7 +2,7 @@ package scala.collection.generic /** A template for companion objects of Sequence and subclasses thereof. */ -abstract class GenericSequenceFactory extends GenericTraversibleFactory { +abstract class GenericSequenceFactory extends GenericTraversableFactory { type Coll <: Sequence[_] diff --git a/src/library/scala/collection/generic/GenericTraversibleFactory.scala.disabled b/src/library/scala/collection/generic/GenericTraversableFactory.scala.disabled index dece49de37..97e3997cba 100755 --- a/src/library/scala/collection/generic/GenericTraversibleFactory.scala.disabled +++ b/src/library/scala/collection/generic/GenericTraversableFactory.scala.disabled @@ -1,10 +1,10 @@ package scala.collection.generic -/** A template for companion objects of Traversible and subclasses thereof. +/** A template for companion objects of Traversable and subclasses thereof. */ -abstract class GenericTraversibleFactory { +abstract class GenericTraversableFactory { - type Coll <: Traversible[_] + type Coll <: Traversable[_] /** The empty iterable of type CC */ def empty[A, That](implicit bf: Coll => Builder[A, That, Coll]): That = apply[A, That]() @@ -21,7 +21,7 @@ abstract class GenericTraversibleFactory { * @param xss the lists that are to be concatenated * @return the concatenation of all the lists */ - def concat[A, That](xss: Traversible[A]*)(implicit bf: Coll => Builder[A, That, Coll]): That = { + def concat[A, That](xss: Traversable[A]*)(implicit bf: Coll => Builder[A, That, Coll]): That = { val b = bf(thisCollection) for (xs <- Iterable.fromOld(xss)) b ++= xs diff --git a/src/library/scala/collection/generic/Growable.scala b/src/library/scala/collection/generic/Growable.scala index 7c4c52413b..d664a60c19 100755 --- a/src/library/scala/collection/generic/Growable.scala +++ b/src/library/scala/collection/generic/Growable.scala @@ -47,7 +47,7 @@ trait Growable[-A] { * * @param iter the iterable object. */ - def ++=(iter: Traversible[A]) { iter foreach += } + def ++=(iter: Traversable[A]) { iter foreach += } /** Clears the collection contents. */ diff --git a/src/library/scala/collection/generic/IterableForwarder.scala b/src/library/scala/collection/generic/IterableForwarder.scala index f783f8c8fd..142edbf509 100755 --- a/src/library/scala/collection/generic/IterableForwarder.scala +++ b/src/library/scala/collection/generic/IterableForwarder.scala @@ -25,7 +25,7 @@ import collection.mutable.Buffer * @author Martin Odersky * @version 2.8 */ -trait IterableForwarder[+A] extends Iterable[A] with TraversibleForwarder[A] { +trait IterableForwarder[+A] extends Iterable[A] with TraversableForwarder[A] { /** The iterable object to which calls are forwarded */ protected def underlying: Iterable[A] diff --git a/src/library/scala/collection/generic/IterableProxyTemplate.scala b/src/library/scala/collection/generic/IterableProxyTemplate.scala index 577bfc24da..646cdbee11 100644 --- a/src/library/scala/collection/generic/IterableProxyTemplate.scala +++ b/src/library/scala/collection/generic/IterableProxyTemplate.scala @@ -22,7 +22,7 @@ import collection.mutable.Buffer * @author Martin Odersky * @version 2.8 */ -trait IterableProxyTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] extends IterableTemplate[A, This] with TraversibleProxyTemplate[A, This] { +trait IterableProxyTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] extends IterableTemplate[A, This] with TraversableProxyTemplate[A, This] { override def elements: Iterator[A] = self.elements override def takeRight(n: Int): This = self.takeRight(n) override def dropRight(n: Int): This = self.dropRight(n) diff --git a/src/library/scala/collection/generic/IterableTemplate.scala b/src/library/scala/collection/generic/IterableTemplate.scala index e0ec5426a9..2df5b6a048 100755 --- a/src/library/scala/collection/generic/IterableTemplate.scala +++ b/src/library/scala/collection/generic/IterableTemplate.scala @@ -20,17 +20,17 @@ import util.control.Breaks._ * elements contained in the collection. They also provide a method `newBuilder` * which creates a builder for collections of the same kind. * - * This trait implements Traversible's `foreach` method by stepping through + * This trait implements Traversable's `foreach` method by stepping through * all elements. Subclasses of `Iterable` should re-implement `foreach` with * something more efficient, if possible. * * This trait adds methods `elements`, `sameElements`, - * `takeRight`, `dropRight` to the methods inherited from trait `Traversible`. + * `takeRight`, `dropRight` to the methods inherited from trait `Traversable`. * * @author Martin Odersky * @version 2.8 */ -trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] extends TraversibleTemplate[A, This] { self => +trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] extends TraversableTemplate[A, This] { self => /** Creates a new iterator over all elements contained in this * iterable object. @@ -40,7 +40,7 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] def elements: Iterator[A] /** Apply a function <code>f</code> to all elements of this - * traversible object. + * traversable object. * * @param f a function that is applied to every element. * @note This method underlies the implementation of most other bulk operations. @@ -140,7 +140,7 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] !these.hasNext && !those.hasNext } - /** Returns a stream with all elements in this traversible object. + /** Returns a stream with all elements in this traversable object. */ override def toStream: Stream[A] = elements.toStream @@ -168,7 +168,7 @@ trait IterableTemplate[+A, +This <: IterableTemplate[A, This] with Iterable[A]] @deprecated def first: A = head /** @deprecated use headOption instead - * <code>None</code> if traversible is empty. + * <code>None</code> if traversable is empty. */ @deprecated def firstOption: Option[A] = headOption diff --git a/src/library/scala/collection/generic/IterableView.scala b/src/library/scala/collection/generic/IterableView.scala index ab36b4550e..18ca7b2494 100755 --- a/src/library/scala/collection/generic/IterableView.scala +++ b/src/library/scala/collection/generic/IterableView.scala @@ -8,7 +8,7 @@ package scala.collection.generic import Math.MAX_INT -import TraversibleView.NoBuilder +import TraversableView.NoBuilder /** A base class for views of Iterables. * @author Martin Odersky @@ -17,6 +17,6 @@ import TraversibleView.NoBuilder trait IterableView[+A, +Coll <: Iterable[_]] extends IterableViewTemplate[A, Coll, IterableView[A, Coll]] object IterableView { - type Coll = TraversibleView[_, _] + type Coll = TraversableView[_, _] implicit def builderFactory[A]: BuilderFactory[A, IterableView[A, Iterable[_]], Coll] = new BuilderFactory[A, IterableView[A, Iterable[_]], Coll] { def apply(from: Coll) = new NoBuilder } } diff --git a/src/library/scala/collection/generic/IterableViewTemplate.scala b/src/library/scala/collection/generic/IterableViewTemplate.scala index 99b6e23a1a..f120e97ac4 100755 --- a/src/library/scala/collection/generic/IterableViewTemplate.scala +++ b/src/library/scala/collection/generic/IterableViewTemplate.scala @@ -8,7 +8,7 @@ package scala.collection.generic import Math.MAX_INT -import TraversibleView.NoBuilder +import TraversableView.NoBuilder /** A base class for views of Iterables. * @author Martin Odersky @@ -17,7 +17,7 @@ import TraversibleView.NoBuilder trait IterableViewTemplate[+A, +Coll <: Iterable[_], +This <: IterableView[A, Coll] with IterableViewTemplate[A, Coll, This]] -extends Iterable[A] with IterableTemplate[A, This] with TraversibleView[A, Coll] with TraversibleViewTemplate[A, Coll, This] +extends Iterable[A] with IterableTemplate[A, This] with TraversableView[A, Coll] with TraversableViewTemplate[A, Coll, This] { self => trait Transformed[+B] extends IterableView[B, Coll] with super.Transformed[B] @@ -53,9 +53,9 @@ extends Iterable[A] with IterableTemplate[A, This] with TraversibleView[A, Coll] /** Boilerplate method, to override in each subclass * This method could be eliminated if Scala had virtual classes */ - protected override def newAppended[B >: A](that: Traversible[B]): Transformed[B] = new Appended[B] { val rest = that } + 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 => Traversible[B]): Transformed[B] = new FlatMapped[B] { val mapping = f } + protected override def newFlatMapped[B](f: A => Traversable[B]): Transformed[B] = new FlatMapped[B] { val mapping = f } protected override def newFiltered(p: A => Boolean): Transformed[A] = new Filtered { val pred = p } protected override def newSliced(_from: Int, _until: Int): Transformed[A] = new Sliced { val from = _from; val until = _until } protected override def newDroppedWhile(p: A => Boolean): Transformed[A] = new DroppedWhile { val pred = p } diff --git a/src/library/scala/collection/generic/LazyBuilder.scala b/src/library/scala/collection/generic/LazyBuilder.scala index 019827d5ad..fd9ddd33ef 100755 --- a/src/library/scala/collection/generic/LazyBuilder.scala +++ b/src/library/scala/collection/generic/LazyBuilder.scala @@ -18,10 +18,10 @@ import mutable.ListBuffer */ abstract class LazyBuilder[Elem, +To, -From] extends Builder[Elem, To, From] { /** The different segments of elements to be added to the builder, represented as iterators */ - protected var parts = new ListBuffer[Traversible[Elem]] + protected var parts = new ListBuffer[Traversable[Elem]] def +=(x: Elem) = { parts += List(x) } override def ++=(xs: Iterator[Elem]) { parts += xs.toStream } - override def ++=(xs: Traversible[Elem]) { parts += xs } + override def ++=(xs: Traversable[Elem]) { parts += xs } def result(): To def clear() { parts.clear() } } diff --git a/src/library/scala/collection/generic/MutableMapTemplate.scala b/src/library/scala/collection/generic/MutableMapTemplate.scala index 3a5801c1df..989e29aa0d 100644 --- a/src/library/scala/collection/generic/MutableMapTemplate.scala +++ b/src/library/scala/collection/generic/MutableMapTemplate.scala @@ -100,7 +100,7 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta * @param iter the iterable object. */ //override - def ++(iter: Traversible[(A, B)]): this.type = { (this /: iter) (_ + _); this } + def ++(iter: Traversable[(A, B)]): this.type = { (this /: iter) (_ + _); this } /** Adds a number of elements provided by an iterator * via its <code>elements</code> method and returns diff --git a/src/library/scala/collection/generic/MutableVectorView.scala b/src/library/scala/collection/generic/MutableVectorView.scala index 4b7ece1dab..ba91e9152c 100755 --- a/src/library/scala/collection/generic/MutableVectorView.scala +++ b/src/library/scala/collection/generic/MutableVectorView.scala @@ -11,7 +11,7 @@ package scala.collection.generic -import TraversibleView.NoBuilder +import TraversableView.NoBuilder /** A non-strict projection of an iterable. * @author Sean McDirmid @@ -21,6 +21,6 @@ import TraversibleView.NoBuilder trait MutableVectorView[A, +Coll <: mutable.Vector[_]] extends MutableVectorViewTemplate[A, Coll, MutableVectorView[A, Coll]] object MutableVectorView { - type Coll = TraversibleView[_, _] + type Coll = TraversableView[_, _] implicit def builderFactory[A]: BuilderFactory[A, MutableVectorView[A, mutable.Vector[_]], Coll] = new BuilderFactory[A, MutableVectorView[A, mutable.Vector[_]], Coll] { def apply(from: Coll) = new NoBuilder } } diff --git a/src/library/scala/collection/generic/MutableVectorViewTemplate.scala b/src/library/scala/collection/generic/MutableVectorViewTemplate.scala index 22b46472c7..e612111e8c 100755 --- a/src/library/scala/collection/generic/MutableVectorViewTemplate.scala +++ b/src/library/scala/collection/generic/MutableVectorViewTemplate.scala @@ -11,7 +11,7 @@ package scala.collection.generic -import TraversibleView.NoBuilder +import TraversableView.NoBuilder /** A non-strict projection of an iterable. * @author Sean McDirmid diff --git a/src/library/scala/collection/generic/SequenceFactory.scala b/src/library/scala/collection/generic/SequenceFactory.scala index cb2762c4d0..b3ae8c7dd2 100755 --- a/src/library/scala/collection/generic/SequenceFactory.scala +++ b/src/library/scala/collection/generic/SequenceFactory.scala @@ -2,7 +2,7 @@ package scala.collection.generic /** A template for companion objects of Sequence and subclasses thereof. */ -abstract class SequenceFactory[CC[A] <: Sequence[A]] extends TraversibleFactory[CC] { +abstract class SequenceFactory[CC[A] <: Sequence[A]] extends TraversableFactory[CC] { /** This method is called in a pattern match { case Sequence(...) => }. * diff --git a/src/library/scala/collection/generic/SequenceView.scala b/src/library/scala/collection/generic/SequenceView.scala index 56b15ac7dc..f9c26093cf 100755 --- a/src/library/scala/collection/generic/SequenceView.scala +++ b/src/library/scala/collection/generic/SequenceView.scala @@ -12,7 +12,7 @@ package scala.collection.generic import Sequence.fill -import TraversibleView.NoBuilder +import TraversableView.NoBuilder /** A non-strict projection of an iterable. * @author Sean McDirmid @@ -22,7 +22,7 @@ import TraversibleView.NoBuilder trait SequenceView[+A, +Coll <: Sequence[_]] extends SequenceViewTemplate[A, Coll, SequenceView[A, Coll]] object SequenceView { - type Coll = TraversibleView[_, _] + type Coll = TraversableView[_, _] implicit def builderFactory[A]: BuilderFactory[A, SequenceView[A, Sequence[_]], Coll] = new BuilderFactory[A, SequenceView[A, Sequence[_]], Coll] { def apply(from: Coll) = new NoBuilder } } diff --git a/src/library/scala/collection/generic/SequenceViewTemplate.scala b/src/library/scala/collection/generic/SequenceViewTemplate.scala index 39283763ea..943fd9a80e 100755 --- a/src/library/scala/collection/generic/SequenceViewTemplate.scala +++ b/src/library/scala/collection/generic/SequenceViewTemplate.scala @@ -12,7 +12,7 @@ package scala.collection.generic import Sequence.fill -import TraversibleView.NoBuilder +import TraversableView.NoBuilder /** A non-strict projection of an iterable. * @author Sean McDirmid @@ -133,9 +133,9 @@ trait SequenceViewTemplate[+A, /** Boilerplate method, to override in each subclass * This method could be eliminated if Scala had virtual classes */ - protected override def newAppended[B >: A](that: Traversible[B]): Transformed[B] = new Appended[B] { val rest = that } + 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 => Traversible[B]): Transformed[B] = new FlatMapped[B] { val mapping = f } + protected override def newFlatMapped[B](f: A => Traversable[B]): Transformed[B] = new FlatMapped[B] { val mapping = f } protected override def newFiltered(p: A => Boolean): Transformed[A] = new Filtered { val pred = p } protected override def newSliced(_from: Int, _until: Int): Transformed[A] = new Sliced { val from = _from; val until = _until } protected override def newDroppedWhile(p: A => Boolean): Transformed[A] = new DroppedWhile { val pred = p } diff --git a/src/library/scala/collection/generic/Shrinkable.scala b/src/library/scala/collection/generic/Shrinkable.scala index 1c4987b90b..937ec2097e 100755 --- a/src/library/scala/collection/generic/Shrinkable.scala +++ b/src/library/scala/collection/generic/Shrinkable.scala @@ -46,7 +46,7 @@ trait Shrinkable[-A] { * * @param iter the iterable object. */ - def --=(iter: Traversible[A]) { iter foreach -= } + def --=(iter: Traversable[A]) { iter foreach -= } } diff --git a/src/library/scala/collection/generic/Subtractable.scala b/src/library/scala/collection/generic/Subtractable.scala index 498b2faf5c..928ef939ae 100755 --- a/src/library/scala/collection/generic/Subtractable.scala +++ b/src/library/scala/collection/generic/Subtractable.scala @@ -46,7 +46,7 @@ trait Subtractable[A, +This <: Subtractable[A, This]] { self => * * @param iter the iterable object. */ - def --(iter: Traversible[A]): This = (thisCollection /: iter) (_ - _) + def --(iter: Traversable[A]): This = (thisCollection /: iter) (_ - _) /** Removes a number of elements provided by an iterator * via its <code>elements</code> method and returns diff --git a/src/library/scala/collection/generic/TraversibleFactory.scala b/src/library/scala/collection/generic/TraversableFactory.scala index 7d054c1b81..244e0859a1 100755 --- a/src/library/scala/collection/generic/TraversibleFactory.scala +++ b/src/library/scala/collection/generic/TraversableFactory.scala @@ -1,8 +1,8 @@ package scala.collection.generic -/** A template for companion objects of Traversible and subclasses thereof. +/** A template for companion objects of Traversable and subclasses thereof. */ -abstract class TraversibleFactory[CC[A] <: Traversible[A]] { +abstract class TraversableFactory[CC[A] <: Traversable[A]] { /** The builder for this kind of collection. */ @@ -23,7 +23,7 @@ abstract class TraversibleFactory[CC[A] <: Traversible[A]] { * @param xss the collections that are to be concatenated * @return the concatenation of all the collections */ - def concat[A](xss: Traversible[A]*): CC[A] = { + def concat[A](xss: Traversable[A]*): CC[A] = { val b = newBuilder[A] for (xs <- xss) b ++= xs b.result diff --git a/src/library/scala/collection/generic/TraversibleForwarder.scala b/src/library/scala/collection/generic/TraversableForwarder.scala index 855289d36c..219021f8e6 100755 --- a/src/library/scala/collection/generic/TraversibleForwarder.scala +++ b/src/library/scala/collection/generic/TraversableForwarder.scala @@ -14,22 +14,22 @@ package scala.collection.generic import mutable.Buffer // import immutable.{List, Nil, ::, Stream} -/** This trait implements a forwarder for traversible objects. It forwards +/** This trait implements a forwarder for traversable objects. It forwards * all calls to a different iterable object, except for * * - toString, hashCode, equals, stringPrefix * - newBuilder, view * - all calls creating a new iterable object of the same kind * - * The above methods are forwarded by subclass TraversibleProxy + * The above methods are forwarded by subclass TraversableProxy * * @author Martin Odersky * @version 2.8 */ -trait TraversibleForwarder[+A] extends Traversible[A] { +trait TraversableForwarder[+A] extends Traversable[A] { /** The iterable object to which calls are forwarded */ - protected def underlying: Traversible[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' diff --git a/src/library/scala/collection/generic/TraversibleProxyTemplate.scala b/src/library/scala/collection/generic/TraversableProxyTemplate.scala index 0c17aa4121..0cd955d50a 100755 --- a/src/library/scala/collection/generic/TraversibleProxyTemplate.scala +++ b/src/library/scala/collection/generic/TraversableProxyTemplate.scala @@ -16,22 +16,22 @@ import collection.mutable.Buffer // Methods could be printed by cat TraversibeTemplate.scala | egrep '^ (override )?def' -/** This trait implements a proxy for traversible objects. It forwards - * all calls to a different traversible object +/** This trait implements a proxy for traversable objects. It forwards + * all calls to a different traversable object * * @author Martin Odersky * @version 2.8 */ -trait TraversibleProxyTemplate[+A, +This <: TraversibleTemplate[A, This] with Traversible[A]] extends TraversibleTemplate[A, This] with Proxy { +trait TraversableProxyTemplate[+A, +This <: TraversableTemplate[A, This] with Traversable[A]] extends TraversableTemplate[A, This] with Proxy { def self: This override def isEmpty: Boolean = self.isEmpty override def size: Int = self.size override def hasDefiniteSize = self.hasDefiniteSize - override def ++[B >: A, That](that: Traversible[B])(implicit bf: BuilderFactory[B, That, This]): That = self.++(that)(bf) + override def ++[B >: A, That](that: Traversable[B])(implicit bf: BuilderFactory[B, That, This]): That = self.++(that)(bf) override def ++[B >: A, That](that: Iterator[B])(implicit bf: BuilderFactory[B, That, This]): That = self.++(that)(bf) override def map[B, That](f: A => B)(implicit bf: BuilderFactory[B, That, This]): That = self.map(f)(bf) - override def flatMap[B, That](f: A => Traversible[B])(implicit bf: BuilderFactory[B, That, This]): That = self.flatMap(f)(bf) + override def flatMap[B, That](f: A => Traversable[B])(implicit bf: BuilderFactory[B, That, This]): That = self.flatMap(f)(bf) override def filter(p: A => Boolean): This = self.filter(p) override def remove(p: A => Boolean): This = self.remove(p) override def partition(p: A => Boolean): (This, This) = self.partition(p) @@ -80,5 +80,5 @@ trait TraversibleProxyTemplate[+A, +This <: TraversibleTemplate[A, This] with Tr override def toString = self.toString override def stringPrefix : String = self.stringPrefix override def view = self.view - override def view(from: Int, until: Int): TraversibleView[A, This] = self.view(from, until) + override def view(from: Int, until: Int): TraversableView[A, This] = self.view(from, until) } diff --git a/src/library/scala/collection/generic/TraversibleTemplate.scala b/src/library/scala/collection/generic/TraversableTemplate.scala index 2ec74ba874..7378abda51 100755 --- a/src/library/scala/collection/generic/TraversibleTemplate.scala +++ b/src/library/scala/collection/generic/TraversableTemplate.scala @@ -6,14 +6,14 @@ ** |/ ** \* */ -// $Id: Traversible.scala 15188 2008-05-24 15:01:02Z stepancheg $ +// $Id: Traversable.scala 15188 2008-05-24 15:01:02Z stepancheg $ package scala.collection.generic // import immutable.{List, Stream, Nil} //!!! import mutable.{Buffer, ArrayBuffer, ListBuffer} import util.control.Breaks._ -/** A template trait for traversible collections. +/** A template trait for traversable collections. * * Collection classes mixing in this trait provide a method * <code>foreach</code> which traverses all the @@ -24,12 +24,12 @@ import util.control.Breaks._ * @author Martin Odersky * @version 2.8 */ -trait TraversibleTemplate[+A, +This <: TraversibleTemplate[A, This] with Traversible[A]] { +trait TraversableTemplate[+A, +This <: TraversableTemplate[A, This] with Traversable[A]] { self => protected def thisCollection: This = this.asInstanceOf[This] - /** Create a new builder for this traversible type. + /** Create a new builder for this traversable type. */ protected[this] def newBuilder: Builder[A, This, Any] @@ -61,19 +61,19 @@ self => */ def hasDefiniteSize = true - /** Creates a new traversible of type `That` which contains all elements of this traversible - * followed by all elements of another traversible + /** Creates a new traversable of type `That` which contains all elements of this traversable + * followed by all elements of another traversable * - * @param that The traversible to append + * @param that The traversable to append */ - def ++[B >: A, That](that: Traversible[B])(implicit bf: BuilderFactory[B, That, This]): That = { + def ++[B >: A, That](that: Traversable[B])(implicit bf: BuilderFactory[B, That, This]): That = { val b = bf(thisCollection) b ++= thisCollection b ++= that b.result } - /** Create a new traversible of type `That` which contains all elements of this traversible + /** Create a new traversable of type `That` which contains all elements of this traversable * followed by all elements of an iterator * * @param that The iterator to append @@ -85,13 +85,13 @@ self => b.result } - /** Returns the traversible that results from applying the given function - * <code>f</code> to each element of this traversible and collecing the results - * in an traversible of type `That`. + /** Returns the traversable that results from applying the given function + * <code>f</code> to each element of this traversable and collecing the results + * in an traversable of type `That`. * * @param f function to apply to each element. * @return <code>f(a<sub>0</sub>), ..., f(a<sub>n</sub>)</code> if this - * traversible is <code>a<sub>0</sub>, ..., a<sub>n</sub></code>. + * traversable is <code>a<sub>0</sub>, ..., a<sub>n</sub></code>. */ def map[B, That](f: A => B)(implicit bf: BuilderFactory[B, That, This]): That = { val b = bf(thisCollection) @@ -100,22 +100,22 @@ self => } /** Applies the given function <code>f</code> to each element of - * this traversible, then concatenates the results in an traversible of type CC. + * this traversable, then concatenates the results in an traversable of type CC. * * @param f the function to apply on each element. * @return <code>f(a<sub>0</sub>) ::: ... ::: f(a<sub>n</sub>)</code> if - * this traversible is <code>a<sub>0</sub>, ..., a<sub>n</sub></code>. + * this traversable is <code>a<sub>0</sub>, ..., a<sub>n</sub></code>. */ - def flatMap[B, That](f: A => Traversible[B])(implicit bf: BuilderFactory[B, That, This]): That = { + def flatMap[B, That](f: A => Traversable[B])(implicit bf: BuilderFactory[B, That, This]): That = { val b = bf(thisCollection) for (x <- this) b ++= f(x) b.result } - /** Returns all the elements of this traversible that satisfy the + /** Returns all the elements of this traversable that satisfy the * predicate <code>p</code>. The order of the elements is preserved. - * @param p the predicate used to filter the traversible. - * @return the elements of this traversible satisfying <code>p</code>. + * @param p the predicate used to filter the traversable. + * @return the elements of this traversable satisfying <code>p</code>. */ def filter(p: A => Boolean): This = { val b = newBuilder @@ -124,22 +124,22 @@ self => b.result } - /** Removes all elements of the traversible which satisfy the predicate + /** Removes all elements of the traversable which satisfy the predicate * <code>p</code>. This is like <code>filter</code> with the * predicate inversed. * * @param p the predicate used to test elements - * @return the traversible without all elements that satisfy <code>p</code> + * @return the traversable without all elements that satisfy <code>p</code> */ def remove(p: A => Boolean): This = filter(!p(_)) - /** Partitions this traversible in two traversibles according to a predicate. + /** Partitions this traversable in two traversables according to a predicate. * * @param p the predicate on which to partition - * @return a pair of traversibles: the traversible that satisfies the predicate - * <code>p</code> and the traversible that does not. - * The relative order of the elements in the resulting traversibles - * is the same as in the original traversible. + * @return a pair of traversables: the traversable that satisfies the predicate + * <code>p</code> and the traversable that does not. + * The relative order of the elements in the resulting traversables + * is the same as in the original traversable. */ def partition(p: A => Boolean): (This, This) = { val l, r = newBuilder @@ -147,7 +147,7 @@ self => (l.result, r.result) } - /** Partion this traversible into a map of traversibles + /** Partion this traversable into a map of traversables * according to some discriminator function. * @invariant (xs partition f)(k) = xs filter (x => f(x) == k) * @@ -169,7 +169,7 @@ self => } /** Apply a function <code>f</code> to all elements of this - * traversible object. + * traversable object. * * @param f a function that is applied to every element. * @note This method underlies the implementation of most other bulk operations. @@ -178,7 +178,7 @@ self => def foreach(f: A => Unit): Unit /** Return true iff the given predicate `p` yields true for all elements - * of this traversible. + * of this traversable. * * @note May not terminate for infinite-sized collections. * @param p the predicate @@ -192,7 +192,7 @@ self => result } - /** Return true iff there is an element in this traversible for which the + /** Return true iff there is an element in this traversable for which the * given predicate `p` yields true. * * @note May not terminate for infinite-sized collections. @@ -207,7 +207,7 @@ self => result } - /** Count the number of elements in the traversible which satisfy a predicate. + /** Count the number of elements in the traversable which satisfy a predicate. * * @note Will not terminate for infinite-sized collections. * @param p the predicate for which to count @@ -221,13 +221,13 @@ self => cnt } - /** Find and return the first element of the traversible object satisfying a + /** Find and return the first element of the traversable object satisfying a * predicate, if any. * * @note may not terminate for infinite-sized collections. - * @note Might return different results for different runs, unless this traversible is ordered. + * @note Might return different results for different runs, unless this traversable is ordered. * @param p the predicate - * @return an option containing the first element in the traversible object + * @return an option containing the first element in the traversable object * satisfying <code>p</code>, or <code>None</code> if none exists. */ def find(p: A => Boolean): Option[A] = { @@ -239,15 +239,15 @@ self => result } - /** Combines the elements of this traversible object together using the binary + /** Combines the elements of this traversable object together using the binary * function <code>f</code>, from left to right, and starting with * the value <code>z</code>. * * @note Will not terminate for infinite-sized collections. - * @note Might return different results for different runs, unless this traversible is ordered, or + * @note Might return different results for different runs, unless this traversable is ordered, or * the operator is associative and commutative. * @return <code>f(... (f(f(z, a<sub>0</sub>), a<sub>1</sub>) ...), - * a<sub>n</sub>)</code> if the traversible is + * a<sub>n</sub>)</code> if the traversable is * <code>[a<sub>0</sub>, a<sub>1</sub>, ..., a<sub>n</sub>]</code>. */ def foldLeft[B](z: B)(op: (B, A) => B): B = { @@ -258,10 +258,10 @@ self => } /** Similar to <code>foldLeft</code> but can be used as - * an operator with the order of traversible and zero arguments reversed. + * an operator with the order of traversable and zero arguments reversed. * That is, <code>z /: xs</code> is the same as <code>xs foldLeft z</code> * @note Will not terminate for infinite-sized collections. - * @note Might return different results for different runs, unless this traversible is ordered, or + * @note Might return different results for different runs, unless this traversable is ordered, or * the operator is associative and commutative. */ def /: [B](z: B)(op: (B, A) => B): B = foldLeft(z)(op) @@ -290,16 +290,16 @@ self => */ def :\ [B](z: B)(op: (A, B) => B): B = foldRight(z)(op) - /** Combines the elements of this traversible object together using the binary + /** Combines the elements of this traversable object together using the binary * operator <code>op</code>, from left to right * @note Will not terminate for infinite-sized collections. - * @note Might return different results for different runs, unless this traversible is ordered, or + * @note Might return different results for different runs, unless this traversable is ordered, or * the operator is associative and commutative. * @param op The operator to apply * @return <code>op(... op(a<sub>0</sub>,a<sub>1</sub>), ..., a<sub>n</sub>)</code> - if the traversible object has elements + if the traversable object has elements * <code>a<sub>0</sub>, a<sub>1</sub>, ..., a<sub>n</sub></code>. - * @throws Predef.UnsupportedOperationException if the traversible object is empty. + * @throws Predef.UnsupportedOperationException if the traversable object is empty. */ def reduceLeft[B >: A](op: (B, A) => B): B = { if (isEmpty) throw new UnsupportedOperationException("empty.reduceLeft") @@ -311,13 +311,13 @@ self => result } - /** Combines the elements of this traversible object together using the binary + /** Combines the elements of this traversable object together using the binary * operator <code>op</code>, from left to right * @note Will not terminate for infinite-sized collections. - * @note Might return different results for different runs, unless this traversible is ordered, or + * @note Might return different results for different runs, unless this traversable is ordered, or * the operator is associative and commutative. * @param op The operator to apply - * @return If the traversible is non-empty, the result of the operations as an Option, otherwise None. + * @return If the traversable is non-empty, the result of the operations as an Option, otherwise None. */ def reduceLeftOpt[B >: A](op: (B, A) => B): Option[B] = { if (isEmpty) None else Some(reduceLeft(op)) @@ -355,10 +355,10 @@ self => if (isEmpty) None else Some(reduceRight(op)) } - /** The first element of this traversible. + /** The first element of this traversable. * - * @note Might return different results for different runs, unless this traversible is ordered - * @throws Predef.NoSuchElementException if the traversible is empty. + * @note Might return different results for different runs, unless this traversable is ordered + * @throws Predef.NoSuchElementException if the traversable is empty. */ def head: A = { var result: () => A = () => throw new NoSuchElementException @@ -371,22 +371,22 @@ self => result() } - /** Returns as an option the first element of this traversible - * or <code>None</code> if traversible is empty. - * @note Might return different results for different runs, unless this traversible is ordered + /** Returns as an option the first element of this traversable + * or <code>None</code> if traversable is empty. + * @note Might return different results for different runs, unless this traversable is ordered */ def headOption: Option[A] = if (isEmpty) None else Some(head) - /** An traversible consisting of all elements of this traversible + /** An traversable consisting of all elements of this traversable * except the first one. - * @note Might return different results for different runs, unless this traversible is ordered + * @note Might return different results for different runs, unless this traversable is ordered */ def tail: This = drop(1) - /** The last element of this traversible. + /** The last element of this traversable. * - * @throws Predef.NoSuchElementException if the traversible is empty. - * @note Might return different results for different runs, unless this traversible is ordered + * @throws Predef.NoSuchElementException if the traversable is empty. + * @note Might return different results for different runs, unless this traversable is ordered */ def last: A = { var lst = head @@ -395,17 +395,17 @@ self => lst } - /** Returns as an option the last element of this traversible or - * <code>None</code> if traversible is empty. + /** Returns as an option the last element of this traversable or + * <code>None</code> if traversable is empty. * * @return the last element as an option. - * @note Might return different results for different runs, unless this traversible is ordered + * @note Might return different results for different runs, unless this traversable is ordered */ def lastOption: Option[A] = if (isEmpty) None else Some(last) - /** An traversible consisting of all elements of this traversible except the last one. + /** An traversable consisting of all elements of this traversable except the last one. * @throws Predef.UnsupportedOperationException if the stream is empty. - * @note Might return different results for different runs, unless this traversible is ordered + * @note Might return different results for different runs, unless this traversable is ordered */ def init: This = { if (isEmpty) throw new UnsupportedOperationException("empty.init") @@ -420,12 +420,12 @@ self => b.result } - /** Return an traversible consisting only of the first <code>n</code> - * elements of this traversible, or else the whole traversible, if it has less + /** Return an traversable consisting only of the first <code>n</code> + * elements of this traversable, or else the whole traversable, if it has less * than <code>n</code> elements. * * @param n the number of elements to take - * @note Might return different results for different runs, unless this traversible is ordered + * @note Might return different results for different runs, unless this traversable is ordered */ def take(n: Int): This = { val b = newBuilder @@ -440,13 +440,13 @@ self => b.result } - /** Returns this traversible without its <code>n</code> first elements - * If this traversible has less than <code>n</code> elements, the empty - * traversible is returned. + /** Returns this traversable without its <code>n</code> first elements + * If this traversable has less than <code>n</code> elements, the empty + * traversable is returned. * * @param n the number of elements to drop - * @return the new traversible - * @note Might return different results for different runs, unless this traversible is ordered + * @return the new traversable + * @note Might return different results for different runs, unless this traversable is ordered */ def drop(n: Int): This = { val b = newBuilder @@ -458,7 +458,7 @@ self => b.result } - /** A sub-traversible starting at index `from` + /** A sub-traversable starting at index `from` * and extending up to (but not including) index `until`. * * @note c.slice(from, to) is equivalent to (but possibly more efficient than) @@ -466,7 +466,7 @@ self => * * @param from The index of the first element of the returned subsequence * @param until The index of the element following the returned subsequence - * @note Might return different results for different runs, unless this traversible is ordered + * @note Might return different results for different runs, unless this traversable is ordered */ def slice(from: Int, until: Int): This = { val b = newBuilder @@ -481,11 +481,11 @@ self => b.result } - /** Returns the longest prefix of this traversible whose elements satisfy + /** Returns the longest prefix of this traversable whose elements satisfy * the predicate <code>p</code>. * * @param p the test predicate. - * @note Might return different results for different runs, unless this traversible is ordered + * @note Might return different results for different runs, unless this traversable is ordered */ def takeWhile(p: A => Boolean): This = { val b = newBuilder @@ -498,11 +498,11 @@ self => b.result } - /** Returns the longest suffix of this traversible whose first element + /** Returns the longest suffix of this traversable whose first element * does not satisfy the predicate <code>p</code>. * * @param p the test predicate. - * @note Might return different results for different runs, unless this traversible is ordered + * @note Might return different results for different runs, unless this traversable is ordered */ def dropWhile(p: A => Boolean): This = { val b = newBuilder @@ -514,13 +514,13 @@ self => b.result } - /** Returns a pair consisting of the longest prefix of the traversible whose - * elements all satisfy the given predicate, and the rest of the traversible. + /** Returns a pair consisting of the longest prefix of the traversable whose + * elements all satisfy the given predicate, and the rest of the traversable. * * @param p the test predicate - * @return a pair consisting of the longest prefix of the traversible whose - * elements all satisfy <code>p</code>, and the rest of the traversible. - * @note Might return different results for different runs, unless this traversible is ordered + * @return a pair consisting of the longest prefix of the traversable whose + * elements all satisfy <code>p</code>, and the rest of the traversable. + * @note Might return different results for different runs, unless this traversable is ordered */ def span(p: A => Boolean): (This, This) = { val l, r = newBuilder @@ -532,13 +532,13 @@ self => (l.result, r.result) } - /** Split the traversible at a given point and return the two parts thus + /** Split the traversable at a given point and return the two parts thus * created. * * @param n the position at which to split - * @return a pair of traversibles composed of the first <code>n</code> + * @return a pair of traversables composed of the first <code>n</code> * elements, and the other elements. - * @note Might return different results for different runs, unless this traversible is ordered + * @note Might return different results for different runs, unless this traversable is ordered */ def splitAt(n: Int): (This, This) = { val l, r = newBuilder @@ -550,7 +550,7 @@ self => (l.result, r.result) } - /** Copy all elements of this traversible to a given buffer + /** Copy all elements of this traversable to a given buffer * @note Will not terminate for infinite-sized collections. * @param dest The buffer to which elements are copied */ @@ -559,8 +559,8 @@ self => } /** Fills the given array <code>xs</code> with at most `len` elements of - * this traversible starting at position `start`. - * Copying will stop once either the end of the current traversible is reached or + * this traversable starting at position `start`. + * Copying will stop once either the end of the current traversable is reached or * `len` elements have been copied or the end of the array is reached. * * @note Will not terminate for infinite-sized collections. @@ -581,8 +581,8 @@ self => } /** Fills the given array <code>xs</code> with the elements of - * this traversible starting at position <code>start</code> - * until either the end of the current traversible or the end of array `xs` is reached. + * this traversable starting at position <code>start</code> + * until either the end of the current traversable or the end of array `xs` is reached. * * @note Will not terminate for infinite-sized collections. * @param xs the array to fill. @@ -593,7 +593,7 @@ self => copyToArray(xs, start, xs.length - start) } - /** Converts this traversible to a fresh Array containing all elements. + /** Converts this traversable to a fresh Array containing all elements. * @note Will not terminate for infinite-sized collections. */ def toArray[B >: A]: Array[B] = { @@ -602,34 +602,34 @@ self => result } - /** Returns a list with all elements of this traversible object. + /** Returns a list with all elements of this traversable object. * @note Will not terminate for infinite-sized collections. */ def toList: List[A] = (new ListBuffer[A] ++ thisCollection).toList - /** Returns an iterable with all elements in this traversible object. + /** Returns an iterable with all elements in this traversable object. * @note Will not terminate for infinite-sized collections. */ def toIterable: Iterable[A] = toStream - /** Returns a sequence with all elements in this traversible object. + /** Returns a sequence with all elements in this traversable object. * @note Will not terminate for infinite-sized collections. */ def toSequence: Sequence[A] = toList - /** Returns a stream with all elements in this traversible object. + /** Returns a stream with all elements in this traversable object. */ def toStream: Stream[A] = toList.toStream - /** Sort the traversible according to the comparison function + /** Sort the traversable according to the comparison function * <code><(e1: a, e2: a) => Boolean</code>, * which should be true iff <code>e1</code> is smaller than * <code>e2</code>. * The sort is stable. That is elements that are equal wrt `lt` appear in the - * same order in the sorted traversible as in the original. + * same order in the sorted traversable as in the original. * * @param lt the comparison function - * @return a traversible sorted according to the comparison function + * @return a traversable sorted according to the comparison function * <code><(e1: a, e2: a) => Boolean</code>. * @ex <pre> * List("Steve", "Tom", "John", "Bob") @@ -645,7 +645,7 @@ self => } */ - /** Returns a string representation of this traversible object. The resulting string + /** Returns a string representation of this traversable object. The resulting string * begins with the string <code>start</code> and is finished by the string * <code>end</code>. Inside, the string representations of elements (w.r.t. * the method <code>toString()</code>) are separated by the string @@ -655,29 +655,29 @@ self => * @param start starting string. * @param sep separator string. * @param end ending string. - * @return a string representation of this traversible object. + * @return a string representation of this traversable object. */ def mkString(start: String, sep: String, end: String): String = addString(new StringBuilder(), start, sep, end).toString - /** Returns a string representation of this traversible object. The string + /** Returns a string representation of this traversable object. The string * representations of elements (w.r.t. the method <code>toString()</code>) * are separated by the string <code>sep</code>. * * @param sep separator string. - * @return a string representation of this traversible object. + * @return a string representation of this traversable object. */ def mkString(sep: String): String = addString(new StringBuilder(), sep).toString - /** Returns a string representation of this traversible object. The string + /** Returns a string representation of this traversable object. The string * representations of elements (w.r.t. the method <code>toString()</code>) * follow each other without any separator string. */ def mkString: String = addString(new StringBuilder()).toString - /** Write all elements of this traversible into given string builder. + /** Write all elements of this traversable into given string builder. * The written text begins with the string <code>start</code> and is finished by the string * <code>end</code>. Inside, the string representations of elements (w.r.t. * the method <code>toString()</code>) are separated by the string @@ -718,14 +718,14 @@ self => string } - /** Creates a view of this traversible @see TraversibleView + /** Creates a view of this traversable @see TraversableView */ - def view = new TraversibleView[A, This] { + def view = new TraversableView[A, This] { protected lazy val underlying = self.thisCollection override def foreach(f: A => Unit) = self foreach f } - /** A sub-traversible starting at index `from` + /** A sub-traversable starting at index `from` * and extending up to (but not including) index `until`. * * @param from The index of the first element of the slice @@ -736,7 +736,7 @@ self => * @note Might return different results for different runs, unless this iterable is ordered * @note view(from, to) is equivalent to view.slice(from, to) */ - def view(from: Int, until: Int): TraversibleView[A, This] = view.slice(from, until) + def view(from: Int, until: Int): TraversableView[A, This] = view.slice(from, until) } diff --git a/src/library/scala/collection/generic/TraversibleView.scala b/src/library/scala/collection/generic/TraversableView.scala index 8c45e9690d..19dfc7e447 100755 --- a/src/library/scala/collection/generic/TraversibleView.scala +++ b/src/library/scala/collection/generic/TraversableView.scala @@ -8,22 +8,22 @@ package scala.collection.generic import Math.MAX_INT -import TraversibleView.NoBuilder +import TraversableView.NoBuilder -/** A base class for views of Traversible. +/** A base class for views of Traversable. * Every subclass has to implenment the foreach method * @author Martin Odersky * @version 2.8 */ -trait TraversibleView[+A, +Coll <: Traversible[_]] extends TraversibleViewTemplate[A, Coll, TraversibleView[A, Coll]] +trait TraversableView[+A, +Coll <: Traversable[_]] extends TraversableViewTemplate[A, Coll, TraversableView[A, Coll]] -object TraversibleView { - class NoBuilder[A] extends Builder[A, Nothing, TraversibleView[_, _]] { +object TraversableView { + class NoBuilder[A] extends Builder[A, Nothing, TraversableView[_, _]] { def +=(elem: A) {} def elements: Iterator[A] = Iterator.empty - def result() = throw new UnsupportedOperationException("TraversibleView.Builder.result") + def result() = throw new UnsupportedOperationException("TraversableView.Builder.result") def clear() {} } - type Coll = TraversibleView[_, _] - implicit def builderFactory[A]: BuilderFactory[A, TraversibleView[A, Traversible[_]], Coll] = new BuilderFactory[A, TraversibleView[A, Traversible[_]], Coll] { def apply(from: Coll) = new NoBuilder } + type Coll = TraversableView[_, _] + implicit def builderFactory[A]: BuilderFactory[A, TraversableView[A, Traversable[_]], Coll] = new BuilderFactory[A, TraversableView[A, Traversable[_]], Coll] { def apply(from: Coll) = new NoBuilder } } diff --git a/src/library/scala/collection/generic/TraversibleView.scala.1 b/src/library/scala/collection/generic/TraversableView.scala.1 index c0999f9b9c..a080c816fe 100755 --- a/src/library/scala/collection/generic/TraversibleView.scala.1 +++ b/src/library/scala/collection/generic/TraversableView.scala.1 @@ -8,15 +8,15 @@ package scalay.collection.generic import Math.MAX_INT -import TraversibleView.NoBuilder +import TraversableView.NoBuilder -/** A base class for views of Traversible. +/** A base class for views of Traversable. * Every subclass has to implenment the foreach method */ -abstract class TraversibleView[+A, +Coll <: Traversible[_]] extends Traversible[A] { +abstract class TraversableView[+A, +Coll <: Traversable[_]] extends Traversable[A] { self => - type This >: this.type <: TraversibleView[A, Coll] { type This = self.This } + type This >: this.type <: TraversableView[A, Coll] { type This = self.This } protected val thisCollection: This = this protected[this] def newBuilder: Builder[A, This, This] = @@ -27,7 +27,7 @@ self => b.result() } - trait Transformed[+B] extends TraversibleView[B, Coll] + trait Transformed[+B] extends TraversableView[B, Coll] /** pre: from >= 0 */ @@ -59,7 +59,7 @@ self => } trait FlatMapped[B] extends Transformed[B] { - protected[this] val mapping: A => Traversible[B] + protected[this] val mapping: A => Traversable[B] override def foreach(f: B => Unit) { for (x <- self) for (y <- mapping(x)) @@ -69,7 +69,7 @@ self => } trait Appended[B >: A] extends Transformed[B] { - protected[this] val rest: Traversible[B] + protected[this] val rest: Traversable[B] override def foreach(f: B => Unit) { for (x <- self) f(x) for (x <- rest) f(x) @@ -109,7 +109,7 @@ self => override def stringPrefix = self.stringPrefix+"D" } - override def ++[B >: A, That](that: Traversible[B])(implicit b: Builder[B, That, This]): That = + override def ++[B >: A, That](that: Traversable[B])(implicit b: Builder[B, That, This]): That = if (b.isInstanceOf[NoBuilder[_]]) newAppended(that).asInstanceOf[That] else super.++[B, That](that)(b) @@ -119,7 +119,7 @@ self => if (b.isInstanceOf[NoBuilder[_]]) newMapped(f).asInstanceOf[That] else super.map[B, That](f)(b) - override def flatMap[B, That](f: A => Traversible[B])(implicit b: Builder[B, That, This]): That = + override def flatMap[B, That](f: A => Traversable[B])(implicit b: Builder[B, That, This]): That = if (b.isInstanceOf[NoBuilder[_]]) newFlatMapped(f).asInstanceOf[That] else super.flatMap[B, That](f)(b) @@ -134,12 +134,12 @@ self => override def splitAt(n: Int): (This, This) = (take(n), drop(n)) } -object TraversibleView { - class NoBuilder[A] extends Builder[A, Nothing, TraversibleView[_, _]] { +object TraversableView { + class NoBuilder[A] extends Builder[A, Nothing, TraversableView[_, _]] { def +=(elem: A) {} def elements: Iterator[A] = Iterator.empty - def result() = throw new UnsupportedOperationException("TraversibleView.Builder.result") + def result() = throw new UnsupportedOperationException("TraversableView.Builder.result") def clear() {} } - implicit def implicitBuilder[A]: Builder[A, TraversibleView[A, Traversible[_]], TraversibleView[_, _]] = new NoBuilder + implicit def implicitBuilder[A]: Builder[A, TraversableView[A, Traversable[_]], TraversableView[_, _]] = new NoBuilder } diff --git a/src/library/scala/collection/generic/TraversibleViewTemplate.scala b/src/library/scala/collection/generic/TraversableViewTemplate.scala index 7cb84d5cfc..c235c20360 100755 --- a/src/library/scala/collection/generic/TraversibleViewTemplate.scala +++ b/src/library/scala/collection/generic/TraversableViewTemplate.scala @@ -8,17 +8,17 @@ package scala.collection.generic import Math.MAX_INT -import TraversibleView.NoBuilder +import TraversableView.NoBuilder -/** A base class for views of Traversible. +/** A base class for views of Traversable. * Every subclass has to implenment the foreach method * @author Martin Odersky * @version 2.8 */ -trait TraversibleViewTemplate[+A, - +Coll <: Traversible[_], - +This <: TraversibleView[A, Coll] with TraversibleViewTemplate[A, Coll, This]] - extends Traversible[A] with TraversibleTemplate[A, This] { +trait TraversableViewTemplate[+A, + +Coll <: Traversable[_], + +This <: TraversableView[A, Coll] with TraversableViewTemplate[A, Coll, This]] + extends Traversable[A] with TraversableTemplate[A, This] { self => override protected[this] def newBuilder: Builder[A, This, Any] = @@ -32,7 +32,7 @@ self => b.result() } - trait Transformed[+B] extends TraversibleView[B, Coll] { + trait Transformed[+B] extends TraversableView[B, Coll] { lazy val underlying = self.underlying } @@ -66,7 +66,7 @@ self => } trait FlatMapped[B] extends Transformed[B] { - protected[this] val mapping: A => Traversible[B] + protected[this] val mapping: A => Traversable[B] override def foreach(f: B => Unit) { for (x <- self) for (y <- mapping(x)) @@ -76,7 +76,7 @@ self => } trait Appended[B >: A] extends Transformed[B] { - protected[this] val rest: Traversible[B] + protected[this] val rest: Traversable[B] override def foreach(f: B => Unit) { for (x <- self) f(x) for (x <- rest) f(x) @@ -119,15 +119,15 @@ self => /** Boilerplate method, to override in each subclass * This method could be eliminated if Scala had virtual classes */ - protected def newAppended[B >: A](that: Traversible[B]): Transformed[B] = new Appended[B] { val rest = that } + 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 => Traversible[B]): Transformed[B] = new FlatMapped[B] { val mapping = f } + protected def newFlatMapped[B](f: A => Traversable[B]): Transformed[B] = new FlatMapped[B] { val mapping = f } protected def newFiltered(p: A => Boolean): Transformed[A] = new Filtered { val pred = p } protected def newSliced(_from: Int, _until: Int): Transformed[A] = new Sliced { val from = _from; val until = _until } protected def newDroppedWhile(p: A => Boolean): Transformed[A] = new DroppedWhile { val pred = p } protected def newTakenWhile(p: A => Boolean): Transformed[A] = new TakenWhile { val pred = p } - override def ++[B >: A, That](that: Traversible[B])(implicit bf: BuilderFactory[B, That, This]): That = { + override def ++[B >: A, That](that: Traversable[B])(implicit bf: BuilderFactory[B, That, This]): That = { val b = bf(thisCollection) if (b.isInstanceOf[NoBuilder[_]]) newAppended(that).asInstanceOf[That] else super.++[B, That](that)(bf) @@ -141,7 +141,7 @@ self => else super.map[B, That](f)(bf) } - override def flatMap[B, That](f: A => Traversible[B])(implicit bf: BuilderFactory[B, That, This]): That = { + override def flatMap[B, That](f: A => Traversable[B])(implicit bf: BuilderFactory[B, That, This]): That = { val b = bf(thisCollection) if (b.isInstanceOf[NoBuilder[_]]) newFlatMapped(f).asInstanceOf[That] else super.flatMap[B, That](f)(bf) diff --git a/src/library/scala/collection/generic/VectorView.scala b/src/library/scala/collection/generic/VectorView.scala index 5460ac9f70..703a6a7496 100755 --- a/src/library/scala/collection/generic/VectorView.scala +++ b/src/library/scala/collection/generic/VectorView.scala @@ -11,7 +11,7 @@ package scala.collection.generic -import TraversibleView.NoBuilder +import TraversableView.NoBuilder /** A non-strict projection of an iterable. * @author Sean McDirmid @@ -21,6 +21,6 @@ import TraversibleView.NoBuilder trait VectorView[+A, +Coll <: Vector[_]] extends VectorViewTemplate[A, Coll, VectorView[A, Coll]] object VectorView { - type Coll = TraversibleView[_, _] + type Coll = TraversableView[_, _] implicit def builderFactory[A]: BuilderFactory[A, VectorView[A, Vector[_]], Coll] = new BuilderFactory[A, VectorView[A, Vector[_]], Coll] { def apply(from: Coll) = new NoBuilder } } diff --git a/src/library/scala/collection/generic/VectorViewTemplate.scala b/src/library/scala/collection/generic/VectorViewTemplate.scala index e8744a3230..0d21b98691 100755 --- a/src/library/scala/collection/generic/VectorViewTemplate.scala +++ b/src/library/scala/collection/generic/VectorViewTemplate.scala @@ -11,7 +11,7 @@ package scala.collection.generic -import TraversibleView.NoBuilder +import TraversableView.NoBuilder /** A non-strict projection of an iterable. * @author Sean McDirmid @@ -66,9 +66,9 @@ trait VectorViewTemplate[+A, /** Boilerplate method, to override in each subclass * This method could be eliminated if Scala had virtual classes */ - protected override def newAppended[B >: A](that: Traversible[B]): Transformed[B] = new Appended[B] { val rest = that } + 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 => Traversible[B]): Transformed[B] = new FlatMapped[B] { val mapping = f } + protected override def newFlatMapped[B](f: A => Traversable[B]): Transformed[B] = new FlatMapped[B] { val mapping = f } protected override def newFiltered(p: A => Boolean): Transformed[A] = new Filtered { val pred = p } protected override def newSliced(_from: Int, _until: Int): Transformed[A] = new Sliced { val from = _from; val until = _until } protected override def newDroppedWhile(p: A => Boolean): Transformed[A] = new DroppedWhile { val pred = p } diff --git a/src/library/scala/collection/immutable/HashSet.scala b/src/library/scala/collection/immutable/HashSet.scala index d5ee878c76..281ae45a60 100644 --- a/src/library/scala/collection/immutable/HashSet.scala +++ b/src/library/scala/collection/immutable/HashSet.scala @@ -28,7 +28,7 @@ import generic._ class HashSet[A] extends Set[A] with SetTemplate[A, HashSet[A]] with mutable.FlatHashTable[A] { override def empty = HashSet.empty - override def traversibleBuilder[B]: Builder[B, HashSet[B], Any] = HashSet.newBuilder[B] + override def traversableBuilder[B]: Builder[B, HashSet[B], Any] = HashSet.newBuilder[B] protected var later: HashSet[A] = null protected var changedElem: A = _ @@ -132,7 +132,7 @@ class HashSet[A] extends Set[A] with SetTemplate[A, HashSet[A]] with mutable.Fla */ object HashSet extends SetFactory[HashSet] { type Coll = HashSet[_] - implicit def builderFactory[A]: BuilderFactory[A, HashSet[A], Coll] = new BuilderFactory[A, HashSet[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, HashSet[A], Coll] = new BuilderFactory[A, HashSet[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def empty[A]: HashSet[A] = new HashSet } diff --git a/src/library/scala/collection/immutable/Iterable.scala b/src/library/scala/collection/immutable/Iterable.scala index 602ee1fffb..70eea1db11 100755 --- a/src/library/scala/collection/immutable/Iterable.scala +++ b/src/library/scala/collection/immutable/Iterable.scala @@ -9,15 +9,15 @@ import generic._ * @autor Martin Odersky * @version 2.8 */ -trait Iterable[+A] extends Traversible[A] with collection.Iterable[A] with IterableTemplate[A, Iterable[A]] { self => +trait Iterable[+A] extends Traversable[A] with collection.Iterable[A] with IterableTemplate[A, Iterable[A]] { self => override protected[this] def newBuilder = Iterable.newBuilder - override def traversibleBuilder[B]: Builder[B, Iterable[B], Any] = Iterable.newBuilder[B] + override def traversableBuilder[B]: Builder[B, Iterable[B], Any] = Iterable.newBuilder[B] } /* A factory object for the trait `Iterable` */ -object Iterable extends TraversibleFactory[Iterable] { +object Iterable extends TraversableFactory[Iterable] { type Coll = Iterable[_] - implicit def builderFactory[A]: BuilderFactory[A, Iterable[A], Coll] = new BuilderFactory[A, Iterable[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, Iterable[A], Coll] = new BuilderFactory[A, Iterable[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def newBuilder[A]: Builder[A, Iterable[A], Any] = new mutable.ListBuffer } diff --git a/src/library/scala/collection/immutable/LinearSequence.scala b/src/library/scala/collection/immutable/LinearSequence.scala index 0508ecca29..7583c8c27b 100755 --- a/src/library/scala/collection/immutable/LinearSequence.scala +++ b/src/library/scala/collection/immutable/LinearSequence.scala @@ -7,11 +7,11 @@ import generic._ */ trait LinearSequence[+A] extends Sequence[A] with collection.LinearSequence[A] with LinearSequenceTemplate[A, LinearSequence[A]] { override protected[this] def newBuilder = LinearSequence.newBuilder - override def traversibleBuilder[B]: Builder[B, LinearSequence[B], Any] = LinearSequence.newBuilder[B] + override def traversableBuilder[B]: Builder[B, LinearSequence[B], Any] = LinearSequence.newBuilder[B] } object LinearSequence extends SequenceFactory[LinearSequence] { type Coll = LinearSequence[_] - implicit def builderFactory[A]: BuilderFactory[A, LinearSequence[A], Coll] = new BuilderFactory[A, LinearSequence[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, LinearSequence[A], Coll] = new BuilderFactory[A, LinearSequence[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def newBuilder[A]: Builder[A, LinearSequence[A], Any] = new mutable.ListBuffer } diff --git a/src/library/scala/collection/immutable/List.scala b/src/library/scala/collection/immutable/List.scala index 4670539917..503deecf06 100755 --- a/src/library/scala/collection/immutable/List.scala +++ b/src/library/scala/collection/immutable/List.scala @@ -25,7 +25,7 @@ import generic.{SequenceFactory, Builder, BuilderFactory, LinearSequenceTemplate */ sealed abstract class List[+A] extends LinearSequence[A] with Product with LinearSequenceTemplate[A, List[A]] { - import collection.{Iterable, Traversible, Sequence, Vector} + import collection.{Iterable, Traversable, Sequence, Vector} /** Returns true if the list does not contain any elements. * @return <code>true</code>, iff the list is empty. @@ -48,7 +48,7 @@ sealed abstract class List[+A] extends LinearSequence[A] with Product with Linea /** Creates a list buffer as builder for this class */ override protected[this] def newBuilder = List.newBuilder - override def traversibleBuilder[B]: Builder[B, List[B], Any] = List.newBuilder[B] + override def traversableBuilder[B]: Builder[B, List[B], Any] = List.newBuilder[B] // New methods in List @@ -141,9 +141,9 @@ sealed abstract class List[+A] extends LinearSequence[A] with Product with Linea // Overridden methods from IterableTemplate or overloaded variants of such methods /** Create a new list which contains all elements of this list - * followed by all elements of Traversible `that' + * followed by all elements of Traversable `that' */ - override def ++[B >: A, That](that: Traversible[B])(implicit bf: BuilderFactory[B, That, List[A]]): That = { + override def ++[B >: A, That](that: Traversable[B])(implicit bf: BuilderFactory[B, That, List[A]]): That = { val b = bf(this) if (b.isInstanceOf[ListBuffer[_]]) (this ::: that.toList).asInstanceOf[That] else super.++(that) diff --git a/src/library/scala/collection/immutable/ListSet.scala b/src/library/scala/collection/immutable/ListSet.scala index bf56a76f72..9e52b1b93e 100644 --- a/src/library/scala/collection/immutable/ListSet.scala +++ b/src/library/scala/collection/immutable/ListSet.scala @@ -16,7 +16,7 @@ import generic._ /** The canonical factory of <a href="ListSet.html">ListSet</a>'s */ object ListSet extends SetFactory[ListSet] { type Coll = ListSet[_] - implicit def builderFactory[A]: BuilderFactory[A, ListSet[A], Coll] = new BuilderFactory[A, ListSet[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, ListSet[A], Coll] = new BuilderFactory[A, ListSet[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def empty[A] = new ListSet[A] } @@ -41,7 +41,7 @@ class ListSet[A] extends Set[A] with SetTemplate[A, ListSet[A]] { self => override def isEmpty: Boolean = true; override def empty = ListSet.empty - override def traversibleBuilder[B]: Builder[B, ListSet[B], Any] = ListSet.newBuilder[B] + override def traversableBuilder[B]: Builder[B, ListSet[B], Any] = ListSet.newBuilder[B] /** Checks if this set contains element <code>elem</code>. * diff --git a/src/library/scala/collection/immutable/Sequence.scala b/src/library/scala/collection/immutable/Sequence.scala index 5265912e11..03fe64711a 100755 --- a/src/library/scala/collection/immutable/Sequence.scala +++ b/src/library/scala/collection/immutable/Sequence.scala @@ -14,13 +14,13 @@ import generic._ */ trait Sequence[+A] extends Iterable[A] with collection.Sequence[A] with SequenceTemplate[A, Sequence[A]] { override protected[this] def newBuilder = Sequence.newBuilder - override def traversibleBuilder[B]: Builder[B, Sequence[B], Any] = Sequence.newBuilder[B] + override def traversableBuilder[B]: Builder[B, Sequence[B], Any] = Sequence.newBuilder[B] override def hashCode = (Sequence.hashSeed /: this)(_ * 41 + _.hashCode) } object Sequence extends SequenceFactory[Sequence] { private val hashSeed = "Sequence".hashCode type Coll = Sequence[_] - implicit def builderFactory[A]: BuilderFactory[A, Sequence[A], Coll] = new BuilderFactory[A, Sequence[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, Sequence[A], Coll] = new BuilderFactory[A, Sequence[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def newBuilder[A]: Builder[A, Sequence[A], Any] = new mutable.ListBuffer } diff --git a/src/library/scala/collection/immutable/Set.scala b/src/library/scala/collection/immutable/Set.scala index 5819d38e03..f9f79db632 100644 --- a/src/library/scala/collection/immutable/Set.scala +++ b/src/library/scala/collection/immutable/Set.scala @@ -21,13 +21,13 @@ trait Set[A] extends Iterable[A] with collection.Set[A] with SetTemplate[A, Set[ override def hashCode = (Set.hashSeed /: this)(_ * 41 + _.hashCode) - override def traversibleBuilder[B]: Builder[B, Set[B], Any] = Set.newBuilder[B] + override def traversableBuilder[B]: Builder[B, Set[B], Any] = Set.newBuilder[B] } object Set extends SetFactory[Set] { private val hashSeed = "Set".hashCode type Coll = Set[_] - implicit def builderFactory[A]: BuilderFactory[A, Set[A], Coll] = new BuilderFactory[A, Set[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, Set[A], Coll] = new BuilderFactory[A, Set[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def empty[A]: Set[A] = FlexSet.empty } diff --git a/src/library/scala/collection/immutable/Stack.scala b/src/library/scala/collection/immutable/Stack.scala index 07ff59100f..7be6635853 100644 --- a/src/library/scala/collection/immutable/Stack.scala +++ b/src/library/scala/collection/immutable/Stack.scala @@ -68,14 +68,14 @@ class Stack[+A] extends Sequence[A] { def pushAll[B >: A](elems: Iterator[B]): Stack[B] = ((this: Stack[B]) /: elems)(_ push _) - /** Push all elements provided by the given traversible object onto + /** Push all elements provided by the given traversable object onto * the stack. The last element returned by the iterable object * will be on top of the new stack. * * @param elems the iterable object. * @return the stack with the new elements on top. */ - def pushAll[B >: A](elems: collection.Traversible[B]): Stack[B] = + def pushAll[B >: A](elems: collection.Traversable[B]): Stack[B] = ((this: Stack[B]) /: elems)(_ push _) /** Returns the top element of the stack. An error is signaled if diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala index 656252c282..20e71181e7 100755 --- a/src/library/scala/collection/immutable/Stream.scala +++ b/src/library/scala/collection/immutable/Stream.scala @@ -37,7 +37,7 @@ import generic.{SequenceFactory, Builder, BuilderFactory, LazyBuilder, LinearSeq */ abstract class Stream[+A] extends LinearSequence[A] with LinearSequenceTemplate[A, Stream[A]] { self => - import collection.{Traversible, Iterable, Sequence, Vector} + import collection.{Traversable, Iterable, Sequence, Vector} /** is this stream empty? */ def isEmpty: Boolean @@ -55,22 +55,22 @@ self => /** Is the tail of this stream defined? */ protected def tailDefined: Boolean - // Implementation of abstract method in Traversible + // Implementation of abstract method in Traversable /** The builder for stream objects. * @note: This builder is lazy only in the sense that it does not go downs the spine - * of traversibles taht are added as a whole. If more layzness can be achieved, + * of traversables taht are added as a whole. If more layzness can be achieved, * this builder should be bypassed. */ override protected[this] def newBuilder = Stream.newBuilder - override def traversibleBuilder[B]: Builder[B, Stream[B], Any] = Stream.newBuilder[B] + override def traversableBuilder[B]: Builder[B, Stream[B], Any] = Stream.newBuilder[B] // New methods in Stream /** The stream resulting from the concatenation of this stream with the argument stream. * @param rest The stream that gets appended to this stream */ - def append[B >: A](rest: => Traversible[B]): Stream[B] = + def append[B >: A](rest: => Traversable[B]): Stream[B] = if (isEmpty) rest.toStream else new Stream.Cons(head, tail append rest) /** Force evaluation of the whole stream and return it */ @@ -102,7 +102,7 @@ self => loop(this, "") } - // Overridden methods from Traversible + // Overridden methods from Traversable override def toStream: Stream[A] = this @@ -112,13 +112,13 @@ self => } /** Create a new stream which contains all elements of this stream - * followed by all elements of Traversible `that' + * followed by all elements of Traversable `that' * @note It's subtle why this works. We know that if the target type * of the Builder That is either a Stream, or one of its supertypes, or undefined, * then StreamBuilder will be chosen for the implicit. * we recognize that fact and optimize to get more laziness. */ - override def ++[B >: A, That](that: Traversible[B])(implicit bf: BuilderFactory[B, That, Stream[A]]): That = { + override def ++[B >: A, That](that: Traversable[B])(implicit bf: BuilderFactory[B, That, Stream[A]]): That = { def loop(these: Stream[A]): Stream[B] = if (these.isEmpty) that.toStream else new Stream.Cons(these.head, loop(these.tail)) if (bf.isInstanceOf[Stream.StreamBuilderFactory[_]]) loop(this).asInstanceOf[That] @@ -152,7 +152,7 @@ self => * @return <code>f(a<sub>0</sub>) ::: ... ::: f(a<sub>n</sub>)</code> if * this stream is <code>[a<sub>0</sub>, ..., a<sub>n</sub>]</code>. */ - override def flatMap[B, That](f: A => Traversible[B])(implicit bf: BuilderFactory[B, That, Stream[A]]): That = { + override def flatMap[B, That](f: A => Traversable[B])(implicit bf: BuilderFactory[B, That, Stream[A]]): That = { def loop(these: Stream[A]): Stream[B] = if (these.isEmpty) Stream.Empty else { @@ -368,7 +368,7 @@ self => object Stream extends SequenceFactory[Stream] { type Coll = Stream[_] - class StreamBuilderFactory[A] extends BuilderFactory[A, Stream[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + class StreamBuilderFactory[A] extends BuilderFactory[A, Stream[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } implicit def builderFactory[A]: BuilderFactory[A, Stream[A], Coll] = new StreamBuilderFactory[A] /** Creates a new builder for a stream */ diff --git a/src/library/scala/collection/immutable/Traversable.scala b/src/library/scala/collection/immutable/Traversable.scala new file mode 100755 index 0000000000..7adc2c3c6c --- /dev/null +++ b/src/library/scala/collection/immutable/Traversable.scala @@ -0,0 +1,24 @@ +package scala.collection.immutable + +import generic._ + +/** A subtrait of Traversable in package collection which represents traversables + * that cannot be mutated. + * !!! todo: revise equality + * @author Matthias Zenger + * @autor Martin Odersky + * @version 2.8 + */ +trait Traversable[+A] extends collection.Traversable[A] with TraversableTemplate[A, Traversable[A]] with Immutable { self => + override protected[this] def newBuilder = Traversable.newBuilder + override def traversableBuilder[B]: Builder[B, Traversable[B], Any] = Traversable.newBuilder[B] +} + +/* A factory object for the trait `Traversable` */ +object Traversable extends TraversableFactory[Traversable] { + type Coll = Traversable[_] + implicit def builderFactory[A]: BuilderFactory[A, Traversable[A], Coll] = new BuilderFactory[A, Traversable[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } + def newBuilder[A]: Builder[A, Traversable[A], Any] = new mutable.ListBuffer +} + + diff --git a/src/library/scala/collection/immutable/Traversible.scala b/src/library/scala/collection/immutable/Traversible.scala deleted file mode 100755 index 5236f59681..0000000000 --- a/src/library/scala/collection/immutable/Traversible.scala +++ /dev/null @@ -1,24 +0,0 @@ -package scala.collection.immutable - -import generic._ - -/** A subtrait of Traversible in package collection which represents traversibles - * that cannot be mutated. - * !!! todo: revise equality - * @author Matthias Zenger - * @autor Martin Odersky - * @version 2.8 - */ -trait Traversible[+A] extends collection.Traversible[A] with TraversibleTemplate[A, Traversible[A]] with Immutable { self => - override protected[this] def newBuilder = Traversible.newBuilder - override def traversibleBuilder[B]: Builder[B, Traversible[B], Any] = Traversible.newBuilder[B] -} - -/* A factory object for the trait `Traversible` */ -object Traversible extends TraversibleFactory[Traversible] { - type Coll = Traversible[_] - implicit def builderFactory[A]: BuilderFactory[A, Traversible[A], Coll] = new BuilderFactory[A, Traversible[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } - def newBuilder[A]: Builder[A, Traversible[A], Any] = new mutable.ListBuffer -} - - diff --git a/src/library/scala/collection/immutable/Vector.scala b/src/library/scala/collection/immutable/Vector.scala index 7bb76c5518..5267683d1f 100755 --- a/src/library/scala/collection/immutable/Vector.scala +++ b/src/library/scala/collection/immutable/Vector.scala @@ -15,7 +15,7 @@ import mutable.ArrayBuffer */ trait Vector[+A] extends Sequence[A] with collection.Vector[A] with VectorTemplate[A, Vector[A]] { self => override protected[this] def newBuilder = Vector.newBuilder - override def traversibleBuilder[B]: Builder[B, Vector[B], Any] = Vector.newBuilder[B] + override def traversableBuilder[B]: Builder[B, Vector[B], Any] = Vector.newBuilder[B] } object Vector extends SequenceFactory[Vector] { @@ -24,6 +24,6 @@ object Vector extends SequenceFactory[Vector] { def length = buf.length def apply(idx: Int) = buf.apply(idx) } - implicit def builderFactory[A]: BuilderFactory[A, Vector[A], Coll] = new BuilderFactory[A, Vector[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, Vector[A], Coll] = new BuilderFactory[A, Vector[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def newBuilder[A]: Builder[A, Vector[A], Any] = new ArrayBuffer[A] mapResult (buf => new Impl(buf)) } diff --git a/src/library/scala/collection/mutable/ArrayBuffer.scala b/src/library/scala/collection/mutable/ArrayBuffer.scala index 82864cc7ee..a6e37a1449 100644 --- a/src/library/scala/collection/mutable/ArrayBuffer.scala +++ b/src/library/scala/collection/mutable/ArrayBuffer.scala @@ -30,7 +30,7 @@ class ArrayBuffer[A](override protected val initialSize: Int) with Builder[A, ArrayBuffer[A], Any] with ResizableArray[A] { - import collection.Traversible + import collection.Traversable def this() = this(16) @@ -43,7 +43,7 @@ class ArrayBuffer[A](override protected val initialSize: Int) } override protected[this] def newBuilder = ArrayBuffer.newBuilder - override def traversibleBuilder[B]: Builder[B, ArrayBuffer[B], Any] = ArrayBuffer.newBuilder[B] + override def traversableBuilder[B]: Builder[B, ArrayBuffer[B], Any] = ArrayBuffer.newBuilder[B] /** Appends a single element to this buffer and returns * the identity of the buffer. It takes constant time. @@ -63,7 +63,7 @@ class ArrayBuffer[A](override protected val initialSize: Int) * @param iter the iterfable object. * @return the updated buffer. */ - override def ++=(iter: Traversible[A]) = iter match { + override def ++=(iter: Traversable[A]) = iter match { case v: Vector[_] => val n = v.length ensureSize(size0 + n) @@ -95,7 +95,7 @@ class ArrayBuffer[A](override protected val initialSize: Int) * @param iter the iterable object. * @return the updated buffer. */ - override def ++:(iter: Traversible[A]): this.type = { insertAll(0, iter); this } + override def ++:(iter: Traversable[A]): this.type = { insertAll(0, iter); this } /** Inserts new elements at the index <code>n</code>. Opposed to method * <code>update</code>, this method will not replace an element with a @@ -105,7 +105,7 @@ class ArrayBuffer[A](override protected val initialSize: Int) * @param iter the iterable object providing all elements to insert. * @throws Predef.IndexOutOfBoundsException if <code>n</code> is out of bounds. */ - def insertAll(n: Int, seq: Traversible[A]) { + def insertAll(n: Int, seq: Traversable[A]) { if ((n < 0) || (n > size0)) throw new IndexOutOfBoundsException(n.toString) val xs = seq.toList @@ -158,7 +158,7 @@ class ArrayBuffer[A](override protected val initialSize: Int) /* Factory object for `ArrayBuffer` class */ object ArrayBuffer extends SequenceFactory[ArrayBuffer] { type Coll = ArrayBuffer[_] - implicit def builderFactory[A]: BuilderFactory[A, ArrayBuffer[A], Coll] = new BuilderFactory[A, ArrayBuffer[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, ArrayBuffer[A], Coll] = new BuilderFactory[A, ArrayBuffer[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def newBuilder[A]: Builder[A, ArrayBuffer[A], Any] = new ArrayBuffer[A] } diff --git a/src/library/scala/collection/mutable/Buffer.scala b/src/library/scala/collection/mutable/Buffer.scala index 5fed53ae04..e020be6d6f 100644 --- a/src/library/scala/collection/mutable/Buffer.scala +++ b/src/library/scala/collection/mutable/Buffer.scala @@ -25,13 +25,13 @@ import generic._ @cloneable trait Buffer[A] extends Sequence[A] with BufferTemplate[A, Buffer[A]] { override protected[this] def newBuilder = Buffer.newBuilder - override def traversibleBuilder[B]: Builder[B, Buffer[B], Any] = Buffer.newBuilder[B] + override def traversableBuilder[B]: Builder[B, Buffer[B], Any] = Buffer.newBuilder[B] } /* Factory object for `Buffer` trait */ object Buffer extends SequenceFactory[Buffer] { type Coll = Buffer[_] - implicit def builderFactory[A]: BuilderFactory[A, Buffer[A], Coll] = new BuilderFactory[A, Buffer[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, Buffer[A], Coll] = new BuilderFactory[A, Buffer[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def newBuilder[A]: Builder[A, Buffer[A], Any] = new ArrayBuffer } diff --git a/src/library/scala/collection/mutable/DoubleLinkedList.scala b/src/library/scala/collection/mutable/DoubleLinkedList.scala index 6b8174357a..4463ab55a5 100644 --- a/src/library/scala/collection/mutable/DoubleLinkedList.scala +++ b/src/library/scala/collection/mutable/DoubleLinkedList.scala @@ -23,12 +23,12 @@ import generic._ @serializable class DoubleLinkedList[A]/*(_elem: A, _next: DoubleLinkedList[A])*/ extends LinearSequence[A] with DoubleLinkedListTemplate[A, DoubleLinkedList[A]] { override protected[this] def newBuilder = DoubleLinkedList.newBuilder - override def traversibleBuilder[B]: Builder[B, DoubleLinkedList[B], Any] = DoubleLinkedList.newBuilder[B] + override def traversableBuilder[B]: Builder[B, DoubleLinkedList[B], Any] = DoubleLinkedList.newBuilder[B] } object DoubleLinkedList extends SequenceFactory[DoubleLinkedList] { type Coll = DoubleLinkedList[_] - implicit def builderFactory[A]: BuilderFactory[A, DoubleLinkedList[A], Coll] = new BuilderFactory[A, DoubleLinkedList[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, DoubleLinkedList[A], Coll] = new BuilderFactory[A, DoubleLinkedList[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def newBuilder[A]: Builder[A, DoubleLinkedList[A], Any] = null // !!! } diff --git a/src/library/scala/collection/mutable/HashSet.scala b/src/library/scala/collection/mutable/HashSet.scala index 14f2d00013..b849f8f731 100644 --- a/src/library/scala/collection/mutable/HashSet.scala +++ b/src/library/scala/collection/mutable/HashSet.scala @@ -23,7 +23,7 @@ import generic._ class HashSet[A] extends Set[A] with SetTemplate[A, HashSet[A]] with FlatHashTable[A] { override def empty = HashSet.empty - override def traversibleBuilder[B]: Builder[B, HashSet[B], Any] = HashSet.newBuilder[B] + override def traversableBuilder[B]: Builder[B, HashSet[B], Any] = HashSet.newBuilder[B] override def size = super.size @@ -51,7 +51,7 @@ class HashSet[A] extends Set[A] with SetTemplate[A, HashSet[A]] with FlatHashTab /** Factory object for `HashSet` class */ object HashSet extends SetFactory[HashSet] { type Coll = HashSet[_] - implicit def builderFactory[A]: BuilderFactory[A, HashSet[A], Coll] = new BuilderFactory[A, HashSet[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, HashSet[A], Coll] = new BuilderFactory[A, HashSet[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def empty[A]: HashSet[A] = new HashSet[A] } diff --git a/src/library/scala/collection/mutable/Iterable.scala b/src/library/scala/collection/mutable/Iterable.scala index 52a42c5e09..f45f077cfd 100755 --- a/src/library/scala/collection/mutable/Iterable.scala +++ b/src/library/scala/collection/mutable/Iterable.scala @@ -15,15 +15,15 @@ import generic._ * @autor Martin Odersky * @version 2.8 */ -trait Iterable[A] extends Traversible[A] with collection.Iterable[A] with IterableTemplate[A, Iterable[A]] { self => +trait Iterable[A] extends Traversable[A] with collection.Iterable[A] with IterableTemplate[A, Iterable[A]] { self => override protected[this] def newBuilder = Iterable.newBuilder - override def traversibleBuilder[B]: Builder[B, Iterable[B], Any] = Iterable.newBuilder[B] + override def traversableBuilder[B]: Builder[B, Iterable[B], Any] = Iterable.newBuilder[B] } /* A factory object for the trait `Iterable` */ -object Iterable extends TraversibleFactory[Iterable] { +object Iterable extends TraversableFactory[Iterable] { type Coll = Iterable[_] - implicit def builderFactory[A]: BuilderFactory[A, Iterable[A], Coll] = new BuilderFactory[A, Iterable[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, Iterable[A], Coll] = new BuilderFactory[A, Iterable[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def newBuilder[A]: Builder[A, Iterable[A], Any] = new ArrayBuffer } diff --git a/src/library/scala/collection/mutable/LinearSequence.scala b/src/library/scala/collection/mutable/LinearSequence.scala index d31da40386..01f38cbe54 100755 --- a/src/library/scala/collection/mutable/LinearSequence.scala +++ b/src/library/scala/collection/mutable/LinearSequence.scala @@ -7,11 +7,11 @@ import generic._ */ trait LinearSequence[A] extends Sequence[A] with collection.LinearSequence[A] with LinearSequenceTemplate[A, LinearSequence[A]] { override protected[this] def newBuilder = LinearSequence.newBuilder - override def traversibleBuilder[B]: Builder[B, LinearSequence[B], Any] = LinearSequence.newBuilder[B] + override def traversableBuilder[B]: Builder[B, LinearSequence[B], Any] = LinearSequence.newBuilder[B] } object LinearSequence extends SequenceFactory[LinearSequence] { type Coll = LinearSequence[_] - implicit def builderFactory[A]: BuilderFactory[A, LinearSequence[A], Coll] = new BuilderFactory[A, LinearSequence[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, LinearSequence[A], Coll] = new BuilderFactory[A, LinearSequence[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def newBuilder[A]: Builder[A, LinearSequence[A], Any] = new MutableList[A] } diff --git a/src/library/scala/collection/mutable/LinkedList.scala b/src/library/scala/collection/mutable/LinkedList.scala index 8c8ebd3b0f..cba50294df 100644 --- a/src/library/scala/collection/mutable/LinkedList.scala +++ b/src/library/scala/collection/mutable/LinkedList.scala @@ -25,12 +25,12 @@ class LinkedList[A](_elem: A, _next: LinkedList[A]) extends LinearSequence[A] wi elem = _elem next = _next override protected[this] def newBuilder = LinkedList.newBuilder - override def traversibleBuilder[B]: Builder[B, LinkedList[B], Any] = LinkedList.newBuilder[B] + override def traversableBuilder[B]: Builder[B, LinkedList[B], Any] = LinkedList.newBuilder[B] } object LinkedList extends SequenceFactory[LinkedList] { type Coll = LinkedList[_] - implicit def builderFactory[A]: BuilderFactory[A, LinkedList[A], Coll] = new BuilderFactory[A, LinkedList[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, LinkedList[A], Coll] = new BuilderFactory[A, LinkedList[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def newBuilder[A]: Builder[A, LinkedList[A], Any] = (new MutableList) mapResult ((l: MutableList[A]) => l.toLinkedList) } diff --git a/src/library/scala/collection/mutable/ListBuffer.scala b/src/library/scala/collection/mutable/ListBuffer.scala index 9374afc3db..5713560ee8 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 Builder[A, List[A], Any] with SequenceForwarder[A] { - import collection.Traversible + import collection.Traversable private var start: List[A] = Nil private var last0: ::[A] = _ @@ -38,7 +38,7 @@ final class ListBuffer[A] protected def underlying: immutable.Sequence[A] = start override protected[this] def newBuilder = ListBuffer.newBuilder[A] - override def traversibleBuilder[B]: Builder[B, ListBuffer[B], Any] = ListBuffer.newBuilder[B] + override def traversableBuilder[B]: Builder[B, ListBuffer[B], Any] = ListBuffer.newBuilder[B] /** The current length of the buffer */ @@ -131,7 +131,7 @@ final class ListBuffer[A] * @param iter the iterable object providing all elements to insert. * @throws Predef.IndexOutOfBoundsException if <code>n</code> is out of bounds. */ - def insertAll(n: Int, seq: Traversible[A]) { + def insertAll(n: Int, seq: Traversable[A]) { try { if (exported) copy() var elems = seq.toList.reverse @@ -319,7 +319,7 @@ final class ListBuffer[A] /* Factory object for `ListBuffer` class */ object ListBuffer extends SequenceFactory[ListBuffer] { type Coll = ListBuffer[_] - implicit def builderFactory[A]: BuilderFactory[A, ListBuffer[A], Coll] = new BuilderFactory[A, ListBuffer[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, ListBuffer[A], Coll] = new BuilderFactory[A, ListBuffer[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def newBuilder[A]: Builder[A, ListBuffer[A], Any] = new AddingBuilder(new ListBuffer[A]) } diff --git a/src/library/scala/collection/mutable/ResizableArray.scala b/src/library/scala/collection/mutable/ResizableArray.scala index 1d260cc275..0193bdf4b6 100644 --- a/src/library/scala/collection/mutable/ResizableArray.scala +++ b/src/library/scala/collection/mutable/ResizableArray.scala @@ -26,7 +26,7 @@ trait ResizableArray[A] extends Vector[A] with VectorTemplate[A, ResizableArray[ import collection.Iterable // !!! override protected[this] def newBuilder = ResizableArray.newBuilder - override def traversibleBuilder[B]: Builder[B, ResizableArray[B], Any] = ResizableArray.newBuilder[B] + override def traversableBuilder[B]: Builder[B, ResizableArray[B], Any] = ResizableArray.newBuilder[B] protected def initialSize: Int = 16 protected var array: Array[AnyRef] = new Array[AnyRef](initialSize max 1) @@ -116,6 +116,6 @@ trait ResizableArray[A] extends Vector[A] with VectorTemplate[A, ResizableArray[ object ResizableArray extends SequenceFactory[ResizableArray] { type Coll = Vector[_] - implicit def builderFactory[A]: BuilderFactory[A, Vector[A], Coll] = new BuilderFactory[A, Vector[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, Vector[A], Coll] = new BuilderFactory[A, Vector[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def newBuilder[A]: Builder[A, ResizableArray[A], Any] = new ArrayBuffer[A] } diff --git a/src/library/scala/collection/mutable/Sequence.scala b/src/library/scala/collection/mutable/Sequence.scala index 01293924ac..04beb61535 100755 --- a/src/library/scala/collection/mutable/Sequence.scala +++ b/src/library/scala/collection/mutable/Sequence.scala @@ -15,13 +15,13 @@ import generic._ */ trait Sequence[A] extends Iterable[A] with collection.Sequence[A] with SequenceTemplate[A, Sequence[A]] with Unhashable { override protected[this] def newBuilder = Sequence.newBuilder - override def traversibleBuilder[B]: Builder[B, Sequence[B], Any] = Sequence.newBuilder[B] + override def traversableBuilder[B]: Builder[B, Sequence[B], Any] = Sequence.newBuilder[B] def update(idx: Int, elem: A) } object Sequence extends SequenceFactory[Sequence] { type Coll = Sequence[_] - implicit def builderFactory[A]: BuilderFactory[A, Sequence[A], Coll] = new BuilderFactory[A, Sequence[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, Sequence[A], Coll] = new BuilderFactory[A, Sequence[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def newBuilder[A]: Builder[A, Sequence[A], Any] = new ArrayBuffer } diff --git a/src/library/scala/collection/mutable/Set.scala b/src/library/scala/collection/mutable/Set.scala index d75b816564..c4b3013ce2 100644 --- a/src/library/scala/collection/mutable/Set.scala +++ b/src/library/scala/collection/mutable/Set.scala @@ -34,7 +34,7 @@ self => override def empty = Set.empty - override def traversibleBuilder[B]: Builder[B, Set[B], Any] = Set.newBuilder[B] + override def traversableBuilder[B]: Builder[B, Set[B], Any] = Set.newBuilder[B] /** This method allows one to add or remove an element <code>elem</code> * from this set depending on the value of parameter <code>included</code>. @@ -108,7 +108,7 @@ self => */ object Set extends SetFactory[Set] { type Coll = Set[_] - implicit def builderFactory[A]: BuilderFactory[A, Set[A], Coll] = new BuilderFactory[A, Set[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, Set[A], Coll] = new BuilderFactory[A, Set[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def empty[A]: Set[A] = HashSet.empty[A] } diff --git a/src/library/scala/collection/mutable/Stack.scala b/src/library/scala/collection/mutable/Stack.scala index 0d554e01da..2ad08c68c4 100644 --- a/src/library/scala/collection/mutable/Stack.scala +++ b/src/library/scala/collection/mutable/Stack.scala @@ -63,13 +63,13 @@ class Stack[A] private (var elems: List[A]) extends collection.Sequence[A] with def pushAll(elems: Iterator[A]): this.type = { for (elem <- elems) { push(elem); () }; this } /** Push all elements provided by the given iterable object onto - * the stack. The last element returned by the traversible object + * the stack. The last element returned by the traversable object * will be on top of the new stack. * * @param elems the iterable object. * @return the stack with the new elements on top. */ - def pushAll(elems: collection.Traversible[A]): this.type = { for (elem <- elems) { push(elem); () }; this } + def pushAll(elems: collection.Traversable[A]): this.type = { for (elem <- elems) { push(elem); () }; this } /** @deprecated use pushAll */ @deprecated def ++=(it: Iterator[A]): Unit = pushAll(it) diff --git a/src/library/scala/collection/mutable/SynchronizedBuffer.scala b/src/library/scala/collection/mutable/SynchronizedBuffer.scala index 03978d9d71..66dba50249 100644 --- a/src/library/scala/collection/mutable/SynchronizedBuffer.scala +++ b/src/library/scala/collection/mutable/SynchronizedBuffer.scala @@ -20,7 +20,7 @@ package scala.collection.mutable */ trait SynchronizedBuffer[A] extends Buffer[A] { - import collection.Traversible + import collection.Traversable abstract override def length: Int = synchronized { super.length @@ -57,7 +57,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] { * * @param iter the iterable object. */ - override def ++(iter: Traversible[A]): Buffer[A] = synchronized { + override def ++(iter: Traversable[A]): Buffer[A] = synchronized { super.++(iter) } @@ -66,7 +66,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] { * * @param iter the iterable object. */ - override def ++=(iter: Traversible[A]): Unit = synchronized { + override def ++=(iter: Traversable[A]): Unit = synchronized { super.++=(iter) } @@ -83,7 +83,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] { * * @param iter the iterable object. */ - override def appendAll(iter: Traversible[A]): Unit = synchronized { + override def appendAll(iter: Traversable[A]): Unit = synchronized { super.appendAll(iter) } @@ -102,7 +102,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] { * * @param iter the iterable object. */ - override def ++:(iter: Traversible[A]): Buffer[A] = synchronized { + override def ++:(iter: Traversable[A]): Buffer[A] = synchronized { super.++:(iter) } @@ -120,7 +120,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] { * * @param iter the iterable object. */ - override def prependAll(elems: Traversible[A]): Unit = synchronized { + override def prependAll(elems: Traversable[A]): Unit = synchronized { super.prependAll(elems) } @@ -142,7 +142,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] { * @param n the index where a new element will be inserted. * @param iter the iterable object providing all elements to insert. */ - abstract override def insertAll(n: Int, iter: Traversible[A]): Unit = synchronized { + abstract override def insertAll(n: Int, iter: Traversable[A]): Unit = synchronized { super.insertAll(n, iter) } diff --git a/src/library/scala/collection/mutable/SynchronizedMap.scala b/src/library/scala/collection/mutable/SynchronizedMap.scala index 6ca07f4fa5..6292b0daf0 100644 --- a/src/library/scala/collection/mutable/SynchronizedMap.scala +++ b/src/library/scala/collection/mutable/SynchronizedMap.scala @@ -21,7 +21,7 @@ package scala.collection.mutable */ trait SynchronizedMap[A, B] extends Map[A, B] { - import collection.Traversible + import collection.Traversable override def mapBuilder[A, B]: Builder[(A, B), SynchronizedMap[A, B], Any] = SynchronizedMap.newBuilder[A, B] @@ -86,7 +86,7 @@ trait SynchronizedMap[A, B] extends Map[A, B] { super.+=(kv1, kv2, kvs: _*) } - override def ++=(map: Traversible[(A, B)]): Unit = synchronized { + override def ++=(map: Traversable[(A, B)]): Unit = synchronized { super.++=(map) } @@ -102,7 +102,7 @@ trait SynchronizedMap[A, B] extends Map[A, B] { super.-=(key1, key2, keys: _*) } - override def --=(keys: Traversible[A]): Unit = synchronized { + override def --=(keys: Traversable[A]): Unit = synchronized { super.--=(keys) } diff --git a/src/library/scala/collection/mutable/SynchronizedQueue.scala b/src/library/scala/collection/mutable/SynchronizedQueue.scala index 7ef88e867f..0b3f870a9f 100644 --- a/src/library/scala/collection/mutable/SynchronizedQueue.scala +++ b/src/library/scala/collection/mutable/SynchronizedQueue.scala @@ -20,7 +20,7 @@ package scala.collection.mutable * @version 1.0, 03/05/2004 */ class SynchronizedQueue[A] extends Queue[A] { - import collection.Traversible + import collection.Traversable /** Checks if the queue is empty. * @@ -40,7 +40,7 @@ class SynchronizedQueue[A] extends Queue[A] { * * @param iter an iterable object */ - override def ++=(iter: Traversible[A]): Unit = synchronized { super.++=(iter) } + override def ++=(iter: Traversable[A]): Unit = synchronized { super.++=(iter) } /** Adds all elements provided by an iterator * at the end of the queue. The elements are prepended in the order they diff --git a/src/library/scala/collection/mutable/SynchronizedSet.scala b/src/library/scala/collection/mutable/SynchronizedSet.scala index f355e5879d..47396fdb84 100644 --- a/src/library/scala/collection/mutable/SynchronizedSet.scala +++ b/src/library/scala/collection/mutable/SynchronizedSet.scala @@ -19,7 +19,7 @@ package scala.collection.mutable * @version 1.0, 08/07/2003 */ trait SynchronizedSet[A] extends Set[A] { - import collection.Traversible + import collection.Traversable abstract override def size: Int = synchronized { super.size @@ -41,7 +41,7 @@ trait SynchronizedSet[A] extends Set[A] { super.+=(elem) } - override def ++=(that: Traversible[A]) = synchronized { + override def ++=(that: Traversable[A]) = synchronized { super.++=(that) } @@ -53,7 +53,7 @@ trait SynchronizedSet[A] extends Set[A] { super.-=(elem) } - override def --=(that: Traversible[A]) = synchronized { + override def --=(that: Traversable[A]) = synchronized { super.--=(that) } diff --git a/src/library/scala/collection/mutable/SynchronizedStack.scala b/src/library/scala/collection/mutable/SynchronizedStack.scala index 6d90f6a531..4c0f63cd76 100644 --- a/src/library/scala/collection/mutable/SynchronizedStack.scala +++ b/src/library/scala/collection/mutable/SynchronizedStack.scala @@ -20,7 +20,7 @@ package scala.collection.mutable * @version 1.0, 03/05/2004 */ class SynchronizedStack[A] extends Stack[A] { - import collection.Traversible + import collection.Traversable /** Checks if the stack is empty. * @@ -42,13 +42,13 @@ class SynchronizedStack[A] extends Stack[A] { */ override def push(elem1: A, elem2: A, elems: A*): this.type = synchronized[this.type] { super.push(elem1, elem2, elems: _*) } - /** Pushes all elements provided by an <code>Traversible</code> object + /** Pushes all elements provided by an <code>Traversable</code> object * on top of the stack. The elements are pushed in the order they * are given out by the iterator. * * @param iter an iterable object */ - override def pushAll(elems: collection.Traversible[A]): this.type = synchronized[this.type] { super.pushAll(elems) } + override def pushAll(elems: collection.Traversable[A]): this.type = synchronized[this.type] { super.pushAll(elems) } /** Pushes all elements provided by an iterator * on top of the stack. The elements are pushed in the order they diff --git a/src/library/scala/collection/mutable/Traversable.scala b/src/library/scala/collection/mutable/Traversable.scala new file mode 100755 index 0000000000..1f48205906 --- /dev/null +++ b/src/library/scala/collection/mutable/Traversable.scala @@ -0,0 +1,30 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2003-2009, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ +package scala.collection.mutable + +import generic._ + +/** A subtrait of collection.Traversable which represents traversables + * that can be mutated. + * + * @autor Martin Odersky + * @version 2.8 + */ +trait Traversable[A] extends collection.Traversable[A] with TraversableTemplate[A, Traversable[A]] with Mutable { self => + override protected[this] def newBuilder = Traversable.newBuilder + override def traversableBuilder[B]: Builder[B, Traversable[B], Any] = Traversable.newBuilder[B] +} + +/* A factory object for the trait `Traversable` */ +object Traversable extends TraversableFactory[Traversable] { + type Coll = Traversable[_] + implicit def builderFactory[A]: BuilderFactory[A, Traversable[A], Coll] = new BuilderFactory[A, Traversable[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } + def newBuilder[A]: Builder[A, Traversable[A], Any] = new ArrayBuffer +} + + diff --git a/src/library/scala/collection/mutable/Traversible.scala b/src/library/scala/collection/mutable/Traversible.scala deleted file mode 100755 index b177c9ca5d..0000000000 --- a/src/library/scala/collection/mutable/Traversible.scala +++ /dev/null @@ -1,30 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2009, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ -package scala.collection.mutable - -import generic._ - -/** A subtrait of collection.Traversible which represents traversibles - * that can be mutated. - * - * @autor Martin Odersky - * @version 2.8 - */ -trait Traversible[A] extends collection.Traversible[A] with TraversibleTemplate[A, Traversible[A]] with Mutable { self => - override protected[this] def newBuilder = Traversible.newBuilder - override def traversibleBuilder[B]: Builder[B, Traversible[B], Any] = Traversible.newBuilder[B] -} - -/* A factory object for the trait `Traversible` */ -object Traversible extends TraversibleFactory[Traversible] { - type Coll = Traversible[_] - implicit def builderFactory[A]: BuilderFactory[A, Traversible[A], Coll] = new BuilderFactory[A, Traversible[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } - def newBuilder[A]: Builder[A, Traversible[A], Any] = new ArrayBuffer -} - - diff --git a/src/library/scala/collection/mutable/Vector.scala b/src/library/scala/collection/mutable/Vector.scala index a253f4b64f..e3178475ad 100755 --- a/src/library/scala/collection/mutable/Vector.scala +++ b/src/library/scala/collection/mutable/Vector.scala @@ -14,11 +14,11 @@ import generic._ */ trait Vector[A] extends Sequence[A] with collection.Vector[A] with MutableVectorTemplate[A, Vector[A]] { override protected[this] def newBuilder = Vector.newBuilder - override def traversibleBuilder[B]: Builder[B, Vector[B], Any] = Vector.newBuilder[B] + override def traversableBuilder[B]: Builder[B, Vector[B], Any] = Vector.newBuilder[B] } object Vector extends SequenceFactory[Vector] { type Coll = Vector[_] - implicit def builderFactory[A]: BuilderFactory[A, Vector[A], Coll] = new BuilderFactory[A, Vector[A], Coll] { def apply(from: Coll) = from.traversibleBuilder[A] } + implicit def builderFactory[A]: BuilderFactory[A, Vector[A], Coll] = new BuilderFactory[A, Vector[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } def newBuilder[A]: Builder[A, Vector[A], Any] = new ArrayBuffer } diff --git a/src/library/scala/runtime/BoxedArray.scala b/src/library/scala/runtime/BoxedArray.scala index 61bf769c2f..4bb18f6d31 100644 --- a/src/library/scala/runtime/BoxedArray.scala +++ b/src/library/scala/runtime/BoxedArray.scala @@ -35,9 +35,9 @@ abstract class BoxedArray[A] extends Vector[A] with VectorTemplate[A, BoxedArray /** Creates new builder for this collection ==> move to subclasses * * */ - override protected[this] def newBuilder = traversibleBuilder[A] + override protected[this] def newBuilder = traversableBuilder[A] - override def traversibleBuilder[B]: Builder[B, BoxedArray[B], Any] = new ArrayBuffer[B].mapResult { + override def traversableBuilder[B]: Builder[B, BoxedArray[B], Any] = new ArrayBuffer[B].mapResult { _.toArray.asInstanceOf[BoxedArray[B]] } diff --git a/src/swing/scala/swing/BufferWrapper.scala b/src/swing/scala/swing/BufferWrapper.scala index ce97123aff..ad2f5d4278 100644 --- a/src/swing/scala/swing/BufferWrapper.scala +++ b/src/swing/scala/swing/BufferWrapper.scala @@ -11,7 +11,7 @@ protected[swing] abstract class BufferWrapper[A] extends Buffer[A] { outer => remove(0) insertAt(n, a) } - def insertAll(n: Int, elems: scala.collection.Traversible[A]) { + def insertAll(n: Int, elems: scala.collection.Traversable[A]) { var i = n for (el <- elems) { insertAt(i, el) |