@effekt-lang/effekt 0.2.1 → 0.2.2

package/libraries/js/io/args.effekt

@@ -0,0 +1,9 @@
+module io/args
+
+import effekt
+import immutable/list
+import mutable/array
+
+extern io def nativeArgs(): Array[String] = "process.argv.slice(2)"
+
+def commandLineArgs(): List[String] = nativeArgs().toList

package/libraries/js/io/async.effekt

@@ -0,0 +1,28 @@
+module io/async
+
+extern include "async.js"
+
+extern type Promise[T]
+
+interface AsyncIO {
+  def read(path: String): Promise[String]
+  def await[T](p: Promise[T]): T
+}
+
+def asyncIO[R](p: () => R / AsyncIO at {io}): R = try {
+  p()
+} with AsyncIO {
+  def read(path) = resume(readPromise(path))
+  def await[T](p) = awaitPromise(p, resume)
+}
+
+def block[T](p: Promise[T]) = do await(p)
+
+extern io def readPromise(path: String): Promise[String] =
+  "fsPromises.readFile(${path}, 'utf8')"
+
+extern io def awaitPromise[T, R](p: Promise[T], cont: T => R at {io}): R =
+  "${p}.then(res => (${cont})(res).run())"
+
+extern io def fork(process: () => Unit at {io}): Unit =
+  "setTimeout(() => (${process})().run(), 0)"

package/libraries/js/io/async.js

@@ -0,0 +1,2 @@
+const fs = require("fs")
+const fsPromises = fs.promises;

package/libraries/js/io/file.effekt

@@ -0,0 +1,50 @@
+module io/file
+
+effect IOException[A](msg: String): A
+
+extern include "file_include.js"
+
+extern type FileDescriptor
+
+extern type Buffer
+
+type Result[A] {
+  Error(msg: String);
+  Success(a: A)
+}
+
+extern type Promise[T]
+
+extern io def readPromise(path: String): Promise[String] =
+  "$effekt.delayed(() => fsPromises.readFile(${path}, 'utf8'))"
+
+def await[T](p: Promise[T]): T / { IOException } =
+  try { awaitImpl(p){exc} } with exc : IOException[A] {
+    msg => do IOException(msg)
+  }
+
+extern io def awaitImpl[T](p: Promise[T]){exc: IOException}: T =
+  "$effekt.callcc(k => ${p}.then(res => k($effekt.pure(res)), err => k(${box { (msg: String) => do IOException[T](msg) }}(err.message)))).then(c => c)"
+
+def open(path: String, mode: String): FileDescriptor / { IOException } =
+  try { openImpl(path, mode){exc} } with exc : IOException[A] {
+    msg => do IOException(msg)
+  }
+
+extern io def openImpl(path: String, mode: String){exc: IOException}: FileDescriptor =
+  "$effekt.delayed(() => { try { return $effekt.pure(fs.openSync(${path}, ${mode})); } catch (err) { return ${box { (msg: String) => do IOException[FileDescriptor](msg) }}(err.message); }}).then(c => c)"
+
+extern io def close(fd: FileDescriptor): Unit =
+  "$effekt.delayed(() => fs.closeSync(${fd}))"
+
+// uses the asynchronous API of node
+extern io def readFile(path: String): Result[String] =
+  "$effekt.callcc(k => fs.readFile(${path}, 'utf8', (err, data) => k(err ? ${box Error}(err.message) : ${box Success}(data))))"
+
+def read(path: String): String / { IOException } =
+  getResult(readFile(path))
+
+def getResult[R](r: Result[R]): R / { IOException } = r match {
+  case Error(msg) => do IOException(msg)
+  case Success(r) => r
+}

package/libraries/js/io/file_include.js

@@ -0,0 +1,13 @@
+const fs = require("fs")
+const fsPromises = fs.promises;
+
+function readAsyncHelper(path, f) {
+    return $effekt.callcc(k => {
+        fs.readFile(path, 'utf8', (err, data) => {
+            // change f, so it returns true
+            const comp = f(err ? Error(err.message) : Success(data)).then(x => $effekt.pure(true))
+            k(comp); // restore the stack, since `f` might use effects
+        });
+        return k($effekt.pure(false))
+    }).then(x => x).then(abort => abort ? $effekt.callcc(k => $effekt.pure(null)) : $effekt.pure(null))
+}

