@effekt-lang/effekt 0.19.0 → 0.20.0

package/libraries/common/union_find.effekt

@@ -0,0 +1,113 @@
+module union_find
+import resizable_array
+
+/// Classic mutable union-find data structure on integer indices,
+/// with union-by-rank and path compression.
+record UnionFind(rawElements: ResizableArray[Int])
+
+namespace internal {
+  // -(rk + 1) for roots
+  // parent for inner nodes
+  def isRoot(u: UnionFind, s: Int): Bool / Exception[MissingValue] = {
+    with on[OutOfBounds].default { do raise(MissingValue(), "No node " ++ s.show) }
+    u.rawElements.get(s) < 0
+  }
+  def parent(u: UnionFind, s: Int): Int / Exception[MissingValue] = {
+    with on[OutOfBounds].default { do raise(MissingValue(), "No node " ++ s.show) }
+    val c = u.rawElements.get(s)
+    if (c < 0) { 
+      do raise(MissingValue(), "Root node " ++ s.show ++ " has no parent.") 
+    } else { 
+      c
+    }
+  }
+  def rank(u: UnionFind, s: Int): Int / Exception[MissingValue] = {
+    with on[OutOfBounds].default { do raise(MissingValue(), "No node " ++ s.show) }
+    val c = u.rawElements.get(s)
+    if (c < 0) {
+      -1 * c - 1
+    } else {
+      do raise(MissingValue(), "Only root nodes have a rank.")
+    }
+  }
+  def setParent(u: UnionFind, child: Int, parent: Int) = {
+    with on[OutOfBounds].default { do raise(MissingValue(), "No node " ++ child.show) }
+    u.rawElements.set(child, parent)
+  }
+  def setRank(u: UnionFind, root: Int, rank: Int) = {
+    with on[OutOfBounds].default { do raise(MissingValue(), "No node " ++ root.show) }
+    u.rawElements.set(root, -1 * rank - 1)
+  }
+}
+
+def unionFind(): UnionFind =
+  UnionFind(resizableArray())
+
+def unionFind(capacity: Int): UnionFind =
+  UnionFind(resizableArray(capacity))
+
+/// Make a new set in the union-find datastructure and return its index
+///
+/// O(1) amortized, worst-case O(n) if the capacity does not suffice
+def makeSet(u: UnionFind): Int = {
+  u.rawElements.add(-1)
+}
+
+/// Find the representative of the given element.
+///
+/// O(inverse-ackermann(n)) amortized
+def find(u: UnionFind, s: Int): Int / Exception[MissingValue] = {
+  def goFind(s: Int): Int = {
+    if (u.internal::isRoot(s)) {
+      s
+    } else {
+      goFind(u.internal::parent(s))
+    }
+  }
+  val root = goFind(s)
+
+  def goCompress(s: Int): Unit = { 
+    if (not(u.internal::isRoot(s))) {
+      val p = u.internal::parent(s)
+      u.internal::setParent(s, root)
+      goCompress(p)
+    }
+  }
+  goCompress(s)
+
+  root
+}
+
+/// Make it such that the sets *represented by* x and y are merged
+///
+/// O(1)
+def unionRoots(u: UnionFind, x: Int, y: Int): Int / Exception[MissingValue] = {
+  if(not(u.internal::isRoot(x) && u.internal::isRoot(y))) { 
+    panic("unionRoots should only be called on representatives")
+  }
+
+  def addChild(root: Int, child: Int) = {
+    if (u.internal::rank(root) == u.internal::rank(child)) {
+      u.internal::setRank(root, u.internal::rank(root) + 1)
+    }
+    u.internal::setParent(child, root)
+    root
+  }
+
+  if (x == y) {
+    x
+  } else if (u.internal::rank(x) < u.internal::rank(y)) {
+    addChild(y, x)
+  } else {
+    addChild(x, y)
+  }
+}
+
+/// Make it so a and b are in the same set
+///
+/// O(inverse-ackermann(n)) amortized
+def union(u: UnionFind, a: Int, b: Int): Int / Exception[MissingValue] = {
+  val x = u.find(a)
+  val y = u.find(b)
+  u.unionRoots(x, y)
+}

package/libraries/llvm/forward-declare-c.ll

@@ -9,6 +9,7 @@ declare void @c_io_println_Double(%Double)
 declare void @c_io_println_String(%Pos)
 
 declare void @hole()
+declare void @duplicated_prompt()
 
 declare %Pos @c_ref_fresh(%Pos)
 declare %Pos @c_ref_get(%Pos)

package/libraries/llvm/io.c

@@ -62,50 +62,12 @@ void c_resume_int_fs(uv_fs_t* request) {
     resume_Int(stack, result);
 }
 
