@effekt-lang/effekt 0.3.0 → 0.5.0

package/libraries/common/io.effekt

@@ -3,52 +3,71 @@ 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
-}
+// Event Loop
+// ----------
 
-/**
-  * 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)
-  }
+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
+  """
 
-interface Concurrent {
-  def yield(): Unit
-  def abort(): Nothing
-}
 
 // Promises
 // --------
 
 extern type Promise[T]
-  // = js "{promise: Promise, resolve: ƒ}"
-  // = llvm "Promise"
+  // = js "{resolve: ƒ, promise: Promise}"
+  // = llvm "{tag: 0, obj: Promise*}"
 
-interface Promises {
-  def promise[T](p: Task[T]): Promise[T]
-  def await[T](p: Promise[T]): T
+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() {
@@ -63,96 +82,7 @@ namespace 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
-    """
 }