@effekt-lang/effekt 0.46.0 → 0.48.0

package/libraries/common/map.effekt

@@ -1,5 +1,7 @@
 module map
 
+import stream
+
 /// Ordered finite immutable map, backed by balanced binary trees of logarithmic depth.
 record Map[K, V](tree: internal::Tree[K, V], compare: (K, K) => Ordering at {})
 
@@ -989,4 +991,36 @@ namespace internal {
 
     "[" ++ res ++ "]"
   }
-}
+}
+
+
+// Streaming
+// ---------
+
+/// Turns a `map` into a producer of a push stream
+/// of `(key, value)` pairs by emitting each contained *in order*.
+def each[K, V](map: Map[K, V]): Unit / emit[(K, V)] =
+  map.foreach { (k, v) => do emit((k, v)) }
+
+/// Turns a `map` into a producer of a push stream
+/// of its keys by emitting each contained *in order*.
+def eachKey[K, V](map: Map[K, V]): Unit / emit[K] =
+  map.foreach { (k, _v) => do emit(k) }
+
+/// Turns a `map` into a producer of a push stream
+/// of its values by emitting each contained.
+def eachValue[K, V](map: Map[K, V]): Unit / emit[V] =
+  map.foreach { (_k, v) => do emit(v) }
+
+def collect[K, V](compare: (K, K) => Ordering at {}) { stream: () => Unit / emit[(K, V)] }: Map[K, V] =
+  returning::collect[K, V, Unit](compare){stream}.second
+
+namespace returning {
+  def collect[K, V, R](compare: (K, K) => Ordering at {}) { stream: () => R / emit[(K, V)] }: (R, Map[K, V]) =
+    try {
+      (stream(), empty(compare))
+    } with emit[(K, V)] { case (k, v) =>
+      val (r, map) = resume(());
+      (r, map.put(k, v))
+    }
+}

package/libraries/common/process.effekt

@@ -1,6 +1,6 @@
 module process
 
-extern io def exit(errorCode: Int): Nothing =
+extern def exit(errorCode: Int) at io: Nothing =
   js   "(function() { process.exit(${errorCode}) })()"
   llvm """
     call void @exit(i64 ${errorCode})

package/libraries/common/queue.effekt

@@ -20,10 +20,10 @@ interface Queue[T] {
 }
 
 
-def emptyQueue[T](): Queue[T] at {global} =
+def emptyQueue[T](): Queue[T] at global =
   emptyQueue[T](64)
 
-def emptyQueue[T](initialCapacity: Int): Queue[T] at {global} = {
+def emptyQueue[T](initialCapacity: Int): Queue[T] at global = {
 
   val contents = ref(array[Option[T]](initialCapacity, None()))
   val head = ref(0)
@@ -103,7 +103,7 @@ def emptyQueue[T](initialCapacity: Int): Queue[T] at {global} = {
       tail.set(mod(tail.get + 1, capacity.get))
     }
   }
-  queue
+  box queue
 }
 
 namespace examples {

package/libraries/common/random.effekt

@@ -1,6 +1,7 @@
 module random
 
 import stream
+import io/filesystem
 import io/error
 
 /// Infinite pull stream of random bytes.

package/libraries/common/ref.effekt

@@ -30,7 +30,7 @@ extern type Ref[T]
 
 /// Allocates a new reference, keeping its value _undefined_.
 /// Prefer using `ref` constructor instead to ensure that the value is defined.
-extern global def allocate[T](): Ref[T] =
+extern def allocate[T]() at global: Ref[T] =
   js "{ value: undefined }"
   chez "(box #f)"
   llvm """
@@ -50,7 +50,7 @@ extern global def allocate[T](): Ref[T] =
   """
 
 /// Creates a new reference with the initial value `init`.
-extern global def ref[T](init: T): Ref[T] =
+extern def ref[T](init: T) at global: Ref[T] =
   js "{ value: ${init} }"
   chez "(box ${init})"
   llvm """
@@ -72,7 +72,7 @@ extern global def ref[T](init: T): Ref[T] =
   vm "ref::ref[T](T)"
 
 /// Gets the referenced element of the `ref` in constant time.
