@effekt-lang/effekt 0.65.0 → 0.67.0

package/libraries/chez/cps/effekt.ss

@@ -65,7 +65,7 @@
         (store-generation-set! store (+ (snap-generation snap) 1))))
 
 ; Cont a = a, MetaCont -> #
-; Prompt = Int
+; Prompt = Symbol
 
 ; MetaCont = Cont * Prompt * Store | Snapshot * MetaCont?
 ; Holds a "copy" of k, as well as its prompt and store
@@ -104,14 +104,8 @@
 ; Ref | MetaCont -> void
 (define (deallocate _) (void))
 
-(define _prompt 1)
-(define (new-prompt)
-    (let ([prompt _prompt])
-         (set! _prompt (+ prompt 1))
-         prompt))
-
 (define (top-level-k x _) x)
-(define top-level-ks (make-meta-cont top-level-k 0 (create-store) '()))
+(define top-level-ks (make-meta-cont top-level-k (gensym "toplevel") (create-store) '()))
 
 ; a, MetaCont -> #
 (define (return x ks)
@@ -123,7 +117,7 @@
 
 ; Program Prompt b, MetaCont, Cont b -> #
 (define (reset prog ks k)
-    (let ([prompt (new-prompt)])
+    (let ([prompt (gensym)])
          (meta-cont-cont-set! ks k)
          (prog prompt (make-meta-cont return prompt (create-store) ks) return)))
 
@@ -134,7 +128,7 @@
               [snap (snapshot (meta-cont-store below))])
              (meta-cont-store-set! below snap)
              (meta-cont-rest-set! below above)
-             (if (= (meta-cont-prompt below) p)
+             (if (symbol=? (meta-cont-prompt below) p)
                  (values below new-below)
                  (worker below new-below))))
     (worker '() ks))
@@ -168,4 +162,4 @@
 
 ; Block b -> b
 (define (run-top-level p)
-    (p top-level-ks top-level-k))
+    (p top-level-ks top-level-k))

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:
@@ -659,12 +662,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
@@ -677,18 +680,27 @@ def feed[T, R](array: Array[T]) { reader: () => R / read[T] }: R = {
   }
 }
 
+/// Collects elements emitted by a push stream producer `stream` into a new array,
+/// discarding the result of the producer.
+/// The provided capacity is a hint for the expected number of elements.
+/// It must be strictly larger than zero.
+def collect[A](capacity: Int) { stream: () => Unit / emit[A] }: Array[A] =
+  returning::collect[A, Unit](capacity){stream}.second
+
 /// Collects elements emitted by a push stream producer `stream` into a new array,
 /// discarding the result of the producer.
 def collect[A] { stream: () => Unit / emit[A] }: Array[A] =
-  returning::collect[A, Unit]{stream}.second
+  collect[A](4){stream}
 
 namespace returning {
 
   /// Collects elements emitted by a push stream producer `stream` into a new array,
   /// returning the result of the producer as well as the collected array.
-  def collect[A, R] { stream: () => R / emit[A] }: (R, Array[A]) = {
+  /// The provided capacity is a hint for the expected number of elements.
+  /// It must be strictly larger than zero.
+  def collect[A, R](capacity: Int) { stream: () => R / emit[A] }: (R, Array[A]) = {
     var i = 0
-    var a = unsafeAllocate(1)
+    var a = unsafeAllocate(capacity)
     try {
       (stream(), a.resize(i))
     } with emit[A] { (v) =>
@@ -698,4 +710,10 @@ namespace returning {
       resume(())
     }
   }
+
+  /// Collects elements emitted by a push stream producer `stream` into a new array,
+  /// returning the result of the producer as well as the collected array.
+  def collect[A, R] { stream: () => R / emit[A] }: (R, Array[A]) =
+    returning::collect[A, R](4){stream}
+
 }

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 =
@@ -283,11 +283,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
@@ -300,13 +300,17 @@ def feed[R](bytes: ByteArray) { reader: () => R / read[Byte] }: R = {
   }
 }
 
+def collect(capacity: Int) { stream: () => Unit / emit[Byte] }: ByteArray =
+  returning::collect[Unit](capacity){stream}.second
+
 def collect { stream: () => Unit / emit[Byte] }: ByteArray =
-  returning::collect[Unit]{stream}.second
+  collect(4){stream}
 
 namespace returning {
-  def collect[R] { stream: () => R / emit[Byte] }: (R, ByteArray) = {
+
+  def collect[R](capacity: Int) { stream: () => R / emit[Byte] }: (R, ByteArray) = {
     var i = 0
-    var a = allocate(1)
+    var a = allocate(capacity)
     try {
       (stream(), a.resize(i))
     } with emit[Byte] { (v) =>
@@ -316,4 +320,8 @@ namespace returning {
       resume(())
     }
   }
+
+  def collect[R] { stream: () => R / emit[Byte] }: (R, ByteArray) =
+    returning::collect(4){stream}
+
 }

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

@@ -175,24 +175,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 +216,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)
+}

package/libraries/common/effekt.effekt

@@ -83,6 +83,7 @@ def println(value: Unit): Unit = println(value.show)
 def println(value: Double): Unit = println(value.show)
 def println(value: Bool): Unit = println(value.show)
 def println(value: Byte): Unit = println(value.show)
+def println(value: Char): Unit = println(value.show)
 
 extern def showBuiltin(value: Int) at {}: String =
   js "'' + ${value}"
@@ -135,9 +136,13 @@ extern def panic(msg: String) at io: Nothing =
   """
 
 extern def show[R](value: R) at {}: String =
+  js "undefined"
+  chez "(void)"
+  llvm "ret %Pos poison"
+
+extern def genericShow[R](value: R) at {}: String =
   js "$effekt.show(${value})"
   chez "(show_impl ${value})"
-  llvm "ret %Pos poison"
 
 // Strings
 // =======
@@ -231,13 +236,10 @@ def println(o: Ordering): Unit = println(o.show)
 // ==============
 
 /// Structural equality: Not available in the LLVM backend
-extern def equals[R](x: R, y: R) at {}: Bool =
+extern def genericEquals[R](x: R, y: R) at {}: Bool =
   js "$effekt.equals(${x}, ${y})"
   chez "(equal_impl ${x} ${y})"
 
-def differsFrom[R](x: R, y: R): Bool =
-  not(equals(x, y))
-
 // TODO fix this in the pattern matching compiler
 extern def infixEq(x: Unit, y: Unit) at {}: Bool =
   default { true }
@@ -745,6 +747,15 @@ extern def isUndefined[A](value: A) at {}: Bool =
   chez "(eq? ${value} #f)"
   vm "effekt::isUndefined[A](A)"
 
+// Ascription
+// ==========
+
+/// Ascribe a type, for example `f().as[Int]`.
+def as[A](x: A): A = x
+
+/// Witness absurdity, for example `f().absurd`.
+/// Very often the type argument is inferred.
+def absurd[A](x: Nothing): A = x match {}
 
 // Tuples
 // ======

package/libraries/common/io/channel.effekt

@@ -3,48 +3,55 @@ module io/channel
 import io
 import io/signal
 
-record Node[A, B](this: Signal[A, B], rest: Ref[Option[Node[A, B]]])
+type Node[A, B] {
+  Nope()
+  Node(this: Signal[A, B], rest: Ref[Node[A, B]])
+}
 
-type Sender[A, B] = Ref[Node[A, B]]
-type Receiver[A, B] = Ref[Node[A, B]]
+type Sender[A, B] = Ref[Ref[Node[A, B]]]
+type Receiver[A, B] = Ref[Ref[Node[A, B]]]
 
 /// Creates a new rendezvous channel and returns the receiving and the sending end.
 /// Every send must be matched by exactly one receive upon which two values are exchanged.
 def channel[A, B](): (Sender[A, B], Receiver[A, B]) = {
-  val node = Node(signal(), ref(None()))
+  val node = ref(Nope())
   (ref(node), ref(node))
 }
 
 /// Sends a value to a channel and blocks until a receiver arrives.
 def send[A, B](sender: Sender[A, B], value: A): B = {
-  val Node(this, rest) = sender.get()
-  rest.get() match {
-    case None() =>
-      val node = Node(signal(), ref(None()))
-      rest.set(Some(node))
-      sender.set(node)
-    case Some(node) =>
-      sender.set(node)
+  val current = sender.get()
+  val (this, rest) = current.get() match {
+    case Nope() =>
+      val this = signal()
+      val rest = ref(Nope())
+      current.set(Node(this, rest))
+      (this, rest)
+    case Node(this, rest) =>
+      (this, rest)
   }
+  sender.set(rest)
   // TODO avoid yield
   yield()
-  this.unsafeFire(value)
+  this.fire(value)
 }
 
 /// Receives a value from a channel and blocks until a sender arrives.
 def receive[A, B](receiver: Receiver[A, B], value: B): A = {
-  val Node(this, rest) = receiver.get()
-  rest.get() match {
-    case None() =>
-      val node = Node(signal(), ref(None()))
-      rest.set(Some(node))
-      receiver.set(node)
-    case Some(node) =>
-      receiver.set(node)
+  val current = receiver.get()
+  val (this, rest) = current.get() match {
+    case Nope() =>
+      val this = signal()
+      val rest = ref(Nope())
+      current.set(Node(this, rest))
+      (this, rest)
+    case Node(this, rest) =>
+      (this, rest)
   }
+  receiver.set(rest)
   // TODO avoid yield
   yield()
-  this.unsafeWait(value)
+  this.wait(value)
 }
 
 // TODO streaming

package/libraries/common/io/console.effekt

@@ -26,7 +26,8 @@ namespace js {
     const readline = require('node:readline');
   """
 
-  extern type JSConsole
+  extern type JSConsole =
+    js "readline.createInterface return type"
 
   extern def newConsole() at io: JSConsole =
     jsNode """readline.createInterface({

package/libraries/common/io/filesystem.effekt

@@ -74,8 +74,8 @@ def appendFile(path: String, contents: String): Unit / Exception[IOError] = {
 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 readFileUTF8[R](path: String) { driver: () => R / next[Char] }: R / Exception[IOError] =
+  readFile(path) { decodeUTF8 { driver() } }
 
 def writeFile[R](path: String) { stream: () => R / emit[Byte] }: R / Exception[IOError] = {
 
@@ -108,7 +108,7 @@ def writeFile[R](path: String) { stream: () => R / emit[Byte] }: R / Exception[I
   }
 }
 
-def readFile[R](path: String) { reader: () => R / read[Byte] }: R / Exception[IOError] = {
+def readFile[R](path: String) { driver: () => R / next[Byte] }: R / Exception[IOError] = {
 
   val file = openForReading(path);
   with on[IOError].finalize { close(file) }
@@ -128,8 +128,8 @@ def readFile[R](path: String) { reader: () => R / read[Byte] }: R / Exception[IO
   }
 
   try {
-    reader()
-  } with read[Byte] {
+    driver()
+  } with next[Byte] {
     resume {
       if (offset >= length) {
         pull()

package/libraries/common/io/network.effekt

@@ -42,13 +42,13 @@ def listen(listener: Listener, handler: Connection => Unit at {io, async, global
 def shutdown(listener: Listener): Unit =
   internal::shutdown(listener)
 
-def streaming[R](connection: Connection) { program: () => R / {read[ByteArray], emit[ByteArray]} }: R / Exception[IOError] =
+def streaming[R](connection: Connection) { program: () => R / {next[ByteArray], emit[ByteArray]} }: R / Exception[IOError] =
   try {
     program()
   } with emit[ByteArray] { bytes =>
     write(connection, bytes, 0, bytes.size)
     resume(())
-  } with read[ByteArray] { () =>
+  } with next[ByteArray] { () =>
     val bytes = bytearray::allocate(4096)
     read(connection, bytes, 0, bytes.size) match {
       case r and r == bytes.size => resume { return bytes }

package/libraries/common/io/promise.effekt

@@ -37,7 +37,7 @@ def await[T](promise: Promise[T]): T =
       val signal = signal()
       promise.set(Pending(Cons(signal, signals)))
       // TODO perhaps yield to avoid stack overflow
-      signal.unsafeWait(())
+      signal.wait(())
   }
 
 /// Resolves the given promise, unblocking all awaiting tasks.
@@ -48,6 +48,6 @@ def resolve[T](promise: Promise[T], value: T): Unit =
     case Pending(signals) =>
       promise.set(Resolved(value))
       // TODO perhaps yield to avoid stack overflow
-      signals.reverse.foreach { signal => unsafeFire(signal, value) }
+      signals.reverse.foreach { signal => fire(signal, value) }
   }