another change to collection libraries

src/library/scala/Iterable.scala

@@ -91,14 +91,19 @@ trait Iterable[+A] {
   /** Appends two iterable objects
    *
    *  @return the new iterable object
+   *  @deprecated  use <code>++</code> instead
    */
-  def concat [B >: A](that: Iterable[B]): Iterable[B] = {
+  [deprecated] def concat [B >: A](that: Iterable[B]): Iterable[B] = {
     val buf = new ArrayBuffer[B]
     this copyToBuffer buf
     that copyToBuffer buf
     buf
   }
 
+  /** Appends two iterable objects
+   *
+   *  @return the new iterable object
+   */
   def ++ [B >: A](that: Iterable[B]): Iterable[B] = {
     val buf = new ArrayBuffer[B]
     this copyToBuffer buf

src/library/scala/Iterator.scala

@@ -248,12 +248,21 @@ trait Iterator[+A] {
 
   /** Returns a new iterator that first yields the elements of this
    *  iterator followed by the elements provided by iterator <code>that</code>.
+   *  @deprecated  use <code>++</code>
    */
   def append[B >: A](that: Iterator[B]) = new Iterator[B] {
     def hasNext = Iterator.this.hasNext || that.hasNext
     def next = if (Iterator.this.hasNext) Iterator.this.next else that.next
   }
 
+  /** Returns a new iterator that first yields the elements of this
+   *  iterator followed by the elements provided by iterator <code>that</code>.
+   */
+  def ++[B >: A](that: Iterator[B]) = new Iterator[B] {
+    def hasNext = Iterator.this.hasNext || that.hasNext
+    def next = if (Iterator.this.hasNext) Iterator.this.next else that.next
+  }
+
   /** Applies the given function <code>f</code> to each element of
    *  this iterator, then concatenates the results.
    *

src/library/scala/Predef.scala

@@ -61,6 +61,8 @@ object Predef {
 
   type Function[-a,+b] = Function1[a,b]
 
+  val Map = collection.mutable.Map
+  val Set = collection.mutable.Set
 
   // errors and asserts -------------------------------------------------
 

src/library/scala/Seq.scala

@@ -78,14 +78,19 @@ trait Seq[+A] extends AnyRef with PartialFunction[Int, A] with Iterable[A] {
   /** Appends two iterable objects
    *
    *  @return the new iterable object
+   *  @deprecated  use <code>++</code> instead
    */
-  override def concat [B >: A](that: Iterable[B]): Seq[B] = {
+  [deprecated] override def concat [B >: A](that: Iterable[B]): Seq[B] = {
     val buf = new ArrayBuffer[B]
     this copyToBuffer buf
     that copyToBuffer buf
     buf
   }
 
+  /** Appends two iterable objects
+   *
+   *  @return the new iterable object
+   */
   override def ++ [B >: A](that: Iterable[B]): Seq[B] = {
     val buf = new ArrayBuffer[B]
     this copyToBuffer buf

src/library/scala/collection/Map.scala

@@ -11,6 +11,8 @@
 
 package scala.collection
 
+import Predef._
+
 
 //import Predef.NoSuchElementException
 

src/library/scala/collection/immutable/ListMap.scala

@@ -24,7 +24,7 @@ object ListMap {
 
   /** The canonical factory for this type
    */
-  //def apply[A, B](elems: Pair[A, B]*) = empty[A, B] ++ elems
+  def apply[A, B](elems: Pair[A, B]*) = empty[A, B] ++ elems
 }
 
 /** This class implements immutable maps using a list-based data

src/library/scala/collection/immutable/ListSet.scala

@@ -27,7 +27,7 @@ object ListSet {
 
   /** The canonical factory for this type
    */
-//  def apply[A, B](elems: A*) = empty[A] ++ elems
+  def apply[A, B](elems: A*) = empty[A] ++ elems
 }
 
 

src/library/scala/collection/immutable/Map.scala

@@ -32,8 +32,17 @@ package scala.collection.immutable
  *  @author  Erik Stenman
  *  @author  Martin Odersky
  *  @version 1.2, 31/06/2006
- *  todo: make contravariant in A?
  */
+object Map {
+
+  /** The empty map of this type; this is implemented as a treemap */
+  def empty[A <% Ordered[A], B] = new TreeMap[A, B]
+
+  /** The canonical factory for this type
+   */
+  def apply[A <% Ordered[A], B](elems: Pair[A, B]*) = empty[A, B] ++ elems
+}
+
 trait Map[A, +B] extends collection.Map[A, B] {
 
   /** This method returns a new map instance of the same class

src/library/scala/collection/immutable/Set.scala

@@ -24,6 +24,16 @@ package scala.collection.immutable
  *  @author  Matthias Zenger
  *  @version 1.1, 03/05/2004
  */
+object Set {
+  /** The empty set of this type
+   */
+  def empty[A <% Ordered[A]] = new TreeSet[A]
+
+  /** The canonical factory for this type
+   */
+  def apply[A <% Ordered[A]](elems: A*) = empty[A] ++ elems
+}
+
 trait Set[A] extends AnyRef with collection.Set[A] {
 
   /** @return an empty set of arbitrary element type

src/library/scala/collection/immutable/TreeMap.scala

@@ -25,7 +25,7 @@ object TreeMap {
 
   /** The canonical factory for this type
    */
-//  def apply[A, B](elems: Pair[A, B]*) = empty[A, B] ++ elems
+  def apply[A <% Ordered[A], B](elems: Pair[A, B]*) = empty[A, B] ++ elems
 }
 
 /** This class implements immutable maps using a tree.

src/library/scala/collection/immutable/TreeSet.scala

@@ -21,6 +21,10 @@ object TreeSet {
   /** The empty set of this type
    */
   def empty[A <% Ordered[A]] = new TreeSet[A]
+
+  /** The canonical factory for this type
+   */
+  def apply[A <% Ordered[A]](elems: A*) = empty[A] ++ elems
 }
 
 /** This class implements immutable sets using a tree.

src/library/scala/collection/immutable/UnbalancedTreeMap.scala

@@ -14,7 +14,13 @@ package scala.collection.immutable
 
 
 object UnbalancedTreeMap {
-  def Empty[A <% Ordered[A], B] = new UnbalancedTreeMap[A, B]
+
+  /** The empty map of this type */
+  def empty[A <% Ordered[A], B] = new UnbalancedTreeMap[A, B]
+
+  /** The canonical factory for this type
+   */
+  def apply[A<% Ordered[A], B](elems: Pair[A, B]*) = empty[A, B] ++ elems
 }
 
 /** This class implements immutable maps using a tree.
@@ -28,7 +34,7 @@ class UnbalancedTreeMap[A <% Ordered[A], +B] extends Map[A, B] {
 
   /** A factory to create empty maps of the same type of keys.
    */
-  def empty[C] = UnbalancedTreeMap.Empty[A, C]
+  def empty[C] = UnbalancedTreeMap.empty[A, C]
 
   def size: Int = 0
 

src/library/scala/collection/mutable/DefaultMapModel.scala

@@ -11,6 +11,8 @@
 
 package scala.collection.mutable
 
+import Predef._
+
 /** This class is used internally. It implements the mutable <code>Map</code>
  *  class in terms of three functions: <code>findEntry</code>,
  *  <code>addEntry</code>, and <code>entries</code>.

src/library/scala/collection/mutable/HashMap.scala

@@ -11,12 +11,24 @@
 
 package scala.collection.mutable
 
+import Predef._
+
 /** This class implements mutable maps using a hashtable.
  *
  *  @author  Matthias Zenger
  *  @author  Martin Odersky
  *  @version 2.0, 31/12/2006
  */
+object HashMap {
+
+  /** The empty map of this type */
+  def empty[A, B] = new HashMap[A, B]
+
+  /** The canonical factory for this type
+   */
+  def apply[A, B](elems: Pair[A, B]*) = empty[A, B] ++ elems
+}
+
 [serializable]
 class HashMap[A, B] extends Map[A,B] with HashTable[A] with DefaultMapModel[A,B] {
 

src/library/scala/collection/mutable/HashSet.scala

@@ -14,8 +14,19 @@ package scala.collection.mutable
 /** This class implements mutable sets using a hashtable.
  *
  *  @author  Matthias Zenger
- *  @version 1.0, 08/07/2003
+ *  @author  Martin Odersky
+ *  @version 2.0, 31/12/2006
  */
+object HashSet {
+
+  /** The empty map of this type */
+  def empty[A] = new HashSet[A]
+
+  /** The canonical factory for this type
+   */
+  def apply[A](elems: A*) = empty[A] ++ elems
+}
+
 [serializable]
 class HashSet[A] extends Set[A] with HashTable[A] {
 

src/library/scala/collection/mutable/Map.scala

@@ -11,6 +11,8 @@
 
 package scala.collection.mutable
 
+import Predef._
+
 //import Predef.UnsupportedOperationException
 
 /** This class represents mutable maps. Concrete map implementations
@@ -19,8 +21,20 @@ package scala.collection.mutable
  *  and <code>-=</code>.
  *
  *  @author  Matthias Zenger
- *  @version 1.1, 09/05/2004
+ *  @author  Martin Odersky
+ *  @version 2.0, 31/12/2006
  */
+
+object Map {
+
+  /** The empty map of this type; this is implemented as a hashtable */
+  def empty[A, B] = new HashMap[A, B]
+
+  /** The canonical factory for this type
+   */
+  def apply[A, B](elems: Pair[A, B]*) = empty[A, B] ++ elems
+}
+
 [cloneable]
 trait Map[A, B] extends AnyRef
       with collection.Map[A, B]

src/library/scala/collection/mutable/Set.scala

@@ -21,6 +21,16 @@ package scala.collection.mutable
  *  @author  Matthias Zenger
  *  @version 1.1, 09/05/2004
  */
+object Set {
+
+  /** The empty map of this type; this is implemented as a hashtable */
+  def empty[A] = new HashSet[A]
+
+  /** The canonical factory for this type
+   */
+  def apply[A](elems: A*) = empty[A] ++ elems
+}
+
 [cloneable]
 trait Set[A] extends collection.Set[A] with Scriptable[Message[A]] {
 
@@ -120,7 +130,7 @@ trait Set[A] extends collection.Set[A] with Scriptable[Message[A]] {
    *
    *  @param elem the element to be removed
    */
-  def - (elem: A) { -=(elem); this }
+  def - (elem: A): Set[A] = { -=(elem); this }
 
   /** Remove two or more elements from this set.
    *  @param    elem1 the first element.