Add ++= and size methods on Lst.Buffer

Author: odersky

tests/run/lst/Lst.scala

@@ -23,7 +23,7 @@ class Lst[+T <: AnyRef](val elems: AnyRef) extends AnyVal {
   def isEmpty = elems == null
   def nonEmpty = elems != null
 
-  inline def foreach(inline op: T => Unit): Unit = {
+  @inline def foreach(@inline op: T => Unit): Unit = {
     def sharedOp(x: T) = op(x)
     elems match {
       case null =>
@@ -34,10 +34,10 @@ class Lst[+T <: AnyRef](val elems: AnyRef) extends AnyVal {
     }
   }
 
-  /** Like `foreach`, but completely inlines `op`, atthe price of generating the code twice.
+  /** Like `foreach`, but completely @inlines `op`, atthe price of generating the code twice.
    *  Should be used only of `op` is small
    */
-  inline def foreachInlined(inline op: T => Unit): Unit = elems match {
+  @inline def foreachInlined(@inline op: T => Unit): Unit = elems match {
     case null =>
     case elems: Array[AnyRef] => def elem(i: Int) = elems(i).asInstanceOf[T]
       var i = 0
@@ -58,7 +58,7 @@ class Lst[+T <: AnyRef](val elems: AnyRef) extends AnyVal {
   }
 
   /** `f` is pulled out, not duplicated */
-  inline def map[U <: AnyRef](inline f: T => U): Lst[U] = {
+  @inline def map[U <: AnyRef](@inline f: T => U): Lst[U] = {
     def op(x: T) = f(x)
     elems match {
       case null => Empty
@@ -142,7 +142,7 @@ class Lst[+T <: AnyRef](val elems: AnyRef) extends AnyVal {
   }
   def filterNot(p: T => Boolean): Lst[T] = filter(!p(_))
 
-  inline def exists(inline p: T => Boolean): Boolean = {
+  @inline def exists(@inline p: T => Boolean): Boolean = {
     def op(x: T) = p(x)
     elems match {
       case null => false
@@ -155,7 +155,7 @@ class Lst[+T <: AnyRef](val elems: AnyRef) extends AnyVal {
     }
   }
 
-  inline def forall(inline p: T => Boolean): Boolean = {
+  @inline def forall(@inline p: T => Boolean): Boolean = {
     def op(x: T) = p(x)
     elems match {
       case null => true
@@ -168,7 +168,7 @@ class Lst[+T <: AnyRef](val elems: AnyRef) extends AnyVal {
     }
   }
 
-  inline def contains[U >: T](x: U): Boolean = elems match {
+  @inline def contains[U >: T](x: U): Boolean = elems match {
     case null => false
     case elems: Array[AnyRef] => def elem(i: Int) = elems(i).asInstanceOf[T]
       var i = 0
@@ -178,7 +178,7 @@ class Lst[+T <: AnyRef](val elems: AnyRef) extends AnyVal {
       elem == x
   }
 
-  inline def foldLeft[U](z: U)(inline f: (U, T) => U) = {
+  @inline def foldLeft[U](z: U)(@inline f: (U, T) => U) = {
     def op(x: U, y: T) = f(x, y)
     elems match {
       case null => z
@@ -192,7 +192,7 @@ class Lst[+T <: AnyRef](val elems: AnyRef) extends AnyVal {
     }
   }
 
-  inline def /: [U](z: U)(inline op: (U, T) => U) = foldLeft(z)(op)
+  @inline def /: [U](z: U)(@inline op: (U, T) => U) = foldLeft(z)(op)
 
   def reduceLeft[U >: T](op: (U, U) => U) = elems match {
     case elems: Array[AnyRef] => def elem(i: Int) = elems(i).asInstanceOf[T]
@@ -422,25 +422,47 @@ object Lst {
   val equalsFn = (x: AnyRef, y: AnyRef) => x `equals` y
 
   class Buffer[T <: AnyRef] {
-    var len = 0
+    private var len = 0
     private var elem: T = _
     private var elems: Arr = _
 
-    def += (x: T) = {
+    def size = len
+
+    /** pre: len > 0, n > 1 */
+    private def ensureSize(n: Int) =
+      if (len == 1) {
+        elems = new Arr(n `max` 16)
+        elems(0) = elem
+      }
+      else if (len < n) {
+        val newLen = n `max` len << 2
+        val newElems = new Arr(newLen)
+        System.arraycopy(elems, 0, newElems, 0, len)
+        elems = newElems
+      }
+
+    def += (x: T): this.type = {
       if (len == 0) elem = x
       else {
-        if (len == 1) {
-          elems = new Arr(16)
-          elems(0) = elem
-        }
-        else if (len == elems.length) {
-          val newElems = new Arr(elems.length * 2)
-          System.arraycopy(elems, 0, newElems, 0, elems.length)
-          elems = newElems
-        }
+        ensureSize(len + 1)
         elems(len) = x
       }
       len += 1
+      this
+    }
+
+    def ++= (xs: Lst[T]): this.type = {
+      xs.elems match {
+        case null => this
+        case elems2: Array[AnyRef] =>
+          if (len == 0) elems = elems2
+          else {
+            ensureSize(len + elems2.length)
+            System.arraycopy(elems2, 0, elems, len, elems2.length)
+          }
+        case elem: T @unchecked => this += elem
+      }
+      this
     }
 
     def toLst: Lst[T] =

tests/run/lst/LstTest.scala

@@ -172,6 +172,17 @@ object Test extends App {
     assert(!zs1.eqElements(zs3))
   }
 
+  def bufferTest() = {
+    val b = new Lst.Buffer[String]
+    b += "a"
+    assert(b.size == 1)
+    assert(b.toLst === Lst("a"))
+    b += "aa"
+    b ++= Lst.fill(20)("a")
+    assert(b.toLst.mkString("") == "a" * 23)
+    assert(b.size == 23)
+  }
+
   println("testing")
   lengthTest()
   concatTest()