@effekt-lang/effekt 0.45.0 → 0.47.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

@@ -42,7 +42,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 +85,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 +102,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 +129,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 """

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)
@@ -64,7 +64,7 @@ def arrayBuffer[T](initialCapacity: Int): Buffer[T] at {global} = {
   }
   buffer
 }
-def refBuffer[T](): Buffer[T] at {global} = {
+def refBuffer[T](): Buffer[T] at global = {
   val content = ref(None())
   new Buffer[T] {
     def capacity() = if (content.get.isEmpty) 1 else 0

package/libraries/common/bytearray.effekt

@@ -20,7 +20,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 +33,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 +43,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 +56,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 +69,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 +113,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 +175,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)

package/libraries/common/char.effekt

@@ -86,7 +86,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 +95,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 +119,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 +130,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 +141,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 +172,6 @@ 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"