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 #335

Author: szeiger

collections/src/main/scala/strawman/collection/BitSet.scala

@@ -18,7 +18,11 @@ import scala.Predef.{assert, intWrapper}
   * @define coll bitset
   * @define Coll `BitSet`
   */
-trait BitSet extends SortedSet[Int] with BitSetOps[BitSet]
+trait BitSet extends SortedSet[Int] with BitSetOps[BitSet] {
+  override protected[this] def fromSpecificIterable(coll: Iterable[Int]): BitSetC = bitSetFactory.fromSpecific(coll)
+  override protected[this] def newSpecificBuilder(): Builder[Int, BitSetC] = bitSetFactory.newBuilder()
+  override def empty: BitSetC = bitSetFactory.empty
+}
 
 object BitSet extends SpecificIterableFactory[Int, BitSet] {
   def empty: BitSet = immutable.BitSet.empty
@@ -31,6 +35,10 @@ trait BitSetOps[+C <: BitSet with BitSetOps[C]]
   extends SortedSetOps[Int, SortedSet, C] { self =>
   import BitSetOps._
 
+  def bitSetFactory: SpecificIterableFactory[Int, BitSetC]
+
+  protected[this] type BitSetC = C
+
   final def ordering: Ordering[Int] = Ordering.Int
 
   /** The number of words (each with 64 bits) making up the set */

collections/src/main/scala/strawman/collection/DefaultMap.scala

@@ -9,29 +9,12 @@
 package strawman
 package collection
 
+import scala.deprecated
+
 /** A default map which builds a default `immutable.Map` implementation for all
   * transformations.
   *
-  *  Instances that inherit from `DefaultMap[K, V]` still have to define:
-  *  {{{
-  *    def get(key: K): Option[V]
-  *    def iterator(): Iterator[(K, V)]
-  *  }}}
-  *
-  *  It might also be advisable to override `foreach` or `size` if efficient
-  *  implementations can be found.
-  *
   *  @since 2.8
   */
-trait DefaultMap[K, +V] extends Map[K, V] { self =>
-
-  // Members declared in IterableOps
-  def iterableFactory: IterableFactory[Iterable] = Iterable
-  protected[this] def fromSpecificIterable(coll: Iterable[(K, V)]): Map[K,V] = mapFactory.from(coll)
-  protected[this] def newSpecificBuilder(): mutable.Builder[(K, V), Map[K,V]] = mapFactory.newBuilder()
-
-  // Members declared in MapOps
-  def mapFactory: MapFactory[Map] = Map
-  def empty: Map[K,V] = mapFactory.empty
-  protected[this] def mapFromIterable[K2, V2](it: Iterable[(K2, V2)]): Map[K2,V2] = mapFactory.from(it)
-}
+@deprecated("DefaultMap is no longer necessary; extend Map directly", "2.13.0")
+trait DefaultMap[K, +V] extends Map[K, V]

collections/src/main/scala/strawman/collection/Iterable.scala

@@ -26,6 +26,10 @@ trait Iterable[+A] extends IterableOnce[A] with IterableOps[A, Iterable, Iterabl
   //TODO scalac generates an override for this in AbstractMap; Making it final leads to a VerifyError
   protected[this] def coll: this.type = this
 
+  protected[this] def fromSpecificIterable(coll: Iterable[A]): IterableCC[A] = iterableFactory.from(coll)
+  protected[this] def newSpecificBuilder(): Builder[A, IterableCC[A]] = iterableFactory.newBuilder[A]()
+
+  def iterableFactory: IterableFactory[IterableCC] = Iterable
 }
 
 /** Base trait for Iterable operations
@@ -64,6 +68,8 @@ trait Iterable[+A] extends IterableOnce[A] with IterableOps[A, Iterable, Iterabl
   */
 trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
 
+  protected[this] type IterableCC[X] = CC[X]
+
   /**
     * @return This collection as an `Iterable[A]`. No new collection will be built if `this` is already an `Iterable[A]`.
     */
@@ -91,7 +97,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
   /**
     * @return The companion object of this ${coll}, providing various factory methods.
     */
-  def iterableFactory: IterableFactory[CC]
+  def iterableFactory: IterableFactory[IterableCC]
 
   /**
     * @return a strict builder for the same collection type.
@@ -1220,4 +1226,4 @@ object Iterable extends IterableFactory.Delegate[Iterable](immutable.Iterable) {
   implicit def toLazyZipOps[A, CC[X] <: Iterable[X]](that: CC[A]): LazyZipOps[A, CC[A]] = new LazyZipOps(that)
 }
 
-abstract class AbstractIterable[+A] extends Iterable[A]
+abstract class AbstractIterable[+A] extends Iterable[A]

collections/src/main/scala/strawman/collection/Map.scala

@@ -15,6 +15,13 @@ trait Map[K, +V]
     with MapOps[K, V, Map, Map[K, V]]
     with Equals {
 
+  override protected[this] def fromSpecificIterable(coll: Iterable[(K, V)]): MapCC[K, V] = mapFactory.from(coll)
+  override protected[this] def newSpecificBuilder(): mutable.Builder[(K, V), MapCC[K, V]] = mapFactory.newBuilder[K, V]()
+
+  def mapFactory: strawman.collection.MapFactory[MapCC] = Map
+
+  def empty: MapCC[K, V] = mapFactory.empty
+
   def canEqual(that: Any): Boolean = true
 
   override def equals(o: Any): Boolean = o match {
@@ -52,10 +59,12 @@ trait MapOps[K, +V, +CC[X, Y] <: MapOps[X, Y, CC, _], +C]
     with PartialFunction[K, V]
     with Equals {
 
-  /** Similar to fromIterable, but returns a Map collection type */
-  protected[this] def mapFromIterable[K2, V2](it: Iterable[(K2, V2)]): CC[K2, V2]
+  protected[this] type MapCC[K, V] = CC[K, V]
+
+  /** Similar to `fromIterable`, but returns a Map collection type */
+  @`inline` protected[this] final def mapFromIterable[K2, V2](it: Iterable[(K2, V2)]): CC[K2, V2] = mapFactory.from(it)
 
-  def mapFactory: MapFactory[CC]
+  def mapFactory: MapFactory[MapCC]
 
   /** Optionally returns the value associated with a key.
     *
@@ -107,11 +116,7 @@ trait MapOps[K, +V, +CC[X, Y] <: MapOps[X, Y, CC, _], +C]
     */
   @SerialVersionUID(3L)
   protected class KeySet extends Set[K] with GenKeySet {
-    def iterableFactory: IterableFactory[Set] = Set
-    protected[this] def fromSpecificIterable(coll: Iterable[K]): Set[K] = fromIterable(coll)
-    protected[this] def newSpecificBuilder(): Builder[K, Set[K]] = iterableFactory.newBuilder()
     def diff(that: Set[K]): Set[K] = fromSpecificIterable(view.filterNot(that))
-    def empty: Set[K] = iterableFactory.empty
   }
 
   /** A generic trait that is reused by keyset implementations */

collections/src/main/scala/strawman/collection/Seq.scala

@@ -20,7 +20,7 @@ trait Seq[+A]
     with SeqOps[A, Seq, Seq[A]]
     with Equals {
 
-  def iterableFactory: SeqFactory[Seq]
+  override def iterableFactory: SeqFactory[IterableCC] = Seq
 
   /** Method called from equality methods, so that user-defined subclasses can
     *  refuse to be equal to other collections of the same kind.

collections/src/main/scala/strawman/collection/Set.scala

@@ -28,6 +28,7 @@ trait Set[A]
 
   override def hashCode(): Int = Set.setHash(toIterable)
 
+  def empty: IterableCC[A] = iterableFactory.empty
 }
 
 /** Base trait for set operations

collections/src/main/scala/strawman/collection/SortedMap.scala

@@ -5,22 +5,33 @@ import strawman.collection.immutable.TreeMap
 import strawman.collection.mutable.Builder
 
 import scala.annotation.unchecked.uncheckedVariance
-import scala.{Boolean, Int, Option, Ordering, PartialFunction, Serializable, SerialVersionUID, `inline`}
+import scala.{Boolean, Int, Option, Ordering, PartialFunction, Serializable, SerialVersionUID, `inline`, Any}
 
 /** Base type of sorted sets */
 trait SortedMap[K, +V]
   extends Map[K, V]
     with SortedMapOps[K, V, SortedMap, SortedMap[K, V]] {
+
   def unsorted: Map[K, V] = this
+
+  override protected[this] def fromSpecificIterable(coll: Iterable[(K, V)]): SortedMapCC[K, V] = sortedMapFactory.from(coll)
+  override protected[this] def newSpecificBuilder(): mutable.Builder[(K, V), SortedMapCC[K, V]] = sortedMapFactory.newBuilder[K, V]()
+
+  def sortedMapFactory: SortedMapFactory[SortedMapCC] = SortedMap
+
+  override def empty: SortedMapCC[K, V] = sortedMapFactory.empty
 }
 
 trait SortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMapOps[K, V, CC, C]]
   extends MapOps[K, V, Map, C]
      with SortedOps[K, C] {
 
-  def sortedMapFactory: SortedMapFactory[CC]
+  protected[this] type SortedMapCC[K, V] = CC[K, V]
+
+  def sortedMapFactory: SortedMapFactory[SortedMapCC]
 
-  protected[this] def sortedMapFromIterable[K2, V2](it: collection.Iterable[(K2, V2)])(implicit ordering: Ordering[K2]): CC[K2, V2]
+  /** Similar to `mapFromIterable`, but returns a SortedMap collection type */
+  @`inline` protected[this] final def sortedMapFromIterable[K2, V2](it: Iterable[(K2, V2)])(implicit ordering: Ordering[K2]): CC[K2, V2] = sortedMapFactory.from(it)
 
   def unsorted: Map[K, V]
 
@@ -91,13 +102,7 @@ trait SortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _],
   /** The implementation class of the set returned by `keySet` */
   @SerialVersionUID(3L)
   protected class KeySortedSet extends SortedSet[K] with GenKeySet with GenKeySortedSet {
-    def iterableFactory: IterableFactory[Set] = Set
-    def sortedIterableFactory: SortedIterableFactory[SortedSet] = SortedSet
-    protected[this] def fromSpecificIterable(coll: Iterable[K]): SortedSet[K] = sortedFromIterable(coll)
-    protected[this] def newSpecificBuilder(): Builder[K, SortedSet[K]] = sortedIterableFactory.newBuilder()
-    protected[this] def sortedFromIterable[B: Ordering](it: Iterable[B]): SortedSet[B] = sortedFromIterable(it)
     def diff(that: Set[K]): SortedSet[K] = fromSpecificIterable(view.filterNot(that))
-    def empty: SortedSet[K] = sortedIterableFactory.empty
     def rangeImpl(from: Option[K], until: Option[K]): SortedSet[K] = {
       val map = SortedMapOps.this.rangeImpl(from, until)
       new map.KeySortedSet

collections/src/main/scala/strawman/collection/SortedSet.scala

@@ -1,20 +1,32 @@
 package strawman.collection
 
-import scala.{Boolean, Ordering, `inline`, None, Option, Some}
+import scala.{Boolean, Ordering, `inline`, None, Option, Some, Any}
 import scala.annotation.unchecked.uncheckedVariance
 
 /** Base type of sorted sets */
 trait SortedSet[A] extends Set[A] with SortedSetOps[A, SortedSet, SortedSet[A]] {
   def unsorted: Set[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]()
+
+  def sortedIterableFactory: SortedIterableFactory[SortedIterableCC] = SortedSet
+
+  override def empty: SortedIterableCC[A] = sortedIterableFactory.empty
 }
 
 trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]]
   extends SetOps[A, Set, C]
      with SortedOps[A, C] {
 
-  def sortedIterableFactory: SortedIterableFactory[CC]
+  protected[this] type SortedIterableCC[X] = CC[X]
 
-  protected[this] def sortedFromIterable[B: Ordering](it: Iterable[B]): CC[B]
+  def sortedIterableFactory: SortedIterableFactory[SortedIterableCC]
+
+  /** Similar to `fromSpecificIterable`, but for a (possibly) different type of element.
+    * Note that the return type is know `CC[E]`.
+    */
+  @`inline` final protected[this] def sortedFromIterable[B: Ordering](it: Iterable[B]): CC[B] = sortedIterableFactory.from(it)
 
   def unsorted: Set[A]
 

collections/src/main/scala/strawman/collection/View.scala

@@ -15,12 +15,7 @@ import scala.Predef.{<:<, intWrapper}
 trait View[+A] extends Iterable[A] with IterableOps[A, View, View[A]] {
   override def view = this
 
-  def iterableFactory = View
-
-  protected[this] def fromSpecificIterable(coll: Iterable[A]): View[A] = fromIterable(coll)
-
-  protected[this] def newSpecificBuilder(): Builder[A, View[A]] =
-    immutable.IndexedSeq.newBuilder().mapResult(_.view)
+  override def iterableFactory = View
 
   override def toString = "View(?)"
 

collections/src/main/scala/strawman/collection/concurrent/TrieMap.scala

@@ -664,10 +664,7 @@ final class TrieMap[K, V] private (r: AnyRef, rtupd: AtomicReferenceFieldUpdater
 
   def this() = this(Hashing.default, Equiv.universal)
 
-  def mapFactory: MapFactory[TrieMap] = TrieMap
-  protected[this] def fromSpecificIterable(coll: collection.Iterable[(K, V)]): TrieMap[K,V] = TrieMap.from(coll)
-  protected[this] def mapFromIterable[K2, V2](it: collection.Iterable[(K2, V2)]): TrieMap[K2,V2] = TrieMap.from(it)
-  protected[this] def newSpecificBuilder(): Builder[(K, V), TrieMap[K,V]] = TrieMap.newBuilder[K, V]()
+  override def mapFactory: MapFactory[TrieMap] = TrieMap
 
   /* internal methods */