changes to maps and sets

38 files changed, 322 insertions, 228 deletions

diff --git a/src/library/scala/collection/DefaultMap.scala b/src/library/scala/collection/DefaultMap.scala
index ec83382660..fe5b7a2c1b 100644
--- a/src/library/scala/collection/DefaultMap.scala
+++ b/src/library/scala/collection/DefaultMap.scala
@@ -13,7 +13,7 @@ package scala.collection
 
 import generic._
 
-/* A default map which implements the `updated` and `minus` methods of maps.
+/* A default map which implements the `updated` and `-` methods of maps.
  * Instances that inherit from DefaultMap[A, B] still have to define:
  *
  *   def get(key: A): Option[B]
@@ -28,10 +28,18 @@ trait DefaultMap[A, +B] extends Map[A, B] { self =>
 
   /** A default implementation which creates a new immutable map.
    */
-  override def updated[B1 >: B](key: A, value: B1): Map[A, B1] =
-    Map[A, B1]() ++ this + ((key, value))
+  override def +[B1 >: B](kv: (A, B1)): Map[A, B1] = {
+    val b = Map.newBuilder[A, B1]
+    b ++= this
+    b += ((kv._1, kv._2))
+    b.result
+  }
 
   /** A default implementation which creates a new immutable map.
    */
-  override def minus (key: A): Map[A, B] = Map[A, B]() ++ this - key
+  override def - (key: A): Map[A, B] = {
+    val b = newBuilder
+    b ++= this filter (key !=)
+    b.result
+  }
 }
diff --git a/src/library/scala/collection/JavaConversions.scala b/src/library/scala/collection/JavaConversions.scala
index 698d1579c5..3801fbb4cd 100644
--- a/src/library/scala/collection/JavaConversions.scala
+++ b/src/library/scala/collection/JavaConversions.scala
@@ -393,9 +393,11 @@ object JavaConversions {
 
     def contains(elem: A): Boolean = underlying.contains(elem)
 
-    def put(elem: A): Boolean = underlying.add(elem)
+    def +=(elem: A): this.type = { underlying.add(elem); this }
+    def -=(elem: A): this.type = { underlying.remove(elem); this }
 
-    def remove(elem: A): Boolean = underlying.remove(elem)
+    override def put(elem: A): Boolean = underlying.add(elem)
+    override def remove(elem: A): Boolean = underlying.remove(elem)
 
     override def clear = underlying.clear
 
@@ -467,6 +469,9 @@ object JavaConversions {
         None
     }
 
+    def +=(kv: (A, B)): this.type = { underlying.put(kv._1, kv._2); this }
+    def -=(key: A): this.type = { underlying.remove(key); this }
+
     override def put(k : A, v : B): Option[B] = {
       val r = underlying.put(k, v)
       if (r != null) Some(r) else None
@@ -479,8 +484,6 @@ object JavaConversions {
       if (r != null) Some(r) else None
     }
 
-    override def delete(k : A) { underlying.remove(k) }
-
     def elements = new Iterator[(A, B)] {
       val ui = underlying.entrySet.iterator
       def hasNext = ui.hasNext
diff --git a/src/library/scala/collection/Map.scala b/src/library/scala/collection/Map.scala
index 4028fe870d..3544c195dd 100644
--- a/src/library/scala/collection/Map.scala
+++ b/src/library/scala/collection/Map.scala
@@ -19,8 +19,8 @@ import generic._
  *
  *   def get(key: A): Option[B]
  *   def elements: Iterator[(A, B)]
- *   def updated[B1 >: B](key: A, value: B1): This
- *   def minus(key: A): This
+ *   def + [B1 >: B](kv: (A, B1)): This
+ *   def -(key: A): This
  *
  * If you wish that methods like, take, drop, filter return the same kind of map, you should also
  * override:
diff --git a/src/library/scala/collection/Traversable.scala b/src/library/scala/collection/Traversable.scala
index 1150a88728..39a7a188f0 100644
--- a/src/library/scala/collection/Traversable.scala
+++ b/src/library/scala/collection/Traversable.scala
@@ -95,7 +95,8 @@ object Traversable extends TraversableFactory[Traversable] { self =>
 
   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] }
+  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]] = immutable.Traversable.newBuilder[A]
 
diff --git a/src/library/scala/collection/generic/Addable.scala b/src/library/scala/collection/generic/Addable.scala
index db580c3771..56bfe4bd49 100644
--- a/src/library/scala/collection/generic/Addable.scala
+++ b/src/library/scala/collection/generic/Addable.scala
@@ -24,15 +24,15 @@ trait Addable[A, +This <: Addable[A, This]] { self =>
    *  @param elem the element to be added
    *  @return a fresh collection
    */
-  def plus(elem: A): This
+  def +(elem: A): This
 
   /** Creates a new collection with an additional element, unless the element is already present.
    *  @param elem the element to be added
    *  @return a fresh collection
    *
-   *  @note  same as `plus`
+   *  @note  same as `+`
    */
-  def + (elem: A): This = plus(elem)
+  def plus (elem: A): This = this.+(elem)
 
   /** Adds two or more elements to this collection and returns
    *  a new collection.
@@ -41,8 +41,8 @@ trait Addable[A, +This <: Addable[A, This]] { self =>
    *  @param elem2 the second element to add.
    *  @param elems the remaining elements to add.
    */
-  def plus (elem1: A, elem2: A, elems: A*): This =
-    this plus elem1 plus elem2 plusAll Iterable.fromOld(elems)
+  def + (elem1: A, elem2: A, elems: A*): This =
+    this + elem1 + elem2 ++ Iterable.fromOld(elems)
 
   /** Adds two or more elements to this collection and returns
    *  a new collection.
@@ -50,16 +50,16 @@ trait Addable[A, +This <: Addable[A, This]] { self =>
    *  @param elem1 the first element to add.
    *  @param elem2 the second element to add.
    *  @param elems the remaining elements to add.
-   *  @note  same as `plus`
+   *  @note  same as `+`
    */
-  def + (elem1: A, elem2: A, elems: A*): This = plus(elem1, elem2, elems: _*)
+  def plus (elem1: A, elem2: A, elems: A*): This = this.+(elem1, elem2, elems: _*)
 
   /** Adds a number of elements provided by a traversable object
    *  and returns a new collection with the added elements.
    *
    *  @param elems     the traversable object.
    */
-  def plusAll(elems: Traversable[A]): This = (thisCollection /: elems) (_ plus _)
+  def ++(elems: Traversable[A]): This = (thisCollection /: elems) (_ + _)
 
   /** Adds a number of elements provided by a traversable object
    *  and returns a new collection with the added elements.
@@ -70,14 +70,14 @@ trait Addable[A, +This <: Addable[A, This]] { self =>
    *         the type of the added elements is a subtype of the element type of the
    *         collection.
    */
-  def ++ (elems: Traversable[A]): This = plusAll(elems)
+  def plusAll (elems: Traversable[A]): This = this.++(elems)
 
   /** Adds a number of elements provided by an iterator
    *  and returns a new collection with the added elements.
    *
    *  @param iter   the iterator
    */
-  def plusAll (iter: Iterator[A]): This = (thisCollection /: iter) (_ plus _)
+  def ++ (iter: Iterator[A]): This = (thisCollection /: iter) (_ + _)
 
   /** Adds a number of elements provided by an iterator
    *  and returns a new collection with the added elements.
@@ -88,7 +88,7 @@ trait Addable[A, +This <: Addable[A, This]] { self =>
    *         the type of the added elements is a subtype of the element type of the
    *         collection.
    */
-  def ++ (iter: Iterator[A]): This = plusAll(iter)
+  def plusAll (iter: Iterator[A]): This = this.++(iter)
 
 }
 
diff --git a/src/library/scala/collection/generic/BufferTemplate.scala b/src/library/scala/collection/generic/BufferTemplate.scala
index 56ae754ec7..981da34d02 100644
--- a/src/library/scala/collection/generic/BufferTemplate.scala
+++ b/src/library/scala/collection/generic/BufferTemplate.scala
@@ -114,13 +114,22 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
     this
   }
 
-  /** Returns a new buffer which contains the elements of this buffer, plus
-   *  the given element appended at the end */
-  def plus(elem: A): This = clone() += elem
-
-  /** Returns a new buffer which contains the elements of this buffer, plus
-   *  except that the given element is removed */
-  def minus (elem: A): This = { -=(elem); thisCollection }
+  /** Perform a += on a clone of this collection */
+  override def plus(elem: A): This = clone() += elem
+  /** Perform a += on a clone of this collection */
+  override def plus(elem1: A, elem2: A, elems: A*): This = clone() += (elem1, elem2, elems: _*)
+  /** Perform a -= on a clone of this collection */
+  override def minus(elem: A): This = clone() -= elem
+  /** Perform a -= on a clone of this collection */
+  override def minus(elem1: A, elem2: A, elems: A*): This = clone() -= (elem1, elem2, elems: _*)
+  /** Perform a ++= on a clone of this collection */
+  override def plusAll(elems: Traversable[A]): This = clone() ++= elems
+  /** Perform a ++= on a clone of this collection */
+  override def plusAll(elems: Iterator[A]): This = clone() ++= elems
+  /** Perform a --= on a clone of this collection */
+  override def minusAll(elems: Traversable[A]): This = clone() --= elems
+  /** Perform a --= on a clone of this collection */
+  override def minusAll(elems: Iterator[A]): This = clone() --= elems
 
   /** Prepend two ore more elements to this buffer and return
    *  the identity of the buffer.
@@ -131,7 +140,7 @@ trait BufferTemplate[A, +This <: BufferTemplate[A, This] with Buffer[A]]
 
   /** Prepends a number of elements provided by an iterable object
    *  via its <code>elements</code> method. The identity of the
-   *  buffer is returned.
+   *  buffer is returned.(thisCollection /: elems) (_ plus _)
    *
    *  @param iter  the iterable object.
    */
