@effekt-lang/effekt 0.5.0 → 0.7.0

package/libraries/js/effekt_runtime.js

@@ -1,385 +1,218 @@
-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
+// Common Runtime
+// --------------
+function Cell(init, region) {
+  const cell = {
+    value: init,
+    backup: function() {
+      const _backup = cell.value;
+      // restore function (has a STRONG reference to `this`)
+      return () => { cell.value = _backup; return cell }
     }
-    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
   }
+  return cell;
+}
 
-  function splitAt(stack, p) {
-    var sub = EmptyStack;
-    var s = stack;
+const global = {
+  fresh: Cell
+}
 
-    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
+function Arena(_region) {
+  const region = _region;
+  return {
+    fresh: function(init) {
+      const cell = Cell(init);
+      // region keeps track what to backup, but we do not need to backup unreachable cells
+      region.push(new WeakRef(cell))
+      return cell;
+    },
+    region: _region,
+    newRegion: function() {
+      // a region aggregates weak references
+      const nested = Arena([])
+      // this doesn't work yet, since Arena.backup doesn't return a thunk
+      region.push(new WeakRef(nested))
+      return nested;
+    },
+    backup: function() {
+      const _backup = []
+      let nextIndex = 0;
+      for (const ref of region) {
+        // console.log(ref)
+        const cell = ref.deref()
+        // only backup live cells
+        if (cell) {
+          _backup[nextIndex] = cell.backup()
+          nextIndex++
+        }
+      }
+      function restore() {
+        const region = []
+        let nextIndex = 0;
+        for (const restoreCell of _backup) {
+          region[nextIndex] = new WeakRef(restoreCell())
+          nextIndex++
+        }
+        return Arena(region)
       }
+      return restore;
     }
-    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)
-    })
-  }
+let _prompt = 1;
 
-  function withStateIn(prompt, init, f) {
-    const cell = Cell(init)
+const TOPLEVEL_K = (x, ks) => { throw { computationIsDone: true, result: x } }
+const TOPLEVEL_KS = { prompt: 0, arena: Arena([]), rest: null }
 
-    if (prompt === toplevel) {
-      return f(cell)
-    } else {
-      return Control(k => {
-        allocateInto(k, prompt, cell);
-        return Step(f(cell), k)
-      })
-    }
-  }
+function THUNK(f) {
+  f.thunk = true
+  return f
+}
 
-  // 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
+function CAPTURE(body) {
+  return (ks, k) => {
+    const res = body(x => TRAMPOLINE(() => k(x, ks)))
+    if (res instanceof Function) return res
+    else throw { computationIsDone: true, result: $effekt.unit }
   }
+}
 
-  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 RETURN = (x, ks) => ks.rest.stack(x, ks.rest)
 
-  const abort = Control(k => $effekt.unit)
+// const r = ks.arena.newRegion(); body
+// const x = r.alloc(init); body
 
+// HANDLE(ks, ks, (p, ks, k) => { STMT })
+function RESET(prog, ks, k) {
+  const prompt = _prompt++;
+  const rest = { stack: k, prompt: ks.prompt, arena: ks.arena, rest: ks.rest }
+  return prog(prompt, { prompt, arena: Arena([]), rest }, RETURN)
+}
 
-  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))
+function DEALLOC(ks) {
+  const arena = ks.arena
+  if (!!arena) {
+    arena.length = arena.length - 1
   }
+}
 
-  //const reset = (p, c => Control(k => Step(c, Stack(Nil, Arena(), p, k)))
+function SHIFT(p, body, ks, k) {
 
-  function handleMonadic(body) {
-    const p = _prompt++;
-    return Control(k => Step(body(p), Stack(Nil, Arena(), p, k)))
-  }
-
-  // Direct Style Runtime
-  // --------------------
+  // TODO avoid constructing this object
+  let meta = { stack: k, prompt: ks.prompt, arena: ks.arena, rest: ks.rest }
+  let cont = null
 
-  // 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;
-    }
+  while (!!meta && meta.prompt !== p) {
+    cont = { stack: meta.stack, prompt: meta.prompt, backup: meta.arena.backup(), rest: cont }
+    meta = meta.rest
   }
