@effekt-lang/effekt 0.18.0 → 0.20.0

package/libraries/common/stringbuffer.effekt

@@ -0,0 +1,65 @@
+module stringbuffer
+
+import bytearray
+
+interface StringBuffer {
+  def write(str: String): Unit
+  def flush(): String
+}
+
+def stringBuffer[A] { prog: => A / StringBuffer }: A = {
+  val initialCapacity = 128
+  var buffer = bytearray::allocate(initialCapacity)
+  // next free index to write to
+  var pos = 0
+
+  def ensureCapacity(sizeToAdd: Int): Unit = {
+    val cap = buffer.size - pos + 1
+    if (sizeToAdd <= cap) ()
+    else {
+      // Double the capacity while ensuring the required capacity
+      val newSize = max(buffer.size * 2, buffer.size + sizeToAdd)
+      buffer = buffer.resize(newSize)
+    }
+  }
+
+  try { prog() }
+  with StringBuffer {
+    def write(str) = {
+      val bytes = fromString(str)
+      ensureCapacity(bytes.size)
+      bytes.foreach { b =>
+        buffer.unsafeSet(pos, b)
+        pos = pos + 1
+      }
+      resume(())
+    }
+    def flush() = {
+      // resize buffer to strip trailing zeros that otherwise would be converted into 0x00 characters
+      val str = bytearray::resize(buffer, pos).toString()
+      // after flushing, the stringbuffer should be empty again
+      buffer = bytearray::allocate(initialCapacity)
+      resume(str)
+    }
+  }
+}
+
+/// Handler for string interpolation using a string buffer
+def s { prog: () => Unit / { literal, splice[String] } }: String =
+  stringBuffer {
+    try { prog(); do flush() }
+    with splice[String] { x => resume(do write(x)) }
+    with literal { s => resume(do write(s)) }
+  }
+
+namespace examples {
+  def main() = {
+    with stringBuffer
+    do write("hello")
+    do write(", world")
+    // prints `hello, world`
+    println(do flush())
+    // prints the empty string
+    println(do flush())
+  }
+}

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/bytearray.c

@@ -152,16 +152,45 @@ struct Pos c_bytearray_equal(const struct Pos left, const struct Pos right) {
         erasePositive(right);
         return BooleanFalse;
     }
-    for (uint64_t j = 0; j < left_size; ++j) {
-        if (c_bytearray_data(left)[j] != c_bytearray_data(right)[j]) {
-            erasePositive(left);
-            erasePositive(right);
-            return BooleanFalse;
-        }
+
+    int cmp = memcmp(c_bytearray_data(left), c_bytearray_data(right), left_size);
+    erasePositive(left);
+    erasePositive(right);
+    return (cmp == 0 ? BooleanTrue : BooleanFalse);
+}
+
+Int c_bytearray_compare(const struct Pos left, const struct Pos right) {
+    uint64_t left_size = left.tag;
+    uint64_t right_size = right.tag;
+    uint64_t min_size = (left_size < right_size) ? left_size : right_size;
+    
+    uint8_t* left_data = c_bytearray_data(left);
+    uint8_t* right_data = c_bytearray_data(right);
+
+    if (left_data == right_data) {
+        erasePositive(left);
+        erasePositive(right);   
+        return 0;
     }
+
+    int cmp = memcmp(left_data, right_data, min_size);
+
     erasePositive(left);
     erasePositive(right);
-    return BooleanTrue;
+
+    if (cmp < 0) {
+        return -1;
+    } else if (cmp > 0) {
+        return 1;
+    }
+    
+    if (left_size < right_size) {
+        return -1;
+    } else if (left_size > right_size) {
+        return 1;
+    }
+
+    return 0;
 }
 
 // TODO deprecate

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)
@@ -37,6 +38,7 @@ declare %Pos @c_bytearray_show_Double(double)
 
 declare %Pos @c_bytearray_concatenate(%Pos, %Pos)
 declare %Pos @c_bytearray_equal(%Pos, %Pos)
+declare %Int @c_bytearray_compare(%Pos, %Pos)
 
 declare %Pos @c_bytearray_substring(%Pos, i64, i64)
 declare %Int @c_bytearray_character_at(%Pos, i64)

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"
 
@@ -40,4 +40,5 @@ int main(int argc, char *argv[]) {
     uv_loop_t *loop = uv_default_loop();
     uv_run(loop, UV_RUN_DEFAULT);
     uv_loop_close(loop);
+    return 0;
 }

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