@effekt-lang/effekt 0.46.0 → 0.48.0

package/libraries/chez/common/immutable/cslist.effekt

@@ -5,21 +5,21 @@ import array
 
 // a chez scheme cons list
 extern type CSList[A]
-extern pure def cons[A](el: A, rest: CSList[A]): CSList[A] =
+extern def cons[A](el: A, rest: CSList[A]) at {}: CSList[A] =
   chez "(cons ${el} ${rest})"
 
-extern pure def nil[A](): CSList[A] =
+extern def nil[A]() at {}: CSList[A] =
   chez "(list)"
 
-extern pure def isEmpty[A](l: CSList[A]): Bool =
+extern def isEmpty[A](l: CSList[A]) at {}: Bool =
   chez "(null? ${l})"
 
 // unsafe!
-extern pure def head[A](l: CSList[A]): A =
+extern def head[A](l: CSList[A]) at {}: A =
   chez "(car ${l})"
 
 // unsafe!
-extern pure def tail[A](l: CSList[A]): CSList[A] =
+extern def tail[A](l: CSList[A]) at {}: CSList[A] =
   chez "(cdr ${l})"
 
 
@@ -33,5 +33,5 @@ def fromChez[A](l: CSList[A]): List[A] =
 
 // Old From Chez
 // -------------
-extern pure def toArray[A](l: CSList[A]): Array[A] =
+extern def toArray[A](l: CSList[A]) at {}: Array[A] =
   chez "(list->vector ${l})"

package/libraries/chez/common/mutable/dict.effekt

@@ -3,25 +3,25 @@ module mutable/dict
 // https://cisco.github.io/ChezScheme/csug9.5/compat.html#g148
 extern type Dict[K, V]
 
-extern io def emptyDict[K, V](): Dict[K, V] =
+extern def emptyDict[K, V]() at io: Dict[K, V] =
     chez "(make-eq-hashtable)"
 
-extern io def emptyWeakDict[K, V](): Dict[K, V] =
+extern def emptyWeakDict[K, V]() at io: Dict[K, V] =
     chez "(make-hash-table #t)"
 
-extern io def put[K, V](d: Dict[K, V], key: K, value: V): Unit =
+extern def put[K, V](d: Dict[K, V], key: K, value: V) at io: Unit =
     chez "(put-hash-table! ${d} ${key} ${value})"
 
-extern io def get[K, V](d: Dict[K, V], key: K, default: V): V =
+extern def get[K, V](d: Dict[K, V], key: K, default: V) at io: V =
     chez "(hashtable-ref ${d} ${key} ${default})"
 
-extern io def unsafeGet[K, V](d: Dict[K, V], key: K): V =
+extern def unsafeGet[K, V](d: Dict[K, V], key: K) at io: V =
     chez "(hashtable-ref ${d} ${key} #f)"
 
-extern io def contains[K, V](d: Dict[K, V], key: K): Bool =
+extern def contains[K, V](d: Dict[K, V], key: K) at io: Bool =
     chez "(hashtable-contains? ${d} ${key})"
 
-extern io def remove[K, V](d: Dict[K, V], key: K): Unit =
+extern def remove[K, V](d: Dict[K, V], key: K) at io: Unit =
     chez "(remove-hash-table! ${d} ${key})"
 
 def get[K, V](d: Dict[K, V], key: K): Option[V] =

package/libraries/common/args.effekt

@@ -1,6 +1,6 @@
 module args
 
-extern io def commandLineArgs(): List[String] =
+extern def commandLineArgs() at io: List[String] =
   js { js::commandLineArgs() }
   chez { chez::commandLineArgs() }
   llvm { llvm::commandLineArgs() }
