Avoid C style namespacing

Author: phischu

examples/benchmarks/input_output/dyck_one.effekt

@@ -28,7 +28,7 @@ type Tree {
 
 def readTree(): Tree / { Scan[Byte], stop } = {
   readIf[Byte] { b => b.toInt == 40 }
-  val children = collectList[Tree] { many { readTree() } }
+  val children = list::collect[Tree] { many { readTree() } }
   skipIf[Byte] { b => b.toInt == 41 }
   Node(children)
 }

examples/stdlib/list/collect.effekt

@@ -2,11 +2,11 @@ module examples/pos/list/collect
 
 def main() = {
   val empty = Nil[Int]()
-  empty.collect { x => Some(x) }.foreach { x => println(x) }
+  empty.collectSome { x => Some(x) }.foreach { x => println(x) }
 
   val l = [1, 2, 3, 4]
-  l.collect { x => if (x > 2) { Some(x * 10) } else { None() } }.foreach { x => println(x) }
+  l.collectSome { x => if (x > 2) { Some(x * 10) } else { None() } }.foreach { x => println(x) }
 
   val optList = [Some(1), None(), Some(2), None(), Some(3), Some(4), None()]
-  optList.collect { x => x }.foreach { x => println(x) }
+  optList.collectSome { x => x }.foreach { x => println(x) }
 }

examples/stdlib/stream/characters.effekt

@@ -5,7 +5,7 @@ def main() = {
     println(show(c) ++ " (" ++ show(c.toInt) ++ ")")
   }
 
-  val list = collectList[Char] { each("Hello") }
+  val list = list::collect[Char] { each("Hello") }
   println(list.map { c => c.show })
 }
 

examples/stdlib/stream/fastexp.effekt

@@ -62,8 +62,8 @@ def main() = {
 
   def testBits(n: Int) = {
     println(n)
-    println(collectList[Bool] {n.eachLSB}.prettyBits)
-    println(collectList[Bool] {n.eachMSB}.prettyBits)
+    println(list::collect[Bool] {n.eachLSB}.prettyBits)
+    println(list::collect[Bool] {n.eachMSB}.prettyBits)
   }
 
   testBits(0)

examples/stdlib/stream/fuse_newlines.effekt

@@ -23,7 +23,7 @@ def skipNewlines(): Nothing / {read[Char], emit[Char], stop} = {
 
 def main() = {
   with feed("ab\n\nc\nde")
-  println(collectString {
+  println(string::collect {
     with exhaustively
     fuseNewlines()
   })

examples/stdlib/stream/map.effekt

@@ -8,10 +8,10 @@ def main() = {
     println(show(k) ++ ": " ++ show(v) ++ " (" ++ show(v.toInt) ++ ")")
   }
 
-  val newMap = collectMap[Int, Char](compareInt) { each(m) }
+  val newMap = map::collect[Int, Char](compareInt) { each(m) }
   println(map::internal::prettyPairs(newMap.toList) { n => show(n) } { c => show(c) })
 
-  val hello: String = collectString { eachValue(m) }
+  val hello: String = string::collect { eachValue(m) }
   println(hello)
 }
 

examples/stdlib/stream/taylor.effekt

@@ -8,7 +8,7 @@ def ints(): Unit / emit[Int] = {
 
 /// Take the `n` first elements of a `stream`, put them in a list.
 def take[A](n: Int) { stream: () => Unit / emit[A] }: List[A] = {
-  with collectList[A]
+  with collect[A]
   with boundary
   with limit[A](n)
   stream()

examples/stdlib/stream/tee.effekt

@@ -11,11 +11,11 @@ def main() = {
     }
   }
   def a{ b: => Unit / emit[Int] }: Unit = {
-    println(collectList[Int]{boundary{limit[Int](4){b}}})
+    println(list::collect[Int]{boundary{limit[Int](4){b}}})
     println("a done")
   }
   def b{ b: => Unit / emit[Int] }: Unit = {
-    println(collectList[Int]{boundary{limit[Int](9){b}}})
+    println(list::collect[Int]{boundary{limit[Int](9){b}}})
     println("b done")
   }
   println("a{ ... }")

libraries/common/array.effekt

@@ -677,11 +677,11 @@ def feed[T, R](array: Array[T]) { reader: () => R / read[T] }: R = {
   }
 }
 
-def collectArray[A] { stream: () => Unit / emit[A] }: Array[A] =
-  returning::collectArray[A, Unit]{stream}.second
+def collect[A] { stream: () => Unit / emit[A] }: Array[A] =
+  returning::collect[A, Unit]{stream}.second
 
 namespace returning {
-  def collectArray[A, R] { stream: () => R / emit[A] }: (R, Array[A]) = {
+  def collect[A, R] { stream: () => R / emit[A] }: (R, Array[A]) = {
     var i = 0
     var a = allocate(1)
     try {

libraries/common/bytearray.effekt

@@ -238,11 +238,11 @@ def feed[R](bytes: ByteArray) { reader: () => R / read[Byte] }: R = {
   }
 }
 
-def collectBytes { stream: () => Unit / emit[Byte] }: ByteArray =
-  returning::collectBytes[Unit]{stream}.second
+def collect { stream: () => Unit / emit[Byte] }: ByteArray =
+  returning::collect[Unit]{stream}.second
 
 namespace returning {
-  def collectBytes[R] { stream: () => R / emit[Byte] }: (R, ByteArray) = {
+  def collect[R] { stream: () => R / emit[Byte] }: (R, ByteArray) = {
     var i = 0
     var a = allocate(1)
     try {