Retrofit BuildFrom into the new design

`BuildFrom` is like `FromSpecificIterable` but with an extra `From`
argument, like in the final version of #45. `FromSpecificIterable`
existed conceptually in that version as `BuildFrom[Any, …]` but didn’t
have a separate type.

This new version has separate abstractions for buildable (strict)
collection types in the form of `StrictBuildFrom` and
`FromSpecificIterableWithBuilder`. Since we can get a surrogate builder
(through one of the new `Builder.from` methods) for any lazy collection
and we can restrict code to work only with strict collections via the
`Buildable` trait, this is not strictly necessary. The only reason for
separating the `Builder` abstractions is to avoid exposing them in
`FromSpecificIterable`. Even though everything can be built in a strict
way, these abstractions sit on top of the lazy ones, not below them.

Author: szeiger

src/main/scala/strawman/collection/Factories.scala

@@ -1,79 +1,107 @@
 package strawman
 package collection
 
-import strawman.collection.mutable.Builder
+import scala.language.implicitConversions
+
+import strawman.collection.mutable.{ArrayBuffer, Builder}
 
 import scala.{Any, Int, Nothing, Ordering}
 import scala.annotation.unchecked.uncheckedVariance
 
+
+/** Builds a collection of type `C` from elements of type `A` when a source collection of type `From` is available.
+  * Implicit instances of `BuildFrom` are available for all collection types.
+  *
+  * @tparam From Type of source collection
+  * @tparam A Type of elements (e.g. `Int`, `Boolean`, etc.)
+  * @tparam C Type of collection (e.g. `List[Int]`, `TreeMap[Int, String]`, etc.)
+  */
+trait BuildFrom[-From, -A, +C] extends Any {
+  def fromSpecificIterable(from: From)(it: Iterable[A]): C
+
+  /** Get a Builder for the collection. For non-strict collection types this will use an intermediate buffer.
+    * Building collections with `fromSpecificIterable` is preferred because it can be lazy for lazy collections. */
+  def newBuilder(from: From): Builder[A, C]
+}
+
+object BuildFrom extends BuildFromLowPriority {
+  /** Build the source collection type from a MapOps */
+  implicit def buildFromMapOps[CC[K, V] <: Map[K, V] with MapOps[K, V, CC, _], A, B, E, F]: BuildFrom[CC[A, B], (E, F), CC[E, F]] = new BuildFrom[CC[A, B], (E, F), CC[E, F]] {
+    //TODO: Reuse a prototype instance
+    def newBuilder(from: CC[A, B]): Builder[(E, F), CC[E, F]] = from.mapFactory.newBuilder[E, F]()
+    def fromSpecificIterable(from: CC[A, B])(it: Iterable[(E, F)]): CC[E, F] = from.mapFactory.fromIterable(it)
+  }
+
+  /** Build the source collection type from a SortedMapOps */
+  implicit def buildFromSortedMapOps[CC[K, V] <: SortedMap[K, V] with SortedMapOps[K, V, CC, _], A, B, E : Ordering, F]: BuildFrom[CC[A, B], (E, F), CC[E, F]] = new BuildFrom[CC[A, B], (E, F), CC[E, F]] {
+    def newBuilder(from: CC[A, B]): Builder[(E, F), CC[E, F]] = from.sortedMapFactory.newBuilder[E, F]()
+    def fromSpecificIterable(from: CC[A, B])(it: Iterable[(E, F)]): CC[E, F] = from.sortedMapFactory.fromSpecificIterable(it)
+  }
+}
+
+trait BuildFromLowPriority {
+  /** Build the source collection type from an IterableOps */
+  implicit def buildFromIterableOps[CC[X] <: Iterable[X] with IterableOps[X, CC, _], A, E]: BuildFrom[CC[A], E, CC[E]] = new BuildFrom[CC[A], E, CC[E]] {
+    //TODO: Reuse a prototype instance
+    def newBuilder(from: CC[A]): Builder[E, CC[E]] = from.iterableFactory.newBuilder[E]()
+    def fromSpecificIterable(from: CC[A])(it: Iterable[E]): CC[E] = from.iterableFactory.fromIterable(it)
+  }
+
+  /** Build the source collection type from an Iterable with SortedOps */
+  implicit def buildFromSortedOps[CC[X] <: Iterable[X] with SortedOps[X, CC[X], CC], A, E : Ordering]: BuildFrom[CC[A], E, CC[E]] = new BuildFrom[CC[A], E, CC[E]] {
+    def newBuilder(from: CC[A]): Builder[E, CC[E]] = from.sortedIterableFactory.newBuilder[E]()
+    def fromSpecificIterable(from: CC[A])(it: Iterable[E]): CC[E] = from.sortedIterableFactory.fromSpecificIterable(it)
+  }
+}
+
 /**
   * Builds a collection of type `C` from elements of type `A`
   * @tparam A Type of elements (e.g. `Int`, `Boolean`, etc.)
   * @tparam C Type of collection (e.g. `List[Int]`, `TreeMap[Int, String]`, etc.)
   */