diff --git a/src/library/scala/collection/generic/ImmutableMapTemplate.scala b/src/library/scala/collection/generic/ImmutableMapTemplate.scala
index 165cc365f7..db1b232d1b 100644
--- a/src/library/scala/collection/generic/ImmutableMapTemplate.scala
+++ b/src/library/scala/collection/generic/ImmutableMapTemplate.scala
@@ -17,8 +17,8 @@ package scala.collection.generic
  *
  *   def get(key: A): Option[B]
  *   def elements: Iterator[(A, B)]
- *   def updated(key: A, value: B): This
- *   def minus(key: A): This
+ *   def + [B1 >: B](kv: (A, B)): Map[A, B1]
+ *   def - (key: A): This
  *
  * If you wish that methods like, take, drop, filter return the same kind of map, you should also
  * override:
@@ -38,20 +38,20 @@ self =>
    *  @param    value the value
    *  @return   A new map with the new key/value mapping
    */
-  def updated [B1 >: B](key: A, value: B1): immutable.Map[A, B1]
+  override def updated [B1 >: B](key: A, value: B1): immutable.Map[A, B1] = this + ((key, value))
 
   /** Add a key/value pair to this map, returning a new map.
    *  @param    kv the key/value pair
    *  @return   A new map with the new binding added to this map
    */
-  override def plus [B1 >: B] (kv: (A, B1)): immutable.Map[A, B1] = updated(kv._1, kv._2)
+  override def plus [B1 >: B] (kv: (A, B1)): immutable.Map[A, B1] = this + kv
 
   /** Add a key/value pair to this map, returning a new map.
    *  @param    kv the key/value pair
    *  @return   A new map with the new binding added to this map
    *  @note  same as `plus`
    */
-  override def + [B1 >: B] (kv: (A, B1)): immutable.Map[A, B1] = updated(kv._1, kv._2)
+  def + [B1 >: B] (kv: (A, B1)): immutable.Map[A, B1]
 
   /** Adds two or more elements to this collection and returns
    *  a new collection.
@@ -60,8 +60,8 @@ self =>
    *  @param elem2 the second element to add.
    *  @param elems the remaining elements to add.
    */
-  override def plus [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *): immutable.Map[A, B1] =
-    this plus elem1 plus elem2 plusAll elems
+  override def + [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *): immutable.Map[A, B1] =
+    this + elem1 + elem2 ++ elems
 
   /** Adds two or more elements to this collection and returns
    *  a new collection.
@@ -70,48 +70,48 @@ self =>
    *  @param elem2 the second element to add.
    *  @param elems the remaining elements to add.
    */
-  override def + [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *): immutable.Map[A, B1] =
-    plus(elem1, elem2, elems: _*)
+  override def plus [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *): immutable.Map[A, B1] =
+    this.+(elem1, elem2, elems: _*)
 
   /** Adds a number of elements provided by a traversable object
    *  and returns a new collection with the added elements.
    *
    *  @param elems     the traversable object.
    */
-  override def plusAll[B1 >: B](elems: Traversable[(A, B1)]): immutable.Map[A, B1] =
-    ((thisCollection: immutable.Map[A, B1]) /: elems) (_ plus _)
+  override def ++[B1 >: B](elems: Traversable[(A, B1)]): immutable.Map[A, B1] =
+    ((thisCollection: immutable.Map[A, B1]) /: elems) (_ + _)
 
   /** Adds a number of elements provided by a traversable object
    *  and returns a new collection with the added elements.
    *
    *  @param elems     the traversable object.
-   *  @note  same as `plusAll`
+   *  @note  same as `++`
    *  @note  This is a more efficient version of Traversable.++ which avoids
    *         copying of the collection's elements. However, it applies only if
    *         the type of the added elements is a subtype of the element type of the
    *         collection.
    */
-  override def ++ [B1 >: B](elems: Traversable[(A, B1)]): immutable.Map[A, B1] = plusAll(elems)
+  override def plusAll [B1 >: B](elems: Traversable[(A, B1)]): immutable.Map[A, B1] = this.++(elems)
 
   /** Adds a number of elements provided by an iterator
    *  and returns a new collection with the added elements.
    *
    *  @param iter   the iterator
    */
-  override def plusAll[B1 >: B] (iter: Iterator[(A, B1)]): immutable.Map[A, B1] =
-    ((thisCollection: immutable.Map[A, B1]) /: iter) (_ plus _)
+  override def ++[B1 >: B] (iter: Iterator[(A, B1)]): immutable.Map[A, B1] =
+    ((thisCollection: immutable.Map[A, B1]) /: iter) (_ + _)
 
   /** Adds a number of elements provided by an iterator
    *  and returns a new collection with the added elements.
    *
    *  @param iter   the iterator
-   *  @note  same as `plusAll`
+   *  @note  same as `++`
    *  @note  This is a more efficient version of Traversable.++ which avoids
    *         copying of the collection's elements. However, it applies only if
    *         the type of the added elements is a subtype of the element type of the
    *         collection.
    */
-  override def ++ [B1 >: B](iter: Iterator[(A, B1)]): immutable.Map[A, B1] = plusAll(iter)
+  override def plusAll [B1 >: B](iter: Iterator[(A, B1)]): immutable.Map[A, B1] = this.++(iter)
 
   /** This function transforms all the values of mappings contained
    *  in this map with function <code>f</code>.
@@ -136,7 +136,7 @@ self =>
   override def filterNot(p: ((A, B)) => Boolean): This = {
     var res: This = thisCollection
     for (kv <- this)
-      if (p(kv)) res = (res minus kv._1).asInstanceOf[This] // !!! concrete overrides abstract problem
+      if (p(kv)) res = (res - kv._1).asInstanceOf[This] // !!! concrete overrides abstract problem
     res
   }
 
diff --git a/src/library/scala/collection/generic/MapTemplate.scala b/src/library/scala/collection/generic/MapTemplate.scala
index 90c5372230..3f2c9d2fb0 100644
--- a/src/library/scala/collection/generic/MapTemplate.scala
+++ b/src/library/scala/collection/generic/MapTemplate.scala
@@ -17,8 +17,8 @@ package scala.collection.generic
  *
  *   def get(key: A): Option[B]
  *   def elements: Iterator[(A, B)]
- *   def updated[B1 >: B](key: A, value: B1): This
- *   def minus(key: A): This
+ *   def + [B1 >: B](kv: (A, B1)): This
+ *   def -(key: A): This
  *
  * If you wish that methods like, take, drop, filter return the same kind of map, you should also
  * override:
@@ -101,8 +101,8 @@ self =>
   protected class DefaultKeySet extends Set[A] {
     def contains(key : A) = self.contains(key)
     def elements = self.elements.map(_._1)
-    def plus (elem: A): Set[A] = (Set[A]() ++ this + elem).asInstanceOf[Set[A]] // !!! concrete overrides abstract problem
-    def minus (elem: A): Set[A] = (Set[A]() ++ this - elem).asInstanceOf[Set[A]] // !!! concrete overrides abstract problem
+    def + (elem: A): Set[A] = (Set[A]() ++ this + elem).asInstanceOf[Set[A]] // !!! concrete overrides abstract problem
+    def - (elem: A): Set[A] = (Set[A]() ++ this - elem).asInstanceOf[Set[A]] // !!! concrete overrides abstract problem
     override def size = self.size
     override def foreach[B](f: A => B) = for ((k, v) <- self) f(k)
   }
@@ -164,20 +164,20 @@ self =>
    *  @param    value the value
    *  @return   A new map with the new key/value mapping
    */
-  def updated [B1 >: B](key: A, value: B1): Map[A, B1]
+  def updated [B1 >: B](key: A, value: B1): Map[A, B1] = this + ((key, value))
 
   /** Add a key/value pair to this map, returning a new map.
    *  @param    kv the key/value pair
    *  @return   A new map with the new binding added to this map
    */
-  def plus [B1 >: B] (kv: (A, B1)): Map[A, B1] = updated(kv._1, kv._2)
+  def + [B1 >: B] (kv: (A, B1)): Map[A, B1]
 
   /** Add a key/value pair to this map, returning a new map.
    *  @param    kv the key/value pair
    *  @return   A new map with the new binding added to this map
-   *  @note  same as `plus`
+   *  @note  same as `+`
    */
-  def + [B1 >: B] (kv: (A, B1)): Map[A, B1] = updated(kv._1, kv._2)
+  def plus [B1 >: B] (kv: (A, B1)): Map[A, B1] = this + kv
 
   /** Adds two or more elements to this collection and returns
    *  a new collection.
@@ -186,8 +186,8 @@ self =>
    *  @param elem2 the second element to add.
    *  @param elems the remaining elements to add.
    */
-  def plus [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *): Map[A, B1] =
-    this plus elem1 plus elem2 plusAll elems
+  def + [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *): Map[A, B1] =
+    this + elem1 + elem2 ++ elems
 
   /** Adds two or more elements to this collection and returns
    *  a new collection.
@@ -196,54 +196,54 @@ self =>
    *  @param elem2 the second element to add.
    *  @param elems the remaining elements to add.
    */
-  def + [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *): Map[A, B1] =
-    plus(elem1, elem2, elems: _*)
+  def plus [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *): Map[A, B1] =
+    this.+(elem1, elem2, elems: _*)
 
   /** Adds a number of elements provided by a traversable object
    *  and returns a new collection with the added elements.
    *
    *  @param elems     the traversable object.
    */
-  def plusAll[B1 >: B](elems: Traversable[(A, B1)]): Map[A, B1] =
-    ((thisCollection: Map[A, B1]) /: elems) (_ plus _)
+  def ++[B1 >: B](elems: Traversable[(A, B1)]): Map[A, B1] =
+    ((thisCollection: Map[A, B1]) /: elems) (_ + _)
 
   /** Adds a number of elements provided by a traversable object
    *  and returns a new collection with the added elements.
    *
    *  @param elems     the traversable object.
-   *  @note  same as `plusAll`
+   *  @note  same as `++`
    *  @note  This is a more efficient version of Traversable.++ which avoids
    *         copying of the collection's elements. However, it applies only if
    *         the type of the added elements is a subtype of the element type of the
    *         collection.
    */
