@effekt-lang/effekt 0.2.1 → 0.3.0

package/libraries/js/effekt_runtime.js

@@ -0,0 +1,385 @@
+const $runtime = (function() {
+
+  // Common Runtime
+  // --------------
+
+  // Regions
+  // TODO maybe use weak refs (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef)
+  function Cell(init) {
+    var _value = init;
+    const cell = ({
+      backup: function() {
+        var _backup = _value
+        var cell = this;
+        return () => { _value = _backup; return cell }
+      }
+    });
+    // $getOp and $putOp are auto generated from the compiler
+    cell[$getOp] = function() {
+      return _value
+    };
+    cell[$putOp] = function(v) {
+      _value = v;
+      return $effekt.unit;
+    };
+    return cell
+  }
+
+  function Arena() {
+    return {
+      fields: [], // Array[Cell],
+      fresh: function(init) {
+        const cell = Cell(init)
+        this.fields.push(cell)
+        return cell;
+      },
+      backup: function() {
+        return this.fields.map(c => c.backup())
+      },
+      restore: function(backup) {
+        this.fields = backup.map(c => c());
+        return this
+      }
+    }
+  }
+
+  const global = {
+    fresh: function(init) { return Cell(init) },
+    backup: function() {},
+    restore: function(_) {}
+  }
+
+  // Lists / Pairs
+  function Cons(head, tail) {
+    return { head: head, tail: tail }
+  }
+  const Nil = null
+
+  // reverseOnto[A, B, C](init: Frames[A, B], tail: Stack[B, C]): Stack[A, C]
+  function reverseOnto(init, tail) {
+    let rest = init;
+    let result = tail;
+    while (rest !== Nil) {
+      result = Cons(rest.head, result)
+      rest = rest.tail
+    }
+    return result
+  }
+
+  let _prompt = 2;
+
+  // Monadic Style Runtime
+  // ---------------------
+
+  const toplevel = 1;
+
+  // Result -- Trampoline
+  function Step(c, k) {
+    return { isStep: true, c: c, k: k }
+  }
+  function trampoline(r) {
+    var res = r
+    while (res !== null && res !== undefined && res.isStep) {
+      res = res.c.apply(res.k)
+    }
+    return res
+  }
+
+  // Frame = A => Control[B]
+
+  // Metacontinuations / Stacks
+  // (frames: List<Frame>, fields: [Cell], prompt: Int, tail: Stack) -> Stack
+  function Stack(frames, arena, prompt, tail) {
+    return { frames: frames, arena: arena, prompt: prompt, tail: tail }
+  }
+  function SubStack(frames, arena, backup, prompt, tail) {
+    return { frames: frames, arena: arena, backup: backup, prompt: prompt, tail: tail }
+  }
+  const EmptyStack = null;
+
+  // (stack: Stack<A, B>, a: A) -> Step<B>
+  function apply(stack, a) {
+    var s = stack;
+    while (true) {
+      if (s === EmptyStack) return a;
+      const fs = s.frames;
+      if (fs === Nil) { s = s.tail; continue }
+      const result = fs.head(a);
+      s.frames = fs.tail;
+      return Step(result, s)
+    }
+  }
+
+  // (subcont: Stack, stack: Stack) -> Stack
+  function pushSubcont(subcont, stack) {
+    var sub = subcont;
+    var s = stack;
+
+    while (sub !== EmptyStack) {
+      s = Stack(sub.frames, sub.arena.restore(sub.backup), sub.prompt, s)
+      sub = sub.tail
+    }
+    return s;
+  }
+
+  function flatMap(stack, f) {
+    if (stack === EmptyStack) { return Stack(Cons(f, Nil), Arena(), null, stack) }
+    var fs = stack.frames
+    // it should be safe to mutate the frames field, since they are copied in the subcont
+    stack.frames = Cons(f, fs)
+    return stack
+  }
+
+  function splitAt(stack, p) {
+    var sub = EmptyStack;
+    var s = stack;
+
+    while (s !== EmptyStack) {
+      const currentPrompt = s.prompt;
+      sub = SubStack(s.frames, s.arena, s.arena.backup(), currentPrompt, sub);
+      s = s.tail;
+      if (currentPrompt === p) { return Cons(sub, s) }
+    }
+    throw ("Prompt " + p + " not found")
+  }
+
+  function allocateInto(stack, p, cell) {
+    var s = stack;
+
+    while (s !== EmptyStack) {
+      const currentPrompt = s.prompt
+      if (currentPrompt === p) {
+        return s.fields.push(cell);
+      } else {
+        s = s.tail
+      }
+    }
+    throw ("Prompt " + p + " not found")
+  }
+
+  function withState(init, f) {
+    return Control(k => {
+      const cell = k.arena.fresh(init)
+      return Step(f(cell), k)
+    })
+  }
+
+  function withRegion(prog) {
+    return Control(k => {
+      return Step(prog(k.arena), k)
+    })
+  }
+
+  function withStateIn(prompt, init, f) {
+    const cell = Cell(init)
+
+    if (prompt === toplevel) {
+      return f(cell)
+    } else {
+      return Control(k => {
+        allocateInto(k, prompt, cell);
+        return Step(f(cell), k)
+      })
+    }
+  }
+
+  // Delimited Control
+  function Control(apply) {
+    const self = {
+      apply: apply,
+      run: () => trampoline(Step(self, Stack(Nil, global, toplevel, EmptyStack))),
+      then: f => Control(k => Step(self, flatMap(k, f))),
+      state: f => self.then(init => withState(init, f))
+    }
+    return self
+  }
+
+  const pure = a => Control(k => apply(k, a))
+
+  const delayed = a => Control(k => apply(k, a()))
+
+  const shift = (p, f) => Control(k => {
+    const split = splitAt(k, p)
+    const localCont = a => Control(k =>
+      Step(pure(a), pushSubcont(split.head, k)))
+    return Step(f(localCont), split.tail)
+  })
+
+  const callcc = f => Control(k => {
+    return f(a => trampoline(apply(k, a)))
+  })
+
+  const abort = Control(k => $effekt.unit)
+
+
+  const capture = f => {
+    // [abort; f
+    const action = () => f($effekt.unit).then(() => abort)
+    return shift(toplevel)(k =>
+      k({
+        shouldRun: false,
+        cont : () => k({ shouldRun: true, cont: action })
+      })).then(a => a.shouldRun ? a.cont() : $effekt.pure(a.cont))
+  }
+
+  //const reset = (p, c => Control(k => Step(c, Stack(Nil, Arena(), p, k)))
+
+  function handleMonadic(body) {
+    const p = _prompt++;
+    return Control(k => Step(body(p), Stack(Nil, Arena(), p, k)))
+  }
+
+  // Direct Style Runtime
+  // --------------------
+
+  // sealed trait Resumption[A, R]
+  // case class Empty[A]() extends Resumption[A, A]
+  // case class Segment[A, B, C](head: Stack[B, C], prompt: Prompt, tail: Resumption[A, B]) extends Resumption[A, C]
+  class Segment {
+    constructor(frames, prompt, region, backup, tail) {
+      this.frames = frames;
+      this.prompt = prompt;
+      this.region = region;
+      this.backup = backup;
+      this.tail = tail;
+    }
+  }
+  const Empty = null;
+
+  // TODO maybe inline later to save native frames
+  function handleOrRethrow(prompt, s, rest) {
+    if (!(s instanceof Suspension)) throw s;
+
+    const region = currentRegion
+    const k = new Segment(reverseOnto(s.frames, rest), prompt, region, region.backup(), s.cont)
+    if (s.prompt === prompt)  {
+      return s.body((value) => rewind(k, () => value))
+    } else {
+      throw new Suspension(s.prompt, s.body, Nil, k)
+    }
+  }
+
+  function rewind(k, thunk) {
+    if (k === Empty) {
+      return thunk()
+    } else {
+      const prompt = k.prompt;
+      const region = k.region;
+      let rest = k.frames // the pure frames
+
+      // The trampoline
+      try {
+        enterRegion(region);
+        region.restore(k.backup);
+
+        let curr = rewind(k.tail, thunk)
+        while (rest !== Nil) {
+          const f = rest.head
+          rest = rest.tail
+          curr = f(curr)
+        }
+        return curr
+      } catch (s) {
+        return handleOrRethrow(prompt, s, rest)
+      } finally {
+        leaveRegion()
+      }
+    }
+  }
+
+
+  // case class Suspend[A, X, Y, R](
+  //   body: Continuation[A, R] => R,
+  //   prompt: Prompt,
+  //   pure: Frames[X, Y],
+  //   cont: Resumption[A, X]
+  // )
+  class Suspension {
+    constructor(p, body, frames, cont) {
+      this.prompt = p;
+      this.body = body;
+      this.frames = frames;
+      this.cont = cont;
+    }
+  }
+
+  // initially the toplevel region.
+  let currentRegion = global
+
+  // a stack of regions
+  let regions = []
+
+  function enterRegion(r) {
+    regions.push(currentRegion)
+    currentRegion = r
+    return r
+  }
+
+  function leaveRegion() {
+    const leftRegion = currentRegion
+    currentRegion = regions.pop()
+    return leftRegion
+  }
+
+  return {
+    // Common API
+    // -----------
+    constructor: (_, tag) => function() {
+      return { __tag: tag, __data: Array.from(arguments) }
+    },
+
+    hole: function() { throw "Implementation missing" },
+
+    // Monadic API
+    // -----------
+    pure: pure,
+    callcc: callcc,
+    capture: capture,
+    delayed: delayed,
+    handleMonadic: handleMonadic,
+    ref: Cell,
+    state: withState,
+    shift: shift,
+    _if: (c, thn, els) => c ? thn() : els(),
+    withRegion: withRegion,
+
+
+    // Direct style API
+    // ----------------
+    fresh: function(init) {
+      return currentRegion.fresh(init)
+    },
+
+    freshPrompt: function() { return ++_prompt; },
+
+    suspend: function(prompt, body) {
+      _stacksize = 0;
+      throw new Suspension(prompt, body, Nil, Empty)
+    },
+    suspend_bidirectional: function(prompt, caps, body) {
+      throw new Suspension(prompt, body, Cons(thunk => thunk.apply(null, caps), Nil), Empty)
+    },
+
+    // suspension: the raised exception.
+    push: function(suspension, frame) {
+      if (!(suspension instanceof Suspension)) throw suspension;
+      // Assuming `suspension` is a value or variable you want to return
+      throw new Suspension(suspension.prompt, suspension.body,
+        Cons(frame, suspension.frames), suspension.cont);
+    },
+
+    handle: function(prompt, s) {
+      return handleOrRethrow(prompt, s, Nil)
+    },
+
+    freshRegion: function() {
+      return enterRegion(new Arena)
+    },
+
+    leaveRegion: leaveRegion,
+
+    global: global
+  }
+})()
+
+Object.assign($effekt, $runtime);

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

