Rename and move futures to channels

Author: phischu

examples/stdlib/acme.effekt

@@ -13,6 +13,7 @@ import effekt
 import exception
 import heap
 import io
+import io/channel
 import io/console
 import io/error
 import io/filesystem

libraries/common/io.effekt

@@ -1,6 +1,5 @@
 module io
 
-import ref
 
 // Event Loop
 // ----------

libraries/common/io/channel.effekt

@@ -0,0 +1,37 @@
+module io/channel
+
+// Channels
+// --------
+
+/// Must be sended exactly once and waited exactly once
+extern type Channel[T]
+
+namespace channel {
+  extern global def allocate[T](): Channel[T] =
+    llvm """
+      %channel = call %Pos @c_channel_make()
+      ret %Pos %channel
+    """
+}
+
+extern global def send[T](channel: Channel[T], value: T): Unit =
+  llvm """
+    call void @c_channel_send(%Pos ${channel}, %Pos ${value})
+    ret %Pos zeroinitializer
+  """
+
+extern async def wait[T](channel: Channel[T]): T =
+  llvm """
+    call void @c_channel_wait(%Pos ${channel}, %Stack %stack)
+    ret void
+  """
+
+extern llvm """
+  declare %Pos @c_channel_make()
+  declare void @c_channel_send(%Pos, %Pos)
+  declare void @c_channel_wait(%Pos, %Stack)
+"""
+
+
+
+

libraries/common/io/promise.effekt

@@ -1,45 +1,14 @@
 module io/promise
 
 import io
-
-// Futures
-// -------
-
-/// Must be filled exactly once and waited exactly once
-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)
-"""
+import io/channel
 
 // Promises
 // --------
 
 type State[T] {
   Resolved(value: T)
-  Pending(futures: List[Future[T]])
+  Pending(channels: List[Channel[T]])
 }
 
 extern type Promise[T]
@@ -76,11 +45,11 @@ extern {async, global} def await[T](promise: Promise[T]): T =
     get(reference) match {
       case Resolved(value) =>
         return value
-      case Pending(futures) =>
-        val future = future::allocate()
-        // TODO use reference.set and future.wait
-        set(reference, Pending(Cons(future, futures)))
-        wait(future)
+      case Pending(channels) =>
+        val channel = channel::allocate()
+        // TODO use reference.set and channel.wait
+        set(reference, Pending(Cons(channel, channels)))
+        wait(channel)
     }
   }
 
@@ -92,11 +61,11 @@ extern {io, global} def resolve[T](promise: Promise[T], value: T): Unit =
     get(reference) match {
       case Resolved(value) =>
         panic("ERROR: Promise already resolved")
-      case Pending(futures) =>
+      case Pending(channels) =>
         // TODO use reference.set
         set(reference, Resolved(value))
-        // TODO use futures.reverse.foreach
-        foreach(reverse(futures)) { future => fill(future, value) }
+        // TODO use channels.reverse.foreach
+        foreach(reverse(channels)) { channel => send(channel, value) }
     }
   }
 

libraries/llvm/io.c

@@ -295,95 +295,95 @@ void c_yield(Stack stack) {
     c_timer_start(0, stack);
 }
 
-// Futures
-// -------
+// Channels
+// --------
 
-typedef enum { EMPTY, FILLED, WAITED } future_state_t;
+typedef enum { EMPTY, SENDED, WAITED } channel_state_t;
 
 typedef struct {
     uint64_t rc;
     void* eraser;
-    future_state_t state;
+    channel_state_t state;
     union {
         struct Pos value;
         Stack stack;
     } payload;
-} Future;
+} Channel;
 
-void c_future_erase(void *envPtr) {
-    // envPtr points to a Future _after_ the eraser, so let's adjust it to point to the beginning.
-    Future *future = (Future*) (envPtr - offsetof(Future, state));
-    future_state_t state = future->state;
+void c_channel_erase(void *envPtr) {
+    // envPtr points to a Channel _after_ the eraser, so let's adjust it to point to the beginning.
+    Channel *channel = (Channel*) (envPtr - offsetof(Channel, state));
+    channel_state_t state = channel->state;
     switch (state) {
     case EMPTY:
         break;
-    case FILLED:
-        erasePositive(future->payload.value);
+    case SENDED:
+        erasePositive(channel->payload.value);
         break;
     case WAITED:
-        eraseStack(future->payload.stack);
+        eraseStack(channel->payload.stack);
         break;
     }
 }
 
-struct Pos c_future_make() {
-    Future* future = (Future*)malloc(sizeof(Future));
+struct Pos c_channel_make() {
+    Channel* channel = (Channel*)malloc(sizeof(Channel));
 
-    future->rc = 0;
-    future->eraser = c_future_erase;
-    future->state = EMPTY;
+    channel->rc = 0;
+    channel->eraser = c_channel_erase;
+    channel->state = EMPTY;
 
-    return (struct Pos) { .tag = 0, .obj = future, };
+    return (struct Pos) { .tag = 0, .obj = channel, };
 }
 
-void c_future_fill(struct Pos future, struct Pos value) {
-    Future* f = (Future*)future.obj;
+void c_channel_send(struct Pos channel, struct Pos value) {
+    Channel* f = (Channel*)channel.obj;
     switch (f->state) {
         case EMPTY: {
-            f->state = FILLED;
+            f->state = SENDED;
             f->payload.value = value;
-            erasePositive(future);
+            erasePositive(channel);
             break;
         }
-        case FILLED: {
-            erasePositive(future);
+        case SENDED: {
+            erasePositive(channel);
             erasePositive(value);
             // TODO more graceful panic
-            fprintf(stderr, "ERROR: Future already filled\n");
+            fprintf(stderr, "ERROR: Channel already sended\n");
             exit(1);
             break;
         }
         case WAITED: {
             Stack stack = f->payload.stack;
             f->state = EMPTY;
-            erasePositive(future);
+            erasePositive(channel);
             resume_Pos(stack, value);
             break;
         }
     }
 }
 
-void c_future_wait(struct Pos future, Stack stack) {
-    Future* f = (Future*)future.obj;
+void c_channel_wait(struct Pos channel, Stack stack) {
+    Channel* f = (Channel*)channel.obj;
     switch (f->state) {
         case EMPTY: {
             f->state = WAITED;
             f->payload.stack = stack;
-            erasePositive(future);
+            erasePositive(channel);
             break;
         }
-        case FILLED: {
+        case SENDED: {
             struct Pos value = f->payload.value;
             f->state = EMPTY;
-            erasePositive(future);
+            erasePositive(channel);
             resume_Pos(stack, value);
             break;
         }
         case WAITED: {
-            erasePositive(future);
+            erasePositive(channel);
             eraseStack(stack);
             // TODO more graceful panic
-            fprintf(stderr, "ERROR: Future already waited\n");
+            fprintf(stderr, "ERROR: Channel already waited\n");
             exit(1);
             break;
         }