-trait FromSpecificIterable[-A, +C] extends Any {
+trait FromSpecificIterable[-A, +C] extends Any with BuildFrom[Any, A, C] {
+  def fromSpecificIterable(from: Any)(it: Iterable[A]): C = fromSpecificIterable(it)
   def fromSpecificIterable(it: Iterable[A]): C
+  def newBuilder(from: Any): Builder[A, C] = newBuilder
+  def newBuilder: Builder[A, C]
 }
 
 /** Base trait for companion objects of unconstrained collection types */
 trait IterableFactory[+CC[_]] {
-
   def fromIterable[E](it: Iterable[E]): CC[E]
-
   def empty[A]: CC[A]
-
   def apply[A](xs: A*): CC[A] = fromIterable(View.Elems(xs: _*))
-
   def fill[A](n: Int)(elem: => A): CC[A] = fromIterable(View.Fill(n)(elem))
-
+  def newBuilder[A](): Builder[A, CC[A]] = new ArrayBuffer[A]().mapResult(fromIterable _)
 }
 
 object IterableFactory {
-  import scala.language.implicitConversions
-
   implicit def toSpecific[A, CC[_]](factory: IterableFactory[CC]): FromSpecificIterable[A, CC[A]] =
     new FromSpecificIterable[A, CC[A]] {
       def fromSpecificIterable(it: Iterable[A]): CC[A] = factory.fromIterable[A](it)
+      def newBuilder: Builder[A, CC[A]] = factory.newBuilder[A]()
     }
 
   class Delegate[CC[_]](delegate: IterableFactory[CC]) extends IterableFactory[CC] {
     def empty[A]: CC[A] = delegate.empty
     def fromIterable[E](it: Iterable[E]): CC[E] = delegate.fromIterable(it)
-  }
-
-}
-
-trait IterableFactoryWithBuilder[+CC[_]] extends IterableFactory[CC] {
-  def newBuilder[A](): Builder[A, CC[A]]
-}
-
-object IterableFactoryWithBuilder {
-  class Delegate[CC[_]](delegate: IterableFactoryWithBuilder[CC])
-    extends IterableFactory.Delegate[CC](delegate)
-      with IterableFactoryWithBuilder[CC] {
-    def newBuilder[A](): Builder[A, CC[A]] = delegate.newBuilder()
+    override def newBuilder[A](): Builder[A, CC[A]] = delegate.newBuilder[A]()
   }
 }
 
 trait SpecificIterableFactory[-A, +C] extends FromSpecificIterable[A, C] {
   def empty: C
-
   def apply(xs: A*): C = fromSpecificIterable(View.Elems(xs: _*))
-
   def fill(n: Int)(elem: => A): C = fromSpecificIterable(View.Fill(n)(elem))
-}
-
-trait SpecificIterableFactoryWithBuilder[-A, +C] extends SpecificIterableFactory[A, C] {
-  def newBuilder(): Builder[A, C]
+  def newBuilder: Builder[A, C] = new ArrayBuffer[A]().mapResult(fromSpecificIterable _)
 }
 
 /** Factory methods for collections of kind `* −> * -> *` */
-trait MapFactory[+CC[_, _]] {
-
+trait MapFactory[+CC[X, Y]] {
   def empty[K, V]: CC[K, V]
   def fromIterable[K, V](it: Iterable[(K, V)]): CC[K, V]
-
   def apply[K, V](elems: (K, V)*): CC[K, V] = fromIterable(elems.toStrawman)
+  def newBuilder[K, V](): Builder[(K, V), CC[K, V]] = new ArrayBuffer[(K, V)]().mapResult(fromIterable _)
 }
 
 object MapFactory {
@@ -82,102 +110,58 @@ object MapFactory {
   implicit def toSpecific[K, V, CC[_, _]](factory: MapFactory[CC]): FromSpecificIterable[(K, V), CC[K, V]] =
     new FromSpecificIterable[(K, V), CC[K, V]] {
       def fromSpecificIterable(it: Iterable[(K, V)]): CC[K, V] = factory.fromIterable[K, V](it)
+      def newBuilder: Builder[(K, V), CC[K, V]] = factory.newBuilder[K, V]()
     }
 
-  class Delegate[CC[_, _]](delegate: MapFactory[CC]) extends MapFactory[CC] {
-    def fromIterable[K, V](it: Iterable[(K, V)]): CC[K, V] = delegate.fromIterable(it)
-    def empty[K, V]: CC[K, V] = delegate.empty
+  class Delegate[C[X, Y]](delegate: MapFactory[C]) extends MapFactory[C] {
+    def fromIterable[K, V](it: Iterable[(K, V)]): C[K, V] = delegate.fromIterable(it)
+    def empty[K, V]: C[K, V] = delegate.empty
+    override def newBuilder[K, V](): Builder[(K, V), C[K, V]] = delegate.newBuilder()
   }
-
-}
-
-trait MapFactoryWithBuilder[+CC[_, _]] extends MapFactory[CC] {
-  def newBuilder[K, V](): Builder[(K, V), CC[K, V]]
-}
-
-object MapFactoryWithBuilder {
-
-  class Delegate[CC[_, _]](delegate: MapFactoryWithBuilder[CC])
-    extends MapFactory.Delegate[CC](delegate)
-      with MapFactoryWithBuilder[CC] {
-    def newBuilder[K, V](): Builder[(K, V), CC[K, V]] = delegate.newBuilder()
-  }
-
 }
 
 /** Base trait for companion objects of collections that require an implicit evidence */
 trait SortedIterableFactory[+CC[_]] {
-
   def sortedFromIterable[E : Ordering](it: Iterable[E]): CC[E]
-
   def empty[A : Ordering]: CC[A]
-
   def apply[A : Ordering](xs: A*): CC[A] = sortedFromIterable(View.Elems(xs: _*))
-
   def fill[A : Ordering](n: Int)(elem: => A): CC[A] = sortedFromIterable(View.Fill(n)(elem))
+  def newBuilder[A : Ordering](): Builder[A, CC[A]] = new ArrayBuffer[A]().mapResult(sortedFromIterable[A] _)
 }
 
 object SortedIterableFactory {
-  import scala.language.implicitConversions
-
   implicit def toSpecific[A: Ordering, CC[_]](factory: SortedIterableFactory[CC]): FromSpecificIterable[A, CC[A]] =
     new FromSpecificIterable[A, CC[A]] {
       def fromSpecificIterable(it: Iterable[A]): CC[A] = factory.sortedFromIterable[A](it)
+      def newBuilder: Builder[A, CC[A]] = factory.newBuilder[A]()
     }
 
   class Delegate[CC[_]](delegate: SortedIterableFactory[CC]) extends SortedIterableFactory[CC] {
     def empty[A : Ordering]: CC[A] = delegate.empty
     def sortedFromIterable[E : Ordering](it: Iterable[E]): CC[E] = delegate.sortedFromIterable(it)
-  }
-
-}
-
-trait SortedIterableFactoryWithBuilder[+CC[_]] extends SortedIterableFactory[CC] {
-  def newBuilder[A : Ordering](): Builder[A, CC[A]]
-}
-
-object SortedIterableFactoryWithBuilder {
-  class Delegate[CC[_]](delegate: SortedIterableFactoryWithBuilder[CC])
-    extends SortedIterableFactory.Delegate[CC](delegate)
-      with SortedIterableFactoryWithBuilder[CC] {
-    def newBuilder[A: Ordering](): Builder[A, CC[A]] = delegate.newBuilder()
+    override def newBuilder[A : Ordering](): Builder[A, CC[A]] = delegate.newBuilder[A]()
   }
 }
 
 /** Factory methods for collections of kind `* −> * -> *` which require an implicit evidence value for the key type */
 trait SortedMapFactory[+CC[X, Y]] {
-
   def empty[K : Ordering, V]: CC[K, V]
-
   def sortedFromIterable[K : Ordering, V](it: Iterable[(K, V)]): CC[K, V]
-
   def apply[K : Ordering, V](elems: (K, V)*): CC[K, V] =
     sortedFromIterable(elems.toStrawman)
+  def newBuilder[K : Ordering, V](): Builder[(K, V), CC[K, V]] = new ArrayBuffer[(K, V)]().mapResult(sortedFromIterable[K, V] _)
 }
 
 object SortedMapFactory {
-  import scala.language.implicitConversions
-
-  implicit def toSpecific[K : Ordering, V, CC[_, _]](factory: SortedMapFactory[CC]): FromSpecificIterable[(K, V), CC[K, V]] =
+  implicit def toSpecific[K : Ordering, V, CC[X, Y]](factory: SortedMapFactory[CC]): FromSpecificIterable[(K, V), CC[K, V]] =
     new FromSpecificIterable[(K, V), CC[K, V]] {
-      def fromSpecificIterable(it: Iterable[(K, V)]): CC[K, V] = factory.sortedFromIterable(it)
+      def fromSpecificIterable(it: Iterable[(K, V)]): CC[K, V] = factory.sortedFromIterable[K, V](it)
+      def newBuilder: Builder[(K, V), CC[K, V]] = factory.newBuilder[K, V]()
     }
 
-  class Delegate[CC[_, _]](delegate: SortedMapFactory[CC]) extends SortedMapFactory[CC] {
-    def empty[K: Ordering, V]: CC[K, V] = delegate.empty[K, V]
-    def sortedFromIterable[K: Ordering, V](it: Iterable[(K, V)]): CC[K, V] = delegate.sortedFromIterable(it)
-  }
-
-}
-
-trait SortedMapFactoryWithBuilder[+CC[_, _]] extends SortedMapFactory[CC] {
-  def newBuilder[K : Ordering, V](): Builder[(K, V), CC[K, V]]
-}
-
-object SortedMapFactoryWithBuilder {
-  class Delegate[CC[_, _]](delegate: SortedMapFactoryWithBuilder[CC])
-    extends SortedMapFactory.Delegate[CC](delegate)
-      with SortedMapFactoryWithBuilder[CC] {
-    def newBuilder[K: Ordering, V](): Builder[(K, V), CC[K, V]] = delegate.newBuilder()
+  class Delegate[C[X, Y]](delegate: SortedMapFactory[C]) extends SortedMapFactory[C] {
+    def sortedFromIterable[K : Ordering, V](it: Iterable[(K, V)]): C[K, V] = delegate.sortedFromIterable(it)
+    def empty[K : Ordering, V]: C[K, V] = delegate.empty
+    override def newBuilder[K : Ordering, V](): Builder[(K, V), C[K, V]] = delegate.newBuilder()
   }
 }

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

@@ -21,6 +21,8 @@ trait MapOps[K, +V, +CC[X, Y] <: Map[X, Y], +C <: Map[K, V]]
   /** Similar to fromIterable, but returns a Map collection type */
   protected[this] def mapFromIterable[K2, V2](it: Iterable[(K2, V2)]): CC[K2, V2]
 
+  def mapFactory: MapFactory[CC]
+
   /** Optionally returns the value associated with a key.
     *
     *  @param  key    the key value

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

@@ -12,7 +12,11 @@ trait SortedMap[K, +V]
 
 trait SortedMapOps[K, +V, +CC[X, Y] <: SortedMap[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMap[K, V]]
   extends MapOps[K, V, Map, C]
-     with SortedOps[K, C] {
+     with SortedOps[K, C, SortedSet] {
+
+  def sortedIterableFactory = SortedSet
+
+  def sortedMapFactory: SortedMapFactory[CC]
 
   protected[this] def sortedMapFromIterable[K2, V2](it: collection.Iterable[(K2, V2)])(implicit ordering: Ordering[K2]): CC[K2, V2]
 

src/main/scala/strawman/collection/SortedOps.scala

@@ -3,10 +3,12 @@ package strawman.collection
 import scala.{Ordering, Option, Some}
 
 /** Base trait for sorted collections */
-trait SortedOps[A, +C] {
+trait SortedOps[A, +C, +CC[_]] {
 
   implicit def ordering: Ordering[A]
 
+  def sortedIterableFactory: SortedIterableFactory[CC]
+
   /** Returns the first key of the collection. */
   def firstKey: A
 

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

@@ -9,7 +9,7 @@ trait SortedSet[A] extends Set[A] with SortedSetOps[A, SortedSet, SortedSet[A]]
 
 trait SortedSetOps[A, +CC[X], +C <: SortedSet[A]]
   extends SetOps[A, Set, C]
-     with SortedOps[A, C] {
+     with SortedOps[A, C, CC] {
 
   protected[this] def sortedFromIterable[B: Ordering](it: Iterable[B]): CC[B]
 

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

@@ -28,6 +28,7 @@ sealed abstract class BitSet
   def empty: BitSet = BitSet.empty
 
   def iterableFactory = Set
+  def sortedIterableFactory = SortedSet
 
   protected[this] def fromSpecificIterable(coll: collection.Iterable[Int]): BitSet = BitSet.fromSpecificIterable(coll)
   protected[this] def sortedFromIterable[B : Ordering](it: collection.Iterable[B]): SortedSet[B] = SortedSet.sortedFromIterable(it)

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

@@ -37,6 +37,7 @@ sealed trait HashMap[K, +V]
   import HashMap.{bufferSize, liftMerger, Merger, MergeFunction, nullToEmpty}
 
   def iterableFactory = List
+  def mapFactory = HashMap
 
   protected[this] def fromSpecificIterable(coll: collection.Iterable[(K, V)]): HashMap[K, V] = HashMap.fromIterable(coll)
 

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

@@ -57,14 +57,14 @@ case object Nil extends List[Nothing] {
   override def tail: Nothing = throw new UnsupportedOperationException("tail of empty list")
 }
 
-object List extends IterableFactoryWithBuilder[List] {
+object List extends IterableFactory[List] {
 
   def fromIterable[B](coll: collection.Iterable[B]): List[B] = coll match {
     case coll: List[B] => coll
     case _ => ListBuffer.fromIterable(coll).toList
   }
 
-  def newBuilder[A](): Builder[A, List[A]] = new GrowableBuilder(ListBuffer.empty[A]).mapResult(_.toList)
+  override def newBuilder[A](): Builder[A, List[A]] = new ListBuffer[A].mapResult(_.toList)
 
   def empty[A]: List[A] = Nil
 }

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

@@ -50,6 +50,7 @@ sealed class ListMap[K, +V]
     with Serializable {
 
   def iterableFactory = List
+  def mapFactory = ListMap
 
   protected[this] def mapFromIterable[K2, V2](it: collection.Iterable[(K2, V2)]): ListMap[K2,V2] = ListMap.fromIterable(it)
 

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

@@ -37,6 +37,8 @@ final class TreeMap[K, +V] private (tree: RB.Tree[K, V])(implicit val ordering:
   def this()(implicit ordering: Ordering[K]) = this(null)(ordering)
 
   def iterableFactory = List
+  def mapFactory = Map
+  def sortedMapFactory = TreeMap
 
   protected[this] def fromSpecificIterable(coll: collection.Iterable[(K, V)]): TreeMap[K, V] =
     TreeMap.sortedFromIterable(coll)

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

@@ -36,6 +36,8 @@ final class TreeSet[A] private (tree: RB.Tree[A, Unit])(implicit val ordering: O
 
   def iterableFactory = Set
 
+  def sortedIterableFactory = TreeSet
+
   protected[this] def fromSpecificIterable(coll: strawman.collection.Iterable[A]): TreeSet[A] =
     TreeSet.sortedFromIterable(coll)
 
@@ -108,7 +110,7 @@ final class TreeSet[A] private (tree: RB.Tree[A, Unit])(implicit val ordering: O
     else newSet(RB.delete(tree, elem))
 }
 
-object TreeSet extends SortedIterableFactoryWithBuilder[TreeSet] {
+object TreeSet extends SortedIterableFactory[TreeSet] {
 
   def empty[A: Ordering]: TreeSet[A] = new TreeSet[A]
 
@@ -118,9 +120,4 @@ object TreeSet extends SortedIterableFactoryWithBuilder[TreeSet] {
       case _ => empty[E] ++ it
     }
 
-  def newBuilder[A : Ordering](): Builder[A, TreeSet[A]] =
-    new ImmutableBuilder[A, TreeSet[A]](empty) {
-      def add(elem: A): this.type = { elems = elems + elem; this }
-    }
-
 }

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

@@ -134,6 +134,8 @@ object ArrayBuffer extends IterableFactory[ArrayBuffer] {
     }
     else new ArrayBuffer[B] ++= coll
 
+  override def newBuilder[A](): Builder[A, ArrayBuffer[A]] = new ArrayBuffer[A]()
+
   def empty[A]: ArrayBuffer[A] = new ArrayBuffer[A]()
 }
 

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

@@ -37,6 +37,8 @@ class BitSet(protected[collection] final var elems: Array[Long])
 
   def iterableFactory = Set
 
+  def sortedIterableFactory = SortedSet
+
   protected[this] def sortedFromIterable[B : Ordering](it: collection.Iterable[B]): collection.mutable.SortedSet[B] =
     collection.mutable.SortedSet.sortedFromIterable(it)