@@ -0,0 +1,31 @@
+module mutable/map
+
+import array
+
+// A mutable map, backed by a JavaScript Map.
+extern type Map[K, V]
+
+extern pure def emptyMap[K, V](): Map[K, V] =
+  js "new Map()"
+
+def get[K, V](m: Map[K, V], key: K): Option[V] =
+  undefinedToOption(m.unsafeGet(key))
+
+extern pure def unsafeGet[K, V](m: Map[K, V], key: K): V =
+  js "${m}.get(${key})"
+
+extern js """
+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 =
+  js "map$update(${m}, ${key}, ${value})"
+
+extern pure def values[K, V](map: Map[K, V]): Array[V] =
+  js "Array.from(${map}.values())"
+
+extern pure def keys[K, V](map: Map[K, V]): Array[K] =
+  js "Array.from(${map}.keys())"

package/libraries/js/text/regex.effekt

@@ -0,0 +1,33 @@
+module text/regex
+
+import string
+
+extern type Regex
+
+record Match(matched: String, index: Int)
+
+extern pure def regex(str: String): Regex =
+  js "new RegExp(${str})"
+
+def exec(reg: Regex, str: String): Option[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 = js "${r}.matched"
+extern pure def index(r: RegexMatch): Int = js "${r}.index"
+
+extern js """
+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 =
+  js "regex$exec(${reg}, ${str})"

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