-extern global def get[T](ref: Ref[T]): T =
+extern def get[T](ref: Ref[T]) at global: T =
   js "${ref}.value"
   chez "(unbox ${ref})"
 llvm """
@@ -88,7 +88,7 @@ llvm """
   vm "ref::get[T](Ref[T])"
 
 /// Sets the referenced element of the `ref` to `value` in constant time.
-extern global def set[T](ref: Ref[T], value: T): Unit =
+extern def set[T](ref: Ref[T], value: T) at global: Unit =
   js "set$impl(${ref}, ${value})"
   chez "(set-box! ${ref} ${value})"
   llvm """
@@ -104,3 +104,7 @@ extern global def set[T](ref: Ref[T], value: T): Unit =
     ret %Pos zeroinitializer
   """
   vm "ref::set[T](Ref[T], T)"
+
+/// Modifies the inner contents of the `ref` with a function `f`
+def map[T](ref: Ref[T]) { f: T => T }: Unit =
+  ref.set(f(ref.get))

package/libraries/common/regex.effekt

@@ -8,7 +8,7 @@ extern type Regex
 
 record Match(matched: String, index: Int)
 
-extern pure def regex(str: String): Regex =
+extern def regex(str: String) at {}: Regex =
   js "new RegExp(${str})"
   chez "(pregexp ${str})"
   vm "regex::regex(String)"
