@effekt-lang/effekt 0.53.0 → 0.55.0

package/libraries/common/stream.effekt

@@ -2,6 +2,7 @@ module stream
 
 import effekt
 import option
+import exception
 
 // Effects
 // -------
@@ -44,7 +45,7 @@ def fix[T] { one: T => Unit / emit[T] } { stream: => Unit / emit[T] }: Unit =
   try {
     stream()
   } with emit[T] { value =>
-    fix[T] {one} { one(value) }
+    fix {one} { one(value) }
     resume(())
   }
 
@@ -128,6 +129,26 @@ def iterate[A](initial: A) { step: A => A }: Unit / emit[A] = {
   }
 }
 
+/// Re-emit from the `stream` as long as the `predicate` holds.
+/// Once the predicate fails, the stream ends.
+///
+/// Examples:
+/// ```effekt
+/// > list::collect[Int] { takeWhile[Int] { x => x < 3 } { [1, 2, 3, 4, 1].each } }
+/// [1, 2]
+///
+/// > list::collect[Int] { takeWhile[Int] { x => x < 10 } { [1, 2, 3].each } }
+/// [1, 2, 3]
+///
+/// > list::collect[Int] { takeWhile[Int] { x => x < 0 } { [1, 2, 3].each } }
+/// []
+/// ```
+def takeWhile[A] { predicate: A => Bool } { stream: () => Unit / emit[A] }: Unit / emit[A] =
+  try { stream() } with emit[A] {
+    case value and predicate(value) => do emit(value); resume(())
+    case _                          => () // end the stream
+  }
+
 
 def sum { stream: () => Unit / emit[Int] }: Int =
   returning::sum[Unit]{stream}.second
@@ -135,6 +156,71 @@ def sum { stream: () => Unit / emit[Int] }: Int =
 def product { stream: () => Unit / emit[Int] }: Int =
   returning::product[Unit]{stream}.second
 
+/// Returns true if all elements in the stream satisfy the given predicate,
+/// false otherwise. Short-circuits as soon as a non-matching element is found.
+///
+/// Examples:
+/// ```effekt
+/// > all[Int] { x => x > 0 } { [1, 2, 3].each }
+/// true
+///
+/// > all[Int] { x => x < 3 } { [1, 2, 3, 4].each }
+/// false
+///
+/// > all[Bool] { x => x } { [false, true, true].each }
+/// false
+///
+/// > all[Int] { x => x >= 0 } { () } // empty stream
+/// true
+/// ```
+def all[A] { cond: A => Bool } { stream: => Unit / emit[A] }: Bool =
+  try { stream(); true } with emit[A] {
+    case value and not(cond(value)) => false
+    case _                          => resume(())
+  }
+
+/// Returns true if any element in the stream satisfies the given predicate,
+/// false otherwise. Short-circuits as soon as a matching element is found.
+///
+/// Examples:
+/// ```effekt
+/// > any[Int] { x => x > 0 } { [-2, -1, 0, 1, 2].each }
+/// true
+///
+/// > any[Int] { x => x > 10 } { [1, 2, 3, 4].each }
+/// false
+///
+/// > any[Bool] { x => x } { [false, true, false].each }
+/// true
+///
+/// > any[Int] { x => x == 0 } { () } // empty stream
+/// false
+/// ```
+def any[A] { cond: A => Bool } { stream: => Unit / emit[A] }: Bool =
+  try { stream(); false } with emit[A] {
+    case value and cond(value) => true
+    case _                     => resume(())
+  }
+
+/// Count the number of emitted values that satisfy the given predicate.
+///
+/// Examples:
+/// ```
+/// > countIf[Int] { x => x > 0 } { [2, -1, 0, 1, -2].each }
+/// 2
+///
+/// > countIf[Bool] { x => x } { [false, false, true, false].each }
+/// 1
+/// ```
+def countIf[A] { shouldCount: A => Bool } { stream: () => Unit / emit[A] }: Int = {
+  var count = 0
+  for {stream} {
+    case x and shouldCount(x) => count = count + 1
+    case _                    => ()
+  }
+  count
+}
+
 def source[A] { stream: () => Unit / emit[A] } { reader: () => Unit / read[A] }: Unit =
   returning::source[A, Unit]{stream}{reader}
 
