@effekt-lang/effekt 0.2.2 → 0.3.0

package/libraries/js/io.js

@@ -0,0 +1,143 @@
+
+/**
+ * Maps the error code to a Effekt-stable (platform independent) numeric value.
+ *
+ * Tries to use most common errno integer values, but introduces fresh values (> 200)
+ * for those without common errno values.
+ */
+function errnoToStableId(errorName) {
+    const errorMap = {
+        EPERM: 1,
+        ENOENT: 2,
+        ESRCH: 3,
+        EINTR: 4,
+        EIO: 5,
+        ENXIO: 6,
+        E2BIG: 7,
+        EBADF: 9,
+        EAGAIN: 11,
+        ENOMEM: 12,
+        EACCES: 13,
+        EFAULT: 14,
+        EBUSY: 16,
+        EEXIST: 17,
+        EXDEV: 18,
+        ENODEV: 19,
+        ENOTDIR: 20,
+        EISDIR: 21,
+        EINVAL: 22,
+        ENFILE: 23,
+        EMFILE: 24,
+        ENOTTY: 25,
+        ETXTBSY: 26,
+        EFBIG: 27,
+        ENOSPC: 28,
+        ESPIPE: 29,
+        EROFS: 30,
+        EMLINK: 31,
+        EPIPE: 32,
+        ERANGE: 34,
+        ENAMETOOLONG: 36,
+        ELOOP: 40,
+        EOVERFLOW: 75,
+        EFTYPE: 79,
+        EILSEQ: 84,
+        ENOTSOCK: 88,
+        EDESTADDRREQ: 89,
+        EMSGSIZE: 90,
+        EPROTOTYPE: 91,
+        ENOPROTOOPT: 92,
+        EPROTONOSUPPORT: 93,
+        ESOCKTNOSUPPORT: 94,
+        ENOTSUP: 95,
+        EAFNOSUPPORT: 97,
+        EADDRINUSE: 98,
+        EADDRNOTAVAIL: 99,
+        ENETDOWN: 100,
+        ENETUNREACH: 101,
+        ECONNABORTED: 103,
+        ECONNRESET: 104,
+        ENOBUFS: 105,
+        EISCONN: 106,
+        ENOTCONN: 107,
+        ETIMEDOUT: 110,
+        ECONNREFUSED: 111,
+        EHOSTUNREACH: 113,
+        EALREADY: 114,
+        ECANCELED: 125,
+        EAI_ADDRFAMILY: 200,
+        EAI_AGAIN: 201,
+        EAI_BADFLAGS: 202,
+        EAI_BADHINTS: 203,
+        EAI_CANCELED: 204,
+        EAI_FAIL: 205,
+        EAI_FAMILY: 206,
+        EAI_MEMORY: 207,
+        EAI_NODATA: 208,
+        EAI_NONAME: 209,
+        EAI_OVERFLOW: 210,
+        EAI_PROTOCOL: 211,
+        EAI_SERVICE: 212,
+        EAI_SOCKTYPE: 213,
+        ECHARSET: 215,
+        ENONET: 216,
+        UNKNOWN: 217,
+        EOF: 218,
+        EUNATCH: 219,
+        ESHUTDOWN: 220
+    };
+
+    return errorMap[errorName] || -1; // Default to -1 for unknown error names
+}
+
+function openFile(path, mode, onSuccess, onFailure) {
+  fs.open(path, mode,
+    (err, fd) => {
+      if (!!err) {
+        console.error(err)
+        return onFailure(errnoToStableId(err.code)).run();
+      } else {
+        return onSuccess(fd).run();
+      }
+    });
+  return $effekt.unit;
+}
+
+function readFile(fd, buffer, offset, onSuccess, onFailure) {
+  let position = offset === -1 ? null : offset;
+  fs.read(fd, toBuffer(buffer), 0, buffer.length, position,
+    (err, bytesRead) => {
+      if (!!err) {
+        return onFailure(errnoToStableId(err.code)).run()
+      } else {
+        return onSuccess(bytesRead).run()
+      }
+    })
+  return $effekt.unit;
+}
+
+/**
+ * @see {https://nodejs.org/api/fs.html#fswritefd-buffer-offset-length-position-callback
+ */
+function writeFile(fd, buffer, offset, onSuccess, onFailure) {
+  let position = offset === -1 ? null : offset;
+  fs.write(fd, toBuffer(buffer), 0, buffer.length, position,
+    (err, bytesWritten) => {
+      if (!!err) {
+        return onFailure(errnoToStableId(err.code)).run()
+      } else {
+        return onSuccess(bytesWritten).run()
+      }
+    })
+  return $effekt.unit;
+}
+
+
+
+/**
+ * Nodejs file operations expect buffers, but we represent buffers as typed arrays.
+ * This function converts between the two without copying.
+ */
+function toBuffer(buffer) {
+  return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength)
+}