-int modeFlags(struct Pos mode) {
-    switch (mode.tag) {
-        case 0: // ReadOnly()
-            return UV_FS_O_RDONLY;
-        case 1: // WriteOnly()
-            return UV_FS_O_WRONLY | UV_FS_O_CREAT | UV_FS_O_TRUNC;
-        case 2: // AppendOnly()
-            return UV_FS_O_WRONLY | UV_FS_O_CREAT | UV_FS_O_APPEND;
-        case 3: // ReadWrite()
-            return UV_FS_O_RDWR | UV_FS_O_CREAT | UV_FS_O_TRUNC;
-        case 4: // ReadAppend()
-            return UV_FS_O_RDWR | UV_FS_O_CREAT | UV_FS_O_APPEND;
-        case 5: // AppendExclusive()
-            return UV_FS_O_WRONLY | UV_FS_O_CREAT | UV_FS_O_APPEND | UV_FS_O_EXCL;
-        case 6: // ReadAppendExclusive()
-            return UV_FS_O_RDWR | UV_FS_O_CREAT | UV_FS_O_APPEND | UV_FS_O_EXCL;
-        case 7: // AppendSync()
-            return UV_FS_O_WRONLY | UV_FS_O_CREAT | UV_FS_O_APPEND | UV_FS_O_SYNC;
-        case 8: // ReadAppendSync()
-            return UV_FS_O_RDWR | UV_FS_O_CREAT | UV_FS_O_APPEND | UV_FS_O_SYNC;
-        case 9: // ReadSync()
-            return UV_FS_O_RDONLY | UV_FS_O_SYNC;
-        case 10: // ReadWriteSync()
-            return UV_FS_O_RDWR | UV_FS_O_SYNC;
-        case 11: // WriteExclusive()
-            return UV_FS_O_WRONLY | UV_FS_O_CREAT | UV_FS_O_TRUNC | UV_FS_O_EXCL;
-        case 12: // ReadWriteExclusive()
-            return UV_FS_O_RDWR | UV_FS_O_CREAT | UV_FS_O_TRUNC | UV_FS_O_EXCL;
-        default:
-            // Invalid tag value
-            return -1;
-    }
-}
-
-void c_fs_open(String path, struct Pos mode, Stack stack) {
+void c_fs_open(String path, int flags, Stack stack) {
 
     // Convert the Effekt String to a 0-terminated string
     char* path_str = c_bytearray_into_nullterminated_string(path);
     erasePositive((struct Pos) path);
 
-    // Convert the Effekt String representing the opening mode to libuv flags
-    int flags = modeFlags(mode);
-    erasePositive((struct Pos) mode);
-
     uv_fs_t* request = malloc(sizeof(uv_fs_t));
     request->data = stack;
 
@@ -123,6 +85,18 @@ void c_fs_open(String path, struct Pos mode, Stack stack) {
     return;
 }
 
+void c_fs_open_reading(String path, Stack stack) {
+    c_fs_open(path, UV_FS_O_RDONLY, stack);
+}
+
+void c_fs_open_writing(String path, Stack stack) {
+    c_fs_open(path, UV_FS_O_WRONLY | UV_FS_O_CREAT | UV_FS_O_TRUNC, stack);
+}
+
+void c_fs_open_appending(String path, Stack stack) {
+    c_fs_open(path, UV_FS_O_WRONLY | UV_FS_O_CREAT | UV_FS_O_APPEND, stack);
+}
+
 void c_fs_read(Int file, struct Pos buffer, Int offset, Int size, Int position, Stack stack) {
 
     uv_buf_t buf = uv_buf_init((char*)(c_bytearray_data(buffer) + offset), size);
@@ -177,11 +151,11 @@ void c_fs_close(Int file, Stack stack) {
 /**
  * Maps the libuv error code to a stable (platform independent) numeric value.
  *
- * Tries to use most common errno integer values, but introduces fresh values (> 200)
- * for those without common errno values.
+ * Tries to use most common error number integer values, but introduces fresh values (> 200)
+ * for those without common error number values.
  */
-Int c_error_number(Int errno) {
-    switch (errno) {
+Int c_error_number(Int error) {
+    switch (error) {
         case UV_EPERM:            return 1;    // EPERM
         case UV_ENOENT:           return 2;    // ENOENT
         case UV_ESRCH:            return 3;    // ESRCH

package/libraries/llvm/main.c

@@ -12,7 +12,7 @@
 #include "types.c"
 #include "bytearray.c"
 #include "io.c"
-#include "hole.c"
+#include "panic.c"
 #include "ref.c"
 #include "array.c"
 

package/libraries/llvm/panic.c

@@ -0,0 +1,20 @@
+#ifndef EFFEKT_PANIC_C
+#define EFFEKT_PANIC_C
+
+#include <stdio.h>
+
+// TODO:
+// this should _morally_ be using `stderr`, but we don't tee it in tests
+// see PR #823 & issue #815 for context
+
+void hole() {
+    printf("PANIC: Reached a hole in the program\n");
+    exit(1);
+}
+
+void duplicated_prompt() {
+    printf("PANIC: Continuation invoked itself\n");
+    exit(1);
+}
+
+#endif