package/libraries/js/mutable/array.effekt

@@ -0,0 +1,98 @@
+module mutable/array
+
+import immutable/option
+import immutable/list
+
+// A mutable 0-based indexed array, backed by a JavaScript array.
+extern type Array[T]
+
+def emptyArray[T](): Array[T] = emptyArray(0)
+
+// Creates a new Array of size `size` filled with the value `default`
+def fill[T](size: Int, default: T): Array[T] = {
+  val arr = emptyArray[T](size)
+  each(0, arr.size()) { i =>
+    put(arr, i, default)
+  }
+  return arr;
+}
+
+// Builds a new Array of size `size` from a computation `index` which gets an index
+// and returns a value that will be on that position in the resulting array
+def build[T](size: Int) { index: Int => T }: Array[T] = {
+  val arr = emptyArray[T](size)
+  each(0, arr.size()) { i =>
+    put(arr, i, index(i))
+  }
+  return arr
+}
+
+// Converts a List `list` to an Array
+def fromList[T](list: List[T]): Array[T] = {
+  val listSize = list.size();
+  val arr = emptyArray(listSize);
+
+  foreachIndex(list) { (i, head) =>
+    put(arr, i, head)
+  }
+  return arr;
+}
+
+extern pure def emptyArray[T](initialSize: Int): Array[T] =
+  "(new Array(${initialSize}))"
+
+def get[T](arr: Array[T], index: Int): Option[T] =
+  arr.unsafeGet(index).undefinedToOption
+
+extern pure def size[T](arr: Array[T]): Int =
+  "${arr}.length"
+
+extern io def unsafeGet[T](arr: Array[T], index: Int): T =
+  "${arr}[${index}]"
+
+extern """
+function put(arr, index, value) {
+  arr[index] = value;
+  return $effekt.unit
+}
+"""
+
+extern io def put[T](arr: Array[T], index: Int, value: T): Unit =
+  "put(${arr}, ${index}, ${value})"
+
+extern pure def copy[T](arr: Array[T]): Array[T] =
+  "[...${arr}]"
+
+// Utility functions:
+
+def toList[T](arr: Array[T]): List[T] = {
+  var i = arr.size - 1;
+  var l = Nil[T]()
+  while (i >= 0) {
+    l = Cons(unsafeGet(arr, i), l)
+    i = i - 1
+  }
+  l
+}
+
+def foreach[T](arr: Array[T]){ action: T => Unit / Control }: Unit = {
+  each(0, arr.size) { i =>
+    val x: T = arr.unsafeGet(i)
+    action(x)
+  }
+}
+
+def foreachIndex[T](arr: Array[T]){ action: (Int, T) => Unit / Control }: Unit = {
+  each(0, arr.size) { i =>
+    val x: T = arr.unsafeGet(i)
+    action(i, x)
+  }
+}
+
+def sum(list: Array[Int]): Int = {
+  var acc = 0
+  list.foreach { x =>
+    acc = acc + x
+  }
+  acc
+}

package/libraries/js/mutable/heap.effekt

@@ -0,0 +1,32 @@
+module mutable/heap
+
+extern """
+var heap$data = {};
+var heap$pointer = 0;
+
+function heap$fresh(init) {
+    const ref = heap$pointer++;
+    heap$data[ref] = init;
+    return ref
+}
+
+function heap$put(ref, value) {
+    heap$data[ref] = value;
+    return null
+}
+
+function get$impl(ref) {
+    return heap$data[ref];
+}
+"""
+
+extern type HeapRef[T]
+
+extern io def fresh[T](init: T): HeapRef[T] =
+    "heap$fresh(${init})"
+
+extern io def put[T](ref: HeapRef[T], value: T): Unit =
+    "heap$put(${ref}, ${value})"
+
+extern io def get[T](ref: HeapRef[T]): T =
+    "heap$data[${ref}]"

