@effekt-lang/effekt 0.47.0 → 0.48.0

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]
@@ -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/buffer.effekt

@@ -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 = {
   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.
  *
@@ -200,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
@@ -175,3 +176,89 @@ def utf16UnitCount(codepoint: Char): Int = codepoint match {
 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))
+  }

package/libraries/common/effekt.effekt

@@ -404,6 +404,9 @@ def square(x: Double): Double = x * x
 def neg(n: Double): Double =
   0.0 - n
 
+def min(n: Double, m: Double): Double =
+  if (n < m) n else m
+
 def max(n: Double, m: Double): Double =
   if (n > m) n else m
 

package/libraries/common/io/error.effekt

@@ -464,3 +464,14 @@ namespace internal {
     """
 
 }
+
+namespace internal {
+  def checkResult(result: Int): Int / Exception[IOError] =
+    if (result < 0) {
+      val ioError = fromNumber(internal::errorNumber(result));
+      do raise[IOError](ioError, message(ioError))
+    } else {
+      result
+    }
+}
+

package/libraries/common/io/filesystem.effekt

@@ -71,6 +71,77 @@ def appendFile(path: String, contents: String): Unit / Exception[IOError] = {
   go()
 }
 
+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 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
+    }
+  }
+}
+
 /// An abstract interface applications can program against.
 ///
 /// Can be interpreted with the `filesystem` handler, or virtualized etc.
@@ -192,7 +263,6 @@ namespace internal {
       ret void
     """
 
-  /// The buffer must be kept alive by using it after the call
   extern def read(file: Int, buffer: ByteArray, offset: Int, size: Int, position: Int) at async: Int =
     jsNode "$effekt.capture(callback => read(${file}, ${buffer}, ${offset}, ${size}, ${position}, callback))"
     llvm """
@@ -200,7 +270,6 @@ namespace internal {
       ret void
     """
 
-  /// The buffer must be kept alive by using it after the call
   extern def write(file: Int, buffer: ByteArray, offset: Int, size: Int, position: Int) at async: Int =
     jsNode "$effekt.capture(callback => write(${file}, ${buffer}, ${offset}, ${size}, ${position}, callback))"
     llvm """
@@ -222,13 +291,6 @@ namespace internal {
       ret void
     """
 
-  def checkResult(result: Int): Int / Exception[IOError] =
-    if (result < 0) {
-      val ioError = fromNumber(internal::errorNumber(result));
-      do raise[IOError](ioError, message(ioError))
-    } else {
-      result
-    }
 }
 
 namespace examples {

package/libraries/common/io/network.effekt

@@ -1,84 +1,116 @@
 module io/network
 
+import stream
 import bytearray
-import io
 
-namespace js {
-  extern jsNode """
-    const net = require('node:net');
+import io/error
 
-    function listen(server, port, host, listener) {
-      server.listen(port, host);
-      server.on('connection', listener);
-    }
-  """
 
-  extern type JSServer // = net.Server
-  extern type JSSocket // = net.Socket
-  extern def server() at io: JSServer =
-    jsNode "net.createServer()"
-  extern def listen(server: JSServer, port: Int, host: String, listener: JSSocket => Unit at {io, async, global}) at io: Unit =
-    jsNode "listen(${server}, ${port}, ${host}, (socket) => $effekt.runToplevel((ks, k) => (${listener})(socket, ks, k)))"
+/// A TCP handle. Should not be inspected.
+type Connection = Int
 
-  extern def send(socket: JSSocket, data: ByteArray) at async: Unit =
-    jsNode "$effekt.capture(callback => ${socket}.write(${data}, callback))"
+/// Reads data from a TCP connection into a buffer at the given offset.
+def read(handle: Connection, buffer: ByteArray, offset: Int, size: Int): Int / Exception[IOError] =
+  internal::checkResult(internal::read(handle, buffer, offset, size))
 
-  extern def receive(socket: JSSocket) at async: ByteArray =
-    jsNode "$effekt.capture(callback => ${socket}.once('data', callback))"
-
-  extern def end(socket: JSSocket) at async: Unit =
-    jsNode "$effekt.capture(k => ${socket}.end(k))"
-}
+/// Writes data from a buffer at the given offset to a TCP connection.
+def write(handle: Connection, buffer: ByteArray, offset: Int, size: Int): Int / Exception[IOError] =
+  internal::checkResult(internal::write(handle, buffer, offset, size))
 
-interface Socket {
-  def send(message: ByteArray): Unit
-  def receive(): ByteArray
-  def end(): Unit
-}
-
-def server(host: String, port: Int, handler: () => Unit / Socket at {io, async, global}): Unit = {
-  val server = js::server();
-  js::listen(server, port, host, box { socket =>
-    println("New connection")
-    spawn(box {
-      try handler()
-      with Socket {
-        def send(message) =
-          resume(js::send(socket, message))
-        def receive() =
-          resume(js::receive(socket))
-        def end() =
-          resume(js::end(socket))
-      }
-    })
-  })
-}
+/// Establishes a TCP connection to the specified host and port.
+def connect(host: String, port: Int): Connection / Exception[IOError] =
+  internal::checkResult(internal::connect(host, port))
 
+/// Closes a TCP connection and releases associated resources.
+def close(handle: Connection): Unit =
+  internal::close(handle)
 
-namespace examples {
-  def helloWorldApp(): Unit / Socket = {
-    val request = do receive().toString;
+/// A TCP listener. Should not be inspected.
+type Listener = Int
 
-    println("Received a request: " ++ request)
+/// Creates a TCP listener bound to the specified host and port.
+def bind(host: String, port: Int): Listener / Exception[IOError] =
+  internal::checkResult(internal::bind(host, port))
 
-    def respond(s: String): Unit / Socket =
-      do send(s.fromString)
+/// Starts listening for incoming connections and handles them with the provided handler function.
+/// Runs until `shutdown` is called on this `Listener`.
+def listen(listener: Listener, handler: Connection => Unit at {io, async, global}): Unit / Exception[IOError] = {
+  internal::checkResult(internal::listen(listener, handler)); ()
+}
 
-    if (request.startsWith("GET /")) {
-      respond("HTTP/1.1 200 OK\r\n\r\nHello from Effekt!")
-    } else {
-      respond("HTTP/1.1 400 Bad Request\r\n\r\n")
+/// Stops a TCP listener and releases associated resources.
+def shutdown(listener: Listener): Unit =
+  internal::shutdown(listener)
+
+
+def streaming[R](connection: Connection) { program: () => R / {read[ByteArray], emit[ByteArray]} }: R / Exception[IOError] =
+  try {
+    program()
+  } with emit[ByteArray] { bytes =>
+    write(connection, bytes, 0, bytes.size)
+    resume(())
+  } with read[ByteArray] { () =>
+    val bytes = bytearray::allocate(4096)
+    read(connection, bytes, 0, bytes.size) match {
+      case r and r == bytes.size => resume { return bytes }
+      case r => resume { bytes.resize(r) }
     }
-    do end()
   }
 
-  // A server that just shows "Hello from Effekt!" on localhost:8080
-  def main() = {
-    val port = 8080
-    println("Starting server on http://localhost:" ++ port.show)
+namespace internal {
+
+  extern llvm """
+    declare void @c_tcp_connect(%Pos, %Int, %Stack)
+    declare void @c_tcp_read(%Int, %Pos, %Int, %Int, %Stack)
+    declare void @c_tcp_write(%Int, %Pos, %Int, %Int, %Stack)
+    declare void @c_tcp_close(%Int, %Stack)
+    declare void @c_tcp_bind(%Pos, %Int, %Int, %Stack)
+    declare void @c_tcp_listen(%Int, %Pos, %Stack)
+    declare void @c_tcp_shutdown(%Int, %Stack)
+  """
+
+  extern def connect(host: String, port: Int) at async: Int =
+    llvm """
+      call void @c_tcp_connect(%Pos ${host}, %Int ${port}, %Stack %stack)
+      ret void
+    """
+
+  extern def read(handle: Int, buffer: ByteArray, offset: Int, size: Int) at async: Int =
+    llvm """
+      call void @c_tcp_read(%Int ${handle}, %Pos ${buffer}, %Int ${offset}, %Int ${size}, %Stack %stack)
+      ret void
+    """
+
+  extern def write(handle: Int, buffer: ByteArray, offset: Int, size: Int) at async: Int =
+    llvm """
+      call void @c_tcp_write(%Int ${handle}, %Pos ${buffer}, %Int ${offset}, %Int ${size}, %Stack %stack)
+      ret void
+    """
+
+  extern def close(handle: Int) at async: Unit =
+    llvm """
+      call void @c_tcp_close(%Int ${handle}, %Stack %stack)
+      ret void
+    """
+
+  extern def bind(host: String, port: Int) at io: Int =
+    llvm """
+      %result = call %Int @c_tcp_bind(%Pos ${host}, %Int ${port})
+      ret %Int %result
+    """
+
+  extern def listen(listener: Int, handler: Int => Unit at {io, async, global}) at async: Int =
+    llvm """
+      call void @c_tcp_listen(%Int ${listener}, %Pos ${handler}, %Stack %stack)
+      ret void
+    """
+
+  extern def shutdown(handle: Int) at async: Unit =
+    llvm """
+      call void @c_tcp_shutdown(%Int ${handle}, %Stack %stack)
+      ret void
+    """
 
-    server("localhost", port, box {
-      helloWorldApp()
-    })
-  }
 }
+
+

package/libraries/common/io.effekt

@@ -16,8 +16,7 @@ extern def spawn(task: Task[Unit]) at async: Unit =
   js "$effekt.capture(k => { setTimeout(() => k($effekt.unit), 0); return $effekt.run(${task}) })"
   llvm """
     call void @c_yield(%Stack %stack)
-    %unboxed = call ccc %Neg @coercePosNeg(%Pos ${task})
-    call void @run(%Neg %unboxed)
+    call void @run(%Pos ${task})
     ret void
   """
 

package/libraries/common/json.effekt

@@ -165,7 +165,7 @@ def decodeJson(): Unit / {Scan[Char], JsonBuilder, Exception[WrongFormat]} = {
       case 'f' => expectString("false"); do bool(false)
       case '-' => do number(readDouble())
       case d and d.isDigit => do number(readDouble())
-      case '"' => do string(collectString { readQuotedString() })
+      case '"' => do string(collect { readQuotedString() })
       case '{' => do dict{ decodeJsonObject() }
       case '[' => do list{ decodeJsonList() }
       case _ => println("Unexpected " ++ c.toString); <>
@@ -179,7 +179,7 @@ def decodeJsonObject(): Unit / {Scan[Char], JsonObjectBuilder, Exception[WrongFo
   skipWhitespace()
   while(do peek[Char]() is c and (c != '}')) {
     if (not(first)) { expectString(",") }
-    val k: String = collectString { readQuotedString() }
+    val k = string::collect { readQuotedString() }
     skipWhitespace()
     expectString(":")
     do field(k){
@@ -277,7 +277,7 @@ def build[R](){ body: => R / JsonBuilder }: (R, JsonValue) = {
   }
   (x, r)
 }
-def buildList[R](){ body: => R / JsonBuilder }: (R, List[JsonValue]) = returning::collectList[JsonValue, R] {
+def buildList[R](){ body: => R / JsonBuilder }: (R, List[JsonValue]) = list::returning::collect[JsonValue, R] {
   try body() with JsonBuilder {
     def number(n) = { do emit(Number(n)); resume(()) }
     def bool(b) = { do emit(Bool(b)); resume(()) }
@@ -295,7 +295,7 @@ def buildList[R](){ body: => R / JsonBuilder }: (R, List[JsonValue]) = returning
     }
   }
 }
-def buildDict[R](){ body: => R / JsonObjectBuilder }: (R, List[(String, JsonValue)]) = returning::collectList[(String, JsonValue), R] {
+def buildDict[R](){ body: => R / JsonObjectBuilder }: (R, List[(String, JsonValue)]) = list::returning::collect[(String, JsonValue), R] {
   try body() with JsonObjectBuilder {
     def field(k) = resume { {v} =>
       val x = build{v}
@@ -315,7 +315,7 @@ namespace test {
     // Read quoted string
     feed("\"\ta\n\ra\"") {
       with scanner[Char]
-      println(collectString { readQuotedString() })
+      println(string::collect { readQuotedString() })
     }
 
     println("")