Updates of strawman

Bring strawman-4 and strawman-5 to feature-parity.
Test also strawman-4.

Author: odersky

src/strawman/collections/CollectionStrawMan4.scala

@@ -2,6 +2,8 @@ package strawman.collections
 
 import Predef.{augmentString => _, wrapString => _, _}
 import scala.reflect.ClassTag
+import annotation.unchecked.uncheckedVariance
+import annotation.tailrec
 
 /** A strawman architecture for new collections. It contains some
  *  example collection classes and methods with the intent to expose
@@ -20,13 +22,6 @@ object CollectionStrawMan4 {
     def iterator: Iterator[A]
   }
 
-  /** Base trait for generic collections */
-  trait Iterable[+A] extends IterableOnce[A] with FromIterable[Iterable] {
-    def iterator: Iterator[A]
-    def view: View[A] = View.fromIterator(iterator)
-    def knownLength: Int = -1
-  }
-
   /** Base trait for instances that can construct a collection from an iterable */
   trait FromIterable[+C[X] <: Iterable[X]] {
     def fromIterable[B](v: Iterable[B]): C[B]
@@ -38,16 +33,27 @@ object CollectionStrawMan4 {
     def apply[A](xs: A*): C[A] = fromIterable(View.Elems(xs: _*))
   }
 
+  /** Base trait for generic collections */
+  trait Iterable[+A] extends IterableOnce[A] with FromIterable[Iterable] {
+    def view: View[A] = View.fromIterator(iterator) // view is overridden, cannot be defined in ops
+    def knownLength: Int = -1
+  }
+
   /** Base trait for sequence collections */
   trait Seq[+A] extends Iterable[A] with FromIterable[Seq] {
     def apply(i: Int): A
     def length: Int
   }
 
+  /** Base trait for collection builders */
   trait Builder[-A, +To] {
     def +=(x: A): this.type
-    def ++=(xs: IterableOnce[A]): Unit = xs.iterator.foreach(+=)
     def result: To
+
+    def ++=(xs: IterableOnce[A]): this.type = {
+      xs.iterator.foreach(+=)
+      this
+    }
   }
 
   /* ------------ Operations ----------------------------------- */
@@ -134,17 +140,18 @@ object CollectionStrawMan4 {
       require(!isEmpty)
       if (i == 0) head else tail.apply(i - 1)
     }
-    def :::[B >: A](prefix: List[B]): List[B] =
-      if (prefix.isEmpty) this
-      else Cons(prefix.head, prefix.tail ::: this)
     def length: Int =
       if (isEmpty) 0 else 1 + tail.length
+    def ++:[B >: A](prefix: List[B]): List[B] =
+      if (prefix.isEmpty) this
+      else Cons(prefix.head, prefix.tail ++: this)
   }
 
