@effekt-lang/effekt 0.5.0 → 0.7.0

package/libraries/common/bytearray.effekt

@@ -0,0 +1,71 @@
+module bytearray
+
+/**
+ * A memory managed, mutable, fixed-length array of bytes.
+ */
+extern type ByteArray
+  // = llvm "%Pos"
+  // = js "Uint8Array"
+
+
+/// Allocates a new bytearray with the given `size`, its values are undefined.
+extern global def allocate(size: Int): ByteArray =
+  js "(new Uint8Array(${size}))"
+  llvm """
+    %arr = call %Pos @c_bytearray_new(%Int ${size})
+    ret %Pos %arr
+  """
+
+extern pure def size(arr: ByteArray): Int =
+  js "${arr}.length"
+  llvm """
+    %size = call %Int @c_bytearray_size(%Pos ${arr})
+    ret %Int %size
+  """
+
+extern global def unsafeGet(arr: ByteArray, index: Int): Byte =
+  js "(${arr})[${index}]"
+  llvm """
+    %byte = call %Byte @c_bytearray_get(%Pos ${arr}, %Int ${index})
+    ret %Byte %byte
+  """
+
+extern global def unsafeSet(arr: ByteArray, index: Int, value: Byte): Unit =
+  js "bytearray$set(${arr}, ${index}, ${value})"
+  llvm """
+    %z = call %Pos @c_bytearray_set(%Pos ${arr}, %Int ${index}, %Byte ${value})
+    ret %Pos %z
+  """
+
+def resize(source: ByteArray, size: Int): ByteArray = {
+  val target = allocate(size)
+  val n = min(source.size, target.size)
+  def go(i: Int): ByteArray =
+    if (i < n) {
+      target.unsafeSet(i, source.unsafeGet(i))
+      go(i + 1)
+    } else {
+      target
+    }
+  go(0)
+}
+
+extern pure def fromUTF8(str: String): ByteArray =
+  js "(new TextEncoder().encode(${str}))"
+  llvm """
+    ret %Pos ${str}
+  """
+
+extern pure def toUTF8(arr: ByteArray): String =
+  js "(new TextDecoder('utf-8').decode(${arr}))"
+  // assuming the buffer is already in UTF-8
+  llvm """
+    ret %Pos ${arr}
+  """
+
+extern js """
+  function bytearray$set(bytes, index, value) {
+    bytes[index] = value;
+    return $effekt.unit;
+  }
+"""

package/libraries/common/effekt.effekt

@@ -56,7 +56,7 @@ extern pure def show(value: Int): String =
   js "'' + ${value}"
   chez "(show-number ${value})"
   llvm """
-    %z = call %Pos @c_buffer_show_Int(%Int ${value})
+    %z = call %Pos @c_bytearray_show_Int(%Int ${value})
     ret %Pos %z
   """
 
@@ -66,7 +66,7 @@ extern pure def show(value: Double): String =
   js "'' + ${value}"
   chez "(show-number ${value})"
   llvm """
-    %z = call %Pos @c_buffer_show_Double(%Double ${value})
+    %z = call %Pos @c_bytearray_show_Double(%Double ${value})
     ret %Pos %z
   """
 
@@ -80,13 +80,13 @@ extern pure def show(value: Char): String =
   js "String.fromCodePoint(${value})"
   chez "(string (integer->char ${value}))"
   llvm """
-    %z = call %Pos @c_buffer_show_Char(%Int ${value})
+    %z = call %Pos @c_bytearray_show_Char(%Int ${value})
     ret %Pos %z
   """
 
 extern pure def show(value: Byte): String =
   llvm """
-    %z = call %Pos @c_buffer_show_Byte(i8 ${value})
+    %z = call %Pos @c_bytearray_show_Byte(i8 ${value})
     ret %Pos %z
   """
 
@@ -105,7 +105,7 @@ extern pure def infixConcat(s1: String, s2: String): String =
   js "((${s1}) + (${s2}))"
   chez "(string-append ${s1} ${s2})"
   llvm """
-    %spz = call %Pos @c_buffer_concatenate(%Pos ${s1}, %Pos ${s2})
+    %spz = call %Pos @c_bytearray_concatenate(%Pos ${s1}, %Pos ${s2})
     ret %Pos %spz
   """
 
