@effekt-lang/effekt 0.2.2 → 0.4.0

package/libraries/common/io/filesystem.effekt

@@ -0,0 +1,274 @@
+module io/filesystem
+
+import bytes
+
+import io
+import io/error
+
+
+/**
+ * Represents the file opening modes with their respective flags
+ * Backends rely on the order of these
+ */
+type Mode {
+  // Most common modes
+  ReadOnly()            // 'r'  exception if does not exist
+  WriteOnly()           // 'w'  created if does not exist, truncated if exists
+  AppendOnly()          // 'a'  created if does not exist
+
+  // Other modes
+  ReadWrite()           // 'w+' created if does not exist, truncated if exists
+  ReadAppend()          // 'a+' created if does not exist
+  AppendExclusive()     // 'ax' created if does not exist, fails if exists
+  ReadAppendExclusive() // 'ax+' created if does not exist, fails if exists
+  AppendSync()          // 'as' created if does not exist, append in synchronous mode
+  ReadAppendSync()      // 'as+' created if does not exist, append in synchronous mode
+  ReadSync()            // 'rs' exception if does not exist, read in synchronous mode
+  ReadWriteSync()       // 'rs+' exception if does not exist, read/write in synchronous mode
+  WriteExclusive()      // 'wx' created if does not exist, truncated if exists, fails if exists
+  ReadWriteExclusive()  // 'wx+' created if does not exist, truncated if exists, fails if exists
+}
+
+
+/**
+ * A file descriptor. Should not be inspected.
+ */
+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 readSize = 1048576 // 1MB
+  var size = readSize
+  var buffer = bytes(size)
+  var offset = 0;
+
+  def go(): String = {
+    read(fd, buffer.slice(offset, min(readSize, size - offset)), -1) match {
+      case 0 =>
+        buffer.slice(0, offset).toUTF8
+      case n and n < 0 => panic("Error!")
+      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
+        }
+        go()
+    }
+  }
+
+  go()
+}
+
+/**
+ * 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 writeSize = 1048576 // 1MB
+
+  // this induces a memcpy that is not strictly necessary, since we use the buffer read-only
+  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()
+    }
+
+  go()
+}
+
+
+/**
+ * An abstract interface applications can program against.
+ *
+ * Can be interpreted with the `filesystem` handler, or virtualized etc.
+ *
+ * See example below.
+ */
+interface Files {
+  def readFile(path: String): String
+  def writeFile(path: String, contents: String): Unit
+}
+
+/**
+ * Using the file system via node.js
+ */
+def filesystem[R] { program: => R / Files }: R / Exception[IOError] = // TODO move Exception to be bidirectional
+  try { program() }
+  with Files {
+    def readFile(path) = resume(readFile(path))
+    def writeFile(path, contents) = resume(writeFile(path, contents))
+  }
+
+
+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 write(fd: File, buffer: Bytes, offset: Int): Int / Exception[IOError] =
+  internal::checkResult(internal::write(fd, buffer, offset))
+
+def close(fd: File): Unit / Exception[IOError] = {
+  internal::checkResult(internal::close(fd)); ()
+}
+
+namespace internal {
+
+  extern js """
+    function modeName(mode) {
+      switch (mode.__tag) {
+      case 0: // ReadOnly()
+        return 'r';
+      case 1: // WriteOnly()
+        return 'w';
+      case 2: // AppendOnly()
+        return 'a';
+      case 3: // ReadWrite()
+        return 'w+';
+      case 4: // ReadAppend()
+        return 'a+';
+      case 5: // AppendExclusive()
+        return 'ax';
+      case 6: // ReadAppendExclusive()
+        return 'ax+';
+      case 7: // AppendSync()
+        return 'as';
+      case 8: // ReadAppendSync()
+        return 'as+';
+      case 9: // ReadSync()
+        return 'rs';
+      case 10: // ReadWriteSync()
+        return 'rs+';
+      case 11: // WriteExclusive()
+        return 'wx';
+      case 12: // ReadWriteExclusive()
+        return 'wx+';
+      default:
+        // Invalid tag value
+        return null;
+      }
+    }
+
+    /**
+     * Nodejs file operations expect buffers, but we represent buffers as typed arrays.
+     * This function converts between the two without copying.
+     */
+    function toBuffer(buffer) {
+      return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength)
+    }
+  """
+
+  extern jsNode """
+    const fs = require("fs");
+
+    function open(path, mode, callback) {
+      fs.open(path, modeName(mode), (err, fd) => {
+        if (err) { callback(err.errno) } else { callback(fd) }
+      })
+    }
+
+    function read(fd, buffer, offset, callback) {
+      let position = offset === -1 ? null : offset;
+      fs.read(fd, toBuffer(buffer), 0, buffer.length, position, (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) => {
+        if (err) { callback(err.errno) } else { callback(bytesWritten) }
+      })
+    }
+
+    function close(fd, callback) {
+      fs.close(fd, (err) => {
+        if (err) { callback(err.errno) } else { callback(0) }
+      })
+    }
+  """
+
+  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_close(%Int, %Stack)
+  """
+
+  extern async def open(path: String, mode: Mode): Int =
+    jsNode "$effekt.callcc(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))"
+    llvm """
+      call void @c_fs_read(%Int ${fd}, %Pos ${buffer}, %Int ${offset}, %Stack %stack)
+      ret void
+    """
+
+  extern async def write(fd: Int, buffer: Bytes, offset: Int): Int =
+    jsNode "$effekt.callcc(callback => write(${fd}, ${buffer}, ${offset}, callback))"
+    llvm """
+      call void @c_fs_write(%Int ${fd}, %Pos ${buffer}, %Int ${offset}, %Stack %stack)
+      ret void
+    """
+
+  extern async def close(fd: Int): Int =
+    jsNode "$effekt.callcc(callback => close(${fd}, callback))"
+    llvm """
+      call void @c_fs_close(%Int ${fd}, %Stack %stack)
+      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 {
+
+  // Example illustrating using abstract files interface
+  // and interpreting it into asynchronous IO
+  def copy(from: String, to: String): Unit / Files = {
+    val contents = do readFile(from)
+    do writeFile(to, contents)
+  }
+
+  def main() = {
+    with on[IOError].panic;
+    with filesystem;
+
+    copy("README.md", "out/test.md")
+  }
+}

package/libraries/common/io/network.effekt

@@ -0,0 +1,81 @@
+module io/network
+
+import bytes
+import io
+
+namespace js {
+  extern jsNode """
+    const net = require('node:net');
+
+    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 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())"
+
+  extern async def send(socket: JSSocket, data: Bytes): Unit =
+    jsNode "$effekt.callcc(callback => ${socket}.write(${data}, callback))"
+
+  extern async def receive(socket: JSSocket): Bytes =
+    jsNode "$effekt.callcc(callback => ${socket}.once('data', callback))"
+
+  extern async def end(socket: JSSocket): Unit =
+    jsNode "$effekt.callcc(callback => ${socket}.end(callback))"
+}
+
+interface Socket {
+  def send(message: Bytes): Unit
+  def receive(): Bytes
+  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))
+      }
+    })
+  })
+}
+
+
+namespace examples {
+  def helloWorldApp(): Unit / Socket = {
+    val request = do receive();
+
+    println("Received a request: " ++ request.toUTF8)
+
+    if (request.toUTF8.startsWith("GET /")) {
+      do send(fromUTF8("HTTP/1.1 200 OK\r\n\r\nHello from Effekt!"))
+    } else {
+      do send("HTTP/1.1 400 Bad Request\r\n\r\n".fromUTF8)
+    }
+    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)
+
+    server("localhost", port, box {
+      helloWorldApp()
+    })
+  }
+}

package/libraries/common/io/time.effekt

@@ -0,0 +1,12 @@
+module io/time
+
+extern llvm """
+  declare void @c_timer_start(%Int, %Stack)
+"""
+
+extern async def wait(millis: Int): Unit =
+  js "$effekt.callcc(callback => setTimeout(() => callback($effekt.unit), ${millis}))"
+  llvm """
+    call void @c_timer_start(%Int ${millis}, %Stack %stack)
+    ret void
+  """

package/libraries/common/io.effekt

@@ -0,0 +1,88 @@
+module io
+
+import ref
+import queue
+
+// Event Loop
+// ----------
+
+type Task[T] = () => T at {io, async, global}
+
+extern llvm """
+  declare void @c_yield(%Stack)
+"""
+
+extern async def spawn(task: Task[Unit]): Unit =
+  js "$effekt.callcc(callback => { setTimeout(() => callback($effekt.unit), 0); ${task}().run()})"
+  llvm """
+    call void @c_yield(%Stack %stack)
+    call void @run(%Neg ${task})
+    ret void
+  """
+
+extern async def yield(): Unit =
+  js "$effekt.callcc(callback => setTimeout(() => callback($effekt.unit), 0))"
+  llvm """
+    call void @c_yield(%Stack %stack)
+    ret void
+  """
+
+extern async def abort(): Nothing =
+  js "$effekt.callcc(callback => { return })"
+  llvm """
+    call void @eraseStack(%Stack %stack)
+    ret void
+  """
+
+
+// Promises
+// --------
+
+extern type Promise[T]
+  // = js "{resolve: ƒ, promise: Promise}"
+  // = llvm "{tag: 0, obj: Promise*}"
+
+def promise[T](task: Task[T]): Promise[T] = {
+  val p = promise::make[T]();
+  spawn(box { p.resolve(task()) });
+  return p
+}
+
+extern llvm """
+  declare %Pos @c_promise_make()
+  declare void @c_promise_resolve(%Pos, %Pos)
+  declare void @c_promise_await(%Pos, %Neg)
+"""
+
+extern async def await[T](promise: Promise[T]): T =
+  js "$effekt.callcc(callback => ${promise}.promise.then(res => callback(res)))"
+  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)})"
+  llvm """
+    call void @c_promise_resolve(%Pos ${promise}, %Pos ${value}, %Stack %stack)
+    ret void
+  """
+
+namespace promise {
+  extern js """
+    function promise$make() {
+      let resolve;
+      const promise = new Promise((res, rej) => {
+        resolve = res;
+      });
+      return { resolve: resolve, promise: promise };
+    }
+  """
+
+  extern io def make[T](): Promise[T] =
+    js "promise$make()"
+    llvm """
+      %promise = call %Pos @c_promise_make()
+      ret %Pos %promise
+    """
+}