@effekt-lang/effekt 0.66.0 → 0.68.0

package/libraries/common/args.effekt

@@ -7,7 +7,7 @@ extern def commandLineArgs() at io: List[String] =
   vm { Nil() }
 
 namespace js {
-  extern type Args // = Array[String]
+  extern type Args = js "Array[String]"
 
   extern def nativeArgs() at io: Args = js "process.argv.slice(1)"
 
@@ -26,7 +26,7 @@ namespace js {
 }
 
 namespace chez {
-  extern type Args // = CSList[String]
+  extern type Args = chez "CSList[String]"
 
   extern def nativeArgs() at io: Args =
     chez "(cdr (command-line))"

package/libraries/common/array.effekt

@@ -8,7 +8,10 @@ import list
 import exception
 
 /// A mutable 0-indexed fixed-sized array.
-extern type Array[T]
+extern type Array[T] =
+  js "Array"
+  chez "vector"
+  llvm "%Pos"
 
 /// We represent arrays like positive types.
 /// The tag is 0 and the obj points to memory with the following layout:
@@ -57,7 +60,6 @@ extern def unsafeAllocate[T](size: Int) at global: Array[T] =
     %ret_pos = insertvalue %Pos { i64 0, ptr poison }, ptr %calloc, 1
     ret %Pos %ret_pos
   """
-  vm "array::unsafeAllocate(Int)"
 
 /// Fills a given array in-place.
 def fill[T](arr: Array[T], filler: T): Unit = {
@@ -96,7 +98,6 @@ extern def size[T](arr: Array[T]) at {}: Int =
     tail call void @erasePositive(%Pos ${arr})
     ret i64 %size
   """
-  vm "array::size[T](Array[T])"
 
 extern llvm """
 define void @assertInbounds(i64 %index, %Pos %arr) alwaysinline {
@@ -138,7 +139,6 @@ extern def get[T](arr: Array[T], index: Int) at global: T =
     tail call void @erasePositive(%Pos ${arr})
     ret %Pos %element
   """
-  vm "array::get[T](Array[T], Int)"
 
 extern js """
   function array$set(arr, index, value) {
@@ -165,7 +165,6 @@ extern def set[T](arr: Array[T], index: Int, value: T) at global: Unit =
     tail call void @erasePositive(%Pos ${arr})
     ret %Pos zeroinitializer
   """
-  vm "array::set[T](Array[T], Int, T)"
 
 // Derived operations:
 
@@ -659,12 +658,12 @@ def each[T](array: Array[T]): Unit / emit[T] = {
   go(0)
 }
 
-/// Connects `array` as a producer to a given pull stream `reader` acting as a consumer.
-def feed[T, R](array: Array[T]) { reader: () => R / read[T] }: R = {
+/// Connects `array` as a producer to a given pull stream `driver` acting as a consumer.
+def feed[T, R](array: Array[T]) { driver: () => R / next[T] }: R = {
   var i = 0
   try {
-    reader()
-  } with read[T] {
+    driver()
+  } with next[T] {
     resume {
       if (i < array.size) {
         val c = i

package/libraries/common/bytearray.effekt

@@ -19,10 +19,10 @@ import array
  *
  * The eraser does nothing.
  */
-extern type ByteArray
-  // = llvm "%Pos"
-  // = js "Uint8Array"
-  // = chez "bytevector"
+extern type ByteArray =
+  llvm "%Pos"
+  js "Uint8Array"
+  chez "bytevector"
 
 /// Allocates a new bytearray with the given `size`, its values are zero bytes.
 extern def allocate(size: Int) at global: ByteArray =
@@ -38,7 +38,6 @@ extern def allocate(size: Int) at global: ByteArray =
     ret %Pos %ret_object2
   """
   chez "(make-bytevector ${size})"
-  vm "bytearray::allocate(Int)"
 
 extern def size(arr: ByteArray) at {}: Int =
   js "${arr}.length"
@@ -48,7 +47,6 @@ extern def size(arr: ByteArray) at {}: Int =
     ret i64 %size
   """
   chez "(bytevector-length ${arr})"
-  vm "bytearray::size(ByteArray)"
 
 extern js """
   function bytearray$get(arr, index) {
@@ -82,7 +80,6 @@ extern def get(arr: ByteArray, index: Int) at global: Byte =
     ret i8 %element
   """
   chez "(bytevector-u8-ref ${arr} ${index})"
-  vm "bytearray::get(ByteArray, Int)"
 
 extern def set(arr: ByteArray, index: Int, value: Byte) at global: Unit =
   js "bytearray$set(${arr}, ${index}, ${value})"
@@ -96,7 +93,6 @@ extern def set(arr: ByteArray, index: Int, value: Byte) at global: Unit =
     ret %Pos zeroinitializer
   """
   chez "(bytevector-u8-set! ${arr} ${index} ${value})"
-  vm "bytearray::set(ByteArray, Int, Byte)"
 
 /// Creates a new ByteArray of size `size` filled with the value `init`
 def bytearray(size: Int, init: Byte): ByteArray = {
@@ -184,7 +180,6 @@ extern def fromString(str: String) at {}: ByteArray =
     ret %Pos ${str}
   """
   chez "(string->utf8 ${str})"
-  vm "bytearray::fromString(String)"
 
 extern def toString(arr: ByteArray) at {}: String =
   js "(new TextDecoder('utf-8').decode(${arr}))"
@@ -193,7 +188,6 @@ extern def toString(arr: ByteArray) at {}: String =
     ret %Pos ${arr}
   """
   chez "(utf8->string ${arr})"
-  vm "bytearray::toString(ByteArray)"
 
 extern js """
   function bytearray$set(bytes, index, value) {
@@ -247,7 +241,6 @@ extern def compareByteArrayImpl(b1: ByteArray, b2: ByteArray) at {}: Int =
     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)
@@ -283,11 +276,11 @@ def each(bytes: ByteArray): Unit / emit[Byte] = {
   go(0)
 }
 
-def feed[R](bytes: ByteArray) { reader: () => R / read[Byte] }: R = {
+def feed[R](bytes: ByteArray) { driver: () => R / next[Byte] }: R = {
   var i = 0
   try {
-    reader()
-  } with read[Byte] {
+    driver()
+  } with next[Byte] {
     resume {
       if (i < bytes.size) {
         val c = i

package/libraries/common/bytestream.effekt

@@ -103,7 +103,7 @@ def hex{ body: => Unit / { write, HexSplices } }: Unit / emit[Byte] = {
       body()
     }
     with splice[String] { s =>
-      feed(s){ loop { do splice[Char](do read[Char]()) } }
+      feed(s){ loop { do splice[Char](do next[Char]()) } }
       resume(())
     }
     with splice[ByteArray] { ba =>
@@ -115,8 +115,8 @@ def hex{ body: => Unit / { write, HexSplices } }: Unit / emit[Byte] = {
       feed(s){
         loop {
           attempt {
-            val upper: Int = hexDigitValue(do read[Char]())
-            val lower: Int = hexDigitValue(do read[Char]())
+            val upper: Int = hexDigitValue(do next[Char]())
+            val lower: Int = hexDigitValue(do next[Char]())
             do emit[Byte]((16 * upper + lower).toByte)
           } { () }
         }
@@ -296,7 +296,7 @@ def bit{ body: => Unit / { write, BitSplices } }: Unit / emit[Bit] = {
   with write { s =>
     feed(s){
       loop {
-        do read[Char]() match {
+        do next[Char]() match {
           case '0' => do emit(B0())
           case '1' => do emit(B1())
           case _ => ()

package/libraries/common/char.effekt

@@ -97,13 +97,11 @@ extern def toInt(ch: Char) at {}: Int =
   js "${ch}"
   chez "${ch}"
   llvm "ret %Int ${ch}"
-  vm "string::toInt(Char)"
 
 extern def toChar(codepoint: Int) at {}: Char =
   js "${codepoint}"
   chez "${codepoint}"
   llvm "ret %Int ${codepoint}"
-  vm "string::toChar(Int)"
 
 
 extern def infixLt(x: Char, y: Char) at {}: Bool =
@@ -115,7 +113,6 @@ extern def infixLt(x: Char, y: Char) at {}: Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
-  vm "string::infixLt(Char, Char)"
 
 extern def infixLte(x: Char, y: Char) at {}: Bool =
   js "(${x} <= ${y})"
@@ -126,7 +123,6 @@ extern def infixLte(x: Char, y: Char) at {}: Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
-  vm "string::infixLte(Char, Char)"
 
 extern def infixGt(x: Char, y: Char) at {}: Bool =
   js "(${x} > ${y})"
@@ -137,7 +133,6 @@ extern def infixGt(x: Char, y: Char) at {}: Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
-  vm "string::infixGt(Char, Char)"
 
 extern def infixGte(x: Char, y: Char) at {}: Bool =
   js "(${x} >= ${y})"
@@ -148,7 +143,6 @@ extern def infixGte(x: Char, y: Char) at {}: Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
-  vm "string::infixGte(Char, Char)"
 
 
 /**
@@ -175,24 +169,24 @@ extern def charWidth(c: Char) at {}: Int =
   js "(${c} > 0xffff) ? 2 : 1"
 
 
-def decodeChar(): Char / {read[Byte], stop} = {
-  val b = do read().toInt
+def decodeChar(): Char / {next[Byte], stop} = {
+  val b = do next().toInt
   if (b < 128) {
     b.toChar
   } else if (b < 224) {
     val part1 = bitwiseShl(bitwiseAnd(b, 31), 6)
-    val part2 = bitwiseAnd(do read().toInt, 63)
+    val part2 = bitwiseAnd(do next().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)
+    val part2 = bitwiseShl(bitwiseAnd(do next().toInt, 63), 6)
+    val part3 = bitwiseAnd(do next().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)
+    val part2 = bitwiseShl(bitwiseAnd(do next().toInt, 63), 12)
+    val part3 = bitwiseShl(bitwiseAnd(do next().toInt, 63), 6)
+    val part4 = bitwiseAnd(do next().toInt, 63)
     bitwiseOr(bitwiseOr(bitwiseOr(part1, part2), part3), part4).toChar
   }
 }
@@ -216,10 +210,10 @@ def encodeChar(char: Char): Unit / emit[Byte] = {
   }
 }
 
-def decodeUTF8[R] { reader: () => R / read[Char] }: R / read[Byte] =
+def decodeUTF8[R] { reader: () => R / next[Char] }: R / next[Byte] =
   try {
     reader()
-  } with read[Char] {
+  } with next[Char] {
     resume { decodeChar() }
   }
 

package/libraries/common/dictionary.effekt

@@ -1,26 +1,33 @@
 module dictionary
 
+import ref
 import array
 import bytearray
 import stream
 
-
-/// A trie-based dictionary for efficient key-value storage with bytearray keys.
-/// Supports String and ByteArray keys with fast lookup and insertion.
-type Dictionary[A] {
+/// Internal trie node type.
+type Trie[A] {
   Empty()
   Leaf(value: A)
-  Branch(children: Array[Dictionary[A]])
-  Node(value: A, children: Array[Dictionary[A]])
+  Branch(children: Array[Trie[A]])
+  Node(value: A, children: Array[Trie[A]])
 }
 
+/// A mutable trie-based dictionary for efficient key-value storage with bytearray keys.
+type Dictionary[A] = Ref[Trie[A]]
+
+/// A record pairing a key with a value for use in streams.
+record Tagged[A](key: ByteArray, value: A)
+
+def empty[A](): Dictionary[A] = ref(Empty())
+
 /// Insert a value with a String key.
-def insert[A](trie: Dictionary[A], key: String, value: A): Dictionary[A] =
-  insert(trie, key.fromString, value)
+def insert[A](dictionary: Dictionary[A], key: String, value: A): Unit =
+  insert(dictionary, key.fromString, value)
 
 /// Insert a key-value pair into the dictionary with a ByteArray key.
-def insert[A](trie: Dictionary[A], key: ByteArray, value: A): Dictionary[A] = {
-  def go(trie: Dictionary[A], i: Int): Dictionary[A] =
+def insert[A](dictionary: Dictionary[A], key: ByteArray, value: A): Unit = {
+  def go(trie: Trie[A], i: Int): Trie[A] =
     if (i < key.size) {
       trie match {
         case Empty() =>
@@ -50,16 +57,16 @@ def insert[A](trie: Dictionary[A], key: ByteArray, value: A): Dictionary[A] = {
         case Branch(children) => Node(value, children)
       }
     }
-  go(trie, 0)
+  dictionary.set(go(dictionary.get, 0))
 }
 
 /// Look up a value in the dictionary by string key.
-def lookup[A](trie: Dictionary[A], key: String): Option[A] =
-  lookup(trie, key.fromString)
+def lookup[A](dictionary: Dictionary[A], key: String): Option[A] =
+  lookup(dictionary, key.fromString)
 
 /// Look up a value in the dictionary by bytearray key.
-def lookup[A](trie: Dictionary[A], key: ByteArray): Option[A] = {
-  def go(trie: Dictionary[A], i: Int): Option[A] =
+def lookup[A](dictionary: Dictionary[A], key: ByteArray): Option[A] = {
+  def go(trie: Trie[A], i: Int): Option[A] =
     if (i < key.size) {
       trie match {
         case Empty() => None()
@@ -75,45 +82,41 @@ def lookup[A](trie: Dictionary[A], key: ByteArray): Option[A] = {
         case Node(value, _) => Some(value)
       }
     }
-  go(trie, 0)
+  go(dictionary.get, 0)
 }
 
-/// A record pairing a key with a value for use in streams.
-record Tagged[A](key: ByteArray, value: A)
-
-/// Collect key-value pairs from a stream of Tagged elements into a Dictionary.
+/// Collect key-value pairs from a stream of Tagged elements into a fresh Dictionary.
 def collect[A] { stream: () => Unit / emit[Tagged[A]] }: Dictionary[A] = {
-  var trie = Empty()
+  val dictionary = ref(Empty())
   for[Tagged[A]] { stream() } { case Tagged(bytes, value) =>
-    trie = trie.insert(bytes, value)
+    dictionary.insert(bytes, value)
   }
-  return trie
+  return dictionary
 }
 
 /// Emit all values stored in the dictionary as a push stream.
-def each[A](trie: Dictionary[A]): Unit / emit[A] =
-  trie match {
-    case Empty() => ()
-    case Leaf(value) => do emit(value)
-    case Branch(children) =>
-      each(0, children.size) { i =>
-        each(children.get(i))
-      }
-    case Node(value, children) =>
-      do emit(value)
-      each(0, children.size) { i =>
-        each(children.get(i))
-      }
-  }
+def each[A](dictionary: Dictionary[A]): Unit / emit[A] = {
+  def go(trie: Trie[A]): Unit / emit[A] =
+    trie match {
+      case Empty() => ()
+      case Leaf(value) => do emit(value)
+      case Branch(children) =>
+        each(0, children.size) { i => go(children.get(i)) }
+      case Node(value, children) =>
+        do emit(value)
+        each(0, children.size) { i => go(children.get(i)) }
+    }
+  go(dictionary.get)
+}
 
 /// Emit all key-value pairs stored in the dictionary as a push stream of Tagged elements.
-def eachTagged[A](trie: Dictionary[A]): Unit / emit[Tagged[A]] = {
+def eachTagged[A](dictionary: Dictionary[A]): Unit / emit[Tagged[A]] = {
   def fromBytesReverse(bytes: List[Byte], n: Int): ByteArray = {
     val key = bytearray::allocate(n)
     foreachIndex(bytes) { (i, b) => key.set(n - 1 - i, b) }
     key
   }
-  def go(trie: Dictionary[A], key: List[Byte], n: Int): Unit =
+  def go(trie: Trie[A], key: List[Byte], n: Int): Unit =
     trie match {
       case Empty() => ()
       case Leaf(value) => do emit(Tagged(fromBytesReverse(key, n), value))
@@ -127,7 +130,5 @@ def eachTagged[A](trie: Dictionary[A]): Unit / emit[Tagged[A]] = {
           go(children.get(i), Cons(i.toByte, key), n + 1)
         }
     }
-  go(trie, Nil(), 0)
-}
-
-
+  go(dictionary.get, Nil(), 0)
+}