@effekt-lang/effekt 0.2.1 → 0.3.0

package/libraries/common/io/files.effekt

@@ -0,0 +1,282 @@
+module io/files
+
+import bytes
+
+import io
+import io/error
+
+extern js """
+  const fs = require("fs");
+"""
+
+extern type FileDescriptor
+  // = llvm:  32bit integer extended to 64bit and stored into the "tag" of "Pos"
+  // = js: FileHandle (https://nodejs.org/api/fs.html#class-filehandle)
+
+extern pure def show(fd: FileDescriptor): String =
+  llvm """
+    %res = call %Pos @c_filedescriptor_show(%Pos %fd)
+    ret %Pos %res
+  """
+
+
+/**
+ * An abstract interface applications can program against.
+ *
+ * Can be interpreted into AsyncIO with the `filesystem`
+ * handler, or virtualized etc.
+ *
+ * See example below.
+ */
+interface Files {
+  def readFile(path: String): String
+  def writeFile(path: String, contents: String): Unit
+}
+
+/**
+ * Represents the file opening modes with their respective flags
+ */
+type Mode {
+  // Most common modes
+  Append()              // 'a'  created if does not exist
+  ReadAppend()          // 'a+' created if does not exist
+  ReadOnly()            // 'r'  exception if does not exist
+  ReadWrite()           // 'w+' created if does not exist, truncated if exists
+  Write()               // 'w'  created if does not exist, truncated if exists
+
+  // Other modes
+  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
+}
+
+def modeName(modes: Mode): String = modes match {
+  case Append()              => "a"
+  case ReadAppend()          => "a+"
+  case ReadOnly()            => "r"
+  case ReadWrite()           => "w+"
+  case Write()               => "w"
+  case AppendExclusive()     => "ax"
+  case ReadAppendExclusive() => "ax+"
+  case AppendSync()          => "as"
+  case ReadAppendSync()      => "as+"
+  case ReadSync()            => "rs"
+  case ReadWriteSync()       => "rs+"
+  case WriteExclusive()      => "wx"
+  case ReadWriteExclusive()  => "wx+"
+}
+
+
+/**
+ * Using the file system via node.js
+ */
+def filesystem[R] { program: => R / Files }: R / { AsyncIO, 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))
+  }
+
+
+// AsyncIO-based API (default)
+// ---------------------------
+
+/**
+ * Reads a file at given path as utf8 encoded string.
+ */
+def readFile(path: String): String / { AsyncIO, Exception[IOError] } = {
+  val fd = openFile(path, ReadOnly());
+  with on[IOError].finalize { closeFile(fd) }
+
+  val readSize = 1048576 // 1MB
+  var size = readSize
+  var buffer = bytes(size)
+  var offset = 0;
+
+  def go(): String = {
+    readFile(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 / { AsyncIO, Exception[IOError] } = {
+  val fd = openFile(path, Write());
+  with on[IOError].finalize { closeFile(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 =
+    writeFile(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()
+}
+
+/**
+ * Opens the file at given path using the specified mode (read, write, etc.)
+ */
+def openFile(path: String, flags: Mode): FileDescriptor / { AsyncIO, Exception[IOError] } =
+  do performIO(box { k =>
+    val res = callback::openFile(path, flags,
+      box { fd => k(Success(fd)) },
+      box { error => k(Error(error, "Error opening file: " ++ error.message)) });
+    ()
+  }).value
+
+def readFile(fd: FileDescriptor, buffer: Bytes, offset: Int): Int / { AsyncIO, Exception[IOError] } =
+  do performIO(box { k =>
+    callback::readFile(fd, buffer, offset,
+      box { n => k(Success(n)) },
+      box { error => k(Error(error, "Error reading from file: " ++ error.message)) })
+  }).value
+
+def writeFile(fd: FileDescriptor, buffer: Bytes, offset: Int): Int / { AsyncIO, Exception[IOError] } =
+  do performIO(box { k =>
+    callback::writeFile(fd, buffer, offset,
+      box { n => k(Success(n)) },
+      box { n =>
+        val error = n.fromCode
+        k(Error(error, "Error writing to file: " ++ error.message))
+      })
+  }).value
+
+extern io def closeFile(fd: FileDescriptor): Unit =
+  js "fs.close(${fd}, () => $effekt.unit)"
+  llvm """
+    ; extract the filedescriptor from the tag of the Pos
+    %tag = extractvalue %Pos ${fd}, 0
+    %fd_int = trunc i64 %tag to i32
+
+    call void @c_file_close(i32 %fd_int)
+    ret %Pos zeroinitializer
+  """
+
+
+// Callback-based API
+// ------------------
+// mostly used as an implementation detail.
+namespace callback {
+
+  def openFile(path: String, mode: Mode,
+      onSuccess: FileDescriptor => Unit at {io, global},
+      onFailure: IOError => Unit at {io, global}): Unit =
+    openFile(path, modeName(mode), onSuccess, box { code => onFailure(fromCode(code)) })
+
+  def readFile(fd: FileDescriptor, buffer: Bytes, offset: Int,
+      onSuccess: (Int) => Unit at {io, global},
+      onFailure: IOError => Unit at {io, global}): Unit =
+    readFile(fd, buffer, offset, onSuccess, box { code => onFailure(fromCode(code)) })
+
+  // The following are supposed to be internal
+
+  extern io def openFile(path: String, mode: String,
+      onSuccess: (FileDescriptor) => Unit at {io, global},
+      onFailure: (Int) => Unit at {io, global}): Unit =
+    js "openFile(${path}, ${mode}, ${onSuccess}, ${onFailure})"
+    llvm """
+      ; stack allocate
+      %onSuccess_ptr = alloca %Neg
+      store %Neg %onSuccess, %Neg* %onSuccess_ptr
+
+      %onFailure_ptr = alloca %Neg
+      store %Neg %onFailure, %Neg* %onFailure_ptr
+
+      call void @c_file_open(%Pos ${path}, %Pos ${mode}, ptr %onSuccess_ptr, ptr %onFailure_ptr) #0
+      ret %Pos zeroinitializer
+    """
+
+  extern io def readFile(fd: FileDescriptor, buffer: Bytes, offset: Int,
+      onSuccess: (Int) => Unit at {io, global},
+      onFailure: (Int) => Unit at {io, global}): Unit =
+    js "readFile(${fd}, ${buffer}, ${offset}, ${onSuccess}, ${onFailure})"
+    llvm """
+      ; extract the filedescriptor from the tag of the Pos
+      %tag = extractvalue %Pos %${fd}, 0
+      %fd_int = trunc i64 %tag to i32
+
+      ; stack allocate
+      %onSuccess_ptr = alloca %Neg
+      store %Neg ${onSuccess}, %Neg* %onSuccess_ptr
+
+      %onFailure_ptr = alloca %Neg
+      store %Neg ${onFailure}, %Neg* %onFailure_ptr
+
+      call void @c_file_read(i32 %fd_int, %Pos ${buffer}, i64 noundef ${offset}, ptr %onSuccess_ptr, ptr %onFailure_ptr) #0
+      ret %Pos zeroinitializer
+    """
+
+  extern io def writeFile(fd: FileDescriptor, buffer: Bytes, offset: Int,
+      onSuccess: (Int) => Unit at {io, global},
+      onFailure: (Int) => Unit at {io, global}): Unit =
+    js "writeFile(${fd}, ${buffer}, ${offset}, ${onSuccess}, ${onFailure})"
+    llvm """
+      ; extract the filedescriptor from the tag of the Pos
+      %tag = extractvalue %Pos ${fd}, 0
+      %fd_int = trunc i64 %tag to i32
+
+      ; stack allocate
+      %onSuccess_ptr = alloca %Neg
+      store %Neg ${onSuccess}, %Neg* %onSuccess_ptr
+
+      %onFailure_ptr = alloca %Neg
+      store %Neg ${onFailure}, %Neg* %onFailure_ptr
+
+      call void @c_file_write(i32 %fd_int, %Pos ${buffer}, i64 noundef ${offset}, ptr %onSuccess_ptr, ptr %onFailure_ptr) #0
+      ret %Pos zeroinitializer
+    """
+}
+
+
+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() = eventloop(box {
+    with on[IOError].panic;
+    with filesystem;
+
+    copy("README.md", "out/test.md")
+  })
+}

package/libraries/common/io/network.effekt

@@ -0,0 +1,105 @@
+module io/network
+
+import bytes
+import queue
+import io
+
+namespace js {
+  extern js """
+    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 =
+    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())"
+
+  extern io def send(socket: JSSocket, data: Bytes, callback: () => Unit at {io, global}): Unit =
+    js "${socket}.write(${data}, () => (${callback})().run())"
+
+  extern io def receive(socket: JSSocket, callback: Bytes => Unit at {io, global}): Unit =
+    js "${socket}.once('data', (data) => (${callback})(data).run())"
+
+  extern io def end(socket: JSSocket, callback: () => Unit at {io, global}): Unit =
+    js "${socket}.end(() => (${callback})().run())"
+}
+
+interface Socket {
+  def send(message: Bytes): Unit
+  def receive(): Bytes
+  def end(): Unit
+}
+
+def server(host: String, port: Int, handler: () => Unit / { Socket, IO } at {io, global}): Unit / IO = {
+  val server = js::server();
+  def connections: Queue[js::JSSocket] = emptyQueue()
+  js::listen(server, port, host, box { socket =>
+    connections.pushFront(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()
+    }
+  }
+}
+
+
+namespace examples {
+  def helloWorldApp(): Unit / Socket = {
+    val request = do receive();
+
+    println("Received a request: " ++ request.show)
+
+    if (request.show.startsWith("GET /")) {
+      do send(toBytes("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 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)
+    eventloop(box {
+      server("localhost", port, box {
+        helloWorldApp()
+      })
+    })
+  }
+}

package/libraries/common/io/time.effekt

@@ -0,0 +1,15 @@
+module io/time
+
+import io
+
+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
+    """
+}

package/libraries/common/io.effekt

@@ -0,0 +1,158 @@
+module io
+
+import ref
+import queue
+
+extern include llvm "../llvm/io.ll"
+extern include js "../js/io.js"
+
+// Asynchronous I/O
+// ----------------
+
+interface AsyncIO {
+  /**
+   * Runs the provided computation and conceptually waits until it completes by
+   * calling the writer-continuation.
+   *
+   * The provided writer-continuation should only ever be called ONCE.
+   * The computation is passed as a thunk in order to prevent accidental usage of
+   * other control effects that would violate the contract of calling the writer
+   * once.
+   */
+  def performIO[T](computation: (T => Unit at {io, global}) => Unit at {io, global}): T
+}
+
+/**
+  * Run an IO computation (that uses callbacks) here.
+  */
+def blocking(program: () => Unit / AsyncIO at {io, global}): Unit =
+  try { program() }
+  with AsyncIO {
+    def performIO[T](computation) = computation(resume)
+  }
+
+
+interface Concurrent {
+  def yield(): Unit
+  def abort(): Nothing
+}
+
+// Promises
+// --------
+
+extern type Promise[T]
+  // = js "{promise: Promise, resolve: ƒ}"
+  // = llvm "Promise"
+
+interface Promises {
+  def promise[T](p: Task[T]): Promise[T]
+  def await[T](p: Promise[T]): T
+}
+
+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 """
+      ; Get the default loop and run it.
+      %promise = call %Pos @c_promise_make()
+      ret %Pos %promise
+    """
+
+  extern io def resolve[T](p: Promise[T], value: T): Unit =
+    js "${p}.resolve(${value})"
+    llvm """
+      ; Get the default loop and run it.
+      call void @c_promise_resolve(%Pos ${p}, %Pos ${value})
+      ret %Pos zeroinitializer
+    """
+
+  extern io def await[T](p: Promise[T], callback: T => Unit at {io, global}): Unit =
+    js "${p}.promise.then(res => (${callback})(res).run())"
+    llvm """
+      ; Get the default loop and run it.
+      call void @c_promise_await(%Pos ${p}, %Neg ${callback})
+      ret %Pos zeroinitializer
+    """
+}
+
+
+// TODO we cannot add effects Files, Console, etc. to Task since modules cannot be recursive, at the moment.
+effect IO = { AsyncIO, Concurrent, Promises }
+
+type Task[T] = () => T / IO at {io, global}
+
+
+// Event Loop
+// ----------
+
+def eventloop(prog: Task[Unit]) = {
+
+  def handle(p: Task[Unit]): Unit =
+    try { p() }
+    with Concurrent {
+      def yield() = eventloop::schedule(box { resume(()) })
+      def abort() = ()
+    } with AsyncIO {
+      // TODO there is a bug in our LLVM backend where eta-reducing the following will break
+      def performIO[T](computation) = computation(box { t =>
+        eventloop::schedule(box { resume(t) })
+      })
+    } with Promises {
+      def promise[T](task: Task[T]) = {
+        val p = promise::make[T]();
+        handle(box {
+          val t = task()
+          promise::resolve(p, t)
+        })
+        eventloop::schedule( box { resume(p) })
+      }
+      def await[T](p: Promise[T]) = promise::await(p, box { t => resume(t) })
+    }
+
+  handle(prog)
+
+  eventloop::start()
+  eventloop::stop()
+}
+
+namespace eventloop {
+  extern io def schedule(program: () => Unit at {io, global}): Unit =
+    js "setTimeout(() => (${program})().run(), 0)"
+    llvm """
+      call void @c_timer_wait(i64 0, %Neg ${program})
+      ret %Pos zeroinitializer
+    """
+
+  extern io def start(): Unit =
+    js "$effekt.unit"
+    llvm """
+      ; Get the default loop and run it.
+      %loop = call ptr @uv_default_loop()
+      %run_result = call i32 @uv_run(ptr %loop, i32 0)
+
+      ; return Unit
+      ret %Pos zeroinitializer
+    """
+
+  extern io def stop(): Unit =
+    js "$effekt.unit"
+    llvm """
+      ; Get the default loop, stop and close it.
+      %loop = call ptr @uv_default_loop()
+      call void @uv_stop(ptr %loop)
+      call void @uv_loop_close(ptr %loop)
+
+      ; return Unit
+      ret %Pos zeroinitializer
+    """
+}