package/libraries/js/mutable/map.effekt

@@ -0,0 +1,32 @@
+module mutable/map
+
+import mutable/array
+import immutable/option
+
+// A mutable map, backed by a JavaScript Map.
+extern type Map[K, V]
+
+extern pure def emptyMap[K, V](): Map[K, V] =
+  "new Map()"
+
+def get[K, V](m: Map[K, V], key: K): Option[V] =
+  m.unsafeGet(key).undefinedToOption
+
+extern pure def unsafeGet[K, V](m: Map[K, V], key: K): V =
+  "${m}.get(${key})"
+
+extern """
+function map$update(m, key, value) {
+  m.set(key, value);
+  return $effekt.unit
+}
+"""
+
+extern io def update[K, V](m: Map[K, V], key: K, value: V): Unit =
+  "map$update(${m}, ${key}, ${value})"
+
+extern pure def values[K, V](map: Map[K, V]): Array[V] =
+  "Array.from(${map}.values())"
+
+extern pure def keys[K, V](map: Map[K, V]): Array[K] =
+  "Array.from(${map}.keys())"

package/libraries/js/test.effekt

@@ -0,0 +1,59 @@
+import text/string
+
+interface Assertion {
+  def assert(condition: Boolean, msg: String): Unit
+}
+
+def assertTrue(condition: Boolean, msg: String) =
+  do assert(condition, msg)
+
+def assertTrue(condition: Boolean) =
+  do assert(condition, "Assertion failed")
+
+def assertFalse(condition: Boolean, msg: String) =
+  do assert(not(condition), msg)
+
+def assertFalse(condition: Boolean) =
+  do assert(not(condition), "Assertion failed")
+
+def assertEqual[A](obtained: A, expected: A, msg: String) =
+  do assert(obtained == expected, msg)
+
+def assertEqual[A](obtained: A, expected: A) =
+  do assert(obtained == expected, "Obtained: " ++ obtained.show ++ "\n but expected:" ++ expected.show)
+
+interface Test {
+  def success(name: String): Unit
+  def failure(name: String, msg: String): Unit
+}
+
+def test(name: String) { body: => Unit / Assertion } =
+  try { body(); do success(name) } with Assertion {
+    def assert(condition, msg) = if (condition) resume(()) else do failure(name, msg)
+  }
+
+def suite(name: String) { body: => Unit / Test }: Boolean = {
+  println("Running suite: " ++ name);
+  var failed = 0
+  var passed = 0
+
+  try { body() } with Test {
+    def success(name) = {
+      passed = passed + 1
+      println(ANSI_GREEN ++ "+ " ++ name ++ "" ++ ANSI_RESET);
+      resume(())
+    }
+    def failure(name, msg) = {
+      failed = failed + 1
+      println(ANSI_RED ++ "- (FAIL) " ++ name ++ "\n    " ++ msg ++ ANSI_RESET);
+      resume(())
+    }
+  }
+  if (failed > 0) {
+    println(ANSI_RED ++ "Some tests failed (" ++ passed.show ++ " passed, " ++ failed.show ++ " failed)" ++ ANSI_RESET)
+    false
+  } else {
+    println(ANSI_GREEN ++ "All tests passed (" ++ passed.show ++ " passed)" ++ ANSI_RESET)
+    true
+  }
+}

package/libraries/js/text/regex.effekt

@@ -0,0 +1,34 @@
+module text/regex
+
+import text/string
+import immutable/option
+
+extern type Regex
+
+record Match(matched: String, index: Int)
+
+extern pure def regex(str: String): Regex =
+  "new RegExp(${str})"
+
+def exec(reg: Regex, str: String): Option[Match] =
+  reg.unsafeExec(str).undefinedToOption match {
+    case None() => None()
+    case Some(v) => Some(Match(v.matched, v.index))
+  }
+
+// internal representation { matched: String, index: Int }
+extern type RegexMatch
+extern pure def matched(r: RegexMatch): String = "${r}.matched"
+extern pure def index(r: RegexMatch): Int = "${r}.index"
+
+extern """
+function regex$exec(reg, str) {
+  var res = reg.exec(str);
+  if (res === null) { return undefined }
+  else { return { matched: res[0], index: res.index } }
+}
+"""
+
+// internals
+extern io def unsafeExec(reg: Regex, str: String): RegexMatch =
+  "regex$exec(${reg}, ${str})"

