wip

Author: szeiger

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

@@ -6,12 +6,36 @@ import strawman.collection.mutable.Builder
 import scala.{Any, Int, Nothing, Ordering}
 import scala.annotation.unchecked.uncheckedVariance
 
+trait BuildFrom[-From, -A, +C] extends Any {
+  def fromSpecificIterable(from: From)(it: Iterable[A]): C
+}
+
+trait StrictBuildFrom[-From, -A, +C] extends Any with BuildFrom[From, A, C] {
+  def newBuilder(from: From): Builder[A, C]
+}
+
+object StrictBuildFrom {
+  /** Build the source collection type from an IterableOps */
+  implicit def buildFromIterableOps[C[X] <: IterableOps[X, C, _], A, E]: StrictBuildFrom[C[A], E, C[E]] = new StrictBuildFrom[C[A], E, C[E]] {
+    //TODO: Reuse a prototype instance
+    def newBuilder(from: C[A]): Builder[E, C[E]] = Builder.surrogateBuilder(from.iterableFactory)
+    def fromSpecificIterable(from: C[A])(it: Iterable[E]): C[E] = from.iterableFactory.fromIterable(it)
+  }
+
+  /** Build the source collection type from an Iterable with SortedOps */
+  implicit def buildFromSortedOps[C[X] <: Iterable[X] with SortedOps[X, C[X], C], A, E : Ordering]: StrictBuildFrom[C[A], E, C[E]] = new StrictBuildFrom[C[A], E, C[E]] {
+    def newBuilder(from: C[A]): Builder[E, C[E]] = Builder.surrogateBuilder(from.sortedIterableFactory)
+    def fromSpecificIterable(from: C[A])(it: Iterable[E]): C[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
 }
 
@@ -91,6 +115,10 @@ trait SortedIterableFactory[+CC[_]] {
   def fill[A : Ordering](n: Int)(elem: => A): CC[A] = sortedFromIterable(View.Fill(n)(elem))
 }
 
+trait SortedIterableFactoryWithBuilder[+CC[_]] extends SortedIterableFactory[CC] {
+  def newBuilder[A : Ordering](): Builder[A, CC[A]]
+}
+
 object SortedIterableFactory {
   import scala.language.implicitConversions
 

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

@@ -12,7 +12,9 @@ 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
 
   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

@@ -27,6 +27,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/TreeSet.scala

@@ -2,7 +2,7 @@ package strawman
 package collection
 package immutable
 
-import mutable.Builder
+import mutable.{ArrayBuffer, Builder}
 import immutable.{RedBlackTree => RB}
 
 import scala.{Boolean, Int, NullPointerException, Option, Ordering, Some, Unit}
@@ -63,6 +63,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)
 
@@ -103,7 +105,7 @@ final class TreeSet[A] private (tree: RB.Tree[A, Unit])(implicit val ordering: O
     else newSet(RB.delete(tree, elem))
 }
 
-object TreeSet extends SortedIterableFactory[TreeSet] {
+object TreeSet extends SortedIterableFactoryWithBuilder[TreeSet] {
 
   def empty[A: Ordering]: TreeSet[A] = new TreeSet[A]
 
@@ -113,4 +115,5 @@ object TreeSet extends SortedIterableFactory[TreeSet] {
       case _ => empty[E] ++ it
     }
 
+  def newBuilder[A : Ordering](): Builder[A, TreeSet[A]] = new ArrayBuffer[A].mapResult(sortedFromIterable[A] _)
 }

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

@@ -36,6 +36,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)
 

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

@@ -1,8 +1,11 @@
 package strawman.collection.mutable
 
-import scala.{Boolean, Any, Char, Unit}
+import scala.{Any, Boolean, Char, Unit}
 import java.lang.String
-import strawman.collection.IterableOnce
+
+import strawman.collection.{IterableFactory, IterableFactoryWithBuilder, IterableOnce, SortedIterableFactory}
+
+import scala.math.Ordering
 
 /** Base trait for collection builders */
 trait Builder[-A, +To] extends Growable[A] { self =>
@@ -24,6 +27,19 @@ trait Builder[-A, +To] extends Growable[A] { self =>
   }
 }
 
+object Builder {
+  /** Get a proper builder for an IterableFactoryWithBuilder, otherwise a Builder that uses an intermediate
+    * ArrayBuffer to store the elements. */
+  def surrogateBuilder[A, CC[_]](fact: IterableFactory[CC]): Builder[A, CC[A]] = fact match {
+    case fact: IterableFactoryWithBuilder[CC] => fact.newBuilder[A]()
+    case fact => new ArrayBuffer[A]().mapResult(fact.fromIterable _)
+  }
+  def surrogateBuilder[A : Ordering, CC[_]](fact: SortedIterableFactory[CC]): Builder[A, CC[A]] = fact match {
+    case fact: IterableFactoryWithBuilder[CC] => fact.newBuilder[A]()
+    case fact => new ArrayBuffer[A]().mapResult(fact.sortedFromIterable[A] _)
+  }
+}
+
 class StringBuilder extends Builder[Char, String] {
   private val sb = new java.lang.StringBuilder
 

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

@@ -1,7 +1,7 @@
 package strawman
 package collection.mutable
 
-import collection.SortedIterableFactory
+import collection.SortedIterableFactoryWithBuilder
 import collection.mutable.{RedBlackTree => RB}
 
 import scala.{Boolean, Int, None, Null, NullPointerException, Option, Ordering, Serializable, SerialVersionUID, Some, Unit}
@@ -45,6 +45,8 @@ sealed class TreeSet[A] private (tree: RB.Tree[A, Null])(implicit val ordering:
 
   def iterableFactory = Set
 
+  def sortedIterableFactory = TreeSet
+
   def keysIteratorFrom(start: A): collection.Iterator[A] = RB.keysIterator(tree, Some(start))
 
   def empty: TreeSet[A] = TreeSet.empty
@@ -175,10 +177,11 @@ sealed class TreeSet[A] private (tree: RB.Tree[A, Null])(implicit val ordering:
   * @author Lucien Pereira
   *
   */
-object TreeSet extends SortedIterableFactory[TreeSet] {
+object TreeSet extends SortedIterableFactoryWithBuilder[TreeSet] {
 
   def empty[A : Ordering]: TreeSet[A] = new TreeSet[A]()
 
   def sortedFromIterable[E : Ordering](it: collection.Iterable[E]): TreeSet[E] = Growable.fromIterable(empty[E], it)
 
+  def newBuilder[A : Ordering](): Builder[A, TreeSet[A]] = new ArrayBuffer[A].mapResult(sortedFromIterable[A] _)
 }

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

@@ -3,51 +3,95 @@ package strawman
 package collection.test
 
 import org.junit.Test
-import strawman.collection.Iterable
-import strawman.collection.mutable.{ArrayBuffer, Builder, Growable}
 import strawman.collection._
+import strawman.collection.mutable.{ArrayBuffer, Builder, Growable}
 
 import scala.{Any, Either, Int, Left, None, Option, Right, Some, Unit}
+import java.lang.String
 import scala.Predef.ArrowAssoc
 import scala.math.Ordering
-import java.lang.String
 
 class TraverseTest {
 
-  def optionSequence[CC[X] <: Iterable[X] with IterableOps[X, CC, _], A](xs: CC[Option[A]]): Option[CC[A]] = {
-    def folder[F[X] <: Growable[X]]: (Option[F[A]], Option[A]) => Option[F[A]] = { (bo, xo) =>
-      (bo, xo) match {
-        case (Some(builder), Some(a)) => Some(builder += a)
-        case _ => None
-      }
-    }
-    val factory = xs.iterableFactory
-    factory match {
-      case iterableBuilder: IterableFactoryWithBuilder[CC] =>
-        xs.foldLeft[Option[Builder[A, CC[A]]]](
-          Some(iterableBuilder.newBuilder[A]())
-        )(
-          folder[({ type l[X] = Builder[X, CC[X]] })#l]
-        ).map(_.result)
-      case _ =>
-        xs.foldLeft[Option[ArrayBuffer[A]]](Some(new ArrayBuffer[A]))(folder).map(_.to(xs.iterableFactory))
-    }
-  }
+  // You can either overload methods for IterableOps and Iterable with SortedOps (if you want to support constrained collection types)
+  def optionSequence1[C[X] <: IterableOps[X, C, _], A](xs: C[Option[A]]): Option[C[A]] =
+    xs.foldLeft[Option[Builder[A, C[A]]]](Some(Builder.surrogateBuilder[A, C](xs.iterableFactory))) {
+      case (Some(builder), Some(a)) => Some(builder += a)
+      case _ => None
+    }.map(_.result)
+  def optionSequence1[C[X] <: Iterable[X] with SortedOps[X, C[X], C], A : Ordering](xs: C[Option[A]]): Option[C[A]] =
+    xs.foldLeft[Option[Builder[A, C[A]]]](Some(Builder.surrogateBuilder[A, C](xs.sortedIterableFactory))) {
+      case (Some(builder), Some(a)) => Some(builder += a)
+      case _ => None
+    }.map(_.result)
+
+  // ...or use BuildFrom to abstract over both and also allow building arbitrary collection types
+  def optionSequence2[CC[X] <: Iterable[X], A, To](xs: CC[Option[A]])(implicit bf: StrictBuildFrom[CC[Option[A]], A, To]): Option[To] =
+    xs.foldLeft[Option[Builder[A, To]]](Some(bf.newBuilder(xs))) {
+      case (Some(builder), Some(a)) => Some(builder += a)
+      case _ => None
+    }.map(_.result)
 
   @Test
   def optionSequence1Test: Unit = {
     val xs1 = immutable.List(Some(1), None, Some(2))
-    val o1 = optionSequence(xs1)
+    val o1 = optionSequence1(xs1)
     val o1t: Option[immutable.List[Int]] = o1
 
-    val xs2: immutable.Set[Option[String]] = immutable.TreeSet(Some("foo"), Some("bar"), None)
-    val o2 = optionSequence(xs2)
+    val xs2: immutable.TreeSet[Option[String]] = immutable.TreeSet(Some("foo"), Some("bar"), None)
+    val o2 = optionSequence1(xs2)
     val o2t: Option[immutable.Set[String]] = o2
 
     val xs4 = immutable.List[Option[(Int, String)]](Some((1 -> "a")), Some((2 -> "b")))
-    val o4 = optionSequence(xs4)
+    val o4 = optionSequence1(xs4)
     val o4t: Option[immutable.List[(Int, String)]] = o4
     val o5: Option[immutable.TreeMap[Int, String]] = o4.map(_.to(immutable.TreeMap))
   }
 
+  def optionSequence2Test: Unit = {
+    val xs1 = immutable.List(Some(1), None, Some(2))
+    val o1 = optionSequence2(xs1)
+    val o1t: Option[immutable.List[Int]] = o1
+
+    val xs2 = immutable.TreeSet(Some("foo"), Some("bar"), None)
+    val o2 = optionSequence2(xs2)
+    val o2t: Option[immutable.TreeSet[String]] = o2
+
+    // 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 = optionSequence2(xs4)(immutable.TreeMap) // same syntax as in `.to`
+    val o4t: Option[immutable.TreeMap[Int, String]] = o4
+  }
+
+  /*
+
+def eitherSequence[C[X] <: Iterable[X], A, B](xs: C[Either[A, B]])(implicit bf: BuildFrom[xs.type, B]): Either[A, bf.To] =
+  xs.foldLeft[Either[A, Builder[B, bf.To]]](Right(bf.newBuilder(xs))) {
+    case (Right(builder), Right(b)) => Right(builder += b)
+    case (Left(a)       ,        _) => Left(a)
+    case (_             ,  Left(a)) => Left(a)
+  }.map(_.result)
+
+def optionSequenceTest: Unit = {
+  val xs1 = immutable.List(Some(1), None, Some(2))
+  val o1 = optionSequence(xs1)
+  val o1t: Option[immutable.List[Int]] = o1
+
+  val xs2 = immutable.TreeSet(Some("foo"), Some("bar"), None)
+  val o2 = optionSequence(xs2)
+  val o2t: Option[immutable.TreeSet[String]] = o2
+
+  // 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) // same syntax as in `.to`
+  val o4t: Option[immutable.TreeMap[Int, String]] = o4
+}
+
+def eitherSequenceTest: Unit = {
+  val xs3 = mutable.ListBuffer(Right("foo"), Left(0), Right("bar"))
+  val e1 = eitherSequence(xs3)
+  val e1t: Either[Int, mutable.ListBuffer[String]] = e1
+}
+*/
+
 }