@effekt-lang/effekt 0.5.0 → 0.6.0

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

@@ -208,28 +208,28 @@ namespace internal {
   """
 
   extern async def open(path: String, mode: Mode): Int =
-    jsNode "$effekt.callcc(callback => open(${path}, ${mode}, callback))"
+    jsNode "$effekt.capture(k => open(${path}, ${mode}, k))"
     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))"
+    jsNode "$effekt.capture(k => read(${fd}, ${buffer}, ${offset}, k))"
     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))"
+    jsNode "$effekt.capture(k => write(${fd}, ${buffer}, ${offset}, k))"
     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))"
+    jsNode "$effekt.capture(k => close(${fd}, k))"
     llvm """
       call void @c_fs_close(%Int ${fd}, %Stack %stack)
       ret void

package/libraries/common/io/network.effekt

@@ -18,16 +18,16 @@ 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))"
+    jsNode "$effekt.capture(k => ${socket}.write(${data}, k))"
 
   extern async def receive(socket: JSSocket): Bytes =
-    jsNode "$effekt.callcc(callback => ${socket}.once('data', callback))"
+    jsNode "$effekt.capture(k => ${socket}.once('data', k))"
 
   extern async def end(socket: JSSocket): Unit =
-    jsNode "$effekt.callcc(callback => ${socket}.end(callback))"
+    jsNode "$effekt.capture(k => ${socket}.end(k))"
 }
 
 interface Socket {

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/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" }