package/libraries/js/text/string.effekt

@@ -0,0 +1,64 @@
+module text/string
+
+import immutable/option
+import mutable/array
+
+def charAt(str: String, index: Int): Option[String] =
+    str.unsafeCharAt(index).undefinedToOption
+
+extern pure def length(str: String): Int =
+  "${str}.length"
+
+extern pure def repeat(str: String, n: Int): String =
+  "${str}.repeat(${n})"
+
+extern pure def unsafeSubstring(str: String, from: Int, to: Int): String =
+  "${str}.substring(${from}, ${to})"
+
+def substring(str: String, from: Int, to: Int): String =
+  if (from >= to) { "" }
+  else {
+    str.unsafeSubstring(from, to)
+  }
+
+def substring(str: String, from: Int): String =
+  str.unsafeSubstring(from, str.length)
+
+extern pure def split(str: String, sep: String): Array[String] =
+  "${str}.split(${sep})"
+
+extern pure def trim(str: String): String =
+  "${str}.trim()"
+
+def toInt(str: String): Option[Int] =
+  str.unsafeToInt.undefinedToOption
+
+extern pure def unsafeCharAt(str: String, n: Int): String =
+  "${str}[${n}]"
+
+extern pure def unsafeToInt(str: String): Int =
+  "(Number.isNaN(parseInt(${str})) ? undefined : parseInt(${str}))"
+
+def indexOf(str: String, sub: String): Option[Int] = {
+  val index = str.unsafeIndexOf(sub)
+  if (index < 0) { None() } else { Some(index) }
+}
+
+def lastIndexOf(str: String, sub: String): Option[Int] = {
+  val index = str.unsafeLastIndexOf(sub)
+  if (index < 0) { None() } else { Some(index) }
+}
+
+extern pure def unsafeIndexOf(str: String, sub: String): Int = "${str}.indexOf(${sub})"
+extern pure def unsafeLastIndexOf(str: String, sub: String): Int = "${str}.lastIndexOf(${sub})"
+
+extern pure def startsWith(str: String, prefix: String): Boolean =
+  "${str}.startsWith(${prefix})"
+
+extern pure def endsWith(str: String, suffix: String): Boolean =
+  "${str}.endsWith(${suffix})"
+
+// ANSI escape codes
+val ANSI_GREEN = "\u001b[32m"
+val ANSI_RED = "\u001b[31m"
+val ANSI_RESET = "\u001b[0m"

package/libraries/js/unsafe/cont.effekt

@@ -0,0 +1,11 @@
+module unsafe/cont
+
+// The type of a captured continuation
+extern type Cont[A, B]
+
+// we mark this as {io} since pure functions should not take block parameters.
+extern io def cont[A, B] { r: A => B / {} }: Cont[A, B] = "${box r}"
+
+// This is unsafe if the continuation left the scope of the
+// capabilities it closed over
+extern control def apply[A, B](k: Cont[A, B], a: A): B / {} = "${k}(${a})"

package/libraries/js/web/dom.effekt