@@ -177,9 +263,9 @@ namespace internal {
 
 /// Use cons to handle prod, but also emit to the outside.
 /// The outside controls iteration, i.e., if cons aborts, the rest of prod will still be emitted.
-/// 
+///
 /// Starts by executing cons. Will stop cons during execution if the outside stops consuming.
-/// 
+///
 /// Example, printing all values consumed by the outside:
 ///
 ///     with teeing{ {s} => for{s}{ e => println(e) } }
@@ -215,9 +301,9 @@ def teeing[A]{ cons: { => Unit / emit[A] } => Unit }{ prod: => Unit / emit[A] }:
 }
 
 /// Binds a `teeing`-like function in the body, stopping the inner producer once all consumers in tees are done consuming.
-/// 
+///
 /// Example of use, equivalent to `tee[A]{cns1}{cns2}{prd}`:
-/// 
+///
 ///     manyTee[A] { {tee} =>
 ///       with tee{cns1}
 ///       with tee{cns2}
@@ -253,6 +339,25 @@ def tee[A]{ cons1: { => Unit / emit[A] } => Unit }{ cons2: { => Unit / emit[A] }
   }
 }
 
+/// Return exactly the very first element of the given stream
+/// or raise MissingValue if no elements are emitted.
+///
+/// Examples:
+/// ```effekt
+/// > first[Int] { [1, 2, 3].each }
+/// 1
+/// > first[Bool] { do emit(true) }
+/// true
+/// > first[String] { () } // empty stream
+/// <Exception MissingValue: code in first did not emit any values>
+/// ```
+def first[A] { body: => Unit / emit[A] }: A / Exception[MissingValue] =
+  try {
+    body()
+    val r: A = do raise[MissingValue](MissingValue(), "code in first did not emit any values")
+    r
+  } with emit[A] { a => a }
+
 namespace returning {
 
 /// Canonical handler of push streams that performs `action` for every

package/libraries/js/mutable/map.effekt

@@ -5,7 +5,7 @@ import array
 // A mutable map, backed by a JavaScript Map.
 extern type Map[K, V]
 
-extern def emptyMap[K, V]() at {}: Map[K, V] =
+extern def emptyMap[K, V]() at io: Map[K, V] =
   js "new Map()"
 
 def get[K, V](m: Map[K, V], key: K): Option[V] =
@@ -28,4 +28,4 @@ extern def values[K, V](map: Map[K, V]) at {}: Array[V] =
   js "Array.from(${map}.values())"
 
 extern def keys[K, V](map: Map[K, V]) at {}: Array[K] =
-  js "Array.from(${map}.keys())"
+  js "Array.from(${map}.keys())"

package/libraries/llvm/io.c

@@ -572,154 +572,254 @@ void c_yield(Stack stack) {
     c_timer_start(0, stack);
 }
 
-
-// Promises
+// Signals
 // --------
 
-typedef enum { UNRESOLVED, RESOLVED } promise_state_t;
-
-typedef struct Listeners {
-    Stack head;
-    struct Listeners* tail;
-} Listeners;
+typedef enum { INITIAL, NOTIFIED } signal_state_t;
 
 typedef struct {
     uint64_t rc;
     void* eraser;
-    promise_state_t state;
-    // state of {
-    //   case UNRESOLVED => Possibly empty (head is NULL) list of listeners
-    //   case RESOLVED   => Pos (the result)
-    // }
-    union {
-        struct Pos value;
-        Listeners listeners;
-    } payload;
-} Promise;
-
-void c_promise_erase_listeners(void *envPtr) {
-    // envPtr points to a Promise _after_ the eraser, so let's adjust it to point to the promise.
-    Promise *promise = (Promise*) (envPtr - offsetof(Promise, state));
-    promise_state_t state = promise->state;
-
-    Stack head;
-    Listeners* tail;
-    Listeners* current;
-
-    switch (state) {
-        case UNRESOLVED:
-            head = promise->payload.listeners.head;
-            tail = promise->payload.listeners.tail;
-            if (head != NULL) {
-                // Erase head
-                eraseStack(head);
-                // Erase tail
-                current = tail;
-                while (current != NULL) {
-                    head = current->head;
-                    tail = current->tail;
-                    free(current);
-                    eraseStack(head);
-                    current = tail;
-                };
-            };
-            break;
-        case RESOLVED:
-            erasePositive(promise->payload.value);
-            break;
-    }
-}
+    signal_state_t state;
+    struct Pos value;
+    Stack stack;
+} Signal;
 