-  const Empty = null;
+  if (!meta) { throw `Prompt not found ${p}` }
 
-  // TODO maybe inline later to save native frames
-  function handleOrRethrow(prompt, s, rest) {
-    if (!(s instanceof Suspension)) throw s;
+  // package the prompt itself
+  cont = { stack: meta.stack, prompt: meta.prompt, backup: meta.arena.backup(), rest: cont }
+  meta = meta.rest
 
-    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 resumeValue(a, ks, k) {
+    return resumeComp((ks, k) => k(a, ks), ks, 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()
-      }
+  function resumeComp(c, ks, k) {
+    //console.log("Resuming", ks.arena)
+    let meta = { stack: k, prompt: ks.prompt, arena: ks.arena, rest: ks.rest }
+    let toRewind = cont
+    while (!!toRewind) {
+      meta = { stack: toRewind.stack, prompt: toRewind.prompt, arena: toRewind.backup(), rest: meta }
+      toRewind = toRewind.rest
     }
-  }
-
 
-  // 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;
-    }
+    const k2 = meta.stack // TODO instead copy meta here, like elsewhere?
+    meta.stack = null
+    return () => c(meta, k2)
   }
 
-  // initially the toplevel region.
-  let currentRegion = global
+  let k1 = meta.stack
+  meta.stack = null
+  return body(resumeValue, resumeComp, meta, k1)
+}
 
-  // 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
+function RUN_TOPLEVEL(comp) {
+  try {
+    let a = comp(TOPLEVEL_KS, TOPLEVEL_K)
+    while (true) { a = a() }
+  } catch (e) {
+    if (e.computationIsDone) return e.result
+    else throw e
   }
+}
 
-  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);
+// trampolines the given computation (like RUN_TOPLEVEL, but doesn't provide continuations)
+function TRAMPOLINE(comp) {
+  let a = comp;
+  try {
+    while (true) {
+      a = a()
+    }
+  } catch (e) {
+    if (e.computationIsDone) return e.result
+    else throw e
+  }
+}
+
+// keeps the current trampoline going and dispatches the given task
+function RUN(task) {
+  return () => task(TOPLEVEL_KS, TOPLEVEL_K)
+}
+
+// aborts the current continuation
+function ABORT(value) {
+  throw { computationIsDone: true, result: value }
+}
+
+
+// "Public API" used in FFI
+// ------------------------
+
+/**
+ * Captures the current continuation as a WHOLE and makes it available
+ * as argument to the passed body. For example:
+ *
+ *   $effekt.capture(k => ... k(42) ...)
+ *
+ * The body
+ *
+ *   $effekt.capture(k => >>> ... <<<)
+ *
+ * conceptually runs on the _native_ JS call stack. You can call JS functions,
+ * like `setTimeout` etc., but you are not expected or required to return an
+ * Effekt value like `$effekt.unit`. If you want to run an Effekt computation
+ * like in `io::spawn`, you can use `$effekt.run`.
+ *
+ * Advanced usage details:
+ *
+ * The value returned by the function passed to `capture` returns
+ * - a function: the returned function will be passed to the
+ *   Effekt runtime, which performs trampolining.
+ *   In this case, the Effekt runtime will keep running, though the
+ *   continuation has been removed.
+ *
+ * - another value (like `undefined`): the Effekt runtime will terminate.
+ */
+$effekt.capture = CAPTURE
+
+/**
+ * Used to call Effekt function arguments in the JS FFI, like in `io::spawn`.
+ *
+ * Requires an active Effekt runtime (trampoline).
+ */
+$effekt.run = RUN
+
+/**
+ * Used to call Effekt function arguments in the JS FFI, like in `network::listen`.
+ *
+ * This function should be used when _no_ Effekt runtime is available. For instance,
+ * in callbacks passed to the NodeJS eventloop.
+ *
+ * If a runtime is available, use `$effekt.run`, instead.
+ */
+$effekt.runToplevel = RUN_TOPLEVEL