@@ -0,0 +1,45 @@
+module web/dom
+
+extern type Node
+
+// can be null
+extern pure def getElementById(id: String): Node =
+  "document.getElementById(${id})"
+
+extern pure def createElement(tag: String): Node =
+  "document.createElement(${tag})"
+
+extern pure def createTextNode(text: String): Node =
+  "document.createTextNode(${text})"
+
+extern pure def setAttribute(node: Node, key: String, value: String): Node =
+  "${node}.setAttribute(${key}, ${value})"
+
+// the string return type is wrong here...
+extern pure def getAttribute(node: Node, key: String): String =
+  "${node}.getAttribute(${key})"
+
+extern pure def appendChild(node: Node, child: Node): Node =
+  "${node}.appendChild(${child})"
+
+extern pure def innerHTML(node: Node, contents: String): Node =
+  "(function() { ${node}.innerHTML = ${contents}; return ${node} })()"
+
+extern type IdleDeadline
+
+extern pure def requestIdleCallback(callback: (IdleDeadline) => Unit at {io}): Unit =
+  "window.requestIdleCallback(deadline => ${callback}(deadline).run())"
+
+extern pure def didDimeout(deadline: IdleDeadline): Boolean =
+  "${deadline}.didTimeout"
+
+extern pure def timeRemaining(deadline: IdleDeadline): Double =
+  "${deadline}.timeRemaining()"
+
+extern pure def onClick(node: Node, handler: () => Unit at {io}): Node =
+  "(function() { ${node}.onclick = () => ${handler}().run(); return ${node} })()"
+
+extern def sleep(n: Int): Unit =
+  "$effekt.callcc(k => window.setTimeout(() => k(null), ${n}))"
+
+def clear(node: Node) = node.innerHTML("")

package/libraries/llvm/buffer.c

