Promises in user space

Author: phischu

examples/stdlib/io/promise.effekt

@@ -1,4 +1,5 @@
 import io
+import io/promise
 
 def main() = {
 

libraries/common/io.effekt

@@ -1,7 +1,6 @@
 module io
 
 import ref
-import queue
 
 // Event Loop
 // ----------
@@ -34,84 +33,3 @@ extern async def abort(): Nothing =
     call void @eraseStack(%Stack %stack)
     ret void
   """
-
-// Futures
-// -------
-
-extern type Future[T]
-
-extern global def allocate[T](): Future[T] =
-  llvm """
-    %future = call %Pos @c_future_make()
-    ret %Pos %future
-  """
-
-extern global def fill[T](future: Future[T], value: T): Unit =
-  llvm """
-    call void @c_future_fill(%Pos ${future}, %Pos ${value})
-    ret %Pos zeroinitializer
-  """
-
-extern async def wait[T](future: Future[T]): T =
-  llvm """
-    call void @c_future_wait(%Pos ${future}, %Stack %stack)
-    ret void
-  """
-
-extern llvm """
-  declare %Pos @c_future_make()
-  declare void @c_future_fill(%Pos, %Pos)
-  declare void @c_future_wait(%Pos, %Stack)
-"""
-
-// 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.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.capture(k => { ${promise}.resolve(${value}); return k($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
-    """
-}

libraries/common/io/promise.effekt

@@ -0,0 +1,115 @@
+module io/promise
+
+import io
+
+// Futures
+// -------
+
+extern type Future[T]
+
+namespace future {
+  extern global def allocate[T](): Future[T] =
+    llvm """
+      %future = call %Pos @c_future_make()
+      ret %Pos %future
+    """
+}
+
+extern global def fill[T](future: Future[T], value: T): Unit =
+  llvm """
+    call void @c_future_fill(%Pos ${future}, %Pos ${value})
+    ret %Pos zeroinitializer
+  """
+
+extern async def wait[T](future: Future[T]): T =
+  llvm """
+    call void @c_future_wait(%Pos ${future}, %Stack %stack)
+    ret void
+  """
+
+extern llvm """
+  declare %Pos @c_future_make()
+  declare void @c_future_fill(%Pos, %Pos)
+  declare void @c_future_wait(%Pos, %Stack)
+"""
+
+// Promises
+// --------
+
+type State[T] {
+  Resolved(value: T)
+  Pending(futures: List[Future[T]])
+}
+
+extern type Promise[T]
+  // = js "{resolve: ƒ, promise: Promise}"
+  // = llvm "Ref[State[T]]"
+
+extern pure def toPromise[T](promise: Ref[State[T]]): Promise[T] =
+  llvm """
+    ret %Pos ${promise}
+  """
+
+extern pure def toRefState[T](promise: Promise[T]): Ref[State[T]] =
+  llvm """
+    ret %Pos ${promise}
+  """
+
+namespace promise {
+  extern global def make[T](): Promise[T] =
+    js "promise$make()"
+    llvm { toPromise(ref(Pending(Nil()))) }
+}
+
+def promise[T](task: Task[T]): Promise[T] = {
+  val p = promise::make[T]();
+  spawn(box { p.resolve(task()) });
+  return p
+}
+
+extern {async, global} def await[T](promise: Promise[T]): T =
+  js "$effekt.capture(k => ${promise}.promise.then(k))"
+  llvm {
+    val reference = toRefState(promise)
+    // TODO use reference.get
+    get(reference) match {
+      case Resolved(value) =>
+        return value
+      case Pending(futures) =>
+        val future = future::allocate()
+        // TODO user reference.set and future.wait
+        set(reference, Pending(Cons(future, futures)))
+        wait(future)
+    }
+  }
+
+extern {io, global} def resolve[T](promise: Promise[T], value: T): Unit =
+  js "promise$resolve(${promise}, ${value})"
+  llvm {
+    val reference = toRefState(promise)
+    // TODO use reference.get
+    get(reference) match {
+      case Resolved(value) =>
+        panic("ERROR: Promise already resolved")
+      case Pending(futures) =>
+        // TODO use reference.set
+        set(reference, Resolved(value))
+        futures.reverse.foreach { future => future.fill(value) }
+    }
+  }
+
+
+extern js """
+  function promise$make() {
+    let resolve;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+    });
+    return { resolve: resolve, promise: promise };
+  }
+
+  function promise$resolve(promise, value) {
+    promise.resolve(value);
+    return $effekt.unit
+  }
+"""