@effekt-lang/effekt 0.3.0 → 0.4.0

package/libraries/common/io/console.effekt

@@ -1,53 +1,49 @@
 module io/console
 
 import io
-import io/time // just for testing
-
-extern js """
-  const readline = require('node:readline');
-"""
 
 interface Console {
   def readLine(): String
   def writeLine(content: String): Unit
 }
 
-namespace js {
-  extern type JSConsole
-  extern {io} def newConsole(): JSConsole =
-    js """readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-      })"""
-  extern {io} def close(console: JSConsole): Unit =
-    js "${console}.close()"
-
-  extern {io} def readline(console: JSConsole, k: String => Unit at {io, global}): Unit =
-    js "${console}.question('', input => (${k})(input).run())"
-}
-
 /**
  * Handler for the console effect, using the Console available in js
  */
-def console[R] { prog: => R / Console }: R / AsyncIO = {
+def console[R] { program: () => R / Console }: R = {
   val c = js::newConsole()
-  try { val res = prog(); js::close(c); res } with Console {
-    def readLine() = {
-      resume(do performIO[String](box { write =>
-        js::readline(c, write)
-      }))
-    }
-    def writeLine(content) = resume(println(content))
+  try {
+    val r = program()
+    js::close(c)
+    return r
+  } with Console {
+    def readLine() = resume(js::readLine(c))
+    def writeLine(message) = resume(js::writeLine(c, message))
   }
 }
 
-// TODO we could also use stdin and out to implement the Console effect:
-namespace alternative {
-  extern {io} def writeStdoutCallback(message: String, k: () => Unit at {io, global}): Unit =
-    js "process.stdout.write(${message}, 'utf-8', () => (${k})().run())"
+namespace js {
+
+  extern jsNode """
+    const readline = require('node:readline');
+  """
 
-  def write(message: String): Unit / IO =
-    do performIO[Unit](box { write => writeStdoutCallback(message, box { write(()) })})
+  extern type JSConsole
+
+  extern io def newConsole(): JSConsole =
+    jsNode """readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      })"""
+
+  extern io def close(console: JSConsole): Unit =
+    jsNode "${console}.close()"
+
+  extern async def readLine(console: JSConsole): String =
+    jsNode "$effekt.callcc(callback => ${console}.once('line', callback))"
+
+  extern io def writeLine(console: JSConsole, message: String): Unit =
+    jsNode "${console}.output.write(${message} + '\\n')"
 }
 
 namespace examples {
@@ -58,9 +54,9 @@ namespace examples {
     do writeLine("Hi " ++ name ++ ", nice to meet you!")
   }
 
-  def main() = eventloop(box {
+  def main() = {
     with console;
     greeter()
-  })
+  }
 
-}
+}

package/libraries/common/io/error.effekt

@@ -280,7 +280,7 @@ def name(error: IOError): String = error match {
  *
  * See documentation of type IOError for further information.
  */
-def fromCode(code: Int): IOError = code match {
+def fromNumber(number: Int): IOError = number match {
   case 1 => EPERM()
   case 2 => ENOENT()
   case 3 => ESRCH()
@@ -361,5 +361,114 @@ def fromCode(code: Int): IOError = code match {
   case 219 => EUNATCH()
   case 220 => ESHUTDOWN()
 
-  case _ => panic("Not a valid error code: " ++ show(code))
+  case _ => panic("Not a valid error code: " ++ show(number))
+}
+
+namespace internal {
+
+  extern llvm """
+    declare %Int @c_error_number(%Int)
+  """
+
+  extern jsNode """
+    const os = require('node:os');
+
+    /**
+     * Maps the error code to a Effekt-stable (platform independent) numeric value.
+     *
+     * Tries to use most common errno integer values, but introduces fresh values (> 200)
+     * for those without common errno values.
+     */
+    function errorNumber(errno) {
+      const errnoMap = {
+        [os.constants.errno.EPERM]: 1,
+        [os.constants.errno.ENOENT]: 2,
+        [os.constants.errno.ESRCH]: 3,
+        [os.constants.errno.EINTR]: 4,
+        [os.constants.errno.EIO]: 5,
+        [os.constants.errno.ENXIO]: 6,
+        [os.constants.errno.E2BIG]: 7,
+        [os.constants.errno.EBADF]: 9,
+        [os.constants.errno.EAGAIN]: 11,
+        [os.constants.errno.ENOMEM]: 12,
+        [os.constants.errno.EACCES]: 13,
+        [os.constants.errno.EFAULT]: 14,
+        [os.constants.errno.EBUSY]: 16,
+        [os.constants.errno.EEXIST]: 17,
+        [os.constants.errno.EXDEV]: 18,
+        [os.constants.errno.ENODEV]: 19,
+        [os.constants.errno.ENOTDIR]: 20,
+        [os.constants.errno.EISDIR]: 21,
+        [os.constants.errno.EINVAL]: 22,
+        [os.constants.errno.ENFILE]: 23,
+        [os.constants.errno.EMFILE]: 24,
+        [os.constants.errno.ENOTTY]: 25,
+        [os.constants.errno.ETXTBSY]: 26,
+        [os.constants.errno.EFBIG]: 27,
+        [os.constants.errno.ENOSPC]: 28,
+        [os.constants.errno.ESPIPE]: 29,
+        [os.constants.errno.EROFS]: 30,
+        [os.constants.errno.EMLINK]: 31,
+        [os.constants.errno.EPIPE]: 32,
+        [os.constants.errno.ERANGE]: 34,
+        [os.constants.errno.ENAMETOOLONG]: 36,
+        [os.constants.errno.ELOOP]: 40,
+        [os.constants.errno.EOVERFLOW]: 75,
+        [os.constants.errno.EFTYPE]: 79,
+        [os.constants.errno.EILSEQ]: 84,
+        [os.constants.errno.ENOTSOCK]: 88,
+        [os.constants.errno.EDESTADDRREQ]: 89,
+        [os.constants.errno.EMSGSIZE]: 90,
+        [os.constants.errno.EPROTOTYPE]: 91,
+        [os.constants.errno.ENOPROTOOPT]: 92,
+        [os.constants.errno.EPROTONOSUPPORT]: 93,
+        [os.constants.errno.ESOCKTNOSUPPORT]: 94,
+        [os.constants.errno.ENOTSUP]: 95,
+        [os.constants.errno.EAFNOSUPPORT]: 97,
+        [os.constants.errno.EADDRINUSE]: 98,
+        [os.constants.errno.EADDRNOTAVAIL]: 99,
+        [os.constants.errno.ENETDOWN]: 100,
+        [os.constants.errno.ENETUNREACH]: 101,
+        [os.constants.errno.ECONNABORTED]: 103,
+        [os.constants.errno.ECONNRESET]: 104,
+        [os.constants.errno.ENOBUFS]: 105,
+        [os.constants.errno.EISCONN]: 106,
+        [os.constants.errno.ENOTCONN]: 107,
+        [os.constants.errno.ETIMEDOUT]: 110,
+        [os.constants.errno.ECONNREFUSED]: 111,
+        [os.constants.errno.EHOSTUNREACH]: 113,
+        [os.constants.errno.EALREADY]: 114,
+        [os.constants.errno.ECANCELED]: 125,
+        [os.constants.errno.EAI_ADDRFAMILY]: 200,
+        [os.constants.errno.EAI_AGAIN]: 201,
+        [os.constants.errno.EAI_BADFLAGS]: 202,
+        [os.constants.errno.EAI_BADHINTS]: 203,
+        [os.constants.errno.EAI_CANCELED]: 204,
+        [os.constants.errno.EAI_FAIL]: 205,
+        [os.constants.errno.EAI_FAMILY]: 206,
+        [os.constants.errno.EAI_MEMORY]: 207,
+        [os.constants.errno.EAI_NODATA]: 208,
+        [os.constants.errno.EAI_NONAME]: 209,
+        [os.constants.errno.EAI_OVERFLOW]: 210,
+        [os.constants.errno.EAI_PROTOCOL]: 211,
+        [os.constants.errno.EAI_SERVICE]: 212,
+        [os.constants.errno.EAI_SOCKTYPE]: 213,
+        [os.constants.errno.ECHARSET]: 215,
+        [os.constants.errno.ENONET]: 216,
+        [os.constants.errno.UNKNOWN]: 217,
+        [os.constants.errno.EOF]: 218,
+        [os.constants.errno.EUNATCH]: 219,
+        [os.constants.errno.ESHUTDOWN]: 220
+      };
+      return errnoMap[-errno] || -1; // Default to -1 for unknown error names
+    }
+  """
+
+  extern pure def errorNumber(errno: Int): Int =
+    jsNode "errorNumber(${errno})"
+    llvm """
+      %z = call %Int @c_error_number(%Int ${errno})
+      ret %Int %z
+    """
+
 }

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

@@ -1,11 +1,10 @@
 module io/network
 
 import bytes
-import queue
 import io
 
 namespace js {
-  extern js """
+  extern jsNode """
     const net = require('node:net');
 
     function listen(server, port, host, listener) {
@@ -17,18 +16,18 @@ namespace js {
   extern type JSServer // = net.Server
   extern type JSSocket // = net.Socket
   extern io def server(): JSServer =
-    js "net.createServer()"
-  extern io def listen(server: JSServer, port: Int, host: String, listener: JSSocket => Unit at {io, global}): Unit =
-    js "listen(${server}, ${port}, ${host}, (socket) => (${listener})(socket).run())"
+    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 io def send(socket: JSSocket, data: Bytes, callback: () => Unit at {io, global}): Unit =
-    js "${socket}.write(${data}, () => (${callback})().run())"
+  extern async def send(socket: JSSocket, data: Bytes): Unit =
+    jsNode "$effekt.callcc(callback => ${socket}.write(${data}, callback))"
 
-  extern io def receive(socket: JSSocket, callback: Bytes => Unit at {io, global}): Unit =
-    js "${socket}.once('data', (data) => (${callback})(data).run())"
+  extern async def receive(socket: JSSocket): Bytes =
+    jsNode "$effekt.callcc(callback => ${socket}.once('data', callback))"
 
-  extern io def end(socket: JSSocket, callback: () => Unit at {io, global}): Unit =
-    js "${socket}.end(() => (${callback})().run())"
+  extern async def end(socket: JSSocket): Unit =
+    jsNode "$effekt.callcc(callback => ${socket}.end(callback))"
 }
 
 interface Socket {
@@ -37,44 +36,22 @@ interface Socket {
   def end(): Unit
 }
 
-def server(host: String, port: Int, handler: () => Unit / { Socket, IO } at {io, global}): Unit / IO = {
+def server(host: String, port: Int, handler: () => Unit / Socket at {io, async, global}): Unit = {
   val server = js::server();
-  def connections: Queue[js::JSSocket] = emptyQueue()
   js::listen(server, port, host, box { socket =>
-    connections.pushFront(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))
+      }
+    })
   })
-
-  // TODO Instead of polling, we should use Channels
-  loop {
-    connections.popBack match {
-      case Some(socket) =>
-        println("New connection")
-        do promise(box {
-          try { handler() } with Socket {
-            def send(message) = {
-              do performIO[Unit](box { k =>
-                js::send(socket, message, box { k(()) })
-              });
-              resume(())
-            }
-            def receive() = {
-              resume(do performIO[Bytes](box { k =>
-                js::receive(socket, k)
-              }))
-            }
-            def end() = {
-              do performIO[Unit](box { k =>
-                js::end(socket, box { k(()) })
-              });
-              resume(())
-            }
-          }
-        });
-        ()
-      case None() =>
-       do yield()
-    }
-  }
 }
 
 
@@ -82,12 +59,12 @@ namespace examples {
   def helloWorldApp(): Unit / Socket = {
     val request = do receive();
 
-    println("Received a request: " ++ request.show)
+    println("Received a request: " ++ request.toUTF8)
 
-    if (request.show.startsWith("GET /")) {
-      do send(toBytes("HTTP/1.1 200 OK\r\n\r\nHello from Effekt!"))
+    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".toBytes)
+      do send("HTTP/1.1 400 Bad Request\r\n\r\n".fromUTF8)
     }
     do end()
   }
@@ -96,10 +73,9 @@ namespace examples {
   def main() = {
     val port = 8080
     println("Starting server on http://localhost:" ++ port.show)
-    eventloop(box {
-      server("localhost", port, box {
-        helloWorldApp()
-      })
+
+    server("localhost", port, box {
+      helloWorldApp()
     })
   }
 }

package/libraries/common/io/time.effekt

@@ -1,15 +1,12 @@
 module io/time
 
-import io
+extern llvm """
+  declare void @c_timer_start(%Int, %Stack)
+"""
 
-def wait(millis: Int): Unit / AsyncIO =
-  do performIO(box { k => callback::wait(millis, box { () => k(()) }) })
-
-namespace callback {
-  extern io def wait(millis: Int, onTimeout: () => Unit at {io, global}): Unit =
-    js "setTimeout(() => (${onTimeout})().run(), ${millis})"
-    llvm """
-      call void @c_timer_wait(i64 ${millis}, %Neg ${onTimeout})
-      ret %Pos zeroinitializer
-    """
-}
+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
+  """