@@ -113,7 +113,7 @@ extern pure def length(str: String): Int =
   js "${str}.length"
   chez "(string-length ${str})"
   llvm """
-    %x = call %Int @c_buffer_length(%Pos ${str})
+    %x = call %Int @c_bytearray_size(%Pos ${str})
     call void @erasePositive(%Pos ${str})
     ret %Int %x
   """
@@ -122,7 +122,7 @@ extern pure def unsafeSubstring(str: String, from: Int, to: Int): String =
   js "${str}.substring(${from}, ${to})"
   chez "(substring ${str} ${from} ${to})" // potentially raises: "Exception in substring: ..."
   llvm """
-    %x = call %Pos @c_buffer_substring(%Pos ${str}, i64 ${from}, i64 ${to})
+    %x = call %Pos @c_bytearray_substring(%Pos ${str}, i64 ${from}, i64 ${to})
     ret %Pos %x
   """
 
@@ -239,7 +239,7 @@ extern pure def infixEq(x: String, y: String): Bool =
   js "${x} === ${y}"
   chez "(equal? ${x} ${y})"
   llvm """
-    %res = call %Pos @c_buffer_eq(%Pos ${x}, %Pos ${y})
+    %res = call %Pos @c_bytearray_equal(%Pos ${x}, %Pos ${y})
     ret %Pos %res
   """
 

package/libraries/common/io/console.effekt

@@ -38,8 +38,7 @@ namespace js {
     jsNode "${console}.close()"
 
   extern async def readLine(console: JSConsole): String =
-    jsNode "$effekt.callcc(callback => ${console}.once('line', callback))"
-
+    jsNode "$effekt.capture(k => ${console}.once('line', k))"
   extern io def writeLine(console: JSConsole, message: String): Unit =
     jsNode "${console}.output.write(${message} + '\\n')"
 }

package/libraries/common/io/filesystem.effekt

@@ -1,6 +1,6 @@
 module io/filesystem
 
-import bytes
+import bytearray
 
 import io
 import io/error