-  def ++ [B1 >: B](elems: Traversable[(A, B1)]): Map[A, B1] = plusAll(elems)
+  def plusAll [B1 >: B](elems: Traversable[(A, B1)]): Map[A, B1] = this.++(elems)
 
   /** Adds a number of elements provided by an iterator
    *  and returns a new collection with the added elements.
    *
    *  @param iter   the iterator
    */
-  def plusAll[B1 >: B] (iter: Iterator[(A, B1)]): Map[A, B1] =
-    ((thisCollection: Map[A, B1]) /: iter) (_ plus _)
+  def ++[B1 >: B] (iter: Iterator[(A, B1)]): Map[A, B1] =
+    ((thisCollection: Map[A, B1]) /: iter) (_ + _)
 
   /** Adds a number of elements provided by an iterator
    *  and returns a new collection with the added elements.
    *
    *  @param iter   the iterator
-   *  @note  same as `plusAll`
+   *  @note  same as `++`
    *  @note  This is a more efficient version of Traversable.++ which avoids
    *         copying of the collection's elements. However, it applies only if
    *         the type of the added elements is a subtype of the element type of the
    *         collection.
    */
-  def ++ [B1 >: B](iter: Iterator[(A, B1)]): Map[A, B1] = plusAll(iter)
+  def plusAll [B1 >: B](iter: Iterator[(A, B1)]): Map[A, B1] = this.++(iter)
 
   /** Removes a key from this map, returning a new map
    *  @param    key the key to be removed
    *  @return   A new map without a binding for <code>key</code>
    */
-  def minus (key: A): This
+  def - (key: A): This
 
   /** Creates a string representation for this map.
    *
diff --git a/src/library/scala/collection/generic/MutableMapTemplate.scala b/src/library/scala/collection/generic/MutableMapTemplate.scala
index 81ebe42997..72c4f9ceda 100644
--- a/src/library/scala/collection/generic/MutableMapTemplate.scala
+++ b/src/library/scala/collection/generic/MutableMapTemplate.scala
@@ -16,8 +16,8 @@ package scala.collection.generic
  *
  *   def get(key: A): Option[B]
  *   def elements: Iterator[(A, B)]
- *   def put(key: A, value: B): Option[B]
- *   def remove(key: A): Option[B]
+ *   def += (kv: (A, B)): this.type
+ *   def -= (key: A): this.type
  *
  * If you wish that methods like, take, drop, filter return the same kind of map, you should also
  * override:
@@ -30,7 +30,7 @@ package scala.collection.generic
  *
  */
 trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with mutable.Map[A, B]]
-  extends MapTemplate[A, B, This]
+  extends MutableMapTemplateBase[A, B, This]
      with Builder[(A, B), This]
      with Growable[(A, B)]
      with Shrinkable[A]
@@ -46,7 +46,11 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta
    * @param key    The key to update
    * @param value  The new value
    */
-  def put(key: A, value: B): Option[B]
+  def put(key: A, value: B): Option[B] = {
+    val r = get(key)
+    update(key, value)
+    r
+  }
 
   /** Adds a new mapping from <code>key</code>
    *  to <code>value</code> to the map. If the map already contains a
@@ -56,13 +60,13 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta
    *  @return   An option consisting of value associated previously associated with `key` in the map,
    *            or None if `key` was not yet defined in the map.
    */
-  def update(key: A, elem: B) { put(key, elem) }
+  def update(key: A, elem: B) { this += ((key, elem)) }
 
   /** Add a new key/value mapping this map.
    *  @param    kv the key/value pair.
    *  @return   the map itself
    */
-  def += (kv: (A, B)): this.type = { update(kv._1, kv._2); this }
+  def += (kv: (A, B)): this.type
 
   /** Create a new map consisting of all elements of the current map
    *  plus the given mapping from `key` to `value`.
@@ -70,15 +74,25 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta
    *  @param value  The new value
    *  @return       A fresh immutable map
    */
-  def updated[B1 >: B](key: A, value: B1): collection.Map[A, B1] =
-    (Map[A, B1]() plusAll thisCollection).updated[B1](key, value)
+  override def updated[B1 >: B](key: A, value: B1): collection.Map[A, B1] =
+    plus((key, value))
 
-  /** Create a  new map consisting of all elements of the current map
-   *  except any mapping from `key`.
-   *  @param    key the key to be removed
-   *  @return   A new map without a binding for <code>key</code>
-   */
-  def minus (key: A): This = clone() minus key
+  /** Perform a += on a clone of this collection */
+  override def plus[B1 >: B](kv: (A, B1)): mutable.Map[A, B1] = clone().asInstanceOf[mutable.Map[A, B1]] += kv
+  /** Perform a += on a clone of this collection */
+  override def plus[B1 >: B](kv1: (A, B1), kv2: (A, B1), kvs: (A, B1)*): mutable.Map[A, B1] = clone().asInstanceOf[mutable.Map[A, B1]] += (kv1, kv2, kvs: _*)
+  /** Perform a -= on a clone of this collection */
+  override def minus(key: A): This = clone() -= key
+  /** Perform a -= on a clone of this collection */
+  override def minus(key1: A, key2: A, keys: A*): This = clone() -= (key1, key2, keys: _*)
+  /** Perform a ++= on a clone of this collection */
+  override def plusAll[B1 >: B](kvs: Traversable[(A, B1)]): mutable.Map[A, B1] = clone().asInstanceOf[mutable.Map[A, B1]] ++= kvs
+  /** Perform a ++= on a clone of this collection */
+  override def plusAll[B1 >: B](kvs: Iterator[(A, B1)]): mutable.Map[A, B1] = clone().asInstanceOf[mutable.Map[A, B1]] ++= kvs
+  /** Perform a --= on a clone of this collection */
+  override def minusAll(keys: Traversable[A]): This = clone() --= keys
+  /** Perform a --= on a clone of this collection */
+  override def minusAll(keys: Iterator[A]): This = clone() --= keys
 
   /** Add a new key/value mapping and return the map itself.
    *
@@ -88,7 +102,7 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta
    *               that map itself, use +=. If you do want to create a fresh map,
    *               you can use `plus` to avoid a @deprecated warning.
    */
-  @deprecated def +(kv: (A, B)): this.type = { update(kv._1, kv._2); this }
+  @deprecated def + (kv: (A, B)): this.type = { update(kv._1, kv._2); this }
 
   /** Adds two or more key/value mappings and return the map itself.
    *  with the added elements.
@@ -132,18 +146,17 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta
    *  If key is not present return None.
    *  @param    key the key to be removed
    */
-  def remove(key: A): Option[B]
-
-  /** Delete a key from this map if it is present.
-   *  @param    key the key to be removed
-   */
-  def delete (key: A) { remove(key) }
+  def remove(key: A): Option[B] = {
+    val r = get(key)
+    this -= key
+    r
+  }
 
   /** Delete a key from this map if it is present.
    *  @param    key the key to be removed
    *  @note     same as `delete`.
    */
-  def -= (key: A): this.type = { delete(key); this }
+  def -= (key: A): this.type
 
   /** Delete a key from this map if it is present and return the map itself.
    *  @param    key the key to be removed
diff --git a/src/library/scala/collection/generic/MutableMapTemplateBase.scala b/src/library/scala/collection/generic/MutableMapTemplateBase.scala
new file mode 100755
index 0000000000..8a0809792b
--- /dev/null
+++ b/src/library/scala/collection/generic/MutableMapTemplateBase.scala
@@ -0,0 +1,35 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2009, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+// $Id: Map.scala 16884 2009-01-09 16:52:09Z cunei $
+
+
+package scala.collection.generic
+
+/** A generic template for mutable maps from keys of type A to values of type B.
+ *  To implement a concrete mutable map, you need to provide implementations of the following methods:
+ *
+ *   def get(key: A): Option[B]
+ *   def elements: Iterator[(A, B)]
+ *   def += (kv: (A, B)): this.type
+ *   def -= (key: A): this.type
+ *
+ * If you wish that methods like, take, drop, filter return the same kind of map, you should also
+ * override:
+ *
+ *   def empty: This
+ *
+ * If you to avoid the unncessary construction of an Option object,
+ * you could also override apply, update, and delete.
+ * It is also good idea to override methods `foreach` and `size` for efficiency.
+ *
+ */
+trait MutableMapTemplateBase[A, B, +This <: MutableMapTemplateBase[A, B, This] with mutable.Map[A, B]]
+  extends MapTemplate[A, B, This] {
+  def + [B1 >: B] (kv: (A, B1)): Map[A, B1] = plus(kv)
+}
diff --git a/src/library/scala/collection/generic/MutableSetTemplate.scala b/src/library/scala/collection/generic/MutableSetTemplate.scala
index f9f4b52dc8..8c5ee54c25 100644
--- a/src/library/scala/collection/generic/MutableSetTemplate.scala
+++ b/src/library/scala/collection/generic/MutableSetTemplate.scala
@@ -15,9 +15,9 @@ package scala.collection.generic
  *  To implement a concrete mutable set, you need to provide implementations of the following methods:
  *
  *  def contains(elem: A): Boolean
- *  def put(elem: A): Boolean
- *  def remove(elem: A): Boolean
  *  def elements: Iterator[A]
+ *  def += (elem: A): this.type
+ *  def -= (elem: A): this.type
  *
  * If you wish that methods like, take, drop, filter return the same kind of map, you should also
  * override:
