Collect with initial capacity (#1350)

We now have collecting functions with initial capacity as a performance
hint. Addresses #1309.

Author: phischu

libraries/common/array.effekt

@@ -677,18 +677,27 @@ def feed[T, R](array: Array[T]) { reader: () => R / read[T] }: R = {
   }
 }
 
+/// Collects elements emitted by a push stream producer `stream` into a new array,
+/// discarding the result of the producer.
+/// The provided capacity is a hint for the expected number of elements.
+/// It must be strictly larger than zero.
+def collect[A](capacity: Int) { stream: () => Unit / emit[A] }: Array[A] =
+  returning::collect[A, Unit](capacity){stream}.second
+
 /// Collects elements emitted by a push stream producer `stream` into a new array,
 /// discarding the result of the producer.
 def collect[A] { stream: () => Unit / emit[A] }: Array[A] =
-  returning::collect[A, Unit]{stream}.second
+  collect[A](4){stream}
 
 namespace returning {
 
   /// Collects elements emitted by a push stream producer `stream` into a new array,
   /// returning the result of the producer as well as the collected array.
-  def collect[A, R] { stream: () => R / emit[A] }: (R, Array[A]) = {
+  /// The provided capacity is a hint for the expected number of elements.
+  /// It must be strictly larger than zero.
+  def collect[A, R](capacity: Int) { stream: () => R / emit[A] }: (R, Array[A]) = {
     var i = 0
-    var a = unsafeAllocate(1)
+    var a = unsafeAllocate(capacity)
     try {
       (stream(), a.resize(i))
     } with emit[A] { (v) =>
@@ -698,4 +707,10 @@ namespace returning {
       resume(())
     }
   }
+
+  /// Collects elements emitted by a push stream producer `stream` into a new array,
+  /// returning the result of the producer as well as the collected array.
+  def collect[A, R] { stream: () => R / emit[A] }: (R, Array[A]) =
+    returning::collect[A, R](4){stream}
+
 }

libraries/common/bytearray.effekt

@@ -300,13 +300,17 @@ def feed[R](bytes: ByteArray) { reader: () => R / read[Byte] }: R = {
   }
 }
 
+def collect(capacity: Int) { stream: () => Unit / emit[Byte] }: ByteArray =
+  returning::collect[Unit](capacity){stream}.second
+
 def collect { stream: () => Unit / emit[Byte] }: ByteArray =
-  returning::collect[Unit]{stream}.second
+  collect(4){stream}
 
 namespace returning {
-  def collect[R] { stream: () => R / emit[Byte] }: (R, ByteArray) = {
+
+  def collect[R](capacity: Int) { stream: () => R / emit[Byte] }: (R, ByteArray) = {
     var i = 0
-    var a = allocate(1)
+    var a = allocate(capacity)
     try {
       (stream(), a.resize(i))
     } with emit[Byte] { (v) =>
@@ -316,4 +320,8 @@ namespace returning {
       resume(())
     }
   }
+
+  def collect[R] { stream: () => R / emit[Byte] }: (R, ByteArray) =
+    returning::collect(4){stream}
+
 }

libraries/common/string.effekt

@@ -251,12 +251,20 @@ def each(string: String): Unit / emit[Char] =
     }
   }
 
+def collect(capacity: Int) { stream: () => Unit / emit[Char] }: String =
+  returning::collect[Unit](capacity){stream}.second
+
 def collect { stream: () => Unit / emit[Char] }: String =
-  returning::collect[Unit]{stream}.second
+  collect(4){stream}
 
 namespace returning {
-  def collect[R] { stream: () => R / emit[Char] }: (R, String) = {
-    val (result, bytes) = bytearray::returning::collect[R] { encodeUTF8 { stream } }
+
+  def collect[R](capacity: Int) { stream: () => R / emit[Char] }: (R, String) = {
+    val (result, bytes) = bytearray::returning::collect[R](capacity) { encodeUTF8 { stream } }
     (result, bytes.toString)
   }
+
+  def collect[R] { stream: () => R / emit[Char] }: (R, String) =
+    returning::collect(4){stream}
+
 }