@@ -34,29 +34,21 @@ type File = Int
 
 /// Reads a file at given path as utf8 encoded string.
 def readFile(path: String): String / Exception[IOError] = {
-  val fd = open(path, ReadOnly());
-  with on[IOError].finalize { close(fd) }
+  val file = open(path, ReadOnly());
+  with on[IOError].finalize { close(file) }
 
-  val readSize = 1048576 // 1MB
-  var size = readSize
-  var buffer = bytes(size)
-  var offset = 0;
+  val chunkSize = 1048576 // 1MB
+  var buffer = bytearray::allocate(chunkSize)
+  var offset = 0
 
   def go(): String = {
-    read(fd, buffer.slice(offset, min(readSize, size - offset)), -1) match {
+    read(file, buffer, offset, chunkSize, -1) match {
       case 0 =>
-        buffer.slice(0, offset).toUTF8
-      case n and n < 0 => panic("Error!")
+        buffer.resize(offset).toUTF8
       case n =>
         offset = offset + n
-
-        // we are at maximum capacity
-        if (n == readSize && (offset + readSize) > size) {
-          val newSize   = size * 2
-          val newBuffer = bytes(newSize)
-          copy(buffer, newBuffer, 0, 0, size)
-          buffer = newBuffer
-          size = newSize
+        if (offset + chunkSize > buffer.size) {
+          buffer = buffer.resize(2 * buffer.size)
         }
         go()
     }
@@ -67,26 +59,18 @@ def readFile(path: String): String / Exception[IOError] = {
 
 /// Writes the (utf8 encoded) string `contents` into the specified file.
 def writeFile(path: String, contents: String): Unit / Exception[IOError] = {
-  val fd = open(path, WriteOnly());
-  with on[IOError].finalize { close(fd) }
+  val file = open(path, WriteOnly());
+  with on[IOError].finalize { close(file) }
 
-  val writeSize = 1048576 // 1MB
-
-  // this induces a memcpy that is not strictly necessary, since we use the buffer read-only
+  val chunkSize = 1048576 // 1MB
   val buffer = contents.fromUTF8
-  val size = buffer.size
-
   var offset = 0;
-  def remaining() = size - offset
 
-  def go(): Unit =
-    write(fd, buffer.slice(offset, min(writeSize, remaining())), -1) match {
-      case 0 => ()
-      case n and n < 0 => panic("Error!")
-      case n =>
-        offset = offset + n;
-        if (remaining() > 0) go()
-    }
+  def go(): Unit = {
+    val n = write(file, buffer, offset, min(buffer.size - offset, chunkSize), -1)
+    offset = offset + n
+    if (offset < buffer.size) { go() }
+  }
 
   go()
 }
@@ -114,14 +98,14 @@ def filesystem[R] { program: => R / Files }: R / Exception[IOError] = // TODO mo
 def open(path: String, mode: Mode): File / Exception[IOError] =
   internal::checkResult(internal::open(path, mode))
 
-def read(fd: File, buffer: Bytes, offset: Int): Int / Exception[IOError] =
-  internal::checkResult(internal::read(fd, buffer, offset))
+def read(file: File, buffer: ByteArray, offset: Int, size: Int, position: Int): Int / Exception[IOError] =
+  internal::checkResult(internal::read(file, buffer, offset, size, position))
 
-def write(fd: File, buffer: Bytes, offset: Int): Int / Exception[IOError] =
-  internal::checkResult(internal::write(fd, buffer, offset))
+def write(file: File, buffer: ByteArray, offset: Int, size: Int, position: Int): Int / Exception[IOError] =
+  internal::checkResult(internal::write(file, buffer, offset, size, position))
 
-def close(fd: File): Unit / Exception[IOError] = {
-  internal::checkResult(internal::close(fd)); ()
+def close(file: File): Unit / Exception[IOError] = {
+  internal::checkResult(internal::close(file)); ()
 }
 
 namespace internal {
@@ -174,27 +158,27 @@ namespace internal {
     const fs = require("fs");
 
     function open(path, mode, callback) {
-      fs.open(path, modeName(mode), (err, fd) => {
-        if (err) { callback(err.errno) } else { callback(fd) }
+      fs.open(path, modeName(mode), (err, file) => {
+        if (err) { callback(err.errno) } else { callback(file) }
       })
     }
 
-    function read(fd, buffer, offset, callback) {
-      let position = offset === -1 ? null : offset;
-      fs.read(fd, toBuffer(buffer), 0, buffer.length, position, (err, bytesRead) => {
+    function read(file, buffer, offset, size, position, callback) {
+      let positionOrNull = position === -1 ? null : position;
+      fs.read(file, toBuffer(buffer), offset, size, positionOrNull, (err, bytesRead) => {
         if (err) { callback(err.errno) } else { callback(bytesRead) }
       })
     }
 
-    function write(fd, buffer, offset, callback) {
-      let position = offset === -1 ? null : offset;
-      fs.write(fd, toBuffer(buffer), 0, buffer.length, position, (err, bytesWritten) => {
+    function write(file, buffer, offset, size, position, callback) {
+      let positionOrNull = position === -1 ? null : position;
+      fs.write(file, toBuffer(buffer), offset, size, positionOrNull, (err, bytesWritten) => {
         if (err) { callback(err.errno) } else { callback(bytesWritten) }
       })
     }
 
-    function close(fd, callback) {
-      fs.close(fd, (err) => {
+    function close(file, callback) {
+      fs.close(file, (err) => {
         if (err) { callback(err.errno) } else { callback(0) }
       })
     }
@@ -202,36 +186,36 @@ namespace internal {
 
   extern llvm """
     declare void @c_fs_open(%Pos, %Pos, %Stack)
-    declare void @c_fs_read(%Int, %Pos, %Int, %Stack)
-    declare void @c_fs_write(%Int, %Pos, %Int, %Stack)
+    declare void @c_fs_read(%Int, %Pos, %Int, %Int, %Int, %Stack)
+    declare void @c_fs_write(%Int, %Pos, %Int, %Int, %Int, %Stack)
     declare void @c_fs_close(%Int, %Stack)
   """
 
   extern async def open(path: String, mode: Mode): Int =
-    jsNode "$effekt.callcc(callback => open(${path}, ${mode}, callback))"
+    jsNode "$effekt.capture(callback => open(${path}, ${mode}, callback))"
     llvm """
       call void @c_fs_open(%Pos ${path}, %Pos ${mode}, %Stack %stack)
       ret void
     """
 
-  extern async def read(fd: Int, buffer: Bytes, offset: Int): Int =
-    jsNode "$effekt.callcc(callback => read(${fd}, ${buffer}, ${offset}, callback))"
+  extern async def read(file: Int, buffer: ByteArray, offset: Int, size: Int, position: Int): Int =
+    jsNode "$effekt.capture(callback => read(${file}, ${buffer}, ${offset}, ${size}, ${position}, callback))"
     llvm """
-      call void @c_fs_read(%Int ${fd}, %Pos ${buffer}, %Int ${offset}, %Stack %stack)
+      call void @c_fs_read(%Int ${file}, %Pos ${buffer}, %Int ${offset}, %Int ${size}, %Int ${position}, %Stack %stack)
       ret void
     """
 
-  extern async def write(fd: Int, buffer: Bytes, offset: Int): Int =
-    jsNode "$effekt.callcc(callback => write(${fd}, ${buffer}, ${offset}, callback))"
+  extern async def write(file: Int, buffer: ByteArray, offset: Int, size: Int, position: Int): Int =
+    jsNode "$effekt.capture(callback => write(${file}, ${buffer}, ${offset}, ${size}, ${position}, callback))"
     llvm """
-      call void @c_fs_write(%Int ${fd}, %Pos ${buffer}, %Int ${offset}, %Stack %stack)
+      call void @c_fs_write(%Int ${file}, %Pos ${buffer}, %Int ${offset}, %Int ${size}, %Int ${position}, %Stack %stack)
       ret void
     """
 
-  extern async def close(fd: Int): Int =
-    jsNode "$effekt.callcc(callback => close(${fd}, callback))"
+  extern async def close(file: Int): Int =
+    jsNode "$effekt.capture(callback => close(${file}, callback))"
     llvm """
-      call void @c_fs_close(%Int ${fd}, %Stack %stack)
+      call void @c_fs_close(%Int ${file}, %Stack %stack)
       ret void
     """
 

package/libraries/common/io/network.effekt

@@ -1,6 +1,6 @@
 module io/network
 
-import bytes
+import bytearray
 import io
 
 namespace js {
@@ -18,21 +18,21 @@ namespace js {
   extern io def server(): JSServer =
     jsNode "net.createServer()"
   extern io def listen(server: JSServer, port: Int, host: String, listener: JSSocket => Unit at {io, async, global}): Unit =
-    jsNode "listen(${server}, ${port}, ${host}, (socket) => (${listener})(socket).run())"
+    jsNode "listen(${server}, ${port}, ${host}, (socket) => $effekt.runToplevel((ks, k) => (${listener})(socket, ks, k)))"
 
-  extern async def send(socket: JSSocket, data: Bytes): Unit =
-    jsNode "$effekt.callcc(callback => ${socket}.write(${data}, callback))"
+  extern async def send(socket: JSSocket, data: ByteArray): Unit =
+    jsNode "$effekt.capture(callback => ${socket}.write(${data}, callback))"
 
-  extern async def receive(socket: JSSocket): Bytes =
-    jsNode "$effekt.callcc(callback => ${socket}.once('data', callback))"
+  extern async def receive(socket: JSSocket): ByteArray =
+    jsNode "$effekt.capture(callback => ${socket}.once('data', callback))"
 
   extern async def end(socket: JSSocket): Unit =
-    jsNode "$effekt.callcc(callback => ${socket}.end(callback))"
+    jsNode "$effekt.capture(k => ${socket}.end(k))"
 }
 
 interface Socket {
-  def send(message: Bytes): Unit
-  def receive(): Bytes
+  def send(message: ByteArray): Unit
+  def receive(): ByteArray
   def end(): Unit
 }
 

package/libraries/common/io/time.effekt

@@ -5,7 +5,7 @@ extern llvm """
 """
 
 extern async def wait(millis: Int): Unit =
-  js "$effekt.callcc(callback => setTimeout(() => callback($effekt.unit), ${millis}))"
+  js "$effekt.capture(k => setTimeout(() => k($effekt.unit), ${millis}))"
   llvm """
     call void @c_timer_start(%Int ${millis}, %Stack %stack)
     ret void

package/libraries/common/io.effekt

@@ -13,7 +13,7 @@ extern llvm """
 """
 
 extern async def spawn(task: Task[Unit]): Unit =
-  js "$effekt.callcc(callback => { setTimeout(() => callback($effekt.unit), 0); ${task}().run()})"
+  js "$effekt.capture(k => { setTimeout(() => k($effekt.unit), 0); return $effekt.run(${task}) })"
   llvm """
     call void @c_yield(%Stack %stack)
     call void @run(%Neg ${task})
@@ -21,14 +21,14 @@ extern async def spawn(task: Task[Unit]): Unit =
   """
 
 extern async def yield(): Unit =
-  js "$effekt.callcc(callback => setTimeout(() => callback($effekt.unit), 0))"
+  js "$effekt.capture(k => setTimeout(() => k($effekt.unit), 0))"
   llvm """
     call void @c_yield(%Stack %stack)
     ret void
   """
 
 extern async def abort(): Nothing =
-  js "$effekt.callcc(callback => { return })"
+  js "$effekt.capture(k => undefined)"
   llvm """
     call void @eraseStack(%Stack %stack)
     ret void
@@ -55,14 +55,14 @@ extern llvm """
 """
 
 extern async def await[T](promise: Promise[T]): T =
-  js "$effekt.callcc(callback => ${promise}.promise.then(res => callback(res)))"
+  js "$effekt.capture(k => ${promise}.promise.then(k))"
   llvm """
     call void @c_promise_await(%Pos ${promise}, %Stack %stack)
     ret void
   """
 
 extern async def resolve[T](promise: Promise[T], value: T): Unit =
-  js "$effekt.callcc(callback => { ${promise}.resolve(${value}); callback($effekt.unit)})"
+  js "$effekt.capture(k => { ${promise}.resolve(${value}); return k($effekt.unit) })"
   llvm """
     call void @c_promise_resolve(%Pos ${promise}, %Pos ${value}, %Stack %stack)
     ret void

package/libraries/common/ref.effekt

@@ -12,7 +12,7 @@ extern js """
 /// Global, mutable references
 extern type Ref[T]
 
-/// Allocates a new reference of size `size`, keeping its value _undefined_.
+/// Allocates a new reference, keeping its value _undefined_.
 /// Prefer using `ref` constructor instead to ensure that the value is defined.
 extern global def allocate[T](): Ref[T] =
   js "{ value: undefined }"

package/libraries/common/string.effekt

@@ -14,7 +14,6 @@ import result
 /**
  * Strings
  * - JS: Strings are represented as UTF-16 code units where some characters take 2 slots (surrogate pairs)
- * - ML: Strings are sequences of 8-bit characters (https://smlfamily.github.io/Basis/string.html)
  * - Chez: Strings are sequences of unicode characters (?)
  * - LLVM: UTF-8 (characters can take from 1-4 bytes).
  */
@@ -237,14 +236,14 @@ def printing[T] { prog: => T / Stream }: T = <>
 // ----------
 //
 //   JS: Int (Unicode codepoints)
-//   CS: ?
+//   Chez: ?
 //   LLVM: i64 representing utf-8 (varying length 1-4 bytes)
 
 extern pure def toString(ch: Char): String =
   js "String.fromCodePoint(${ch})"
   chez "(string (integer->char ${ch}))"
   llvm """
-    %z = call %Pos @c_buffer_show_Char(%Int ${ch})
+    %z = call %Pos @c_bytearray_show_Char(%Int ${ch})
     ret %Pos %z
   """
 
@@ -324,16 +323,6 @@ def utf16UnitCount(codepoint: Char): Int = codepoint match {
   case c => panic("Not a valid code point")
 }
 
-// TODO this is copied from the LLVM-backend stdlib. Do we need this?
-// def showQuoted(s: String): String =
-//  "\x22" ++ s.map { c =>
-//    if(c == "\x22") {
-//     "\\\x22"
-//    } else if (c == "\\") {
-//     "\\\\"
-//    } else c
-//  } ++ "\x22"
-
 extern pure def charWidth(c: Char): Int =
   // JavaScript strings are UTF-16 where every unicode character after 0xffff takes two units
   js "(${c} > 0xffff) ? 2 : 1"
@@ -348,6 +337,6 @@ extern pure def unsafeCharAt(str: String, n: Int): Char =
   js "${str}.codePointAt(${n})"
   chez "(char->integer (string-ref ${str} ${n}))"
   llvm """
-    %x = call %Int @c_buffer_character_at(%Pos ${str}, i64 ${n})
+    %x = call %Int @c_bytearray_character_at(%Pos ${str}, %Int ${n})
     ret %Int %x
   """

package/libraries/js/effekt_builtins.js

@@ -54,4 +54,8 @@ $effekt.println = function println$impl(str) {
   console.log(str); return $effekt.unit;
 }
 
-$effekt.unit = { __unit: true }
+$effekt.unit = { __unit: true }
+
+$effekt.emptyMatch = function() { throw "empty match" }
+
+$effekt.hole = function() { throw "not implemented, yet" }