@@ -9,11 +9,11 @@ extern io def commandLineArgs(): List[String] =
 namespace js {
   extern type Args // = Array[String]
 
-  extern io def nativeArgs(): Args = js "process.argv.slice(1)"
+  extern def nativeArgs() at io: Args = js "process.argv.slice(1)"
 
-  extern io def argCount(args: Args): Int = js "${args}.length"
+  extern def argCount(args: Args) at io: Int = js "${args}.length"
 
-  extern io def argument(args: Args, i: Int): String = js "${args}[${i}]"
+  extern def argument(args: Args, i: Int) at io: String = js "${args}[${i}]"
 
   def commandLineArgs(): List[String] = {
     def toList(args: Args, start: Int, acc: List[String]): List[String] =
@@ -28,16 +28,16 @@ namespace js {
 namespace chez {
   extern type Args // = CSList[String]
 
-  extern io def nativeArgs(): Args =
+  extern def nativeArgs() at io: Args =
     chez "(cdr (command-line))"
 
-  extern pure def isEmpty(l: Args): Bool =
+  extern def isEmpty(l: Args) at {}: Bool =
     chez "(null? ${l})"
 
-  extern pure def head(l: Args): String =
+  extern def head(l: Args) at {}: String =
     chez "(car ${l})"
 
-  extern pure def tail(l: Args): Args =
+  extern def tail(l: Args) at {}: Args =
     chez "(cdr ${l})"
 
   def toList(l: Args): List[String] =
@@ -47,13 +47,13 @@ namespace chez {
 }
 
 namespace llvm {
-  extern io def argCount(): Int =
+  extern def argCount() at io: Int =
     llvm """
       %c = call %Int @c_get_argc()
       ret %Int %c
     """
 
-  extern io def argument(i: Int): String =
+  extern def argument(i: Int) at io: String =
     llvm """
       %s = call %Pos @c_get_arg(%Int ${i})
       ret %Pos %s

package/libraries/common/array.effekt

@@ -4,6 +4,7 @@ import effekt
 import exception
 import list
 import option
+import stream
 
 /// A mutable 0-indexed fixed-sized array.
 extern type Array[T]
@@ -42,7 +43,7 @@ exit:
 
 /// Allocates a new array of size `size`, keeping its values _undefined_.
 /// Prefer using `array` constructor instead to ensure that values are defined.
-extern global def allocate[T](size: Int): Array[T] =
+extern def allocate[T](size: Int) at global: Array[T] =
   js "(new Array(${size}))"
   chez "(make-vector ${size})" // creates an array filled with 0s on CS
   llvm """
@@ -85,7 +86,7 @@ def fromList[T](list: List[T]): Array[T] = {
 }
 
 /// Gets the length of the array in constant time.
-extern pure def size[T](arr: Array[T]): Int =
+extern def size[T](arr: Array[T]) at {}: Int =
   js "${arr}.length"
   chez "(vector-length ${arr})"
   llvm """
@@ -102,7 +103,7 @@ extern pure def size[T](arr: Array[T]): Int =
 /// Unchecked Precondition: `index` is in bounds (0 ≤ index < arr.size)
 ///
 /// Prefer using `get` instead.
-extern global def unsafeGet[T](arr: Array[T], index: Int): T =
+extern def unsafeGet[T](arr: Array[T], index: Int) at global: T =
   js "${arr}[${index}]"
   chez "(vector-ref ${arr} ${index})"
   llvm """
@@ -129,7 +130,7 @@ extern js """
 /// Unchecked Precondition: `index` is in bounds (0 ≤ index < arr.size)
 ///
 /// Prefer using `set` instead.
-extern global def unsafeSet[T](arr: Array[T], index: Int, value: T): Unit =
+extern def unsafeSet[T](arr: Array[T], index: Int, value: T) at global: Unit =
   js "array$set(${arr}, ${index}, ${value})"
   chez "(begin (vector-set! ${arr} ${index} ${value}) #f)"
   llvm """
@@ -641,3 +642,55 @@ def println(l: Array[Int]): Unit = println(show(l))
 def println(l: Array[Double]): Unit = println(show(l))
 def println(l: Array[Bool]): Unit = println(show(l))
 def println(l: Array[String]): Unit = println(show(l))
+
+
+// Streaming
+// ---------
+
+/// 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)
+}
+
+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 collect[A] { stream: () => Unit / emit[A] }: Array[A] =
+  returning::collect[A, Unit]{stream}.second
+
+namespace returning {
+  def collect[A, R] { stream: () => R / emit[A] }: (R, Array[A]) = {
+    var i = 0
+    var a = 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(())
+    }
+  }
+}

package/libraries/common/bench.effekt

@@ -7,7 +7,7 @@ type Nanos = Int
 /// The actual precision varies across the different backends.
 /// - js: Milliseconds
 /// - chez: Microseconds
-extern io def timestamp(): Nanos =
+extern def timestamp() at io: Nanos =
   js "Date.now() * 1000000"
   chez "(timestamp)"
   llvm """
@@ -34,7 +34,7 @@ extern jsNode """
 ///
 /// This timestamp should only be used for **relative** measurements,
 /// as gives no guarantees on the absolute time (unlike a UNIX timestamp).
-extern io def relativeTimestamp(): Nanos =
+extern def relativeTimestamp() at io: Nanos =
   js "Math.round(performance.now() * 1000000)"
   default { timestamp() }
 

package/libraries/common/buffer.effekt

@@ -27,11 +27,11 @@ interface Buffer[T] {
   def write(el: T): Unit / Exception[BufferOverflow]
 }
 
-def emptyBuffer[T](capacity: Int): Buffer[T] at {global} = {
+def emptyBuffer[T](capacity: Int): Buffer[T] at global = {
   if (capacity == 1) refBuffer()
   else arrayBuffer(capacity)
 }
-def arrayBuffer[T](initialCapacity: Int): Buffer[T] at {global} = {
+def arrayBuffer[T](initialCapacity: Int): Buffer[T] at global = {
   // TODO allocate buffer (and array) into a region r.
   val contents = array::allocate[T](initialCapacity)
   val head = ref(0)
@@ -62,11 +62,11 @@ def arrayBuffer[T](initialCapacity: Int): Buffer[T] at {global} = {
       tail.set(mod(tail.get + 1, initialCapacity))
     }
   }
-  buffer
+  box buffer
 }
-def refBuffer[T](): Buffer[T] at {global} = {
+def refBuffer[T](): Buffer[T] at global = {
   val content = ref(None())
-  new Buffer[T] {
+  box new Buffer[T] {
     def capacity() = if (content.get.isEmpty) 1 else 0
     def full?() = content.get.isDefined
     def empty?() = isEmpty(content.get)

package/libraries/common/bytearray.effekt

@@ -1,5 +1,8 @@
 module bytearray
 
+import effekt
+import stream
+
 /**
  * A memory managed, mutable, fixed-length array of bytes.
  *
@@ -20,7 +23,7 @@ extern type ByteArray
   // = chez "bytevector"
 
 /// Allocates a new bytearray with the given `size`, its values are undefined.
-extern global def allocate(size: Int): ByteArray =
+extern def allocate(size: Int) at global: ByteArray =
   js "(new Uint8Array(${size}))"
   llvm """
     %object_size = add i64 ${size}, 16
@@ -33,8 +36,9 @@ extern global def allocate(size: Int): ByteArray =
     ret %Pos %ret_object2
   """
   chez "(make-bytevector ${size})"
+  vm "bytearray::allocate(Int)"
 
-extern pure def size(arr: ByteArray): Int =
+extern def size(arr: ByteArray) at {}: Int =
   js "${arr}.length"
   llvm """
     %size = extractvalue %Pos ${arr}, 0
@@ -42,8 +46,9 @@ extern pure def size(arr: ByteArray): Int =
     ret i64 %size
   """
   chez "(bytevector-length ${arr})"
+  vm "bytearray::size(ByteArray)"
 
-extern global def unsafeGet(arr: ByteArray, index: Int): Byte =
+extern def unsafeGet(arr: ByteArray, index: Int) at global: Byte =
   js "(${arr})[${index}]"
   llvm """
     %arr_ptr = extractvalue %Pos ${arr}, 1
@@ -54,8 +59,9 @@ extern global def unsafeGet(arr: ByteArray, index: Int): Byte =
     ret i8 %element
   """
   chez "(bytevector-u8-ref ${arr} ${index})"
+  vm "bytearray::unsafeGet(ByteArray, Int)"
 
-extern global def unsafeSet(arr: ByteArray, index: Int, value: Byte): Unit =
+extern def unsafeSet(arr: ByteArray, index: Int, value: Byte) at global: Unit =
   js "bytearray$set(${arr}, ${index}, ${value})"
   llvm """
     %arr_ptr = extractvalue %Pos ${arr}, 1
@@ -66,6 +72,7 @@ extern global def unsafeSet(arr: ByteArray, index: Int, value: Byte): Unit =
     ret %Pos zeroinitializer
   """
   chez "(bytevector-u8-set! ${arr} ${index} ${value})"
+  vm "bytearray::unsafeSet(ByteArray, Int, Byte)"
 
 /// Creates a new ByteArray of size `size` filled with the value `init`
 def bytearray(size: Int, init: Byte): ByteArray = {
@@ -109,20 +116,22 @@ def foreachIndex(arr: ByteArray){ action: (Int, Byte) {Control} => Unit }: Unit
     action(i, arr.unsafeGet(i)) {label}
   }
 
-extern pure def fromString(str: String): ByteArray =
+extern def fromString(str: String) at {}: ByteArray =
   js "(new TextEncoder().encode(${str}))"
   llvm """
     ret %Pos ${str}
   """
   chez "(string->utf8 ${str})"
+  vm "bytearray::fromString(String)"
 
-extern pure def toString(arr: ByteArray): String =
+extern def toString(arr: ByteArray) at {}: String =
   js "(new TextDecoder('utf-8').decode(${arr}))"
   // assuming the buffer is already in UTF-8
   llvm """
     ret %Pos ${arr}
   """
   chez "(utf8->string ${arr})"
+  vm "bytearray::toString(ByteArray)"
 
 extern js """
   function bytearray$set(bytes, index, value) {
@@ -169,13 +178,14 @@ extern chez """
           [else (loop (+ i 1))]))))
 """
 
-extern pure def compareByteArrayImpl(b1: ByteArray, b2: ByteArray): Int =
+extern def compareByteArrayImpl(b1: ByteArray, b2: ByteArray) at {}: Int =
   js "bytearray$compare(${b1}, ${b2})"
   llvm """
     %x = call %Int @c_bytearray_compare(%Pos ${b1}, %Pos ${b2})
     ret %Int %x
   """
   chez "(bytearray$compare ${b1} ${b2})"
+  vm "bytearray::compare(ByteArray, ByteArray)"
 
 def compareByteArray(b1: ByteArray, b2: ByteArray): Ordering = {
   val ret = compareByteArrayImpl(b1, b2)
@@ -193,3 +203,55 @@ def compareStringBytes(left: String, right: String): Ordering = {
   val r = right.fromString
   compareByteArray(l, r)
 }
+
+
+// Streaming
+// ---------
+
+/// 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)
+}
+
+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 collect { stream: () => Unit / emit[Byte] }: ByteArray =
+  returning::collect[Unit]{stream}.second
+
+namespace returning {
+  def collect[R] { stream: () => R / emit[Byte] }: (R, ByteArray) = {
+    var i = 0
+    var a = 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(())
+    }
+  }
+}

package/libraries/common/char.effekt

@@ -5,6 +5,7 @@ import effekt
 import exception
 import option
 import result
+import stream
 
 
 /// Checks if the given character is an ASCII whitespace
@@ -86,7 +87,7 @@ def isAlphabetic(c: Char): Bool = isLower(c) || isUpper(c)
 //   Chez: ?
 //   LLVM: i64 representing utf-8 (varying length 1-4 bytes)
 
-extern pure def toString(ch: Char): String =
+extern def toString(ch: Char) at {}: String =
   js "String.fromCodePoint(${ch})"
   chez "(string (integer->char ${ch}))"
   llvm """
@@ -95,20 +96,20 @@ extern pure def toString(ch: Char): String =
   """
 
 // Since we currently represent Char by integers in all backends, we could reuse comparison
-extern pure def toInt(ch: Char): Int =
+extern def toInt(ch: Char) at {}: Int =
   js "${ch}"
   chez "${ch}"
   llvm "ret %Int ${ch}"
   vm "string::toInt(Char)"
 
-extern pure def toChar(codepoint: Int): Char =
+extern def toChar(codepoint: Int) at {}: Char =
   js "${codepoint}"
   chez "${codepoint}"
   llvm "ret %Int ${codepoint}"
   vm "string::toChar(Int)"
 
 
-extern pure def infixLt(x: Char, y: Char): Bool =
+extern def infixLt(x: Char, y: Char) at {}: Bool =
   js "(${x} < ${y})"
   chez "(< ${x} ${y})"
   llvm """
@@ -119,7 +120,7 @@ extern pure def infixLt(x: Char, y: Char): Bool =
   """
   vm "string::infixLt(Char, Char)"
 
-extern pure def infixLte(x: Char, y: Char): Bool =
+extern def infixLte(x: Char, y: Char) at {}: Bool =
   js "(${x} <= ${y})"
   chez "(<= ${x} ${y})"
   llvm """
@@ -130,7 +131,7 @@ extern pure def infixLte(x: Char, y: Char): Bool =
   """
   vm "string::infixLte(Char, Char)"
 
-extern pure def infixGt(x: Char, y: Char): Bool =
+extern def infixGt(x: Char, y: Char) at {}: Bool =
   js "(${x} > ${y})"
   chez "(> ${x} ${y})"
   llvm """
@@ -141,7 +142,7 @@ extern pure def infixGt(x: Char, y: Char): Bool =
   """
   vm "string::infixGt(Char, Char)"
 
-extern pure def infixGte(x: Char, y: Char): Bool =
+extern def infixGte(x: Char, y: Char) at {}: Bool =
   js "(${x} >= ${y})"
   chez "(>= ${x} ${y})"
   llvm """
@@ -172,6 +173,92 @@ def utf16UnitCount(codepoint: Char): Int = codepoint match {
   case c => panic("Not a valid code point")
 }
 
-extern pure def charWidth(c: Char): Int =
+extern def charWidth(c: Char) at {}: Int =
   // JavaScript strings are UTF-16 where every unicode character after 0xffff takes two units
   js "(${c} > 0xffff) ? 2 : 1"
+
+
+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 returning {
+  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 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))
+  }