@@ -29,12 +29,12 @@ namespace internal {
     // js: { matched: String, index: Int } | undefined
     // vm: scala.util.matching.Regex.Match | null
 
-  extern pure def matched(r: RegexMatch): String =
+  extern def matched(r: RegexMatch) at {}: String =
     js "${r}.matched"
     chez "(vector-ref ${r} 0)"
     vm "regex::matched(RegexMatch)"
 
-  extern pure def index(r: RegexMatch): Int =
+  extern def index(r: RegexMatch) at {}: Int =
     js "${r}.index"
     chez "(vector-ref ${r} 1)"
     vm "regex::index(RegexMatch)"
@@ -57,7 +57,7 @@ namespace internal {
         #f))))
   """
 
-  extern io def exec(reg: Regex, str: String): RegexMatch =
+  extern def exec(reg: Regex, str: String) at io: RegexMatch =
     js "regex$exec(${reg}, ${str})"
     chez "(regex-exec ${reg} ${str})"
     vm "regex::exec(Regex, String)"

package/libraries/common/seq.effekt

@@ -875,7 +875,7 @@ def map[A, B](seq: Seq[A]) { f: (A) {Control} => B }: Seq[B] = {
 
 // def iterate[A, R](seq: Seq[A]) { prog: {Iterator[A]} => R }: R = {
 
-//   var k: Unit => Unit at {} = fun(unit: Unit) { () }
+//   var k: Unit => Unit at {} = box { () => () }
 //   var v: Option[A] = None()
 
 //   try { seq.each { el => do yield(el) } } with Generator[A] {

package/libraries/common/set.effekt

@@ -1,6 +1,7 @@
 module set
 
 import map
+import stream
 
 /// Ordered finite immutable set, backed by balanced binary trees of logarithmic depth.
 record Set[A](tree: internal::Tree[A, Unit], compare: (A, A) => Ordering at {})
@@ -231,4 +232,26 @@ def intersection[A](s1: Set[A], s2: Set[A], compare: (A, A) => Ordering at {}):
 ///
 /// O(???)
 def intersection[A](s1: Set[A], s2: Set[A]): Set[A] =
-  s1.intersection(s2, s1.compare)
+  s1.intersection(s2, s1.compare)
+
+
+// Streaming
+// ---------
+
+/// Turns a `set` into a producer of a push stream
+/// by emitting each contained *in order*.
+def each[A](set: Set[A]): Unit / emit[A] =
+  set.foreach { x => do emit(x) }
+
+def collect[A](compare: (A, A) => Ordering at {}) { stream: () => Unit / emit[A] }: Set[A] =
+  returning::collect[A, Unit](compare){stream}.second
+
+namespace returning {
+  def collect[A, R](compare: (A, A) => Ordering at {}) { stream: () => R / emit[A] }: (R, Set[A]) =
+    try {
+      (stream(), empty(compare))
+    } with emit[A] { (v) =>
+      val (r, set) = resume(());
+      (r, set.insert(v))
+    }
+}

package/libraries/common/stream.effekt

@@ -1,12 +1,7 @@
 module stream
 
-import array
-import bytearray
-import map
-import set
-
-import io/filesystem
-import io/error
+import effekt
+import option
 
 // Effects
 // -------
@@ -53,68 +48,6 @@ def fix[T] { one: T => Unit / emit[T] } { stream: => Unit / emit[T] }: Unit =
     resume(())
   }
 
-/// Turns a `list` into a producer of a push stream
-/// by emitting each contained value left-to-right.
-def each[A](list: List[A]): Unit / emit[A] =
-  list match {
-    case Nil() => ()
-    case Cons(head, tail) =>
-      do emit(head)
-      each(tail)
-  }
-
-/// Turns an `array` into a producer of a push stream
-/// by emitting each contained value from 0 to length - 1.
-def each[T](array: Array[T]): Unit / emit[T] = {
-  val n = array.size
-  def go(i: Int): Unit = {
-    if (i < n) {
-      do emit(array.unsafeGet(i))
-      go(i + 1)
-    }
-  }
-  go(0)
-}
-
-/// Turns `bytes` into a producer of a push stream
-/// by emitting each contained value from 0 to length - 1.
-def each(bytes: ByteArray): Unit / emit[Byte] = {
-  val n = bytes.size
-  def go(i: Int): Unit = {
-    if (i < n) {
-      do emit(bytes.unsafeGet(i))
-      go(i + 1)
-    }
-  }
-  go(0)
-}
-
-/// Turns a `map` into a producer of a push stream
-/// of `(key, value)` pairs by emitting each contained *in order*.
-def each[K, V](map: Map[K, V]): Unit / emit[(K, V)] =
-  map.foreach { (k, v) => do emit((k, v)) }
-
-/// Turns a `map` into a producer of a push stream
-/// of its keys by emitting each contained *in order*.
-def eachKey[K, V](map: Map[K, V]): Unit / emit[K] =
-  map.foreach { (k, _v) => do emit(k) }
-
-/// Turns a `map` into a producer of a push stream
-/// of its values by emitting each contained.
-def eachValue[K, V](map: Map[K, V]): Unit / emit[V] =
-  map.foreach { (_k, v) => do emit(v) }
-
-/// Turns a `set` into a producer of a push stream
-/// by emitting each contained *in order*.
-def each[A](set: Set[A]): Unit / emit[A] =
-  set.foreach { x => do emit(x) }
-
-// not option
-// not dequeue
-// not queue
-// not result
-// not seq
-
 
 def boundary { program: () => Unit / stop }: Unit = {
   returning::boundary[Unit]{program}
@@ -202,87 +135,6 @@ def sum { stream: () => Unit / emit[Int] }: Int =
 def product { stream: () => Unit / emit[Int] }: Int =
   returning::product[Unit]{stream}.second
 
-def collectList[A] { stream: () => Unit / emit[A] }: List[A] =
-  returning::collectList[A, Unit]{stream}.second
-
-def collectArray[A] { stream: () => Unit / emit[A] }: Array[A] =
-  returning::collectArray[A, Unit]{stream}.second
-
-def collectBytes { stream: () => Unit / emit[Byte] }: ByteArray =
-  returning::collectBytes[Unit]{stream}.second
-
-def feed[T, R](list: List[T]) { reader: () => R / read[T] }: R = {
-  var l = list
-  try {
-    reader()
-  } with read[T] {
-    resume {
-      l match {
-        case Nil() => do stop()
-        case Cons(value, rest) =>
-          l = rest
-          return value
-      }
-    }
-  }
-}
-
-def collectMap[K, V, R](compare: (K, K) => Ordering at {}) { stream: () => R / emit[(K, V)] }: (R, Map[K, V]) =
-  try {
-    (stream(), map::empty(compare))
-  } with emit[(K, V)] { case (k, v) =>
-    val (r, map) = resume(());
-    (r, map.put(k, v))
-  }
-
-def collectMap[K, V](compare: (K, K) => Ordering at {}) { stream: () => Any / emit[(K, V)] }: Map[K, V] =
-  collectMap[K, V, Any](compare){stream}.second
-
-def collectSet[A, R](compare: (A, A) => Ordering at {}) { stream: () => R / emit[A] }: (R, Set[A]) =
-  try {
-    (stream(), set::empty(compare))
-  } with emit[A] { (v) =>
-    val (r, set) = resume(());
-    (r, set.insert(v))
-  }
-
-def collectSet[A](compare: (A, A) => Ordering at {}) { stream: () => Any / emit[A] }: Set[A] =
-  collectSet[A, Any](compare){stream}.second
-
-def feed[T, R](array: Array[T]) { reader: () => R / read[T] }: R = {
-  var i = 0
-  try {
-    reader()
-  } with read[T] {
-    resume {
-      if (i < array.size) {
-        val c = i
-        i = c + 1
-        array.unsafeGet(c)
-      } else {
-        do stop()
-      }
-    }
-  }
-}
-
-def feed[R](bytes: ByteArray) { reader: () => R / read[Byte] }: R = {
-  var i = 0
-  try {
-    reader()
-  } with read[Byte] {
-    resume {
-      if (i < bytes.size) {
-        val c = i
-        i = c + 1
-        bytes.unsafeGet(c)
-      } else {
-        do stop()
-      }
-    }
-  }
-}
-
 def source[A] { stream: () => Unit / emit[A] } { reader: () => Unit / read[A] }: Unit =
   returning::source[A, Unit]{stream}{reader}
 
@@ -319,155 +171,6 @@ def zipLongest[A, B] { stream1: () => Unit / emit[A] } { stream2: () => Unit / e
   }
 }
 
-def writeFile[R](path: String) { stream: () => R / emit[Byte] }: R / Exception[IOError] = {
-
-  val file = openForWriting(path);
-  with on[IOError].finalize { close(file) }
-
-  val chunkSize = 1048576 // 1MB
-  val buffer = bytearray::allocate(chunkSize)
-  var offset = 0
-
-  def push(i: Int, n: Int): Unit = {
-    val r = write(file, buffer, i, n, -1)
-    if (r < n) {
-      push(i + r, n - r)
-    }
-  }
-
-  try {
-    val r = stream()
-    push(0, offset)
-    return r
-  } with emit[Byte] { (byte) =>
-    if (offset >= buffer.size) {
-      push(0, buffer.size)
-      offset = 0
-    }
-    buffer.unsafeSet(offset, byte)
-    offset = offset + 1
-    resume(())
-  }
-}
-
-def readFile[R](path: String) { reader: () => R / read[Byte] }: R / Exception[IOError] = {
-
-  val file = openForReading(path);
-  with on[IOError].finalize { close(file) }
-
-  val chunkSize = 1048576 // 1MB
-  val buffer = bytearray::allocate(chunkSize)
-  var offset = 0
-  var length = 0
-
-  def pull(): Unit / stop = {
-    read(file, buffer, 0, chunkSize, -1) match {
-      case 0 =>
-        do stop()
-      case n =>
-        length = n
-    }
-  }
-
-  try {
-    reader()
-  } with read[Byte] {
-    resume {
-      if (offset >= length) {
-        pull()
-        offset = 0
-      }
-      val byte = buffer.unsafeGet(offset)
-      offset = offset + 1
-      return byte
-    }
-  }
-}
-
-def decodeChar(): Char / {read[Byte], stop} = {
-  val b = do read().toInt
-  if (b < 128) {
-    b.toChar
-  } else if (b < 224) {
-    val part1 = bitwiseShl(bitwiseAnd(b, 31), 6)
-    val part2 = bitwiseAnd(do read().toInt, 63)
-    bitwiseOr(part1, part2).toChar
-  } else if (b < 240) {
-    val part1 = bitwiseShl(bitwiseAnd(b, 15), 12)
-    val part2 = bitwiseShl(bitwiseAnd(do read().toInt, 63), 6)
-    val part3 = bitwiseAnd(do read().toInt, 63)
-    bitwiseOr(bitwiseOr(part1, part2), part3).toChar
-  } else {
-    val part1 = bitwiseShl(bitwiseAnd(b, 7), 18)
-    val part2 = bitwiseShl(bitwiseAnd(do read().toInt, 63), 12)
-    val part3 = bitwiseShl(bitwiseAnd(do read().toInt, 63), 6)
-    val part4 = bitwiseAnd(do read().toInt, 63)
-    bitwiseOr(bitwiseOr(bitwiseOr(part1, part2), part3), part4).toChar
-  }
-}
-
-def encodeChar(char: Char): Unit / emit[Byte] = {
-  val code = char.toInt
-  if (code < 128) {
-    do emit(code.toByte)
-  } else if (code < 2048) {
-    do emit(bitwiseOr(192, bitwiseShr(code, 6)).toByte)
-    do emit(bitwiseOr(128, bitwiseAnd(code, 63)).toByte)
-  } else if (code < 65536) {
-    do emit(bitwiseOr(224, bitwiseShr(code, 12)).toByte)
-    do emit(bitwiseOr(128, bitwiseAnd(bitwiseShr(code, 6), 63)).toByte)
-    do emit(bitwiseOr(128, bitwiseAnd(code, 63)).toByte)
-  } else {
-    do emit(bitwiseOr(240, bitwiseShr(code, 18)).toByte)
-    do emit(bitwiseOr(128, bitwiseAnd(bitwiseShr(code, 12), 63)).toByte)
-    do emit(bitwiseOr(128, bitwiseAnd(bitwiseShr(code, 6), 63)).toByte)
-    do emit(bitwiseOr(128, bitwiseAnd(code, 63)).toByte)
-  }
-}
-
-def decodeUTF8[R] { reader: () => R / read[Char] }: R / read[Byte] =
-  try {
-    reader()
-  } with read[Char] {
-    resume { decodeChar() }
-  }
-
-def encodeUTF8[R] { stream: () => R / emit[Char] }: R / emit[Byte] =
-  try {
-    stream()
-  } with emit[Char] { char =>
-    resume(encodeChar(char))
-  }
-
-def writeFileUTF8[R](path: String) { stream: () => R / emit[Char] }: R / Exception[IOError] =
-  writeFile(path) { encodeUTF8 { stream() } }
-
-def readFileUTF8[R](path: String) { reader: () => R / read[Char] }: R / Exception[IOError] =
-  readFile(path) { decodeUTF8 { reader() } }
-
-def feed[R](string: String) { reader: () => R / read[Char] } =
-  feed(string.fromString) {
-    decodeUTF8 {
-      reader()
-    }
-  }
-
-def each(string: String): Unit / emit[Char] =
-  feed(string) {
-    exhaustively {
-      do emit[Char](do read[Char]())
-    }
-  }
-
-def collectString { stream: () => Unit / emit[Char] }: String =
-  returning::collectString[Unit]{stream}.second
-
-def writeLine { body: () => Unit / emit[Char] }: Unit / emit[Char] =
-  returning::writeLine[Unit]{body}
-
-def readLine { body: () => Unit / read[Char] }: Unit / {read[Char], stop} =
-  returning::readLine[Unit]{body}
-
 namespace internal {
   effect snapshot(): Unit
 }
@@ -640,67 +343,6 @@ def product[R] { stream: () => R / emit[Int] }: (R, Int) = {
   }
 }
 
-def collectList[A, R] { stream: () => R / emit[A] }: (R, List[A]) =
-  try {
-    (stream(), Nil())
-  } with emit[A] { (v) =>
-    val (r, vs) = resume(());
-    (r, Cons(v, vs))
-  }
-
-def collectArray[A, R] { stream: () => R / emit[A] }: (R, Array[A]) = {
-  var i = 0
-  var a = array::allocate(1)
-  try {
-    (stream(), a.resize(i))
-  } with emit[A] { (v) =>
-    if (i >= a.size) { a = a.resize(2 * a.size) }
-    a.unsafeSet(i, v)
-    i = i + 1
-    resume(())
-  }
-}
-
-def collectBytes[R] { stream: () => R / emit[Byte] }: (R, ByteArray) = {
-  var i = 0
-  var a = bytearray::allocate(1)
-  try {
-    (stream(), a.resize(i))
-  } with emit[Byte] { (v) =>
-    if (i >= a.size) { a = a.resize(2 * a.size) }
-    a.unsafeSet(i, v)
-    i = i + 1
-    resume(())
-  }
-}
-
-def collectString[R] { stream: () => R / emit[Char] }: (R, String) = {
-  val (result, bytes) = collectBytes[R] { encodeUTF8 { stream } }
-  (result, bytes.toString)
-}
-
-def writeLine[R] { body: () => R / emit[Char] }: R / emit[Char] = {
-  val result = body()
-  do emit('\n')
-  return result
-}
-
-def readLine[R] { body: () => R / read[Char] }: R / {read[Char], stop} = {
-  var stopped = false
-  try {
-    body()
-  } with read[Char] {
-    if(stopped){
-      resume { do stop() }
-    } else {
-      do read[Char] match {
-        case '\n' => stopped = true; resume { do stop() }
-        case char => resume { return char }
-      }
-    }
-  }
-}
-
 def source[A, R] { stream: () => Unit / emit[A] } { reader: () => R / read[A] }: R = {
   var next = box { None() }
   next = box {

package/libraries/common/string.effekt

@@ -2,10 +2,12 @@ module string
 
 import effekt
 import option
+import stream
 import list
 import exception
 import result
 import char
+import bytearray
 
 // TODO
 // - [ ] handle unicode codepoints (that can span two indices) correctly
@@ -111,7 +113,7 @@ def join(strings: List[String], sep: String): String = {
   }
 }
 
-extern pure def trim(str: String): String =
+extern def trim(str: String) at {}: String =
   js "${str}.trim()"
 
 // Parsing
@@ -169,7 +171,7 @@ def toInt(str: String, base: Int): Int / Exception[WrongFormat] = {
 }
 
 /// Native versions of toInt (unused right now)
-extern pure def unsafeToInt(str: String): Int =
+extern def unsafeToInt(str: String) at {}: Int =
   js "(Number.isNaN(parseInt(${str})) ? undefined : parseInt(${str}))"
   chez "(string->number ${str})"
 
@@ -203,7 +205,7 @@ def lastIndexOf(str: String, sub: String, from: Int): Option[Int] = {
 
 // TODO more efficient (native) implementations could be integrated as follows
 
-// extern pure def indexOf(str: String, sub: String): Option[Int] =
+// extern def indexOf(str: String, sub: String) at {}: Option[Int] =
 //   //js { nativeIndexOf(str, sub) }
 //   default { indexOf(str, sub, 0) }
 
@@ -212,7 +214,7 @@ def lastIndexOf(str: String, sub: String, from: Int): Option[Int] = {
 //   if (index < 0) { None() } else { Some(index) }
 // }
 
-// extern pure def unsafeIndexOf(str: String, sub: String): Int =
+// extern def unsafeIndexOf(str: String, sub: String) at {}: Int =
 //   js "${str}.indexOf(${sub})"
 
 def charAt(str: String, index: Int): Char / Exception[OutOfBounds] =
@@ -221,7 +223,7 @@ def charAt(str: String, index: Int): Char / Exception[OutOfBounds] =
   else
     unsafeCharAt(str, index)
 
-extern pure def unsafeCharAt(str: String, n: Int): Char =
+extern def unsafeCharAt(str: String, n: Int) at {}: Char =
   js "${str}.codePointAt(${n})"
   chez "(char->integer (string-ref ${str} ${n}))"
   llvm """
@@ -229,3 +231,31 @@ extern pure def unsafeCharAt(str: String, n: Int): Char =
     ret %Int %x
   """
   vm "string::unsafeCharAt(String, Int)"
+
+
+// Streaming
+// ---------
+
+def feed[R](string: String) { reader: () => R / read[Char] } =
+  feed(string.fromString) {
+    decodeUTF8 {
+      reader()
+    }
+  }
+
+def each(string: String): Unit / emit[Char] =
+  feed(string) {
+    exhaustively {
+      do emit[Char](do read[Char]())
+    }
+  }
+
+def collect { stream: () => Unit / emit[Char] }: String =
+  returning::collect[Unit]{stream}.second
+
+namespace returning {
+  def collect[R] { stream: () => R / emit[Char] }: (R, String) = {
+    val (result, bytes) = bytearray::returning::collect[R] { encodeUTF8 { stream } }
+    (result, bytes.toString)
+  }
+}

package/libraries/common/stringbuffer.effekt

@@ -1,5 +1,6 @@
 module stringbuffer
 
+import effekt
 import bytearray
 
 interface StringBuffer {