-  case class Cons[+A](x: A, xs: List[A]) extends List[A] {
+  case class Cons[+A](x: A, private[collections] var next: List[A @uncheckedVariance]) // sound because `next` is used only locally
+  extends List[A] {
     def isEmpty = false
     def head = x
-    def tail = xs
+    def tail = next
   }
 
   case object Nil extends List[Nothing] {
@@ -157,20 +164,64 @@ object CollectionStrawMan4 {
     def fromIterator[B](it: Iterator[B]): List[B] =
       if (it.hasNext) Cons(it.next, fromIterator(it)) else Nil
     def fromIterable[B](c: Iterable[B]): List[B] = c match {
-      case View.Concat(xs, ys: Iterable[B]) =>
-        fromIterable(xs) ::: fromIterable(ys)
+      case View.Concat(xs, ys: List[B]) =>
+        fromIterable(xs) ++: ys
       case View.Drop(xs: List[B], n) =>
-        var i = 0
-        var ys = xs
-        while (i < n && !xs.isEmpty) {
-          ys = ys.tail
-          i += 1
-        }
-        ys
+        @tailrec def loop(xs: List[B], n: Int): List[B] =
+          if (n > 0) loop(xs.tail, n - 1) else xs
+        loop(xs, n)
+      case c: List[B] => c
       case _ => fromIterator(c.iterator)
     }
   }
 
+  /** Concrete collection type: ListBuffer */
+  class ListBuffer[A] extends Seq[A] with FromIterable[ListBuffer] with Builder[A, List[A]] {
+    private var first, last: List[A] = Nil
+    private var aliased = false
+    def iterator = first.iterator
+    def fromIterable[B](coll: Iterable[B]) = ListBuffer.fromIterable(coll)
+    def apply(i: Int) = first.apply(i)
+    def length = first.length
+
+    private def copyElems(): Unit = {
+      val buf = ListBuffer.fromIterable(result)
+      first = buf.first
+      last = buf.last
+      aliased = false
+    }
+    def result = {
+      aliased = true
+      first
+    }
+    def +=(elem: A) = {
+      if (aliased) copyElems()
+      val last1 = Cons(elem, Nil)
+      last match {
+        case last: Cons[A] => last.next = last1
+        case _ => first = last1
+      }
+      last = last1
+      this
+    }
+    override def toString: String =
+      if (first.isEmpty) "ListBuffer()"
+      else {
+        val b = new StringBuilder("ListBuffer(").append(first.head)
+        first.tail.foldLeft(b)(_.append(", ").append(_)).append(")").toString
+      }
+  }
+
+  object ListBuffer extends IterableFactory[ListBuffer] {
+    def fromIterable[B](coll: Iterable[B]): ListBuffer[B] = coll match {
+      case pd @ View.Partitioned(partition: View.Partition[B]) =>
+        partition.distribute(new ListBuffer[B]())
+        pd.forced.get.asInstanceOf[ListBuffer[B]]
+      case _ =>
+        new ListBuffer[B] ++= coll
+    }
+  }
+
   /** Concrete collection type: ArrayBuffer */
   class ArrayBuffer[A] private (initElems: Array[AnyRef], initLength: Int)
   extends Seq[A] with FromIterable[ArrayBuffer] with Builder[A, ArrayBuffer[A]] {
@@ -234,12 +285,6 @@ object CollectionStrawMan4 {
     def apply(n: Int) = elems(start + n).asInstanceOf[A]
   }
 
-  case class StringView(s: String) extends RandomAccessView[Char] {
-    val start = 0
-    val end = s.length
-    def apply(n: Int) = s.charAt(n)
-  }
-
   /** Concrete collection type: String */
   implicit class StringOps(val s: String) extends AnyVal with Ops[Char] {
     def iterator: Iterator[Char] = new StringView(s).iterator
@@ -277,6 +322,12 @@ object CollectionStrawMan4 {
     def ++(xs: String): String = s + xs
   }
 
+  case class StringView(s: String) extends RandomAccessView[Char] {
+    val start = 0
+    val end = s.length
+    def apply(n: Int) = s.charAt(n)
+  }
+
   /* ------------ Views --------------------------------------- */
 
   /** A lazy iterable */
@@ -322,6 +373,8 @@ object CollectionStrawMan4 {
     }
     case class Partition[A](val underlying: Iterable[A], p: A => Boolean) {
       val left, right = Partitioned(this)
+      // `distribute` makes up for the lack of generic push-based functionality.
+      // It forces both halves of the partition with a given builder.
       def distribute(bf: => Builder[A, Iterable[A]]) = {
         val lb, rb = bf
         val it = underlying.iterator

src/strawman/collections/CollectionStrawMan5.scala

@@ -3,6 +3,7 @@ package strawman.collections
 import Predef.{augmentString => _, wrapString => _, _}
 import scala.reflect.ClassTag
 import annotation.unchecked.uncheckedVariance
+import annotation.tailrec
 
 /** A strawman architecture for new collections. It contains some
  *  example collection classes and methods with the intent to expose
@@ -32,24 +33,8 @@ object CollectionStrawMan5 {
     def apply[A](xs: A*): C[A] = fromIterable(View.Elems(xs: _*))
   }
 
-  /** Base trait for Iterable operations */
-  trait IterableLike[+A, +C[X] <: Iterable[X]]
-    extends FromIterable[C]
-       with IterableOps[A]
-       with IterableMonoTransforms[A @uncheckedVariance, C[A @uncheckedVariance]]
-       with IterablePolyTransforms[A @uncheckedVariance, C] {
-    protected[this] def fromLikeIterable(coll: Iterable[A]): C[A] = fromIterable(coll)
-  }
-
-  /** Base trait for Seq operations */
-  trait SeqLike[+A, +C[X] <: Seq[X]]
-  extends IterableLike[A, C] with SeqMonoTransforms[A @uncheckedVariance, C[A @uncheckedVariance]]
-
   /** Base trait for generic collections */
   trait Iterable[+A] extends IterableOnce[A] with IterableLike[A, Iterable] {
-    override def iterator: Iterator[A]
-    override def fromIterable[B](it: Iterable[B]): Iterable[B]
-
     protected def coll: Iterable[A] = this
     def knownLength: Int = -1
   }
@@ -58,18 +43,21 @@ object CollectionStrawMan5 {
   trait Seq[+A] extends Iterable[A] with SeqLike[A, Seq] {
     def apply(i: Int): A
     def length: Int
-    override def iterator: Iterator[A]
   }
 
+  /** Base trait for strict collections */
   trait Buildable[+A, +To <: Iterable[A]] extends Iterable[A] {
     protected[this] def newBuilder: Builder[A, To]
     override def partition(p: A => Boolean): (To, To) = {
       val l, r = newBuilder
       iterator.foreach(x => (if (p(x)) l else r) += x)
       (l.result, r.result)
     }
+    // one might also override other transforms here to avoid generating
+    // iterators if it helps efficiency.
   }
 
+  /** Base trait for collection builders */
   trait Builder[-A, +To] {
     def +=(x: A): this.type
     def result: To
@@ -82,6 +70,29 @@ object CollectionStrawMan5 {
 
   /* ------------ Operations ----------------------------------- */
 
+  /** Base trait for Iterable operations
+   *
+   *  VarianceNote
+   *  ============
+   *
+   *  We require that for all child classes of Iterable the variance of
+   *  the child class and the variance of the `C` parameter passed to `IterableLike`
+   *  are the same. We cannot express this since we lack variance polymorphism. That's
+   *  why we have to resort at some places to write `C[A @uncheckedVariance]`.
+   *
+   */
+  trait IterableLike[+A, +C[X] <: Iterable[X]]
+    extends FromIterable[C]
+       with IterableOps[A]
+       with IterableMonoTransforms[A, C[A @uncheckedVariance]] // sound bcs of VarianceNote
+       with IterablePolyTransforms[A, C] {
+    protected[this] def fromLikeIterable(coll: Iterable[A]): C[A] = fromIterable(coll)
+  }
+
+  /** Base trait for Seq operations */
+  trait SeqLike[+A, +C[X] <: Seq[X]]
+  extends IterableLike[A, C] with SeqMonoTransforms[A, C[A @uncheckedVariance]] // sound bcs of VarianceNote
+
   trait IterableOps[+A] extends Any {
     def iterator: Iterator[A]
     def foreach(f: A => Unit): Unit = iterator.foreach(f)
@@ -93,16 +104,19 @@ object CollectionStrawMan5 {
     def view: View[A] = View.fromIterator(iterator)
   }
 
-  trait IterableMonoTransforms[A, +Repr] extends Any {
+  trait IterableMonoTransforms[+A, +Repr] extends Any {
     protected def coll: Iterable[A]
-    protected def fromLikeIterable(coll: Iterable[A]): Repr
+    protected[this] def fromLikeIterable(coll: Iterable[A]): Repr
     def filter(p: A => Boolean): Repr = fromLikeIterable(View.Filter(coll, p))
     def partition(p: A => Boolean): (Repr, Repr) = {
       val pn = View.Partition(coll, p)
       (fromLikeIterable(pn.left), fromLikeIterable(pn.right))
     }
     def drop(n: Int): Repr = fromLikeIterable(View.Drop(coll, n))
-    def to[C[X] <: Iterable[X]](fi: FromIterable[C]): C[A] = fi.fromIterable(coll)
+    def to[C[X] <: Iterable[X]](fi: FromIterable[C]): C[A @uncheckedVariance] =
+      // variance seems sound because `to` could just as well have been added
+      // as a decorator. We should investigate this further to be sure.
+      fi.fromIterable(coll)
   }
 
   trait IterablePolyTransforms[+A, +C[A]] extends Any {
@@ -112,9 +126,10 @@ object CollectionStrawMan5 {
     def flatMap[B](f: A => IterableOnce[B]): C[B] = fromIterable(View.FlatMap(coll, f))
     def ++[B >: A](xs: IterableOnce[B]): C[B] = fromIterable(View.Concat(coll, xs))
     def zip[B](xs: IterableOnce[B]): C[(A @uncheckedVariance, B)] = fromIterable(View.Zip(coll, xs))
+       // sound bcs of VarianceNote
   }
 
-  trait SeqMonoTransforms[A, +Repr] extends Any with IterableMonoTransforms[A, Repr] {
+  trait SeqMonoTransforms[+A, +Repr] extends Any with IterableMonoTransforms[A, Repr] {
     def reverse: Repr = {
       var xs: List[A] = Nil
       var it = coll.iterator
@@ -150,10 +165,12 @@ object CollectionStrawMan5 {
       case xs: List[B] => this ++: xs
       case _ => super.++(xs)
     }
-    override def reverse = super.reverse
+    @tailrec final override def drop(n: Int) =
+      if (n > 0) tail.drop(n - 1) else this
   }
 
-  case class Cons[+A](x: A, private[collections] var next: List[A @uncheckedVariance]) extends List[A] {
+  case class Cons[+A](x: A, private[collections] var next: List[A @uncheckedVariance]) // sound because `next` is used only locally
+  extends List[A] {
     override def isEmpty = false
     override def head = x
     def tail = next
@@ -176,11 +193,7 @@ object CollectionStrawMan5 {
   class ListBuffer[A] extends Seq[A] with SeqLike[A, ListBuffer] with Builder[A, List[A]] {
     private var first, last: List[A] = Nil
     private var aliased = false
-    def iterator = new Iterator[A] {
-      var current: List[A] = first
-      def hasNext = ???
-      def next = ???
-    }
+    def iterator = first.iterator
     def fromIterable[B](coll: Iterable[B]) = ListBuffer.fromIterable(coll)
     def apply(i: Int) = first.apply(i)
     def length = first.length
@@ -205,6 +218,12 @@ object CollectionStrawMan5 {
       last = last1
       this
     }
+    override def toString: String =
+      if (first.isEmpty) "ListBuffer()"
+      else {
+        val b = new StringBuilder("ListBuffer(").append(first.head)
+        first.tail.foldLeft(b)(_.append(", ").append(_)).append(")").toString
+      }
   }
 
   object ListBuffer extends IterableFactory[ListBuffer] {
@@ -291,12 +310,12 @@ object CollectionStrawMan5 {
     def fromIterable[B](coll: Iterable[B]): List[B] = List.fromIterable(coll)
     def map(f: Char => Char): String = {
       val sb = new StringBuilder
-      for (ch <- StringOps(s)) sb.append(f(ch))
+      for (ch <- s) sb.append(f(ch))
       sb.toString
     }
     def flatMap(f: Char => String): String = {
       val sb = new StringBuilder
-      for (ch <- StringOps(s)) sb.append(f(ch))
+      for (ch <- s) sb.append(f(ch))
       sb.toString
     }
     def ++(xs: IterableOnce[Char]): String = {
@@ -393,15 +412,6 @@ object CollectionStrawMan5 {
           -1
       }
     }
-    case class Reverse[A](underlying: Iterable[A]) extends View[A] {
-      def iterator = {
-        var xs: List[A] = Nil
-        val it = underlying.iterator
-        while (it.hasNext) xs = Cons(it.next(), xs)
-        xs.iterator
-      }
-      override def knownLength = underlying.knownLength
-    }
   }
 
 /* ---------- Iterators ---------------------------------------------------*/