@@ -42,13 +42,21 @@ trait MutableSetTemplate[A, +This <: MutableSetTemplate[A, This] with mutable.Se
    *  @param elem the element to be added
    *  @return true if the element was already present in the set.
    */
-  def put(elem: A): Boolean
+  def put(elem: A): Boolean = {
+    val r = contains(elem)
+    this += elem
+    r
+  }
 
   /** Removes a single element from a set.
    *  @param elem  The element to be removed.
    *  @return  true if the element was already present in the set.
    */
-  def remove(elem: A): Boolean
+  def remove(elem: A): Boolean = {
+    val r = contains(elem)
+    this -= elem
+    r
+  }
 
   /** 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>.
@@ -57,19 +65,21 @@ trait MutableSetTemplate[A, +This <: MutableSetTemplate[A, This] with mutable.Se
    *
    */
   def update(elem: A, included: Boolean) {
-    if (included) this put elem else this remove elem
+    if (included) this += elem else this -= elem
   }
 
+
+
   /** Adds a new element to the set.
    *
    *  @param elem the element to be added
    */
-  def +=(elem: A): this.type = { put(elem); this }
+  def +=(elem: A): this.type
 
   /** Removes a single element from a set.
    *  @param elem  The element to be removed.
    */
-  def -=(elem: A): this.type = { remove(elem); this }
+  def -=(elem: A): this.type
 
   /** Removes all elements from the set for which the predicate <code>p</code>
    *  yields the value <code>false</code>.
@@ -83,9 +93,22 @@ trait MutableSetTemplate[A, +This <: MutableSetTemplate[A, This] with mutable.Se
 
   override def clone(): This = empty ++= thisCollection
 
-  def plus(elem: A): This = clone() += elem
-
-  def minus(elem: A): This = clone() -= elem
+  /** Perform a += on a clone of this collection */
+  override def plus(elem: A): This = clone() += elem
+  /** Perform a += on a clone of this collection */
+  override def plus(elem1: A, elem2: A, elems: A*): This = clone() += (elem1, elem2, elems: _*)
+  /** Perform a -= on a clone of this collection */
+  override def minus(elem: A): This = clone() -= elem
+  /** Perform a -= on a clone of this collection */
+  override def minus(elem1: A, elem2: A, elems: A*): This = clone() -= (elem1, elem2, elems: _*)
+  /** Perform a ++= on a clone of this collection */
+  override def plusAll(elems: Traversable[A]): This = clone() ++= elems
+  /** Perform a ++= on a clone of this collection */
+  override def plusAll(elems: Iterator[A]): This = clone() ++= elems
+  /** Perform a --= on a clone of this collection */
+  override def minusAll(elems: Traversable[A]): This = clone() --= elems
+  /** Perform a --= on a clone of this collection */
+  override def minusAll(elems: Iterator[A]): This = clone() --= elems
 
   def result: This = thisCollection
 
diff --git a/src/library/scala/collection/generic/SetTemplate.scala b/src/library/scala/collection/generic/SetTemplate.scala
index 5d69abe389..5d5abca295 100644
--- a/src/library/scala/collection/generic/SetTemplate.scala
+++ b/src/library/scala/collection/generic/SetTemplate.scala
@@ -16,8 +16,8 @@ package scala.collection.generic
  *
  *   def contains(key: A): Boolean
  *   def elements: Iterator[A]
- *   def plus(elem: A): This
- *   def minus(elem: A): This
+ *   def +(elem: A): This
+ *   def -(elem: A): This
  *
  * If you wish that methods like, take, drop, filter return the same kind of set, you should also
  * override:
@@ -44,12 +44,12 @@ self =>
   /** Creates a new set with an additional element, unless the element is already present.
    *  @param elem the element to be added
    */
-  def plus (elem: A): This
+  def + (elem: A): This
 
   /** Creates a new set with given element removed from this set, unless the element is not present.
    *  @param elem the element to be removed
    */
-  def minus (elem: A): This
+  def - (elem: A): This
 
   /** Checks if this set is empty.
    *
@@ -97,7 +97,7 @@ self =>
    *  @return     a set containing the elements of this
    *              set and those of the given set <code>that</code>.
    */
-  def union(that: Set[A]): This = plusAll(that)
+  def union(that: Set[A]): This = this.++(that)
 
   /** The union of this set and the given set <code>that</code>.
    *
@@ -114,7 +114,7 @@ self =>
    *  @return     a set containing those elements of this
    *              set that are not also contained in the given set <code>that</code>.
    */
-  def diff(that: Set[A]): This = minusAll(that)
+  def diff(that: Set[A]): This = --(that)
 
   /** The difference of this set and the given set <code>that</code>.
    *
diff --git a/src/library/scala/collection/generic/SortedMapTemplate.scala b/src/library/scala/collection/generic/SortedMapTemplate.scala
index a7bed88567..eefd257136 100644
--- a/src/library/scala/collection/generic/SortedMapTemplate.scala
+++ b/src/library/scala/collection/generic/SortedMapTemplate.scala
@@ -30,8 +30,8 @@ self =>
     def compare(k0: A, k1: A) = self.thisCollection.compare(k0, k1)
     /** We can't give an implementation of +/- here because we do not have a generic sorted set implementation
      */
-    override def plus (elem: A): SortedSet[A] = throw new UnsupportedOperationException("keySet.+")
-    override def minus (elem: A): SortedSet[A] = throw new UnsupportedOperationException("keySet.-")
+    override def + (elem: A): SortedSet[A] = throw new UnsupportedOperationException("keySet.+")
+    override def - (elem: A): SortedSet[A] = throw new UnsupportedOperationException("keySet.-")
     override def rangeImpl(from : Option[A], until : Option[A]) : SortedSet[A] = {
       val map = self.rangeImpl(from, until)
       new map.DefaultKeySet
@@ -45,13 +45,13 @@ self =>
    *  @param    value the value
    *  @return   A new map with the new binding added to this map
    */
-  def updated[B1 >: B](key: A, value: B1): SortedMap[A, B1]
+  override def updated[B1 >: B](key: A, value: B1): SortedMap[A, B1] = this+((key, value))
 
   /** Add a key/value pair to this map.
    *  @param    kv the key/value pair
    *  @return   A new map with the new binding added to this map
    */
-  override def plus [B1 >: B] (kv: (A, B1)): SortedMap[A, B1] = updated(kv._1, kv._2)
+  def + [B1 >: B] (kv: (A, B1)): SortedMap[A, B1]
 
   // todo: Add generic +,-, and so on.
 
@@ -63,9 +63,9 @@ self =>
    *  @param elem2 the second element to add.
    *  @param elems the remaining elements to add.
    */
-  override def plus [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *): SortedMap[A, B1] = {
-    var m = this plus elem1 plus elem2;
-    for (e <- elems) m = m plus e
+  override def + [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *): SortedMap[A, B1] = {
+    var m = this + elem1 + elem2;
+    for (e <- elems) m = m + e
     m
   }
 }
diff --git a/src/library/scala/collection/generic/Subtractable.scala b/src/library/scala/collection/generic/Subtractable.scala
index c83e70ca13..5d264759ee 100644
--- a/src/library/scala/collection/generic/Subtractable.scala
+++ b/src/library/scala/collection/generic/Subtractable.scala
@@ -25,15 +25,15 @@ trait Subtractable[A, +This <: Subtractable[A, This]] { self =>
    *
    *  @param elem  the element to remove.
    */
-  def minus(elem: A): This
+  def -(elem: A): This
 
   /** Returns a new collection that contains all elements of the current collection
    *  except a given element.
    *
    *  @param elem  the element to remove.
-   *  @note  same as `minus`
+   *  @note  same as `-`
    */
-  def -(elem: A): This = minus(elem)
+  def minus(elem: A): This = this - elem
 
   /** Returns a new collection that contains all elements of the current collection
    *  except a two or more given elements.
@@ -42,8 +42,8 @@ trait Subtractable[A, +This <: Subtractable[A, This]] { self =>
    *  @param elem2 the second element to remove.
    *  @param elems the remaining elements to remove.
    */
-  def minus(elem1: A, elem2: A, elems: A*): This =
-    this minus elem1 minus elem2 minusAll Iterable.fromOld(elems)
+  def -(elem1: A, elem2: A, elems: A*): This =
+    this - elem1 - elem2 -- elems
 
   /** Returns a new collection that contains all elements of the current collection
    *  except two or more given elements.
@@ -51,38 +51,38 @@ trait Subtractable[A, +This <: Subtractable[A, This]] { self =>
    *  @param elem1 the first element to remove.
    *  @param elem2 the second element to remove.
    *  @param elems the remaining elements to remove.
-   *  @note  same as minus
+   *  @note  same as -
    */
-  def - (elem1: A, elem2: A, elems: A*): This = minus(elem1, elem2, elems: _*)
+  def minus (elem1: A, elem2: A, elems: A*): This = this - (elem1, elem2, elems: _*)
 
   /** Returns a new collection that contains all elements of the current collection
    *  except the elements provided by a traversable object
    *
    *  @param elems     the traversable object containing the elements that do not form part of the new collection.
    */
-  def minusAll(elems: Traversable[A]): This = (thisCollection /: elems) (_ minus _)
+  def --(elems: Traversable[A]): This = (thisCollection /: elems) (_ - _)
 
   /** Returns a new collection that contains all elements of the current collection
    *  except the elements provided by a traversable object
    *
    *  @param elems     the traversable object containing the elements that do not form part of the new collection.
-   *  @note  same as minusAll
+   *  @note  same as --
    */
-  def --(elems: Traversable[A]): This = minusAll(elems)
+  def minusAll(elems: Traversable[A]): This = this -- elems
 
   /** Returns a new collection that contains all elements of the current collection
    *  except the elements provided by an iterator
    *
    *  @param elems     the iterator containing the elements that do not form part of the new collection
-   *  @note  same as minusAll
+   *  @note  same as --
    */
-  def minusAll(iter: Iterator[A]): This = (thisCollection /: iter) (_ minus _)
+  def --(iter: Iterator[A]): This = (thisCollection /: iter) (_ - _)
 
   /** Returns a new collection that contains all elements of the current collection
    *  except the elements provided by an iterator
    *
    *  @param elems     the iterator containing the elements that do not form part of the new collection
-   *  @note  same as minusAll
+   *  @note  same as --
    */
-  def --(iter: Iterator[A]): This = minusAll(iter)
+  def minusAll(iter: Iterator[A]): This = this -- iter
 }
diff --git a/src/library/scala/collection/generic/TraversableBuildable.scala b/src/library/scala/collection/generic/TraversableBuildable.scala
deleted file mode 100755
index d1137632fc..0000000000
--- a/src/library/scala/collection/generic/TraversableBuildable.scala
+++ /dev/null
@@ -1,14 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2003-2009, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-// $Id: Traversable.scala 15188 2008-05-24 15:01:02Z stepancheg $
-package scala.collection.generic
-
-trait TraversableClass[CC[X] <: Traversable[X]] {
-  def factory: TraversableFactory[CC]
-  protected[this] def newBuilder = factory.newBuilder
-}
diff --git a/src/library/scala/collection/generic/TraversableTemplate.scala b/src/library/scala/collection/generic/TraversableTemplate.scala
index 735f883a2a..aa651de27b 100644
--- a/src/library/scala/collection/generic/TraversableTemplate.scala
+++ b/src/library/scala/collection/generic/TraversableTemplate.scala
@@ -87,8 +87,8 @@ self =>
 
   /** Same as ++
    */
-  def concat[B >: A, That](that: Traversable[B])(implicit bf: BuilderFactory[B, That, This]): That = ++(that)(bf)
-  def concat[B >: A, That](that: Iterator[B])(implicit bf: BuilderFactory[B, That, This]): That = ++(that)(bf)
+  def concat[B >: A, That](that: Traversable[B])(implicit bf: BuilderFactory[B, That, This]): That = this.++(that)(bf)
+  def concat[B >: A, That](that: Iterator[B])(implicit bf: BuilderFactory[B, That, This]): That = this.++(that)(bf)
 
   /** Returns the traversable that results from applying the given function
    *  <code>f</code> to each element of this traversable and collecing the results
diff --git a/src/library/scala/collection/immutable/BitSet.scala b/src/library/scala/collection/immutable/BitSet.scala
index ac6970a9f9..f3bfffff81 100644
--- a/src/library/scala/collection/immutable/BitSet.scala
+++ b/src/library/scala/collection/immutable/BitSet.scala
@@ -27,7 +27,7 @@ abstract class BitSet extends Set[Int] with collection.BitSet with BitSetTemplat
 
   /** Adds element to bitset, returning a new set.
    */
-  def plus (elem: Int): BitSet = {
+  def + (elem: Int): BitSet = {
     require(elem >= 0)
     if (contains(elem)) this
     else {
@@ -38,7 +38,7 @@ abstract class BitSet extends Set[Int] with collection.BitSet with BitSetTemplat
 
   /** Removes element from bitset, returning a new set
    */
-  def minus (elem: Int): BitSet = {
+  def - (elem: Int): BitSet = {
     require(elem >= 0)
     if (contains(elem)) {
       val idx = elem >> LogWL
diff --git a/src/library/scala/collection/immutable/FlexMap.scala b/src/library/scala/collection/immutable/FlexMap.scala
index 7ea21b3c64..8370acd07c 100644
--- a/src/library/scala/collection/immutable/FlexMap.scala
+++ b/src/library/scala/collection/immutable/FlexMap.scala
@@ -20,6 +20,7 @@ import generic._
  */
 trait FlexMap[A, +B] extends Map[A, B] { self =>
   override def empty: Map[A, B] = FlexMap.empty
+  def + [B1 >: B] (kv: (A, B1)): Map[A, B1] = updated(kv._1, kv._2)
 }
 
 /* Factory object for `FlexMap class */
@@ -31,8 +32,8 @@ object FlexMap extends ImmutableMapFactory[Map] {
     override def size: Int = 0
     def get(key: A): Option[B] = None
     def elements: Iterator[(A, B)] = Iterator.empty
-    def updated [B1 >: B] (key: A, value: B1): Map[A, B1] = new Map1(key, value)
-    def minus (key: A): Map[A, B] = this
+    override def updated [B1 >: B] (key: A, value: B1): Map[A, B1] = new Map1(key, value)
+    def - (key: A): Map[A, B] = this
   }
 
   @serializable
@@ -41,10 +42,10 @@ object FlexMap extends ImmutableMapFactory[Map] {
     def get(key: A): Option[B] =
       if (key == key1) Some(value1) else None
     def elements = Iterator((key1, value1))
-    def updated [B1 >: B] (key: A, value: B1): Map[A, B1] =
+    override def updated [B1 >: B] (key: A, value: B1): Map[A, B1] =
       if (key == key1) new Map1(key1, value)
       else new Map2(key1, value1, key, value)
-    def minus (key: A): Map[A, B] =
+    def - (key: A): Map[A, B] =
       if (key == key1) empty else this
     override def foreach[U](f: ((A, B)) =>  U): Unit = {
       f((key1, value1))
@@ -59,11 +60,11 @@ object FlexMap extends ImmutableMapFactory[Map] {
       else if (key == key2) Some(value2)
       else None
     def elements = Iterator((key1, value1), (key2, value2))
-    def updated [B1 >: B] (key: A, value: B1): Map[A, B1] =
+    override def updated [B1 >: B] (key: A, value: B1): Map[A, B1] =
       if (key == key1) new Map2(key1, value, key2, value2)
       else if (key == key2) new Map2(key1, value1, key2, value)
       else new Map3(key1, value1, key2, value2, key, value)
-    def minus (key: A): Map[A, B] =
+    def - (key: A): Map[A, B] =
       if (key == key1) new Map1(key2, value2)
       else if (key == key2) new Map1(key1, value1)
       else this
@@ -81,12 +82,12 @@ object FlexMap extends ImmutableMapFactory[Map] {
       else if (key == key3) Some(value3)
       else None
     def elements = Iterator((key1, value1), (key2, value2), (key3, value3))
-    def updated [B1 >: B] (key: A, value: B1): Map[A, B1] =
+    override def updated [B1 >: B] (key: A, value: B1): Map[A, B1] =
       if (key == key1)      new Map3(key1, value, key2, value2, key3, value3)
       else if (key == key2) new Map3(key1, value1, key2, value, key3, value3)
       else if (key == key3) new Map3(key1, value1, key2, value2, key3, value)
       else new Map4(key1, value1, key2, value2, key3, value3, key, value)
-    def minus (key: A): Map[A, B] =
+    def - (key: A): Map[A, B] =
       if (key == key1)      new Map2(key2, value2, key3, value3)
       else if (key == key2) new Map2(key1, value1, key3, value3)
       else if (key == key3) new Map2(key1, value1, key2, value2)
@@ -106,13 +107,13 @@ object FlexMap extends ImmutableMapFactory[Map] {
       else if (key == key4) Some(value4)
       else None
     def elements = Iterator((key1, value1), (key2, value2), (key3, value3), (key4, value4))
-    def updated [B1 >: B] (key: A, value: B1): Map[A, B1] =
+    override def updated [B1 >: B] (key: A, value: B1): Map[A, B1] =
       if (key == key1)      new Map4(key1, value, key2, value2, key3, value3, key4, value4)
       else if (key == key2) new Map4(key1, value1, key2, value, key3, value3, key4, value4)
       else if (key == key3) new Map4(key1, value1, key2, value2, key3, value, key4, value4)
       else if (key == key4) new Map4(key1, value1, key2, value2, key3, value3, key4, value)
       else new HashMap + ((key1, value1), (key2, value2), (key3, value3), (key4, value4), (key, value))
-    def minus (key: A): Map[A, B] =
+    def - (key: A): Map[A, B] =
       if (key == key1)      new Map3(key2, value2, key3, value3, key4, value4)
       else if (key == key2) new Map3(key1, value1, key3, value3, key4, value4)
       else if (key == key3) new Map3(key1, value1, key2, value2, key4, value4)
diff --git a/src/library/scala/collection/immutable/FlexSet.scala b/src/library/scala/collection/immutable/FlexSet.scala
index b1410961b2..37082a4407 100644
--- a/src/library/scala/collection/immutable/FlexSet.scala
+++ b/src/library/scala/collection/immutable/FlexSet.scala
@@ -30,8 +30,8 @@ object FlexSet extends SetFactory[Set] {
   class EmptySet[A] extends FlexSet[A] {
     override def size: Int = 0
     def contains(elem: A): Boolean = false
-    def plus (elem: A): Set[A] = new Set1(elem)
-    def minus (elem: A): Set[A] = this
+    def + (elem: A): Set[A] = new Set1(elem)
+    def - (elem: A): Set[A] = this
     def elements: Iterator[A] = Iterator.empty
     override def foreach[U](f: A =>  U): Unit = {}
   }
@@ -42,10 +42,10 @@ object FlexSet extends SetFactory[Set] {
     override def size: Int = 1
     def contains(elem: A): Boolean =
       elem == elem1
-    def plus (elem: A): Set[A] =
+    def + (elem: A): Set[A] =
       if (contains(elem)) this
       else new Set2(elem1, elem)
-    def minus (elem: A): Set[A] =
+    def - (elem: A): Set[A] =
       if (elem == elem1) new EmptySet[A]
       else this
     def elements: Iterator[A] =
@@ -61,10 +61,10 @@ object FlexSet extends SetFactory[Set] {
     override def size: Int = 2
     def contains(elem: A): Boolean =
       elem == elem1 || elem == elem2
-    def plus (elem: A): Set[A] =
+    def + (elem: A): Set[A] =
       if (contains(elem)) this
       else new Set3(elem1, elem2, elem)
-    def minus (elem: A): Set[A] =
+    def - (elem: A): Set[A] =
       if (elem == elem1) new Set1(elem2)
       else if (elem == elem2) new Set1(elem1)
       else this
@@ -81,10 +81,10 @@ object FlexSet extends SetFactory[Set] {
     override def size: Int = 3
     def contains(elem: A): Boolean =
       elem == elem1 || elem == elem2 || elem == elem3
-    def plus (elem: A): Set[A] =
+    def + (elem: A): Set[A] =
       if (contains(elem)) this
       else new Set4(elem1, elem2, elem3, elem)
-    def minus (elem: A): Set[A] =
+    def - (elem: A): Set[A] =
       if (elem == elem1) new Set2(elem2, elem3)
       else if (elem == elem2) new Set2(elem1, elem3)
       else if (elem == elem3) new Set2(elem1, elem2)
@@ -102,10 +102,10 @@ object FlexSet extends SetFactory[Set] {
     override def size: Int = 4
     def contains(elem: A): Boolean =
       elem == elem1 || elem == elem2 || elem == elem3 || elem == elem4
-    def plus (elem: A): Set[A] =
+    def + (elem: A): Set[A] =
       if (contains(elem)) this
       else new HashSet[A] + (elem1, elem2, elem3, elem4, elem)
-    def minus (elem: A): Set[A] =
+    def - (elem: A): Set[A] =
       if (elem == elem1) new Set3(elem2, elem3, elem4)
       else if (elem == elem2) new Set3(elem1, elem3, elem4)
       else if (elem == elem3) new Set3(elem1, elem2, elem4)
diff --git a/src/library/scala/collection/immutable/HashMap.scala b/src/library/scala/collection/immutable/HashMap.scala
index 6f0277a43f..7979d096aa 100644
--- a/src/library/scala/collection/immutable/HashMap.scala
+++ b/src/library/scala/collection/immutable/HashMap.scala
@@ -53,7 +53,7 @@ class HashMap[A, +B] extends Map[A,B] with ImmutableMapTemplate[A, B, HashMap[A,
     else Some(getValue(e))
   }
 
-  def updated [B1 >: B] (key: A, value: B1): HashMap[A, B1] = synchronized {
+  override def updated [B1 >: B] (key: A, value: B1): HashMap[A, B1] = synchronized {
     makeCopyIfUpdated()
     val e = findEntry(key)
     if (e == null) {
@@ -83,7 +83,7 @@ class HashMap[A, +B] extends Map[A,B] with ImmutableMapTemplate[A, B, HashMap[A,
   override def + [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *): HashMap[A, B1] =
     this + elem1 + elem2 ++ elems
 
-  def minus (key: A): HashMap[A, B] = synchronized {
+  def - (key: A): HashMap[A, B] = synchronized {
     makeCopyIfUpdated()
     val e = findEntry(key)
     if (e == null) this
diff --git a/src/library/scala/collection/immutable/HashSet.scala b/src/library/scala/collection/immutable/HashSet.scala
index 9433ec9c8f..3abffa6ec4 100644
--- a/src/library/scala/collection/immutable/HashSet.scala
+++ b/src/library/scala/collection/immutable/HashSet.scala
@@ -46,7 +46,7 @@ class HashSet[A] extends Set[A] with SetTemplate[A, HashSet[A]] with mutable.Fla
     m.containsEntry(elem)
   }
 
-  def plus (elem: A): HashSet[A] = synchronized {
+  def + (elem: A): HashSet[A] = synchronized {
     makeCopyIfUpdated()
     if (containsEntry(elem)) this
     else {
@@ -56,7 +56,7 @@ class HashSet[A] extends Set[A] with SetTemplate[A, HashSet[A]] with mutable.Fla
     }
   }
 
-  def minus (elem: A): HashSet[A] = synchronized {
+  def - (elem: A): HashSet[A] = synchronized {
     makeCopyIfUpdated()
     if (!containsEntry(elem)) this
     else {
diff --git a/src/library/scala/collection/immutable/IntMap.scala b/src/library/scala/collection/immutable/IntMap.scala
index e243a63bf3..a7b66628bb 100644
--- a/src/library/scala/collection/immutable/IntMap.scala
+++ b/src/library/scala/collection/immutable/IntMap.scala
@@ -239,7 +239,9 @@ sealed abstract class IntMap[+T] extends scala.collection.immutable.Map[Int, T]
     case IntMap.Nil => error("key not found");
   }
 
-  def updated[S >: T](key : Int, value : S) : IntMap[S] = this match {
+  def + [S >: T] (kv: (Int, S)): IntMap[S] = updated(kv._1, kv._2)
+
+  override def updated[S >: T](key : Int, value : S) : IntMap[S] = this match {
     case IntMap.Bin(prefix, mask, left, right) => if (!hasMatch(key, prefix, mask)) join(key, IntMap.Tip(key, value), prefix, this);
                                           else if (zero(key, mask)) IntMap.Bin(prefix, mask, left.updated(key, value), right)
                                           else IntMap.Bin(prefix, mask, left, right.updated(key, value));
@@ -272,7 +274,7 @@ sealed abstract class IntMap[+T] extends scala.collection.immutable.Map[Int, T]
     case IntMap.Nil => IntMap.Tip(key, value);
   }
 
-  def minus (key : Int) : IntMap[T] = this match {
+  def - (key : Int) : IntMap[T] = this match {
     case IntMap.Bin(prefix, mask, left, right) =>
       if (!hasMatch(key, prefix, mask)) this;
       else if (zero(key, mask)) bin(prefix, mask, left - key, right);
diff --git a/src/library/scala/collection/immutable/ListMap.scala b/src/library/scala/collection/immutable/ListMap.scala
index 389c0c63bb..b812cef8df 100644
--- a/src/library/scala/collection/immutable/ListMap.scala
+++ b/src/library/scala/collection/immutable/ListMap.scala
@@ -60,13 +60,13 @@ class ListMap[A, +B] extends Map[A, B] with ImmutableMapTemplate[A, B, ListMap[A
    *  @param key  the key element of the updated entry.
    *  @param value the value element of the updated entry.
    */
-  def updated [B1 >: B] (key: A, value: B1): ListMap[A, B1] = new Node[B1](key, value)
+  override def updated [B1 >: B] (key: A, value: B1): ListMap[A, B1] = new Node[B1](key, value)
 
   /** Add a key/value pair to this map.
    *  @param    kv the key/value pair
    *  @return   A new map with the new binding added to this map
    */
-  override def + [B1 >: B] (kv: (A, B1)): ListMap[A, B1] = updated(kv._1, kv._2)
+  def + [B1 >: B] (kv: (A, B1)): ListMap[A, B1] = updated(kv._1, kv._2)
 
   /** Adds two or more elements to this collection and returns
    *  either the collection itself (if it is mutable), or a new collection
@@ -85,7 +85,7 @@ class ListMap[A, +B] extends Map[A, B] with ImmutableMapTemplate[A, B, ListMap[A
    *
    *  @param key a map without a mapping for the given key.
    */
-  def minus (key: A): ListMap[A, B] = this
+  def - (key: A): ListMap[A, B] = this
 
   /** Returns an iterator over key-value pairs.
    */
@@ -156,7 +156,7 @@ class ListMap[A, +B] extends Map[A, B] with ImmutableMapTemplate[A, B, ListMap[A
      *  @param k ...
      *  @return  ...
      */
-    override def minus (k: A): ListMap[A, B1] =
+    override def - (k: A): ListMap[A, B1] =
       if (k == key)
         next
       else {
diff --git a/src/library/scala/collection/immutable/ListSet.scala b/src/library/scala/collection/immutable/ListSet.scala
index 6872d96464..6257e8c9cc 100644
--- a/src/library/scala/collection/immutable/ListSet.scala
+++ b/src/library/scala/collection/immutable/ListSet.scala
@@ -52,12 +52,12 @@ class ListSet[A] extends Set[A] with SetTemplate[A, ListSet[A]] { self =>
 
   /** This method creates a new set with an additional element.
    */
-  def plus (elem: A): ListSet[A] = new Node(elem)
+  def + (elem: A): ListSet[A] = new Node(elem)
 
   /** <code>-</code> can be used to remove a single element from
    *  a set.
    */
-  def minus (elem: A): ListSet[A] = this
+  def - (elem: A): ListSet[A] = this
 
   /** Creates a new iterator over all elements contained in this set.
    *
@@ -106,12 +106,12 @@ class ListSet[A] extends Set[A] with SetTemplate[A, ListSet[A]] { self =>
 
     /** This method creates a new set with an additional element.
      */
-    override def plus(e: A): ListSet[A] = if (contains(e)) this else new Node(e)
+    override def +(e: A): ListSet[A] = if (contains(e)) this else new Node(e)
 
     /** <code>-</code> can be used to remove a single element from
      *  a set.
      */
-    override def minus(e: A): ListSet[A] = if (e == elem) self else {
+    override def -(e: A): ListSet[A] = if (e == elem) self else {
       val tail = self - e; new tail.Node(elem)
     }
 
diff --git a/src/library/scala/collection/immutable/LongMap.scala b/src/library/scala/collection/immutable/LongMap.scala
index 9e8ac7627e..f30f9eb17d 100644
--- a/src/library/scala/collection/immutable/LongMap.scala
+++ b/src/library/scala/collection/immutable/LongMap.scala
@@ -240,7 +240,9 @@ sealed abstract class LongMap[+T] extends scala.collection.immutable.Map[Long, T
     case LongMap.Nil => error("key not found");
   }
 
-  def updated[S >: T](key : Long, value : S) : LongMap[S] = this match {
+  def + [S >: T] (kv: (Long, S)): LongMap[S] = updated(kv._1, kv._2)
+
+  override def updated[S >: T](key : Long, value : S) : LongMap[S] = this match {
     case LongMap.Bin(prefix, mask, left, right) => if (!hasMatch(key, prefix, mask)) join(key, LongMap.Tip(key, value), prefix, this);
                                           else if (zero(key, mask)) LongMap.Bin(prefix, mask, left.update(key, value), right)
                                           else LongMap.Bin(prefix, mask, left, right.update(key, value));
@@ -273,7 +275,7 @@ sealed abstract class LongMap[+T] extends scala.collection.immutable.Map[Long, T
     case LongMap.Nil => LongMap.Tip(key, value);
   }
 
-  def minus(key : Long) : LongMap[T] = this match {
+  def -(key : Long) : LongMap[T] = this match {
     case LongMap.Bin(prefix, mask, left, right) =>
       if (!hasMatch(key, prefix, mask)) this;
       else if (zero(key, mask)) bin(prefix, mask, left - key, right);
diff --git a/src/library/scala/collection/immutable/Map.scala b/src/library/scala/collection/immutable/Map.scala
index ba8ad9ab6b..8a1325735f 100644
--- a/src/library/scala/collection/immutable/Map.scala
+++ b/src/library/scala/collection/immutable/Map.scala
@@ -25,7 +25,8 @@ trait Map[A, +B] extends Iterable[(A, B)]
    *  @param    value the value
    *  @return   A new map with the new binding added to this map
    */
-  def updated [B1 >: B](key: A, value: B1): Map[A, B1]
+  override def updated [B1 >: B](key: A, value: B1): Map[A, B1]
+  def + [B1 >: B](kv: (A, B1)): Map[A, B1]
 
   /** A hash method compatible with <code>equals</code>
    */
@@ -52,8 +53,9 @@ object Map extends ImmutableMapFactory[Map] {
     def get(key: A) = underlying.get(key)
     def elements = underlying.elements
     override def empty = new WithDefault(underlying.empty, d)
-    def updated[B1 >: B](key: A, value: B1): WithDefault[A, B1] = new WithDefault[A, B1](underlying.updated[B1](key, value), d)
-    def minus (key: A): WithDefault[A, B] = new WithDefault(underlying - key, d)
+    override def updated[B1 >: B](key: A, value: B1): WithDefault[A, B1] = new WithDefault[A, B1](underlying.updated[B1](key, value), d)
+    def + [B1 >: B](kv: (A, B1)): WithDefault[A, B1] = updated(kv._1, kv._2)
+    def - (key: A): WithDefault[A, B] = new WithDefault(underlying - key, d)
     override def default(key: A): B = d(key)
   }
 }
diff --git a/src/library/scala/collection/immutable/SortedMap.scala b/src/library/scala/collection/immutable/SortedMap.scala
index f1e1c4b9b8..43a7562f84 100644
--- a/src/library/scala/collection/immutable/SortedMap.scala
+++ b/src/library/scala/collection/immutable/SortedMap.scala
@@ -26,31 +26,27 @@ trait SortedMap[A, +B] extends Map[A, B]
                          with SortedMapTemplate[A, B, SortedMap[A, B]] {
 
   /** Needs to be overridden in subclasses. */
-  override def empty: SortedMap[A, B] = throw new UnsupportedOperationException("SortedMap.empty")
+  override def empty: SortedMap[A, B] = throw new AbstractMethodError("SortedMap.empty")
 
   /** Needs to be overridden in subclasses. */
   override protected[this] def newBuilder : Builder[(A, B), SortedMap[A, B]] =
-    throw new UnsupportedOperationException("SortedMap.newBuilder")
+    throw new AbstractMethodError("SortedMap.newBuilder")
+
+  override def updated [B1 >: B](key: A, value: B1): SortedMap[A, B1] = this + ((key, value))
 
   /** Add a key/value pair to this map.
    *  @param    key the key
    *  @param    value the value
    *  @return   A new map with the new binding added to this map
+   *  @note     needs to be overridden in subclasses
    */
-  def updated [B1 >: B](key: A, value: B1): SortedMap[A, B1]
-
-  /** Add a key/value pair to this map, returning a new map.
-   *  @param    kv the key/value pair
-   *  @return   A new map with the new binding added to this map
-   */
-  override def plus [B1 >: B] (kv: (A, B1)): SortedMap[A, B1] = updated(kv._1, kv._2)
+  def + [B1 >: B](kv: (A, B1)): SortedMap[A, B1] = throw new AbstractMethodError("SortedMap.+")
 
   /** Add a key/value pair to this map, returning a new map.
    *  @param    kv the key/value pair
    *  @return   A new map with the new binding added to this map
-   *  @note  same as `plus`
    */
-  override def + [B1 >: B] (kv: (A, B1)): SortedMap[A, B1] = updated(kv._1, kv._2)
+  override def plus [B1 >: B] (kv: (A, B1)): SortedMap[A, B1] = this + kv
 
   /** Adds two or more elements to this collection and returns
    *  a new collection.
@@ -59,8 +55,8 @@ trait SortedMap[A, +B] extends Map[A, B]
    *  @param elem2 the second element to add.
    *  @param elems the remaining elements to add.
    */
-  override def plus [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *): SortedMap[A, B1] =
-    this plus elem1 plus elem2 plusAll elems
+  override def + [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *): SortedMap[A, B1] =
+    this + elem1 + elem2 ++ elems
 
   /** Adds two or more elements to this collection and returns
    *  a new collection.
@@ -69,47 +65,47 @@ trait SortedMap[A, +B] extends Map[A, B]
    *  @param elem2 the second element to add.
    *  @param elems the remaining elements to add.
    */
-  override def + [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *): SortedMap[A, B1] =
-    plus(elem1, elem2, elems: _*)
+  override def plus [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *): SortedMap[A, B1] =
+    this.+(elem1, elem2, elems: _*)
 
   /** Adds a number of elements provided by a traversable object
    *  and returns a new collection with the added elements.
    *
    *  @param elems     the traversable object.
    */
-  override def plusAll[B1 >: B](elems: collection.Traversable[(A, B1)]): SortedMap[A, B1] =
-    ((thisCollection: SortedMap[A, B1]) /: elems) (_ plus _)
+  override def ++[B1 >: B](elems: collection.Traversable[(A, B1)]): SortedMap[A, B1] =
+    ((thisCollection: SortedMap[A, B1]) /: elems) (_ + _)
 
   /** Adds a number of elements provided by a traversable object
    *  and returns a new collection with the added elements.
    *
    *  @param elems     the traversable object.
-   *  @note  same as `plusAll`
+   *  @note  same as `++`
    *  @note  This is a more efficient version of Traversable.++ which avoids
    *         copying of the collection's elements. However, it applies only if
    *         the type of the added elements is a subtype of the element type of the
    *         collection.
    */
-  override def ++ [B1 >: B](elems: collection.Traversable[(A, B1)]): SortedMap[A, B1] = plusAll(elems)
+  override def plusAll [B1 >: B](elems: collection.Traversable[(A, B1)]): SortedMap[A, B1] = this.++(elems)
 
   /** Adds a number of elements provided by an iterator
    *  and returns a new collection with the added elements.
    *
    *  @param iter   the iterator
    */
-  override def plusAll[B1 >: B] (iter: Iterator[(A, B1)]): SortedMap[A, B1] =
-    ((thisCollection: SortedMap[A, B1]) /: iter) (_ plus _)
+  override def ++[B1 >: B] (iter: Iterator[(A, B1)]): SortedMap[A, B1] =
+    ((thisCollection: SortedMap[A, B1]) /: iter) (_ + _)
 
   /** Adds a number of elements provided by an iterator
    *  and returns a new collection with the added elements.
    *
    *  @param iter   the iterator
-   *  @note  same as `plusAll`
+   *  @note  same as `++`
    *  @note  This is a more efficient version of Traversable.++ which avoids
    *         copying of the collection's elements. However, it applies only if
    *         the type of the added elements is a subtype of the element type of the
    *         collection.
    */
-  override def ++ [B1 >: B](iter: Iterator[(A, B1)]): SortedMap[A, B1] = plusAll(iter)
+  override def plusAll [B1 >: B](iter: Iterator[(A, B1)]): SortedMap[A, B1] = this.++(iter)
 }
 
diff --git a/src/library/scala/collection/immutable/TreeHashMap.scala b/src/library/scala/collection/immutable/TreeHashMap.scala
index 8ebc680e6d..780a69dfde 100644
--- a/src/library/scala/collection/immutable/TreeHashMap.scala
+++ b/src/library/scala/collection/immutable/TreeHashMap.scala
@@ -112,7 +112,7 @@ class TreeHashMap[Key, +Value] private (private val underlying : IntMap[AssocMap
     underlying.updateWith[AssocMap[Key, S]](hash(key), AssocMap.singleton[Key, S](key, value), (x, y) => y.merge(x))
   )
 
-  def minus(key : Key) : TreeHashMap[Key, Value] = {
+  def -(key : Key) : TreeHashMap[Key, Value] = {
     val h = hash(key);
     underlying.get(h) match {
       case None => this;
@@ -254,7 +254,7 @@ private[collection] sealed abstract class AssocMap[Key, +Value] extends immutabl
       else Cons(key, newval, newtail);
   }
 
-  def minus(key : Key) : AssocMap[Key, Value]= this match {
+  def -(key : Key) : AssocMap[Key, Value]= this match {
     case Nil() => this;
     case Cons(key2, value, tail) =>
       if (key == key2) tail;
diff --git a/src/library/scala/collection/immutable/TreeMap.scala b/src/library/scala/collection/immutable/TreeMap.scala
index 34e5e977e8..fd596465a0 100644
--- a/src/library/scala/collection/immutable/TreeMap.scala
+++ b/src/library/scala/collection/immutable/TreeMap.scala
@@ -74,7 +74,7 @@ class TreeMap[A <% Ordered[A], +B](override val size: Int, t: RedBlack[A]#Tree[B
    *  @param value ...
    *  @return ...
    */
-  def updated [B1 >: B](key: A, value: B1): TreeMap[A, B1] = {
+  override def updated [B1 >: B](key: A, value: B1): TreeMap[A, B1] = {
     val newsize = if (tree.lookup(key).isEmpty) size + 1 else size
     newMap(newsize, tree.update(key, value))
   }
@@ -104,7 +104,7 @@ class TreeMap[A <% Ordered[A], +B](override val size: Int, t: RedBlack[A]#Tree[B
     newMap(size + 1, tree.update(key, value))
   }
 
-  def minus (key:A): TreeMap[A, B] =
+  def - (key:A): TreeMap[A, B] =
     if (tree.lookup(key).isEmpty) this
     else newMap(size - 1, tree.delete(key))
 
diff --git a/src/library/scala/collection/immutable/TreeSet.scala b/src/library/scala/collection/immutable/TreeSet.scala
index 84715d2363..0f352356b8 100644
--- a/src/library/scala/collection/immutable/TreeSet.scala
+++ b/src/library/scala/collection/immutable/TreeSet.scala
@@ -53,7 +53,7 @@ class TreeSet[A <% Ordered[A]](override val size: Int, t: RedBlack[A]#Tree[Unit]
 
   /** A new TreeSet with the entry added is returned,
    */
-  def plus (elem: A): TreeSet[A] = {
+  def + (elem: A): TreeSet[A] = {
     val newsize = if (tree.lookup(elem).isEmpty) size + 1 else size
     newSet(newsize, tree.update(elem, ()))
   }
@@ -66,7 +66,7 @@ class TreeSet[A <% Ordered[A]](override val size: Int, t: RedBlack[A]#Tree[Unit]
     newSet(size + 1, tree.update(elem, ()))
   }
 
-  def minus (elem:A): TreeSet[A] =
+  def - (elem:A): TreeSet[A] =
     if (tree.lookup(elem).isEmpty) this
     else newSet(size - 1, tree.delete(elem))
 
diff --git a/src/library/scala/collection/mutable/BitSet.scala b/src/library/scala/collection/mutable/BitSet.scala
index 67ca52fba8..9518597b2f 100644
--- a/src/library/scala/collection/mutable/BitSet.scala
+++ b/src/library/scala/collection/mutable/BitSet.scala
@@ -32,7 +32,7 @@ class BitSet (protected var elems: Array[Long]) extends Set[Int] with collection
   /** Adds element to bitset,
    *  @return element was already present.
    */
-  def put (elem: Int): Boolean = {
+  override def put (elem: Int): Boolean = {
     require(elem >= 0)
     if (contains(elem)) true
     else {
@@ -45,7 +45,7 @@ class BitSet (protected var elems: Array[Long]) extends Set[Int] with collection
   /** Removes element from bitset.
    *  @return element was already present.
    */
-  def remove (elem: Int): Boolean = {
+  override def remove (elem: Int): Boolean = {
     require(elem >= 0)
     if (contains(elem)) {
       val idx = elem >> LogWL
@@ -54,6 +54,9 @@ class BitSet (protected var elems: Array[Long]) extends Set[Int] with collection
     } else false
   }
 
+  def += (elem: Int): this.type = { put(elem); this }
+  def -= (elem: Int): this.type = { remove(elem); this }
+
   def toImmutable = immutable.BitSet.fromArray(elems)
 
   override def clone(): BitSet = {
diff --git a/src/library/scala/collection/mutable/DefaultMapModel.scala b/src/library/scala/collection/mutable/DefaultMapModel.scala
index ee1b978065..9acf089506 100644
--- a/src/library/scala/collection/mutable/DefaultMapModel.scala
+++ b/src/library/scala/collection/mutable/DefaultMapModel.scala
@@ -32,12 +32,14 @@ trait DefaultMapModel[A, B] extends Map[A, B] {
     else Some(e.value)
   }
 
-  def put(key: A, value: B): Option[B] = {
+  override def put(key: A, value: B): Option[B] = {
     val e = findEntry(key)
     if (e == null) { addEntry(new Entry(key, value)); None }
     else { val v = e.value; e.value = value; Some(v) }
   }
 
+  def += (kv: (A, B)): this.type = { put(kv._1, kv._2); this }
+
   def elements = entries map {e => (e.key, e.value)}
 }
 
diff --git a/src/library/scala/collection/mutable/HashMap.scala b/src/library/scala/collection/mutable/HashMap.scala
index a44a6bdcc5..a2cce3358b 100644
--- a/src/library/scala/collection/mutable/HashMap.scala
+++ b/src/library/scala/collection/mutable/HashMap.scala
@@ -20,11 +20,13 @@ class HashMap[A, B] extends Map[A, B] with MutableMapTemplate[A, B, HashMap[A, B
   override def empty: HashMap[A, B] = HashMap.empty[A, B]
   override def mapBuilder[A, B]: Builder[(A, B), HashMap[A, B]] = HashMap.newBuilder[A, B]
 
-  def remove(key: A): Option[B] = removeEntry(key) match {
+  override def remove(key: A): Option[B] = removeEntry(key) match {
     case Some(e) => Some(e.value)
     case None => None
   }
 
+  override def -=(key: A): this.type = { remove(key); this }
+
   override def clear() = super.clear()
 
   override def size: Int = super[HashTable].size
diff --git a/src/library/scala/collection/mutable/HashSet.scala b/src/library/scala/collection/mutable/HashSet.scala
index 971e70ad1a..b72f3dc6fd 100644
--- a/src/library/scala/collection/mutable/HashSet.scala
+++ b/src/library/scala/collection/mutable/HashSet.scala
@@ -29,9 +29,11 @@ class HashSet[A] extends Set[A] with MutableSetTemplate[A, HashSet[A]] with Flat
 
   def contains(elem: A): Boolean = containsEntry(elem)
 
-  def put(elem: A): Boolean = addEntry(elem)
+  def += (elem: A): this.type = { addEntry(elem); this }
+  def -= (elem: A): this.type = { removeEntry(elem); this }
 
-  def remove(elem: A): Boolean = !removeEntry(elem).isEmpty
+  override def put(elem: A): Boolean = addEntry(elem)
+  override def remove(elem: A): Boolean = !removeEntry(elem).isEmpty
 
   override def clear() = super.clear()
 
diff --git a/src/library/scala/collection/mutable/LinkedHashMap.scala b/src/library/scala/collection/mutable/LinkedHashMap.scala
index 954821715c..e02e574c43 100644
--- a/src/library/scala/collection/mutable/LinkedHashMap.scala
+++ b/src/library/scala/collection/mutable/LinkedHashMap.scala
@@ -37,6 +37,8 @@ class LinkedHashMap[A, B] extends Map[A,B] with HashTable[A] with DefaultMapMode
 
   private var ordered = List[Entry]()
 
+  def -= (key: A): this.type = { remove(key); this }
+
   override def remove(key: A): Option[B] = removeEntry(key) match {
     case None => None
     case Some(e) =>
@@ -44,8 +46,6 @@ class LinkedHashMap[A, B] extends Map[A,B] with HashTable[A] with DefaultMapMode
       Some(e.value)
     }
 
-  override def delete (key: A) { remove(key) }
-
   override def put(key: A, value: B): Option[B] = {
     val e = findEntry(key)
     if (e == null) {
diff --git a/src/library/scala/collection/mutable/LinkedHashSet.scala b/src/library/scala/collection/mutable/LinkedHashSet.scala
index 481c8667dc..1b3c9e29fc 100644
--- a/src/library/scala/collection/mutable/LinkedHashSet.scala
+++ b/src/library/scala/collection/mutable/LinkedHashSet.scala
@@ -33,13 +33,16 @@ class LinkedHashSet[A] extends Set[A] with MutableSetTemplate[A, LinkedHashSet[A
 
   def contains(elem: A): Boolean = containsEntry(elem)
 
-  def put(elem: A): Boolean =
+  def += (elem: A): this.type = { put(elem); this }
+  def -= (elem: A): this.type = { remove(elem); this }
+
+  override def put(elem: A): Boolean =
     if (addEntry(elem)) {
       ordered = elem :: ordered
       true
     } else false
 
-  def remove(elem: A): Boolean = removeEntry(elem) match {
+  override def remove(elem: A): Boolean = removeEntry(elem) match {
     case None => false
     case Some(elem) => ordered = ordered.filter(_ != elem); true
   }
diff --git a/src/library/scala/collection/mutable/OpenHashMap.scala b/src/library/scala/collection/mutable/OpenHashMap.scala
index 3c84721b9e..5a0810cfe4 100644
--- a/src/library/scala/collection/mutable/OpenHashMap.scala
+++ b/src/library/scala/collection/mutable/OpenHashMap.scala
@@ -106,6 +106,9 @@ class OpenHashMap[Key, Value](initialSize : Int) extends scala.collection.mutabl
     put(key, hashOf(key), value);
   }
 
+  def += (kv: (Key, Value)): this.type = { put(kv._1, kv._2); this }
+  def -= (key: Key): this.type = { remove(key); this }
+
   override def put(key : Key, value : Value): Option[Value] =
     put(key, hashOf(key), value)
 
@@ -137,8 +140,6 @@ class OpenHashMap[Key, Value](initialSize : Int) extends scala.collection.mutabl
     } else None
   }
 
-  override def delete(key: Key) { remove(key) }
-
   def get(key : Key) : Option[Value] = {
     val hash = hashOf(key);
 
diff --git a/src/library/scala/collection/mutable/Set.scala b/src/library/scala/collection/mutable/Set.scala
index c2b8ca1c2d..79a31cc5ef 100644
--- a/src/library/scala/collection/mutable/Set.scala
+++ b/src/library/scala/collection/mutable/Set.scala
@@ -17,9 +17,9 @@ import generic._
  *  have to provide functionality for the abstract methods in Set:
  *
  *  def contains(elem: A): Boolean
- *  def put(elem: A): Boolean
- *  def remove(elem: A): Boolean
  *  def elements: Iterator[A]
+ *  def += (elem: A): this.type
+ *  def -= (elem: A): this.type
  *
  *  @author Matthias Zenger
  *  @author Martin Odersky