Remove the boilerplate associated with the new design (and more)

- The respective `CC` types are exposed (to `protected[this]`) through
  aliases `IterableCC`, `SortedIterableCC`, `MapCC` and `SortedMapCC`
  in the respective `Ops` traits, plus a `BitSetC` for the shared
  `BitSetOps` trait.

- This allows defining `fromSpecificIterable`, `newSpecificBuilder`
  and `empty` (for all but `Iterable`) in the respective collection
  traits `Iterable`, `SortedSet`, `Map` and `SortedMap` (*not* in their
  `Ops` traits) where the `CC` type is visible and set to a concrete
  type but can still be refined in subtypes. This gives us a valid
  implementation until a concrete collection type with a refined `CC`
  gets defined. In this case the inherited implementations have the
  wrong type, so the user is forced to override them.

- Implementations of `fromSpecificIterable`, `newSpecificBuilder` and
  `empty` can be removed from almost all collection implementations
  except the ones where they need to be refined even further than what
  a factory can provide (e.g. `IntMap`, `PriorityQueue`).

- Factories are generally overridden in abstract collection types that
  refine a `CC` (e.g. `Iterable` -> `Seq` -> `immutable.Set` ->
  `immutable.IndexedSeq`) so that concrete implementations without
  further refinement do not need to override them.

- DefaultMap is deprecated because there is no more boilerplate left
  that it could implement.

- `sortedFromIterable`, `mapFromIterable` and `sortedMapFromIterable`
  are treated the same way as `fromIterable`. They are implemented as
  `inline final` calls to the respective factory method.

Fixes scala/collection-strawman#335

Author: szeiger

src/main/scala/strawman/collection/MultiDict.scala