package/libraries/js/mutable/map.effekt

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

package/libraries/js/text/regex.effekt

@@ -1,27 +1,26 @@
 module text/regex
 
-import text/string
-import immutable/option
+import string
 
 extern type Regex
 
 record Match(matched: String, index: Int)
 
 extern pure def regex(str: String): Regex =
-  "new RegExp(${str})"
+  js "new RegExp(${str})"
 
 def exec(reg: Regex, str: String): Option[Match] =
-  reg.unsafeExec(str).undefinedToOption match {
+   undefinedToOption(reg.unsafeExec(str)) 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 pure def matched(r: RegexMatch): String = js "${r}.matched"
+extern pure def index(r: RegexMatch): Int = js "${r}.index"
 
-extern """
+extern js """
 function regex$exec(reg, str) {
   var res = reg.exec(str);
   if (res === null) { return undefined }
@@ -31,4 +30,4 @@ function regex$exec(reg, str) {
 
 // internals
 extern io def unsafeExec(reg: Regex, str: String): RegexMatch =
-  "regex$exec(${reg}, ${str})"
+  js "regex$exec(${reg}, ${str})"

package/libraries/js/unsafe/cont.effekt

@@ -4,8 +4,8 @@ module unsafe/cont
 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}"
+extern io def cont[A, B] { r: A => B / {} }: Cont[A, B] = js "${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})"
+extern control def apply[A, B](k: Cont[A, B], a: A): B / {} = js "${k}(${a})"

package/libraries/js/web/dom.effekt

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

package/libraries/llvm/array.c

@@ -0,0 +1,53 @@
+#ifndef EFFEKT_ARRAY_C
+#define EFFEKT_ARRAY_C
+
+/** We represent arrays like positive types.
+ *  The tag is 0 and the obj points to memory with the following layout:
+ *
+ *   +--[ Header ]--+------+------------+
+ *   | Rc  | Eraser | Size | Fields ... |
+ *   +--------------+------+------------+
+ */
+
+void c_array_erase_fields(void *envPtr) {
+  uint64_t *sizePtr = envPtr;
+  struct Pos *dataPtr = envPtr + sizeof(uint64_t);
+  uint64_t size = *sizePtr;
+  for (uint64_t i = 0; i < size; i++) {
+    erasePositive(dataPtr[i]);
+  }
+}
+
+struct Pos c_array_new(const Int size) {
+  void *objPtr = calloc(sizeof(struct Header) + sizeof(uint64_t) + size * sizeof(struct Pos), 1);
+  struct Header *headerPtr = objPtr;
+  uint64_t *sizePtr = objPtr + sizeof(struct Header);
+  *headerPtr = (struct Header) { .rc = 0, .eraser = c_array_erase_fields, };
+  *sizePtr = size;
+  return (struct Pos) {
+    .tag = 0,
+    .obj = objPtr,
+  };
+}
+
+Int c_array_size(const struct Pos arr) {
+  uint64_t *sizePtr = arr.obj + sizeof(struct Header);
+  return *sizePtr;
+}
+
+struct Pos c_array_get(const struct Pos arr, const Int index) {
+  struct Pos *dataPtr = arr.obj + sizeof(struct Header) + sizeof(uint64_t);
+  struct Pos element = dataPtr[index];
+  sharePositive(element);
+  return element;
+}
+
+struct Pos c_array_set(const struct Pos arr, const Int index, const struct Pos value) {
+  struct Pos *dataPtr = arr.obj + sizeof(struct Header) + sizeof(uint64_t);
+  struct Pos element = dataPtr[index];
+  erasePositive(element);
+  dataPtr[index] = value;
+  return Unit;
+}
+
+#endif