@@ -0,0 +1,181 @@
+#ifndef EFFEKT_BUFFER_C
+#define EFFEKT_BUFFER_C
+
+// NOTE: Buffers are NOT 0-terminated!
+
+#include "stdlib.h"
+#include <stdint.h>
+
+// TODO It may be performance-advantageous to implement this C file's semantics
+// in LLVM, since the linker cannot realistically be asked to satisfactorily
+// inline.
+// Alternatively, one could drop gcc and combine Effekt-compiler-generated LLVM
+// with clang-generated LLVM from this file's entire translation unit.
+
+
+// Eight bytes for the reference counter.
+// E.g. capacity could later also be stored in the header.
+#define BUFFER_HEADER_WIDTH (8)
+
+uint64_t c_buffer_length(const struct Pos buffer) {
+    return buffer.tag;
+}
+
+// NOTE: This assumes a homogenously used byte order.
+uint64_t *c_buffer_refcount(const struct Pos buffer) {
+    return (uint64_t *) (buffer.obj + 0);
+}
+
+uint8_t *c_buffer_bytes(const struct Pos buffer) {
+    return (uint8_t *) (buffer.obj + BUFFER_HEADER_WIDTH);
+}
+
+
+struct Pos c_buffer_construct(const uint64_t n, const uint8_t *data) {
+    uint8_t *obj = malloc(BUFFER_HEADER_WIDTH + n * sizeof *obj);
+    ASSERT_NON_NULL(obj)
+
+    // reference count (a reference count of zero means one sole owner)
+    for (uint64_t j = 0; j < BUFFER_HEADER_WIDTH; ++j)
+        obj[j] = 0;
+
+    // data
+    for (uint64_t j = 0; j < n; ++j)
+        obj[BUFFER_HEADER_WIDTH + j] = data[j];
+
+    return (struct Pos) {
+        .tag = n,
+        .obj = obj,
+    };
+}
+
+void c_buffer_destruct(const struct Pos buffer) {
+    free(buffer.obj);
+}
+
+
+void c_buffer_refcount_increment(const struct Pos buffer) {
+    if (DEBUG_REFCOUNT) {
+        fprintf(stderr, "c_buffer_refcount_increment((struct Pos) "
+            "{ .tag = %" PRIu64 ", .obj = %p }): from %" PRIu64 "\n",
+            buffer.tag, buffer.obj, *(c_buffer_refcount(buffer)));
+        fflush(stderr);
+    }
+
+    (*c_buffer_refcount(buffer))++;
+}
+
+void c_buffer_refcount_decrement(const struct Pos buffer) {
+    if (DEBUG_REFCOUNT) {
+        fprintf(stderr, "c_buffer_refcount_decrement((struct Pos) "
+            "{ .tag = %" PRIu64 ", .obj = %p }): from %" PRIu64 "\n",
+            buffer.tag, buffer.obj, *(c_buffer_refcount(buffer)));
+        fflush(stderr);
+    }
+
+    if (!(*c_buffer_refcount(buffer))--)
+        c_buffer_destruct(buffer);
+}
+
+
+struct Pos c_buffer_construct_zeroed(const uint64_t n) {
+    uint8_t *zeroes = calloc(n, sizeof *zeroes);
+    ASSERT_NON_NULL(zeroes)
+    const struct Pos buffer = c_buffer_construct(n, zeroes);
+    free(zeroes);
+    return buffer;
+}
+
+void c_buffer_truncate(struct Pos buffer, const uint64_t n) {
+    if (n > c_buffer_length(buffer))
+        return;
+    buffer.tag = n;
+}
+
+struct Pos c_buffer_copy(const struct Pos buffer) {
+    return c_buffer_construct(c_buffer_length(buffer), c_buffer_bytes(buffer));
+}
+
+
+// incurs a malloc: the returned pointer needs to be managed
+char *c_buffer_as_null_terminated_string(const struct Pos buffer) {
+    // Zero runes are represented as non-minimal utf8 in the null-terminated
+    // string. As such, a count reveals the necessary number of bytes.
+    uint64_t zero_runes = 0;
+    for (uint64_t j = 0; j < c_buffer_length(buffer); ++j)
+        zero_runes += !c_buffer_bytes(buffer)[j];
+
+    const uint64_t n = c_buffer_length(buffer) + zero_runes;
+    char *buf = (char *) malloc((n+1) * sizeof *buf);
+    ASSERT_NON_NULL(buf)
+
+    uint64_t i = 0;
+    for (uint64_t j = 0; j < c_buffer_length(buffer); ++j) {
+        buf[i++] = c_buffer_bytes(buffer)[j];
+        if (!buf[i]) {
+            buf[i]   = 0xc0; // 0b110.00000
+            buf[i++] = 0x80; // 0b10.000000
+        }
+    }
+
+    // null-terminated
+    buf[n] = '\00';
+
+    return buf;
+}
+
+struct Pos c_buffer_construct_from_null_terminated_string(const char *data_nt) {
+    uint64_t n = 0;
+    while (data_nt[++n]);
+
+    return c_buffer_construct(n, (uint8_t *) data_nt);
+}
+
+
+struct Pos c_buffer_concatenate(const struct Pos left, const struct Pos right) {
+    const struct Pos concatenated = c_buffer_construct_zeroed(
+        c_buffer_length(left) + c_buffer_length(right));
+    for (uint64_t j = 0; j < c_buffer_length(concatenated); ++j)
+        c_buffer_bytes(concatenated)[j]
+            = j < c_buffer_length(left)
+            ? c_buffer_bytes(left)[j]
+            : c_buffer_bytes(right)[j - c_buffer_length(left)];
+    return concatenated;
+}
+
+struct Pos c_buffer_eq(const struct Pos left, const struct Pos right) {
+    uint64_t left_len = c_buffer_length(left);
+    uint64_t right_len = c_buffer_length(right);
+    if(left_len != right_len) return BooleanFalse;
+    for(uint64_t j = 0; j < left_len; ++j) {
+        if(c_buffer_bytes(left)[j] != c_buffer_bytes(right)[j]) {
+            return BooleanFalse;
+        }
+    }
+    return BooleanTrue;
+}
+
+struct Pos c_buffer_substring(const struct Pos str, uint64_t start, uint64_t end) {
+    const struct Pos substr = c_buffer_construct_zeroed(end - start);
+    for (uint64_t j = 0; j < c_buffer_length(substr); ++j) {
+        c_buffer_bytes(substr)[j] = c_buffer_bytes(str)[start+j];
+    }
+    return substr;
+}
+
+struct Pos c_buffer_show_Int(const Int n) {
+    char str[24];
+    sprintf(str, "%" PRId64, n);
+    return c_buffer_construct_from_null_terminated_string(str);
+}
+struct Pos c_buffer_show_Double(const Double x) {
+    char str[64]; // TODO is this large enough? Possibly use snprintf first
+    sprintf(str, "%g", x);
+    return c_buffer_construct_from_null_terminated_string(str);
+}
+
+uint64_t c_buffer_index(const struct Pos str, const uint64_t index) {
+    return c_buffer_bytes(str)[index];
+}
+
+#endif