Add strict version of Build, unify Build & CanBuild

Author: szeiger

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

@@ -96,8 +96,9 @@ trait IterableOps[+A] extends Any {
   def to[F <: BuildConstrained](fi: F)(implicit c: fi.Constraint[A @uncheckedVariance]): c.To[A @uncheckedVariance] =
     c.fromIterable(coll)
 
-  def to[C[_], Ev[_]](fi: ConstrainedFromIterable[C, Ev])(implicit ev: Ev[A @uncheckedVariance]): C[A @uncheckedVariance] =
-    fi.constrainedFromIterable(coll)
+  // Could be defined in addition to the method above; less generic but doesn't have to wrap the evidence
+  //def to[C[_], Ev[_]](fi: ConstrainedFromIterable[C, Ev])(implicit ev: Ev[A @uncheckedVariance]): C[A @uncheckedVariance] =
+  //  fi.constrainedFromIterable(coll)
 
   /** Convert collection to array. */
   def toArray[B >: A: ClassTag]: Array[B] =

src/main/scala/strawman/collection/IterableFactories.scala

@@ -3,17 +3,24 @@ package collection
 
 import strawman.collection.mutable.Builder
 
-import scala.{Any, Int}
+import scala.{Any, Int, Nothing}
 import scala.annotation.unchecked.uncheckedVariance
 
 /** Instances of Build[B] can build some kind of collection from values of type B. */
 trait Build[-B] {
   type To[_]
   def fromIterable[E <: B](it: Iterable[E]): To[E]
 }
+trait BuildStrict[-B] extends Build[B] {
+  def newBuilder[E <: B]: Builder[E, To[E]]
+}
 
+/** Instances of BuildConstrained can build some kind of collection from values with an implicit constraint. */
 trait BuildConstrained {
-  trait Constraint[E] extends Build[E]
+  trait Constraint[E] <: Build[E]
+}
+trait BuildStrictConstrained extends BuildConstrained {
+  trait Constraint[E] extends super.Constraint[E] with BuildStrict[E]
 }
 
 /** Base trait for instances that can construct a collection from an iterable */
@@ -24,12 +31,12 @@ trait FromIterable[+C[_]] extends Build[Any] {
 
 /** Base trait for instances that can construct a collection from an iterable by using an implicit evidence
   * for the element type. */
-trait ConstrainedFromIterable[+CC[_], Ev[_]] {
+trait ConstrainedFromIterable[+CC[_], Ev[_]] extends BuildConstrained {
   def constrainedFromIterable[E : Ev](it: Iterable[E]): CC[E]
 }
 
 /** Base trait for companion objects of unconstrained collection types */
-trait IterableFactory[+C[_]] extends FromIterable[C] { self =>
+trait IterableFactory[+C[_]] extends FromIterable[C] with BuildStrict[Any] { self =>
   def empty[A]: C[A] = fromIterable(View.Empty)
 
   def apply[A](xs: A*): C[A] = fromIterable(View.Elems(xs: _*))
@@ -38,21 +45,33 @@ trait IterableFactory[+C[_]] extends FromIterable[C] { self =>
 
   def newBuilder[A]: Builder[A, C[A]]
 
-  protected[this] lazy val canBuildProto: CanBuild[Any, C[Any]] = new CanBuild[Any, C[Any]] {
-    def fromIterable(it: Iterable[Any]): C[Any] = self.fromIterable[Any](it)
-    def newBuilder: Builder[Any, C[Any]] = self.newBuilder[Any]
+  protected[this] lazy val buildFromProto: BuildFrom[C[Any], Any] = new BuildFrom[C[Any], Any] {
+    type To[_] = C[Any]
+    def fromIterable[E](it: Iterable[E]): C[Any] = self.fromIterable[Any](it)
+    def newBuilder[E]: Builder[E, C[Any]] = self.newBuilder[Any]
   }
 
-  implicit def canBuild[E]: CanBuild[E, C[E]] = canBuildProto.asInstanceOf[CanBuild[E, C[E]]]
+  implicit def buildFrom[F, E]: BuildFrom[C[F], E] { type To[_] <: C[E] } =
+    buildFromProto.asInstanceOf[BuildFrom[C[F], E] { type To[_] <: C[E] }]
+
+  def buildFromAny[E]: BuildFrom[Nothing, E] { type To[_] <: C[E] } =
+    buildFromProto.asInstanceOf[BuildFrom[Nothing, E] { type To[_] <: C[E] }]
 }
 
-trait CanBuild[E, +Repr] {
-  def fromIterable(it: Iterable[E]): Repr
-  def newBuilder: Builder[E, Repr]
+/** Implicit instances of this type are available for building arbitrary collection types */
+trait BuildFrom[+Repr, E] extends BuildStrict[E] { self =>
+  def any: BuildFrom[Nothing, E] { type To[X] = self.To[X] } = this.asInstanceOf[BuildFrom[Nothing, E] { type To[X] = self.To[X] }]
 }
 
 /** Base trait for companion objects of collections that require an implicit evidence */
-trait ConstrainedIterableFactory[+CC[X], Ev[_]] extends ConstrainedFromIterable[CC, Ev] {
+trait ConstrainedIterableFactory[+CC[X], Ev[_]] extends ConstrainedFromIterable[CC, Ev] with BuildStrictConstrained {
+
+  class ConstraintImpl[E : Ev] extends Constraint[E] {
+    type To[_] = CC[E] @uncheckedVariance
+    def fromIterable[X <: E](it: Iterable[X]): CC[E] = constrainedFromIterable[E](it)
+    def newBuilder[X <: E]: Builder[X, CC[E]] = constrainedNewBuilder[E]
+  }
+  implicit def constraint[E : Ev]: ConstraintImpl[E] = new ConstraintImpl[E]
 
   def empty[A : Ev]: CC[A] = constrainedFromIterable(View.Empty)
 
@@ -62,8 +81,12 @@ trait ConstrainedIterableFactory[+CC[X], Ev[_]] extends ConstrainedFromIterable[
 
   def constrainedNewBuilder[A : Ev]: Builder[A, CC[A]]
 
-  implicit def canBuild[E : Ev]: CanBuild[E, CC[E]] = new CanBuild[E, CC[E]] {
-    def fromIterable(it: Iterable[E]): CC[E] = constrainedFromIterable[E](it)
-    def newBuilder: Builder[E, CC[E]] = constrainedNewBuilder[E]
+  implicit def buildFrom[F, E : Ev]: BuildFrom[CC[F], E] { type To[_] <: CC[E] } = new BuildFrom[CC[F], E] {
+    type To[_] = CC[E]
+    def fromIterable[X <: E](it: Iterable[X]): CC[E] = constrainedFromIterable[E](it)
+    def newBuilder[X <: E]: Builder[X, CC[E]] = constrainedNewBuilder[E]
   }
+
+  def buildFromAny[E : Ev]: BuildFrom[Nothing, E] { type To[_] <: CC[E] } =
+    buildFrom[Any, E].asInstanceOf[BuildFrom[Nothing, E] { type To[_] <: CC[E] }]
 }

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

@@ -2,7 +2,7 @@ package strawman.collection
 
 import strawman.collection.mutable.Builder
 
-import scala.{Option, Any}
+import scala.{Option, Any, Nothing}
 import scala.annotation.unchecked.uncheckedVariance
 import scala.Predef.???
 
@@ -49,13 +49,17 @@ trait MapFactory[+C[_, _]] extends BuildConstrained { self =>
   def apply[K, V](elems: (K, V)*): C[K, V] =
     newBuilder[K, V].++=(elems.toStrawman).result
 
-  protected[this] lazy val canBuildProto: CanBuild[(Any, Any), C[Any, Any]] = new CanBuild[(Any, Any), C[Any, Any]] {
-    def fromIterable(it: Iterable[(Any, Any)]): C[Any, Any] = self.fromIterable[Any, Any](it)
-    def newBuilder: Builder[(Any, Any), C[Any, Any]] = self.newBuilder[Any, Any]
+  protected[this] lazy val buildFromProto: BuildFrom[C[Any, Any], (Any, Any)] { type To[_] <: C[Any, Any] } = new BuildFrom[C[Any, Any], (Any, Any)] {
+    type To[_] = C[Any, Any]
+    def fromIterable[E <: (Any, Any)](it: Iterable[E]): C[Any, Any] = self.fromIterable[Any, Any](it)
+    def newBuilder[E <: (Any, Any)]: Builder[E, C[Any, Any]] = self.newBuilder[Any, Any]
   }
 
-  implicit def canBuild[K, V]: CanBuild[(K, V), C[K, V]] =
-    canBuildProto.asInstanceOf[CanBuild[(K, V), C[K, V]]]
+  implicit def buildFrom[K2, V2, K, V]: BuildFrom[C[K2, V2], (K, V)] { type To[_] <: C[K, V] } =
+    buildFromProto.asInstanceOf[BuildFrom[C[K2, V2], (K, V)] { type To[_] <: C[K, V] }]
+
+  def buildFromAny[K, V]: BuildFrom[Nothing, (K, V)] { type To[_] <: C[K, V] } =
+    buildFrom[Any, Any, K, V].asInstanceOf[BuildFrom[Nothing, (K, V)] { type To[_] <: C[K, V] }]
 }
 
 /** Factory methods for collections of kind `* −> * -> *` which require an implicit evidence value for the key type */
@@ -72,8 +76,12 @@ trait ConstrainedMapFactory[+C[_, _], Ev[_]] { self =>
   def apply[K : Ev, V](elems: (K, V)*): C[K, V] =
     constrainedNewBuilder[K, V].++=(elems.toStrawman).result
 
-  implicit def canBuild[K : Ev, V]: CanBuild[(K, V), C[K, V]] = new CanBuild[(K, V), C[K, V]] {
-    def fromIterable(it: Iterable[(K, V)]): C[K, V] = self.constrainedFromIterable(it)
-    def newBuilder: Builder[(K, V), C[K, V]] = self.constrainedNewBuilder
+  implicit def buildFrom[K2, V2, K : Ev, V]: BuildFrom[C[K2, V2], (K, V)] { type To[_] <: C[K, V] } = new BuildFrom[C[K2, V2], (K, V)] {
+    type To[_] = C[K, V]
+    def fromIterable[E <: (K, V)](it: Iterable[E]): C[K, V] = self.constrainedFromIterable(it)
+    def newBuilder[E <: (K, V)]: Builder[E, C[K, V]] = self.constrainedNewBuilder
   }
+
+  def buildFromAny[K : Ev, V]: BuildFrom[Nothing, (K, V)] { type To[_] <: C[K, V] } =
+    buildFrom[Any, Any, K, V].asInstanceOf[BuildFrom[Nothing, (K, V)] { type To[_] <: C[K, V] }]
 }

src/test/scala/strawman/collection/test/TraverseTest.scala

@@ -13,14 +13,14 @@ import java.lang.String
 
 class TraverseTest {
 
-  def optionSequence[C[X] <: Iterable[X], A](xs: C[Option[A]])(implicit fi: CanBuild[A, C[A]]): Option[C[A]] =
-    xs.foldLeft[Option[Builder[A, C[A]]]](Some(fi.newBuilder)) {
+  def optionSequence[C[X] <: Iterable[X], A](xs: C[Option[A]])(implicit bf: BuildFrom[C[_], A]): Option[bf.To[A]] =
+    xs.foldLeft[Option[Builder[A, bf.To[A]]]](Some(bf.newBuilder)) {
       case (Some(builder), Some(a)) => Some(builder += a)
       case _ => None
     }.map(_.result)
 
-  def eitherSequence[C[X] <: Iterable[X], A, B](xs: C[Either[A, B]])(implicit fi: CanBuild[B, C[B]]): Either[A, C[B]] =
-    xs.foldLeft[Either[A, Builder[B, C[B]]]](Right(fi.newBuilder)) {
+  def eitherSequence[C[X] <: Iterable[X], A, B](xs: C[Either[A, B]])(implicit bf: BuildFrom[C[_], B]): Either[A, bf.To[B]] =
+    xs.foldLeft[Either[A, Builder[B, bf.To[B]]]](Right(bf.newBuilder)) {
       case (Right(builder), Right(b)) => Right(builder += b)
       case (Left(a)       ,        _) => Left(a)
       case (_             ,  Left(a)) => Left(a)
@@ -41,10 +41,10 @@ class TraverseTest {
     val e1 = eitherSequence(xs3)
     val e1t: Either[Int, mutable.ListBuffer[String]] = e1
 
-    // This use case from https://github.com/scala/scala/pull/5233 still eludes us
-    //val xs4 = immutable.List((1 -> "a"), (2 -> "b"))
-    //val o4 = optionSequence(xs1)(immutable.TreeMap.iterableFactory)
-    //val o4t: Option[immutable.TreeMap[Int, String]] = o4
+    // Breakout-like use case from https://github.com/scala/scala/pull/5233:
+    val xs4 = immutable.List[Option[(Int, String)]](Some((1 -> "a")), Some((2 -> "b")))
+    val o4 = optionSequence(xs4)(immutable.TreeMap.buildFromAny)
+    val o4t: Option[immutable.TreeMap[Int, String]] = o4
   }
 
 }