-void c_promise_resume_listeners(Listeners* listeners, struct Pos value) {
-    if (listeners != NULL) {
-        Stack head = listeners->head;
-        Listeners* tail = listeners->tail;
-        free(listeners);
-        c_promise_resume_listeners(tail, value);
-        sharePositive(value);
-        resume_Pos(head, value);
-    }
+void c_signal_erase(void *envPtr) {
+    // envPtr points to a Signal _after_ the eraser, so let's adjust it to point to the beginning.
+    Signal *signal = (Signal*) (envPtr - offsetof(Signal, state));
+    erasePositive(signal->value);
+    if (signal->stack != NULL) { eraseStack(signal->stack); }
 }
 
-void c_promise_resolve(struct Pos promise, struct Pos value, Stack stack) {
-    Promise* p = (Promise*)promise.obj;
+struct Pos c_signal_make() {
+    Signal* f = (Signal*)malloc(sizeof(Signal));
 
-    Stack head;
-    Listeners* tail;
+    f->rc = 0;
+    f->eraser = c_signal_erase;
+    f->state = INITIAL;
+    f->value = (struct Pos) { .tag = 0, .obj = NULL, };
+    f->stack = NULL;
 
-    switch (p->state) {
-        case UNRESOLVED:
-            head = p->payload.listeners.head;
-            tail = p->payload.listeners.tail;
-
-            p->state = RESOLVED;
-            p->payload.value = value;
-            resume_Pos(stack, Unit);
+    return (struct Pos) { .tag = 0, .obj = f, };
+}
 
-            if (head != NULL) {
-                // Execute tail
-                c_promise_resume_listeners(tail, value);
-                // Execute head
-                sharePositive(value);
-                resume_Pos(head, value);
-            };
+void c_signal_notify(struct Pos signal, struct Pos value, Stack stack) {
+    Signal* f = (Signal*)signal.obj;
+    switch (f->state) {
+        case INITIAL: {
+            f->state = NOTIFIED;
+            f->value = value;
+            f->stack = stack;
+            erasePositive(signal);
             break;
-        case RESOLVED:
-            erasePositive(promise);
-            erasePositive(value);
-            eraseStack(stack);
-            fprintf(stderr, "ERROR: Promise already resolved\n");
-            exit(1);
+        }
+        case NOTIFIED: {
+            struct Pos other_value = f->value;
+            f->value = (struct Pos) { .tag = 0, .obj = NULL, };
+            Stack other_stack = f->stack;
+            f->stack = NULL;
+            erasePositive(signal);
+            resume_Pos(other_stack, value);
+            resume_Pos(stack, other_value);
             break;
+        }
     }
-    // TODO stack overflow?
-    // We need to erase the promise now, since we consume it.
-    erasePositive(promise);
 }
 
-void c_promise_await(struct Pos promise, Stack stack) {
-    Promise* p = (Promise*)promise.obj;
+// Subprocesses
+// ------------
 
-    Stack head;
-    Listeners* tail;
-    Listeners* node;
-    struct Pos value;
+struct Pos c_spawn_options_default() {
+    uv_process_options_t* options = (uv_process_options_t*)malloc(sizeof(uv_process_options_t));
+    memset(options, 0, sizeof(uv_process_options_t));
+    uv_stdio_container_t* stdio = (uv_stdio_container_t*)malloc(3*sizeof(uv_stdio_container_t));
+    stdio[0].flags = UV_INHERIT_FD;
+    stdio[0].data.fd = 0;
+    stdio[1].flags = UV_INHERIT_FD;
+    stdio[1].data.fd = 1;
+    stdio[2].flags = UV_INHERIT_FD;
+    stdio[2].data.fd = 2;
+    options->stdio = stdio;
+    options->stdio_count = 3;
+    return (struct Pos) { .tag = 0, .obj = options, };
+}
 
-    switch (p->state) {
-        case UNRESOLVED:
-            head = p->payload.listeners.head;
-            tail = p->payload.listeners.tail;
-            if (head != NULL) {
-                node = (Listeners*)malloc(sizeof(Listeners));
-                node->head = head;
-                node->tail = tail;
-                p->payload.listeners.head = stack;
-                p->payload.listeners.tail = node;
-            } else {
-                p->payload.listeners.head = stack;
-            };
-            break;
-        case RESOLVED:
-            value = p->payload.value;
-            sharePositive(value);
-            resume_Pos(stack, value);
-            break;
-    };
-    // TODO hmm, stack overflow?
-    erasePositive(promise);
+static void subproc_alloc_cb(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) {
+    (void)handle;
+    buf->base = malloc(suggested_size);
+    buf->len = suggested_size;
+}
+
+typedef struct {
+  struct Pos handler;
+} subproc_stream_cb_closure_t;
+void subproc_stream_cb(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf) {
+  subproc_stream_cb_closure_t* clos = (subproc_stream_cb_closure_t*)(stream->data);
+  if(nread >= 0) {
+    struct Pos chunk = c_bytearray_construct(nread, (uint8_t*)(buf->base));
+    if (buf->base) free(buf->base);
+    run_Pos(clos->handler, chunk);
+  } else {
+    uv_read_stop(stream);
+    erasePositive(clos->handler);
+    free(clos);
+    if (buf->base) free(buf->base);
+  }
+}
+struct Pos subproc_options_on_stream(struct Pos opts, size_t id, uv_stdio_flags flags, struct Pos callback) {
+    uv_process_options_t* options = (uv_process_options_t*)opts.obj;
+
+    options->stdio[id].flags = UV_CREATE_PIPE | flags;
+    uv_pipe_t* pipe = (uv_pipe_t*)malloc(sizeof(uv_pipe_t));
+
+    uv_pipe_init(uv_default_loop(), pipe, 1);
+    options->stdio[id].data.stream = (uv_stream_t*)pipe;
+
+    subproc_stream_cb_closure_t* clos = (subproc_stream_cb_closure_t*)malloc(sizeof(subproc_stream_cb_closure_t));
+    clos->handler = callback;
+    pipe->data = clos;
+
+    return opts;
+}
+struct Pos c_spawn_options_on_stdout(struct Pos opts, struct Pos callback) {
+  return subproc_options_on_stream(opts, 1, UV_WRITABLE_PIPE, callback);
+}
+struct Pos c_spawn_options_on_stderr(struct Pos opts, struct Pos callback) {
+  return subproc_options_on_stream(opts, 2, UV_WRITABLE_PIPE, callback);
+}
+struct Pos c_spawn_options_pipe_stdin(struct Pos opts, struct Pos callback) {
+  return subproc_options_on_stream(opts, 0, UV_READABLE_PIPE, callback);
 }
 
-struct Pos c_promise_make() {
-    Promise* promise = (Promise*)malloc(sizeof(Promise));
 
-    promise->rc = 0;
-    promise->eraser = c_promise_erase_listeners;
-    promise->state = UNRESOLVED;
-    promise->payload.listeners.head = NULL;
-    promise->payload.listeners.tail = NULL;
+typedef struct {
+  char** args;
+  Stack k;
+  uv_process_options_t* opts;
+} subproc_proc_data_t;
+void c_close_stream_callback_exit(uv_handle_t* req) {
+    free(req);
+}
+void subproc_on_close(uv_handle_t* handle) {
+    subproc_proc_data_t* pd = (subproc_proc_data_t*)((uv_process_t*)handle)->data;
+    uv_process_options_t* opts = (uv_process_options_t*)(pd->opts);
+    if(opts->stdio[0].flags & UV_CREATE_PIPE){
+        uv_close((uv_handle_t*)(opts->stdio[0].data.stream), c_close_stream_callback_exit);
+    }
+    if(opts->stdio[1].flags & UV_CREATE_PIPE){
+        uv_close((uv_handle_t*)(opts->stdio[1].data.stream), c_close_stream_callback_exit);
+    }
+    if(opts->stdio[2].flags & UV_CREATE_PIPE){
+        uv_close((uv_handle_t*)(opts->stdio[2].data.stream), c_close_stream_callback_exit);
+    }
+    // TODO shutdown pipes for stdio
+    free(opts->stdio);
+    free(opts);
+    free(pd);
+    free(handle);
+}
+void subproc_on_exit(uv_process_t* proc, int64_t exit_status, int term_signal) {
+    (void)term_signal; (void)exit_status;
+    subproc_proc_data_t* pd = (subproc_proc_data_t*)proc->data;
+    if (pd->args) {
+        for(int i = 0; pd->args[i] != NULL; i++) {
+            free(pd->args[i]);
+        }
+        free(pd->args);
+    }
+    Stack k = pd->k;
+    uv_close((uv_handle_t*)proc, subproc_on_close);
+    resume_Int(k, exit_status);
+}
 
-    return (struct Pos) { .tag = 0, .obj = promise, };
+void c_close_stream_callback(uv_shutdown_t* req, int status) {
+    if(status != 0){
+        // TODO error handling
+    }
+    free(req);
+}
+void c_close_stream(struct Pos stream) {
+    uv_stream_t* str = (uv_stream_t*)stream.obj;
+    uv_shutdown_t* req = (uv_shutdown_t*)malloc(sizeof(uv_shutdown_t));
+    uv_shutdown(req, str, c_close_stream_callback);
 }
 
+typedef struct {
+    struct Pos buffer;
+    uv_buf_t buf;
+} subproc_write_req_data_t;
+void c_write_stream_callback(uv_write_t* req, int status) {
+    if(status != 0){
+        // TODO error handling
+    }
+    subproc_write_req_data_t* data = (subproc_write_req_data_t*)(req->data);
+    erasePositive(data->buffer);
+    free(data);
+    free(req);
+}
+void c_write_stream(struct Pos stream, struct Pos buffer) {
+    uv_stream_t* str = (uv_stream_t*)stream.obj;
+    uv_write_t* req = (uv_write_t*)malloc(sizeof(uv_write_t));
+    memset(req, 0, sizeof(uv_write_t));
+    subproc_write_req_data_t* data = (subproc_write_req_data_t*)malloc(sizeof(subproc_write_req_data_t));
+    data->buffer = buffer;
+    uv_buf_t buf = uv_buf_init((char*)(c_bytearray_data(buffer)), buffer.tag);
+    req->data = data;
+    data->buf = buf;
+    uv_write(req, str, &(data->buf), 1, c_write_stream_callback);
+}
+
+void c_spawn(struct Pos cmd, struct Pos args, struct Pos options, Stack stack) {
+    uv_process_options_t* opts = (uv_process_options_t*)options.obj;
+    uv_process_t* proc = (uv_process_t*)malloc(sizeof(uv_process_t));
+
+    // command
+    char* cmd_s = c_bytearray_into_nullterminated_string(cmd);
+    erasePositive(cmd);
+    opts->file = cmd_s;
+
+    // args
+    int _argc = (int)((uint64_t*)args.obj)[2];
+    char** _args = (char**)malloc((2 + _argc) * sizeof(char*));
+    struct Pos* _argv = (struct Pos*)(((uint64_t*)args.obj) + 3);
+    _args[0] = cmd_s;
+    for(int i = 0; i < _argc; i++) {
+        _args[i + 1] = c_bytearray_into_nullterminated_string(_argv[i]);
+    }
+    erasePositive(args);
+    _args[_argc + 1] = NULL;
+    opts->args = _args;
+    // callback to free _args
+    opts->exit_cb = subproc_on_exit;
+    subproc_proc_data_t* pd = (subproc_proc_data_t*)malloc(sizeof(subproc_proc_data_t));
+    pd->args = _args;
+    pd->k = stack;
+    proc->data = pd;
+
+    // spawn process
+    int err = uv_spawn(uv_default_loop(), proc, opts);
+
+    if(opts->stdio[0].flags & UV_CREATE_PIPE) {
+        uv_stream_t* stream = (uv_stream_t*)(opts->stdio[0].data.stream);
+        subproc_stream_cb_closure_t* clos = (subproc_stream_cb_closure_t*)(stream->data);
+        struct Pos str = (struct Pos) { .tag = 0, .obj = stream, };
+        run_Pos(clos->handler, str);
+        erasePositive(clos->handler);
+        free(clos);
+    }
+    if(opts->stdio[1].flags & UV_CREATE_PIPE)
+      uv_read_start((uv_stream_t*)(opts->stdio[1].data.stream), subproc_alloc_cb, subproc_stream_cb);
+    if(opts->stdio[2].flags & UV_CREATE_PIPE)
+      uv_read_start((uv_stream_t*)(opts->stdio[2].data.stream), subproc_alloc_cb, subproc_stream_cb);
+    pd->opts = opts;
+
+    erasePositive(options);
+    if(err) {
+        printf("%s\n", uv_strerror(err));
+        free(_args);
+        free(proc);
+    }
+}
 
 #endif