@@ -11,6 +11,11 @@ trait MultiDict[K, V]
     with MultiDictOps[K, V, MultiDict, MultiDict[K, V]]
     with Equals {
 
+  def multiMapFactory: MapFactory[MultiDictCC] = MultiDict
+
+  override protected[this] def fromSpecificIterable(coll: Iterable[(K, V)]): MultiDictCC[K, V] = multiMapFactory.from(coll)
+  override protected[this] def newSpecificBuilder(): mutable.Builder[(K, V), MultiDictCC[K, V]] = multiMapFactory.newBuilder[K, V]()
+
   def canEqual(that: Any): Boolean = true
 
   override def equals(o: Any): Boolean = o match {
@@ -35,7 +40,9 @@ trait MultiDict[K, V]
 trait MultiDictOps[K, V, +CC[X, Y] <: MultiDict[X, Y], +C <: MultiDict[K, V]]
   extends IterableOps[(K, V), Iterable, C] {
 
-  def multiMapFactory: MapFactory[CC]
+  protected[this] type MultiDictCC[K, V] = CC[K, V]
+
+  def multiMapFactory: MapFactory[MultiDictCC]
 
   protected[this] def multiMapFromIterable[L, W](it: Iterable[(L, W)]): CC[L, W] =
     multiMapFactory.from(it)

src/main/scala/strawman/collection/SortedMultiDict.scala

@@ -12,14 +12,17 @@ trait SortedMultiDict[K, V]
 
   def unsorted: MultiDict[K, V] = this
 
+  override protected[this] def fromSpecificIterable(coll: Iterable[(K, V)]): SortedMultiDictCC[K, V] = sortedMultiMapFactory.from(coll)
+  override protected[this] def newSpecificBuilder(): mutable.Builder[(K, V), SortedMultiDictCC[K, V]] = sortedMultiMapFactory.newBuilder[K, V]()
 }
 
 trait SortedMultiDictOps[K, V, +CC[X, Y] <: MultiDict[X, Y], +C <: MultiDict[K, V]]
   extends MultiDictOps[K, V, MultiDict, C]
     with SortedOps[K, C] {
 
-  def multiMapFactory: MapFactory[MultiDict] = MultiDict
-  def sortedMultiMapFactory: SortedMapFactory[CC]
+  protected[this] type SortedMultiDictCC[K, V] = CC[K, V]
+
+  def sortedMultiMapFactory: SortedMapFactory[SortedMultiDictCC]
 
   protected[this] def sortedFromIterable[L : Ordering, W](it: Iterable[(L, W)]): CC[L, W]
   protected[this] def sortedFromSets[L : Ordering, W](it: Iterable[(L, Set[W])]): CC[L, W] =

src/main/scala/strawman/collection/SortedMultiSet.scala

@@ -12,15 +12,23 @@ trait SortedMultiSet[A]
 
   def unsorted: MultiSet[A] = this
 
+  override protected[this] def fromSpecificIterable(coll: Iterable[A]): SortedIterableCC[A] = sortedIterableFactory.from(coll)
+  override protected[this] def newSpecificBuilder(): mutable.Builder[A, SortedIterableCC[A]] = sortedIterableFactory.newBuilder[A]()
+
+  protected[this] def sortedFromIterable[B : Ordering](it: strawman.collection.Iterable[B]): SortedIterableCC[B] = sortedIterableFactory.from(it)
+
+  def sortedIterableFactory: SortedIterableFactory[SortedIterableCC] = SortedMultiSet
 }
 
 trait SortedMultiSetOps[A, +CC[X] <: MultiSet[X], +C <: MultiSet[A]]
   extends MultiSetOps[A, MultiSet, C]
     with SortedOps[A, C] {
 
-  def sortedIterableFactory: SortedIterableFactory[CC]
+  protected[this] type SortedIterableCC[X] = CC[X]
+
+  def sortedIterableFactory: SortedIterableFactory[SortedIterableCC]
 
-  protected[this] def sortedFromIterable[B : Ordering](it: Iterable[B]): CC[B]
+  protected[this] def sortedFromIterable[B : Ordering](it: Iterable[B]): SortedIterableCC[B]
   protected[this] def sortedFromOccurrences[B : Ordering](it: Iterable[(B, Int)]): CC[B] =
     sortedFromIterable(it.view.flatMap { case (b, n) => View.Fill(n)(b) })
 

src/main/scala/strawman/collection/immutable/MultiDict.scala

@@ -18,11 +18,7 @@ class MultiDict[K, V] private (elems: Map[K, Set[V]])
 
   def sets: Map[K, Set[V]] = elems
 
-  def iterableFactory: IterableFactory[Iterable] = Iterable
-  def multiMapFactory: MapFactory[MultiDict] = MultiDict
-
-  protected[this] def fromSpecificIterable(coll: collection.Iterable[(K, V)]): MultiDict[K, V] = multiMapFromIterable(coll)
-  protected[this] def newSpecificBuilder(): Builder[(K, V), MultiDict[K, V]] = multiMapFactory.newBuilder[K, V]()
+  override def multiMapFactory: MapFactory[MultiDict] = MultiDict
 
   /**
     * @return a new multidict that contains all the entries of this multidict

src/main/scala/strawman/collection/immutable/MultiSet.scala

@@ -17,9 +17,7 @@ class MultiSet[A] private (elems: Map[A, Int])
 
   def occurrences: Map[A, Int] = elems
 
-  def iterableFactory: IterableFactory[MultiSet] = MultiSet
-  protected[this] def fromSpecificIterable(coll: collection.Iterable[A]): MultiSet[A] = fromIterable(coll)
-  protected[this] def newSpecificBuilder(): Builder[A, MultiSet[A]] = iterableFactory.newBuilder()
+  override def iterableFactory: IterableFactory[MultiSet] = MultiSet
 
   /**
     * @return an immutable multiset containing all the elements of this multiset

src/main/scala/strawman/collection/immutable/SortedMultiDict.scala

@@ -17,11 +17,8 @@ class SortedMultiDict[K, V] private (elems: SortedMap[K, Set[V]])(implicit val o
     with collection.IterableOps[(K, V), Iterable, SortedMultiDict[K, V]] {
 
   def sortedMultiMapFactory: SortedMapFactory[SortedMultiDict] = SortedMultiDict
-  def iterableFactory: IterableFactory[Iterable] = Iterable
 
-  protected[this] def fromSpecificIterable(coll: collection.Iterable[(K, V)]): SortedMultiDict[K, V] = sortedMultiMapFactory.from(coll)
   protected[this] def sortedFromIterable[L: Ordering, W](it: collection.Iterable[(L, W)]): SortedMultiDict[L, W] = sortedMultiMapFactory.from(it)
-  protected[this] def newSpecificBuilder(): Builder[(K, V), SortedMultiDict[K, V]] = sortedMultiMapFactory.newBuilder()
 
   def sets: SortedMap[K, Set[V]] = elems
 

src/main/scala/strawman/collection/immutable/SortedMultiSet.scala

@@ -17,12 +17,8 @@ class SortedMultiSet[A] private (elems: SortedMap[A, Int])(implicit val ordering
 
   def occurrences: SortedMap[A, Int] = elems
 
-  def iterableFactory: IterableFactory[MultiSet] = MultiSet
-  def sortedIterableFactory: SortedIterableFactory[SortedMultiSet] = SortedMultiSet
-
-  protected[this] def fromSpecificIterable(coll: collection.Iterable[A]): SortedMultiSet[A] = sortedFromIterable(coll)
-  protected[this] def sortedFromIterable[B : Ordering](it: collection.Iterable[B]): SortedMultiSet[B] = sortedIterableFactory.from(it)
-  protected[this] def newSpecificBuilder(): Builder[A, SortedMultiSet[A]] = sortedIterableFactory.newBuilder()
+  override def iterableFactory: IterableFactory[MultiSet] = MultiSet
+  override def sortedIterableFactory: SortedIterableFactory[SortedMultiSet] = SortedMultiSet
 
   def rangeImpl(from: Option[A], until: Option[A]): SortedMultiSet[A] =
     new SortedMultiSet(elems.rangeImpl(from, until))

src/main/scala/strawman/collection/mutable/MultiDict.scala

@@ -15,10 +15,7 @@ class MultiDict[K, V] private (elems: Map[K, Set[V]])
     with Growable[(K, V)]
     with Shrinkable[(K, V)] {
 
-  def iterableFactory: IterableFactory[collection.Iterable] = collection.Iterable
-  def multiMapFactory: MapFactory[MultiDict] = MultiDict
-  protected[this] def fromSpecificIterable(coll: collection.Iterable[(K, V)]): MultiDict[K, V] = multiMapFactory.from(coll)
-  protected[this] def newSpecificBuilder(): Builder[(K, V), MultiDict[K, V]] = multiMapFactory.newBuilder()
+  override def multiMapFactory: MapFactory[MultiDict] = MultiDict
 
   def sets: collection.Map[K, collection.Set[V]] = elems
 

src/main/scala/strawman/collection/mutable/MultiSet.scala

@@ -13,9 +13,7 @@ class MultiSet[A] private (val elems: Map[A, Int])
     with Growable[A]
     with Shrinkable [A] {
 
-  def iterableFactory: IterableFactory[MultiSet] = MultiSet
-  protected[this] def fromSpecificIterable(coll: collection.Iterable[A]): MultiSet[A] = fromIterable(coll)
-  protected[this] def newSpecificBuilder(): Builder[A, MultiSet[A]] = iterableFactory.newBuilder()
+  override def iterableFactory: IterableFactory[MultiSet] = MultiSet
 
   def occurrences: collection.Map[A, Int] = elems
 

src/main/scala/strawman/collection/mutable/SortedMultiDict.scala

@@ -17,12 +17,9 @@ class SortedMultiDict[K, V] private (elems: SortedMap[K, Set[V]])(implicit val o
 
   def sets: collection.SortedMap[K, collection.Set[V]] = elems
 
-  def iterableFactory: IterableFactory[collection.Iterable] = collection.Iterable
   def sortedMultiMapFactory: SortedMapFactory[SortedMultiDict] = SortedMultiDict
 
-  protected[this] def fromSpecificIterable(coll: collection.Iterable[(K, V)]): SortedMultiDict[K, V] = sortedMultiMapFactory.from(coll)
   protected[this] def sortedFromIterable[L: Ordering, W](it: collection.Iterable[(L, W)]): SortedMultiDict[L, W] = sortedMultiMapFactory.from(it)
-  protected[this] def newSpecificBuilder(): Builder[(K, V), SortedMultiDict[K, V]] = sortedMultiMapFactory.newBuilder()
 
   def rangeImpl(from: Option[K], until: Option[K]): SortedMultiDict[K, V] =
     new SortedMultiDict(elems.rangeImpl(from, until))